Continual Reasoning: Non-Monotonic Reasoning in Neurosymbolic AI using Continual Learning

📝 Paper Summary

Neurosymbolic AI Continual Learning Non-monotonic Reasoning

Continual Reasoning enables Logic Tensor Networks to solve non-monotonic reasoning tasks by splitting rule learning into sequential stages with rehearsal, allowing belief revision without logical contradictions.

Core Problem

Deep learning struggles with non-monotonic reasoning (retracting conclusions given new evidence) because standard training treats all data/rules as simultaneously true, leading to contradictions or averaging artifacts.

Why it matters:

Commonsense reasoning requires jumping to conclusions that might later be retracted (e.g., birds fly → penguins don't), which classical logic and standard neural training fail to handle gracefully
Previous approaches like Autoepistemic logic are computationally expensive, while standard neural networks lack formalization for explicit belief revision

Concrete Example: In the Penguin Exception Task, a system learns 'Birds fly' and 'Penguins are birds'. Later, it learns 'Penguins don't fly'. Standard monotonic logic fails due to contradiction. A standard neural network might converge to an uninformative 0.5 truth value for 'Penguins fly', failing to fully retract the earlier belief.

Key Novelty

Continual Reasoning Paradigm

Treats logical rules as a sequence of tasks rather than a single static knowledge base, using Continual Learning techniques to update beliefs over time
Implements non-monotonicity via curriculum design: learning general rules first (birds fly), then specific exceptions (penguins don't), utilizing rehearsal to prevent forgetting unrelated facts

Evaluation Highlights

+28-36% accuracy improvement on the Penguin Exception Task using Task Separation curriculum compared to a Baseline single-stage training
Achieves 99.9% satisfiability for 'Penguins do not fly' in the final stage while retaining 99.5% for 'Normal Birds fly', successfully handling the exception
Outperforms Baseline curriculum on the Smokers and Friends task, achieving higher satisfiability in 5 out of 9 logical rules using Knowledge Completion curriculum

Breakthrough Assessment

7/10

Novel application of Continual Learning to solve logical non-monotonicity in Neurosymbolic systems. Demonstrates clear improvements on prototypical tasks, though tested primarily on small-scale reasoning problems.

⚙️ Technical Details

Problem Definition

Setting: Learning a Knowledge Base of First-Order Logic rules where some rules act as exceptions to others, creating potential contradictions if learned simultaneously

Inputs: A set of First-Order Logic rules (axioms) and ground facts

Outputs: Learned grounding of predicates (neural networks) that satisfy the non-monotonic interpretation of the rules (e.g., high truth value for 'Penguins don't fly')

Pipeline Flow

Curriculum Design (Split KB into stages)
Stage 1 Training (Train LTN on first subset of rules)
Stage N Training (Train LTN on next subset + Rehearsal of previous facts)

System Modules

Curriculum Splitter

Divides the FOL Knowledge Base into sequential stages based on strategies like Task Separation or Knowledge Completion

Model or implementation: Rule-based selection

Logic Tensor Network (LTN)

Learns vector groundings and predicate networks to maximize satisfiability of the current stage's rules

Model or implementation: User-defined neural networks (e.g., MLPs for predicates)

Novel Architectural Elements

Integration of Curriculum Learning directly into the logical satisfiability optimization loop of LTNs to enforce non-monotonicity
Task Separation Curriculum: separating rules by the predicate they define to isolate learning tasks
Knowledge Completion Curriculum: separating facts (atomic knowledge) from general rules to build up complexity

Modeling

Base Model: Logic Tensor Networks (LTN)

Training Method: Continual Learning with Rehearsal (Experience Replay)

Objective Functions:

Purpose: Maximize truth value of logical rules.

Formally: Loss = 1 - Sat(KB), where Sat is the aggregated truth value using differentiable fuzzy logic norms (e.g., Lukasiewicz t-norm).

Training Data:

Penguin Exception Task (synthetic)
Smokers and Friends (statistical relational learning dataset)
bAbI Task 1 (converted to FOL via GPT-3)

Compute: Not reported in the paper

Comparison to Prior Work

vs. DeepProbLog: Uses curriculum-based belief revision for non-monotonicity rather than probabilistic conditioning
vs. LNN: LTN with Continual Reasoning handles exceptions via sequential updates rather than static bounds
vs. MLN: Optimizes differentiable truth values directly via curriculum rather than maximizing formula weights over a static database
+ 1 more
vs. CILP [not cited in paper]: Focuses on sequential rule injection into a generic neurosymbolic framework (LTN) rather than compiling rules into network weights

Limitations

Curriculum design is manual and heuristic (Task Separation vs. Knowledge Completion); no automated discovery of optimal order
Experiments limited to small-scale toy problems (Penguins, Smokers, single bAbI task)
Handling 'exceptions to exceptions' (e.g., super-penguins) proved difficult in preliminary exploration
Relies on Rehearsal to prevent forgetting, which may scale poorly with very large knowledge bases

Reproducibility

No replication artifacts mentioned in the paper. The datasets (Smokers, bAbI) are standard, but the specific LTN implementation and curriculum scripts are not provided.

📊 Experiments & Results

Evaluation Setup

Satisfiability of specific logical queries after training sequence

Benchmarks:

Penguin Exception Task (PET) (Non-monotonic reasoning / Logic puzzle)
Smokers and Friends (Statistical Relational Learning)
bAbI Task 1 (Reasoning QA)

Metrics:

Satisfiability (truth value) of target rules
Classification accuracy
Statistical methodology: Not explicitly reported in the paper

Key Results

Benchmark	Metric	Baseline	This Paper	Δ
In the Penguin Exception Task, the goal is to correctly classify that Penguins do NOT fly (rule 4) while Normal Birds DO fly (rule 3), despite Penguins being Birds. Task Separation (TS) succeeds best.
Penguin Exception Task (PET)	Satisfiability: not(can_fly(Penguins))	0.628	0.997	+0.369
Penguin Exception Task (PET)	Satisfiability: can_fly(Birds)	0.962	0.995	+0.033
Penguin Exception Task (PET)	Satisfiability: is_bird(Penguins)	0.618	0.999	+0.381
Smokers and Friends task comparison shows Knowledge Completion (KC) curriculum improving satisfiability of key causal rules compared to Baseline.
Smokers and Friends	Satisfiability: Smokes(x) => Cancer(x)	0.715	0.978	+0.263
Smokers and Friends	Satisfiability: not(Smokes(x)) => not(Cancer(x))	0.917	0.991	+0.074

Experiment Figures

Satisfiability curves for four key queries (Normal birds are birds, Penguins are birds, Normal birds fly, Penguins fly) over training stages for Knowledge Completion vs. Task Separation curricula.

Main Takeaways

Curriculum matters significantly: Task Separation (grouping by predicate) yields the most robust results for non-monotonic tasks like PET, preventing the averaging of contradictory rules.
Rehearsal is critical: Recalling previously learned facts (e.g., 'Normal birds can fly') allows the model to adjust beliefs when new contradictory info ('Penguins don't fly') is introduced, recovering from temporary dips in satisfiability.
Even Random curricula outperform the single-stage Baseline on average, suggesting that breaking the problem into any sequence is better than simultaneous learning for these logical contradictions.
Knowledge Completion (learning facts then rules) is effective for statistical relational tasks (Smokers & Friends) but less robust for pure non-monotonic reasoning compared to Task Separation.

📚 Prerequisite Knowledge

Prerequisites

First-Order Logic (FOL)
Neurosymbolic AI concepts (grounding, satisfiability)
Continual Learning (catastrophic forgetting, rehearsal)

Key Terms

LTN: Logic Tensor Networks—a neurosymbolic framework that grounds FOL predicates into neural networks and treats logical satisfiability as a loss function

Non-monotonic Reasoning (NMR): A logic system where adding new axioms can invalidate previous theorems (e.g., learning about penguins invalidates 'all birds fly')

Catastrophic Forgetting: A phenomenon in neural networks where learning new information causes the abrupt loss of previously learned information

Rehearsal: A Continual Learning technique where a subset of previous data (or rules) is mixed in with new data to prevent forgetting

Curriculum Learning: Organizing training data/rules into a meaningful sequence rather than shuffling them randomly

Real Logic: A differentiable logic used in LTN that maps truth values to the interval [0,1], allowing gradient-based optimization of satisfiability

Grounding: Mapping symbolic logical constants to vector embeddings and predicates to neural networks