Neural Logic Programming

The fundamental units of a neural logic program. Unlike static symbols in Prolog, neural predicates are represented as parameterized, differentiable functions (often small neural networks).

• A predicate p(X, Y) has its truth value computed by a neural module.
• These modules learn embeddings for constants and relations from data.
• Enables the program to handle noisy, incomplete, or continuous-valued data.

The logical rules (Horn clauses) of the program are made end-to-end differentiable. This allows gradient-based optimization of rule weights and predicate parameters.

• Traditional logical operators (AND, OR, implication) are replaced with fuzzy logic or product t-norm approximations.
• Example: The rule grandparent(X, Z) :- parent(X, Y), parent(Y, Z) becomes a differentiable computation graph.
• Rule weights can be learned, indicating the strength or confidence of the rule.

All symbolic entities (constants, variables) are associated with continuous vector embeddings in a latent space.

• The symbol 'Alice' is represented by a dense vector, e.g., [0.2, -0.7, 0.4].
• Similar entities have similar embeddings, allowing for soft unification and generalization to unseen symbols.
• These embeddings are learned jointly with the predicate and rule parameters during training.

The mechanism that performs logical inference (e.g., backward chaining) in a differentiable manner. It computes the truth value of queries by propagating gradients through the proof structure.

• Replaces discrete search and unification with continuous relaxation.
• Calculates a proof score or probability for a given query.
• Enables the use of standard backpropagation to train the entire program based on a loss function defined on query outcomes.

A set of pre-defined, hard logical constraints or facts that provide domain structure. This background knowledge is not learned but acts as a scaffold for the neural components.

• Injects symbolic priors and guarantees logical consistency in certain parts of the model.
• Can include type constraints, ontological hierarchies, or immutable domain axioms.
• Distinguishes the system from a purely black-box neural network.

A supervised learning setup where the program is trained to maximize the likelihood of observed ground atoms (facts).

• The loss function measures the discrepancy between the program's predicted truth values and the actual truth values in the training data.
• Common losses include binary cross-entropy or mean squared error on the truth values of queries.
• This data-driven training allows the neural components to adapt the logical program to fit empirical evidence.

A machine learning framework that learns logic programs (sets of rules) from examples using gradient-based optimization. Unlike traditional ILP, which performs discrete search, ∂ILP treats rule learning as a continuous optimization problem.

• Core Mechanism: Represents logical predicates as differentiable neural modules.
• Training: Uses gradient descent to adjust rule weights based on input-output examples.
• Key Benefit: Bridges symbolic rule induction with the scalability of neural network training.

A neuro-symbolic framework that uses first-order fuzzy logic to define semantic constraints, which are injected into a deep learning model. LTNs allow a neural network to learn from both data and prior logical knowledge.

• Knowledge Injection: Logical axioms are converted into loss functions that regularize network training.
• Fuzzy Logic: Employs continuous truth values between 0 and 1, enabling differentiability.
• Primary Use Case: Supervising learning in data-scarce environments by enforcing logical consistency.

The application of neural networks to guide or perform automated logical deduction. This approach often involves learning to select relevant proof steps or embedding logical formulae into a continuous space for similarity-based reasoning.

• Two Main Paradigms: 1) Neural guidance for symbolic provers (e.g., premise selection). 2) End-to-end neural proof generation.
• Representation: Logical formulas are embedded using graph neural networks or transformers.
• Objective: Overcome the combinatorial search challenge in large theorem spaces.

An architecture that applies graph neural networks to structured, symbolic knowledge representations like knowledge graphs. It enables relational reasoning and learning over entities and their connections in a differentiable manner.

• Data Structure: Operates directly on graphs where nodes are entities/constants and edges are predicates/relations.
• Reasoning: Performs multi-hop inference by passing messages along graph edges.
• Typical Task: Knowledge base completion (link prediction) with learned, compositional rules.

A foundational framework that reformulates discrete logical operations (AND, OR, NOT, implication) into continuous, differentiable functions. This allows symbolic rules to be incorporated into neural networks and tuned via gradient descent.

• Key Technique: Uses fuzzy logic or probabilistic relaxations (e.g., Product T-norm, Łukasiewicz).
• Integration: Enables logic rules to become part of a neural network's loss function or architectural constraint.
• Outcome: Creates a seamless gradient pathway from symbolic objectives to neural parameters.

Architectures that implement classic, rule-based production systems (condition-action rules) using differentiable neural components. They create a learnable version of symbolic expert systems.

• Mechanism: A neural network evaluates conditions (working memory patterns) and selects/executes actions.
• Differentiability: The rule-matching and selection process is softened to allow gradient flow.
• Advantage: Combines the interpretable, modular structure of symbolic rules with the learning capacity of neural networks.