## Logic Tensor Networks (LTN)

Logic Tensor Network (LTN) is a neurosymbolic framework that supports querying, learning and reasoning with both rich data and rich abstract knowledge about the world. LTN uses a differentiable first-order logic language, called Real Logic, to incorporate data and logic.

LTN converts Real Logic formulas (e.g. `∀x(cat(x) → ∃y(partOf(x,y)∧tail(y)))`

) into TensorFlow computational graphs.

Such formulas can express complex queries about the data, prior knowledge to satisfy during learning, statements to prove ...

One can represent and effectively compute the most important tasks of deep learning. Examples of such tasks are classification, regression, clustering, or link prediction.

The "Getting Started" section of the README links to tutorials and examples of LTN code.

```
@misc{badreddine2021logic,
title={Logic Tensor Networks},
author={Samy Badreddine and Artur d'Avila Garcez and Luciano Serafini and Michael Spranger},
year={2021},
eprint={2012.13635},
archivePrefix={arXiv},
primaryClass={cs.AI}
}
```

## Installation

Clone the LTN repository and install it using `pip install -e <local project path>`

.

Following are the dependencies we used for development (similar versions should run fine):

- python 3.8
- tensorflow >= 2.2 (for running the core system)
- numpy >= 1.18 (for examples)
- matplotlib >= 3.2 (for examples)

## Repository structure

`logictensornetworks/core.py`

-- core system for defining constants, variables, predicates, functions and formulas,`logictensornetworks/fuzzy_ops.py`

-- a collection of fuzzy logic operators defined using Tensorflow primitives,`logictensornetworks/utils.py`

-- a collection of useful functions,`tutorials/`

-- tutorials to start with LTN,`examples/`

-- various problems approached using LTN,`tests/`

-- tests.

## Getting Started

### Tutorials

`tutorials/`

contains a walk-through of LTN. In order, the tutorials cover the following topics:

- Grounding in LTN part 1: Real Logic, constants, predicates, functions, variables,
- Grounding in LTN part 2: connectives and quantifiers (+ complement: choosing appropriate operators for learning),
- Learning in LTN: using satisfiability of LTN formulas as a training objective,
- Reasoning in LTN: measuring if a formula is the logical consequence of a knowledgebase.

The tutorials are implemented using jupyter notebooks.

### Examples

`examples/`

contains a series of experiments. Their objective is to show how the language of Real Logic can be used to specify a number of tasks that involve learning from data and reasoning about logical knowledge. Examples of such tasks are: classification, regression, clustering, link prediction.

- The binary classification example illustrates in the simplest setting how to ground a binary classifier as a predicate in LTN, and how to feed batches of data during training,
- The multiclass classification examples (single-label, multi-label) illustrate how to ground predicates that can classify samples in several classes,
- The MNIST digit addition example showcases the power of a neurosymbolic approach in a classification task that only provides groundtruth for some final labels (result of the addition), where LTN is used to provide prior knowledge about intermediate labels (possible digits used in the addition),
- The regression example illustrates how to ground a regressor as a function symbol in LTN,
- The clustering example illustrates how LTN can solve a task using first-order constraints only, without any label being given through supervision,
- The Smokes Friends Cancer example is a classical link prediction problem of Statistical Relational Learning where LTN learns embeddings for individuals based on fuzzy groundtruths and first-order constraints.

The examples are presented with both jupyter notebooks and Python scripts.