Paper deep dive
Continual learning and refinement of causal models through dynamic predicate invention
Enrique Crespo-Fernandez, Oliver Ray, Telmo de Menezes e Silva Filho, Peter Flach
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 7/21/2026, 12:13:25 AM
Summary
The paper proposes a framework for constructing symbolic causal world models entirely online by integrating continuous model learning and repair into an agent's decision loop. Leveraging Meta-Interpretive Learning (MIL) and dynamic predicate invention, the system constructs a hierarchy of disentangled, high-quality concepts from observations. This lifted inference approach scales to domains with complex relational dynamics, avoiding the combinatorial explosion of propositional methods, and achieves sample efficiency orders of magnitude higher than PPO neural-network baselines.
Entities (8)
Relation Signals (6)
Proposed Framework → uses → Meta-Interpretive Learning
confidence 98% · We propose a framework... by leveraging the power of Meta-Interpretive Learning
Proposed Framework → uses → Predicate Invention
confidence 97% · integrating continuous model learning and repair... by leveraging the power of... predicate invention
Proposed Framework → outperforms → PPO
confidence 95% · achieving sample-efficiency orders of magnitude higher than the established PPO neural-network-based baseline
Proposed Framework → employs → Lifted Inference
confidence 94% · our lifted inference approach scales to domains with complex relational dynamics
Proposed Framework → evaluatedon → MiniHack
confidence 92% · We demonstrate that our lifted inference approach scales to domains... MiniHack ‘Lava Crossing’ task
Proposed Framework → buildson → Louise
confidence 85% · Building on recent developments in Meta-Interpretive Learning... Louise system
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Efficiently navigating complex environments requires agents to internalize the underlying logic of their world, yet standard world modelling methods often struggle with sample inefficiency, lack of transparency, and poor scalability. We propose a framework for constructing symbolic causal world models entirely online by integrating continuous model learning and repair into the agent's decision loop, by leveraging the power of Meta-Interpretive Learning and predicate invention to find semantically meaningful and reusable abstractions, allowing an agent to construct a hierarchy of disentangled, high-quality concepts from its observations. We demonstrate that our lifted inference approach scales to domains with complex relational dynamics, where propositional methods suffer from combinatorial explosion, while achieving sample-efficiency orders of magnitude higher than the established PPO neural-network-based baseline.
Tags
Links
- Source: https://arxiv.org/abs/2602.17217v1
- Canonical: https://arxiv.org/abs/2602.17217v1
Trouble viewing inline? Open PDF directly →
Full Text
35,633 characters extracted from source content.
Expand or collapse full text
Continual learning and refinement of causal models through dynamic predicate invention Enrique Crespo-Fernández, Oliver Ray, Telmo de Menezes e Silva Filho & Peter Flach University of Bristol Bristol, UK Abstract Efficiently navigating complex environments requires agents to internalize the underlying logic of their world, yet standard world modelling methods often struggle with sample inefficiency, lack of transparency, and poor scalability. We propose a framework for constructing symbolic causal world models entirely online by integrating continuous model learning and repair into the agent’s decision loop, by leveraging the power of Meta-Interpretive Learning and predicate invention to find semantically meaningful and reusable abstractions, allowing an agent to construct a hierarchy of disentangled, high-quality concepts from its observations. We demonstrate that our lifted inference approach scales to domains with complex relational dynamics, where propositional methods suffer from combinatorial explosion, while achieving sample-efficiency orders of magnitude higher than the established PPO neural-network-based baseline. Learnt Dynamics % Rule: movement att+1(A,B)⇐p1(A,B) _t+1(A,B) [rgb]1,0,1 [named]pgfstrokecolorrgb1,0,1 @color@cmyk@stroke0100 @color@cmyk@fill0100p1(A,B) % Rule: dying deadt+1(A)⇐p5(A) _t+1(A) [rgb]1,0,0 [named]pgfstrokecolorrgb1,0,0p5(A) Learnt Constraints % Agent cannot occupy two locations att(A,B)⊗att(A,D) _t(A,B) _t(A,D) % A cannot be dead and alive alivet(A)⊗deadt(A) _t(A) _t(A) Learnt Abstractions % Agent A alive at loc B p4(A,B)←at(A,B)∧alive(A) [rgb].5,0,.5 [named]pgfstrokecolorrgb.5,0,.5p4(A,B) (A,B) (A) % Surroundings of the agent A p3(A,C,D)←p4(A,B)∧adjacent(B,C,D) [rgb]0,1,1 [named]pgfstrokecolorrgb0,1,1 @color@cmyk@stroke1000 @color@cmyk@fill1000p3(A,C,D)← [rgb].5,0,.5 [named]pgfstrokecolorrgb.5,0,.5p4(A,B) (B,C,D) % Agent A moving towards cell B p2(A,B)←move(C)∧p3(A,C,B) [rgb].75,.5,.25 [named]pgfstrokecolorrgb.75,.5,.25p2(A,B)← move(C) [rgb]0,1,1 [named]pgfstrokecolorrgb0,1,1 @color@cmyk@stroke1000 @color@cmyk@fill1000p3(A,C,B) % Valid move p1(A,B)←p2(A,B)∧not_wall(B) [rgb]1,0,1 [named]pgfstrokecolorrgb1,0,1 @color@cmyk@stroke0100 @color@cmyk@fill0100p1(A,B)← [rgb].75,.5,.25 [named]pgfstrokecolorrgb.75,.5,.25p2(A,B) \_wall(B) % Moving into lava p5(A)←p2(A,B)∧is_lava(B) [rgb]1,0,0 [named]pgfstrokecolorrgb1,0,0p5(A)← [rgb].75,.5,.25 [named]pgfstrokecolorrgb.75,.5,.25p2(A,B) \_lava(B) Figure 1: Visualization of a selected set of rules from the learnt symbolic causal model on the MiniHack ‘Lava Crossing’ task. The environment is modelled as a hierarchy of interpretable concepts, transition rules, and physical constraints. (Left) State Interpretation: Colored overlays illustrate how the Learnt Abstractions (Right) ground to specific regions of the state space. The agent (p4p4, purple) senses its neighborhood (p3p3, cyan). The concept of ”moving” (p2p2, orange) is reused in two rules: the one modelling movement (p1p1) and the one modelling death (p5p5). (Center) Dynamics & Constraints: The Learnt Dynamics use these high-level abstractions to predict state evolution. For example, the dying rule is triggered only when the abstract condition p5p5 (moving into lava) is met. Learnt Constraints enforce physical consistency, such as mutual exclusion (⊗ ), ensuring the agent cannot be simultaneously alive and dead or occupy multiple coordinates. 1 Introduction Intelligent agents deployed in dynamic environments must learn compact world models from scarce experience, reason with them, and adapt when predictions fail. Modern deep model-based reinforcement learning offers powerful function approximation but remains data-hungry and opaque (Sutton and Barto, 2018; Moerland et al., 2022; Zhang and Yu, 2020). Conversely, traditional symbolic systems possess structural properties—specifically, inherent compositionality, the capacity for arbitrary-depth computation, and interpretability—that make them ideal candidates for the backbone of a causal agent. However, classical automated planning typically presupposes a hand-engineered symbolic world model (Ghallab et al., 2004; Fikes and Nilsson, 1971; Yu et al., 2023; Smet et al., 2025). Bridging these paradigms requires a framework that acquires a symbolic dynamics model from experience while retaining the deliberative strengths of classical planning. The acquisition of such models requires an agent to formulate hypotheses that rationalize environmental changes as they occur, to test their consistency over time, and to update beliefs when they are falsified (Sutton and Barto, 2018; Evans et al., 2021b). Crucially, if the aim is general-purpose agency, the learner must be able to formulate and refine these hypotheses during interaction without reliance on pre-collected trajectories, batched histories, or external oracles, as is common in many existing Inductive Logic Programming (ILP) approaches (Evans et al., 2021b; Cropper et al., 2020; Cropper and Morel, 2021). To this end, we present a self-supervised, online framework for learning symbolic world models. Our agent operates in a continuous loop: it (i) incrementally induces a symbolic transition theory from streams of experience, (i) predicts state evolution to plan actions, and (i) reacts to prediction–observation mismatches by revising its model in real-time. Building on recent developments in Meta-Interpretive Learning (MIL) (Muggleton et al., 2015; Cropper and Tourret, 2020; Patsantzis and Muggleton, 2021), our system generates logical explanations for unpredicted transitions in the language of First-Order Logic. We employ a template-based approach to manage the combinatorial complexity of the search space. Furthermore, we introduce a dynamic predicate invention that composes short, general abstract rules to define complex relationships. This hierarchical structure ensures that the learned dynamic rules remain concise, general, and interpretable while remaining sufficiently robust to capture deep causal dependencies. The main contributions of this work can be summarized as follows. We introduce a Continuous Model Repair framework that utilizes prediction error to refine symbolic theories incrementally, eliminating the need for retraining. By using lifted inference and predicate invention, the complexity of our Scale-Invariant Learning mechanism depends only on the logic depth and vocabulary size and not on the grounding size, a standard limitation of propositional methods (ASP- and SAT-based). We empirically validate the Sample Efficiency of our system on grid-world environments, where it achieves superior sample efficiency compared to standard PPO Schulman et al. (2017) baselines. By integrating symbolic learning and model repair into a single loop, we enable agents that are not only effective but also transparent and data-efficient. The remainder of this paper is structured as follows: Section 2 formalizes the MIL framework and the self-supervised Predict-Verify-Refine cycle. Section 3 presents an empirical evaluation of the system’s sample efficiency and model repair capabilities in the MiniHack environment. Section 4 situates our work within the broader context of symbolic and neurosymbolic world models, and Section 5 concludes with a discussion of future research directions. 2 Method This section details the MIL framework for acquiring predictive world models. We employ a self-supervised continuous learning paradigm in which the agent induces a logic program H to predict state transitions and iteratively refines it based on prediction failures. 2.1 Problem Definition The learning task is to induce a hypothesis H that rationalizes transitions in a sequence S=⟨S0,S1,…,Sn⟩S= S_0,S_1,…,S_n within a deterministic, fully observable environment. A state StS_t is a set of ground atoms. The goal is to learn a transition function T:S×A→S′T:S× A→ S as a logic program H=⟨Abs,Dyn,Con⟩H= Abs,Dyn,Con . Here, AbsAbs is a set of definite clauses defining invented predicates, enabling compositional representation of spatial or semantic relations of the form pi←Bodyp_i← Body. DynDyn is a set of transition rules governing the addition of atoms, taking the form add(P)←Bodyadd(P)← Body. ConCon is a set of rules governing the removal of atoms, taking the form del(P)←Bodydel(P)← Body. BodyBody is a conjunction of literals drawn from the background knowledge ℬB, the current state StS_t, and the set of invented predicates defined in AbsAbs. The transition logic is defined by: St+1=(St∖)∪S_t+1=(S_t ) where =h|HDyn∪St∪ℬ⊧hA=\h|H_Dyn∪ S_t h\ and =h|HCon∪St∪ℬ⊧hD=\h|H_Con∪ S_t h\, with ℬB representing background knowledge (static predicates). We assume lifted dynamics, meaning rules depend on object relations rather than identities. The search space is the power set of the logic language ℒL. To manage the super-exponential complexity online, we use a Predict-Verify-Refine cycle rather than batch learning. We maintain a current hypothesis HtH_t; when HtH_t fails to predict St+1S_t+1, we trigger localized MIL search to repair the theory via generalization (metarule-guided construction) or specialization (clause pruning), see Algorithm 2 in Appendix B. 1 2Function MetaruleInduction(LiteralL,DepthkLiteral\ L,Depth\ k): 3 if k>Dmaxk>D_max then return failure ; // Terminate at max abstraction depth 4 5ℋ←∅,←∅H← ,T← ; 6 7foreach metarule m∈ℳm (H←B1,…,BnH← B_1,…,B_n) do 8 Apply substitution θ such that Hθ=LHθ=L ; 9 Body←[]Body←[\ ]; 10 11 foreach literal lit∈[B1θ,…,Bnθ]lit∈[B_1θ,…,B_nθ] do 12 if litlit is primitive OR entails ℬB then 13 BodyBody.append(litlit); 14 15 else // Recursive abduction for predicate invention 16 (P,Rulep,Typep)←MetaruleInduction(lit,k+1)(P,Rule_p,Type_p) (lit,k+1); BodyBody.append(P) ; // Invented predicate P added to the body ℋ←ℋ∪RulepH ∪ Rule_p ; // Rule that explains P is stored ←∪TypepT ∪ Type_p ; // Type signature of P is stored 17 18 19 if k==0k==0 then 20 ℋ←ℋ∪H←BodyH ∪\H← Body\; 21 Pret←LP_ret← L; 22 23 else 24 Pret←ReuseOrRegister(Body,ℋ)P_ret (Body,H); 25 26 27return (Pret,ℋ,)(P_ret,H,T); Algorithm 1 Metarule-Guided Abduction with Predicate Reuse 2.2 Metarule-Guided Hypothesis construction and refinement To overcome the combinatorial explosion typical of inductive synthesis, we restrict the search space using rule templates (Muggleton et al., 2015). Rather than searching the space of all Horn clauses, we search the space of proofs generated by a set of second-order templates called metarules ℳM. A metarule M∈ℳM is a second-order clause defining a valid syntactic structure for a rule. For example, the Chain metarule allows the agent to discover transitive relationships, and the absorption metarule to restrict a relation with a property: Mchain:P(X,Y)←Q(X,Z),R(Z,Y) M_chain:P(X,Y)← Q(X,Z),R(Z,Y) Mabsorption:P(X,Y)←Q(X,Y),R(Y) M_absorption:P(X,Y)← Q(X,Y),R(Y) While users select metarules, these typically have a general structure and can be reused across domains. Additionally, the system can compensate for a missing metarule by composing the available metarules through predicate invention. Top Program Construction. Building on the Louise system (Patsantzis and Muggleton, 2021), we avoid searching for a single hypothesis directly. Instead, we construct the Top Program ⊤ , the most general logic program entailing observed positive examples (E+E^+) within constraints: ⊤=Mθ∣M∈ℳ,∃(Ei+∈E+):entails(Mθ,Ei+) =\Mθ M ,∃(E^+_i∈ E^+):entails(Mθ,E^+_i)\ (1) In our online setting, ⊤ represents the set of all plausible explanations. Learning reduces to generalizing ⊤ to explain new changes and specializing ⊤ by pruning falsified clauses (see Figure 3 in Appendix A). Recursive Abduction and Predicate Invention. Hypotheses are constructed via abductive instantiation. Given an unexplained observation O, the system identifies a metarule M and a substitution θ such that head(M)θ=Ohead(M)θ=O. Body literals are resolved against ℬ∪StB∪ S_t or further abduced. These unexplained literals become targets for further abduction using abstraction metarules ℳabsM_abs (see Algorithm 1. This process builds a hierarchical derivation chain in which higher-level predicates are defined in terms of lower-level ones, continuing recursively until the chain is grounded in ℬB or the maximum depth DmaxD_max is reached. To bound complexity, we impose a type system T, considering only instantiations that respect predicate typing in ℬB. The user manually assigns a type to primary predicates; invented predicates inherit the type from the predicates in their body. Error Signals and Refinement. For any state transition (St→St+1)(S_t→ S_t+1), the learner derives error signals via set difference operations on the observed states. We distinguish between two types of prediction errors that drive the lattice search, see Figure 3 in Appendix A: • False Negatives (FNFN): These represent observed changes in the environment that the current hypothesis H failed to predict (i.e., St+1∖SpredictedS_t+1 S_predicted). These examples trigger the generalization of ⊤ by invoking the abductive engine to generate new metarule instantiations that entail the missing atoms, adding them to ⊤ and H. • False Positives (FPFP): These represent changes predicted by H that did not occur in reality (i.e., Spredicted∖St+1S_predicted S_t+1). When the model hallucinates an effect, the system identifies the specific clauses in H responsible for the hallucination and specialises ⊤ by pruning them. Explicitly constructing the set of all non-changes in a large environment is intractable. To mitigate it without intractable global checks, we employ an Inertia Assumption (Fikes and Nilsson, 1971): the state is assumed invariant unless a specific rule in H predicts a change. This reduces the verification step to checking only predicted effects (Spredicted∖St+1S_predicted S_t+1). 2.3 Complexity Analysis A defining characteristic of our framework is its scale invariance: the computational cost of hypothesis generation depends on the complexity of the underlying logic maxD_max rather than on the size of the state space. By operating on lifted predicates with intensional background knowledge, our system evaluates rules such as adjacent/3adjacent/3 via procedural attachment rather than by scanning a state matrix that grows exponentially with grid size. While the search space for logic programs is theoretically infinite, our approach bounds the search through three structural constraints: Fixed Metarules, a Strong Type System, and Canonicalization. The worst-case complexity of expanding the hypothesis space for a single generalization step can be stated as: O(|ℳ|⋅|typed|k⋅Dmax)O(|M|·|P_typed|^k· D_max) (2) Here, |ℳ||M| is the finite set of second-order metarules. |typed||P_typed| is the effective branching factor, constrained by the type system. k is the arity of the metarules (typically k=2k=2). Our algorithm employs Top Program Construction with memorization, which effectively converts the search from a Tree Traversal into a Directed Acyclic Graph Construction. We maintain a Global Predicate Registry (Ω ) of all discovered predicate signatures. When the abductive engine generates a new rule body (e.g., P←Q,RP← Q,R), it computes a canonical hash of the body literals. If a semantically equivalent predicate already exists in Ω , the system reuses it rather than inventing a duplicate. We cache the results of abductive queries. If the system encounters a subgoal that has already been solved within the current ”budget” of depth, it retrieves the solution in O(1)O(1) time. By collapsing redundant branches and preventing the re-derivation of known concepts, the total work becomes the sum of the work required to construct each layer of the hierarchy, rather than the product. 3 Experiments We evaluate our framework against three core desiderata for concept learning: the ability to perform continuous model repair; sample efficiency relative to neural baselines; and the robustness of the learned abstractions across varying domain sizes and semantic alignment. 0202040406060808010010005050100100150150TimestepNumber of ClausesModel Size EvolutionConstraintsDynamicsAbstractions 010010020020030030040040050050000.50.511First success ep. 2ep. 128EpisodeReward (20-ep moving avg)Learning CurvesPPOOurs Figure 2: Our system vs PPO on the 10×10 grid version of the MiniHack ‘Lava Crossing’ task. (a) Our system converges to 43 clauses (28 abstractions, 13 dynamics, 2 constraints) by step 23. (b) Our system reaches the goal at episode 2 since then it is able to consistently navigate the environment to it relying on it learn model; PPO requires 129 episodes for first success and it is not until episode 300 that it starts to converge. 3.1 Online Model Repair and Convergence To validate the Predict-Verify-Refine cycle, we track the evolution of the symbolic hypothesis H during a single run in the MiniHack environment. Figure 2 visualizes the internal model evolution. We monitor Model Size |Dyn∪Cons∪Abs||Dyn∪ Cons∪ Abs|. Spikes in model size correspond to generalization events, where unexpected observations FNFN trigger the invention of new candidate rules. Subsequent sharp drops correspond to specialization, where the agent prunes rules that lead to FPFP. By time step 20, the model stabilizes into a set of plausible rules that have not been disproven. Prediction error drops to zero, demonstrating that the system successfully disentangles valid causal mechanisms from transient noise. 3.2 Sample Efficiency and Scale Invariance We compare the sample efficiency of our Online MIL agent with that of a standard PPO baseline initialized with pre-trained CNN weights. As shown in Figure 2, the symbolic agent solves the environment in Episode 2 (one-shot learning after a single failure), whereas PPO requires approx. 128 episodes. Although a logic-based learner is expected to outperform a gradient-based learner on grid worlds, this result highlights the representational efficiency of lifted concepts. Unlike neural weights, which approximate the state manifold, our agent immediately lifts observations into a relational space. Consequently, the ”danger” concept learned on a 10×1010× 10 grid is structurally identical to one on a 100×100100× 100 grid. We confirmed that the model learned in the small environment generalizes zero-shot to the larger grid, demonstrating that the learned concepts are invariant to the state-space scale. 3.3 Semantic alignment and Interpretability A key advantage of our approach over neural world models is the immediate interpretability of the latent space. The system invents predicates (pnp_n) to compress the state space. Figure 1 illustrates the semantic alignment between the automatically invented predicates and human concepts for the ’Lava Crossing’ task. The predicate p2p_2, for example, is reused to define the death and movement transition rules, demonstrating that the system creates hierarchical abstractions rather than flat correlations. 4 Related Work Symbolic and Neurosymbolic World Models. Learning symbolic dynamics is traditionally framed as batch constraint satisfaction. While the Apperception Engine (Evans et al., 2021b) offers robust unification, however it is framed as a constraint satisfaction problem, which makes it computationally prohibitive for real-time agents in big environments. Neurosymbolic alternatives (Athalye et al., 2025; Silver et al., 2021; 2023; Piriyakulkij et al., 2025) improve speed but often rely on expensive pre-trained LLMs, which poses a challenge for systems that work offline or are limited on compute. Our framework bridges this gap by framing the problem as local, iterative refinement, updating beliefs only when immediate predictions are falsified. Our work system exclusively relies on pure logic programming rather than gradient-based search. This ensures the automated acquisition of the transition model results in a transparent, verifiable First-Order Logic theory at every step. Non-Monotonic Learning. Modern Inductive learners such as FastLAS (Law et al., 2020) and Popper (Cropper and Morel, 2021; Cropper et al., 2020) typically operate in a batch setting, requiring full traces or labelled examples. We extend the Lousie Patsantzis and Muggleton (2021) system by enabling incremental repair of transition rules during exploration via a self-supervision framework and by maintaining a persistent predicate registry, we enable the incremental repair of transition rules during exploration. Recently, PyGol (Varghese et al., 2025) outperformed Deep RL in sample efficiency, taking a similar approach to ours. However, they focused on learning policies and are not able to perform predicate invention. Abstraction and Program Synthesis. Systems like DreamCoder (Ellis et al., 2021) compress solution spaces via offline “wake-sleep” cycles, creating a lag between observation and adaptation. In contrast, our system performs abstraction online. By inventing reusable predicates during the decision loop, we merge the wake and sleep phases, making hierarchical concepts immediately available for planning. 5 Conclusion This work introduces a novel online learning framework that leverages the representational power of invented predicates to generate compact, interpretable transition functions online. We show that this system is effective at learning models of classic RL environments. Additionally, we show that, when combined with an off-the-shelf planning algorithm, the agent efficiently solves the MiniHack lava environment, surpassing established RL benchmarks. These results suggest that this approach opens avenues for research into methods to address longstanding RL challenges in which agents must interact with diverse objects and reason about their behaviour. A promising research direction is to enforce active model refinement, in which the agent sets the rule body as a goal and tests whether the rule is valid. Other promising avenues of research include moving towards probabilistic logic and the use of neural predicates (Manhaeve et al., 2021; Evans et al., 2021a; Smet et al., 2025). This would allow a transition from hand-engineered domain encoding to a more autonomous learning framework in which primary predicates are also learnt. Combining this method with a neural policy could enable the agent to plan and react efficiently and robustly. References A. Athalye, N. Kumar, T. Silver, Y. Liang, J. Wang, T. Lozano-Pérez, and L. P. Kaelbling (2025) From Pixels to Predicates: Learning Symbolic World Models via Pretrained Vision-Language Models. arXiv. Note: arXiv:2501.00296 [cs] External Links: Link, Document Cited by: §4. A. Cropper, R. Evans, and M. Law (2020) Inductive general game playing. Machine Learning 109 (7), p. 1393–1434 (en). External Links: ISSN 1573-0565, Link, Document Cited by: §1, §4. A. Cropper and R. Morel (2021) Learning programs by learning from failures. Machine Learning 110 (4), p. 801–856 (en). External Links: ISSN 0885-6125, 1573-0565, Link, Document Cited by: §1, §4. A. Cropper and S. Tourret (2020) Logical reduction of metarules. Machine Learning 109 (7), p. 1323–1369 (en). External Links: ISSN 0885-6125, 1573-0565, Link, Document Cited by: §1. K. Ellis, C. Wong, M. Nye, M. Sablé-Meyer, L. Morales, L. Hewitt, L. Cary, A. Solar-Lezama, and J. B. Tenenbaum (2021) DreamCoder: bootstrapping inductive program synthesis with wake-sleep library learning. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, Virtual Canada, p. 835–850 (en). External Links: ISBN 978-1-4503-8391-2, Link, Document Cited by: §4. R. Evans, M. Bošnjak, L. Buesing, K. Ellis, D. Pfau, P. Kohli, and M. Sergot (2021a) Making sense of raw input. Artificial Intelligence 299, p. 103521. External Links: ISSN 0004-3702, Link, Document Cited by: §5. R. Evans, J. Hernández-Orallo, J. Welbl, P. Kohli, and M. Sergot (2021b) Making sense of sensory input. Artificial Intelligence 293, p. 103438. External Links: ISSN 0004-3702, Link, Document Cited by: §1, §4. R. E. Fikes and N. J. Nilsson (1971) Strips: A new approach to the application of theorem proving to problem solving. Artificial Intelligence 2 (3), p. 189–208. External Links: ISSN 0004-3702, Link, Document Cited by: §1, §2.2. M. Ghallab, D. Nau, and P. Traverso (2004) Automated Planning: Theory and Practice. Elsevier (en). Note: Google-Books-ID: uYnpze57MSgC External Links: ISBN 978-0-08-049051-9 Cited by: §1. M. Law, A. Russo, E. Bertino, K. Broda, and J. Lobo (2020) FastLAS: Scalable Inductive Logic Programming Incorporating Domain-Specific Optimisation Criteria. Proceedings of the AAAI Conference on Artificial Intelligence 34 (03), p. 2877–2885 (en). External Links: ISSN 2374-3468, Link, Document Cited by: §4. R. Manhaeve, S. Dumančić, A. Kimmig, T. Demeester, and L. De Raedt (2021) Neural probabilistic logic programming in DeepProbLog. Artificial Intelligence 298, p. 103504. External Links: ISSN 0004-3702, Link, Document Cited by: §5. T. M. Moerland, J. Broekens, A. Plaat, and C. M. Jonker (2022) Model-based Reinforcement Learning: A Survey. arXiv. Note: arXiv:2006.16712 [cs] External Links: Link, Document Cited by: §1. S. H. Muggleton, D. Lin, and A. Tamaddoni-Nezhad (2015) Meta-interpretive learning of higher-order dyadic datalog: predicate invention revisited. Machine Learning 100 (1), p. 49–73 (en). External Links: ISSN 0885-6125, 1573-0565, Link, Document Cited by: §1, §2.2. S. Patsantzis and S. H. Muggleton (2021) Top program construction and reduction for polynomial time Meta-Interpretive learning. Machine Learning 110 (4), p. 755–778 (en). External Links: ISSN 1573-0565, Link, Document Cited by: §A.2, §1, §2.2, §4. W. T. Piriyakulkij, Y. Liang, H. Tang, A. Weller, M. Kryven, and K. Ellis (2025) PoE-World: Compositional World Modeling with Products of Programmatic Experts. arXiv. Note: arXiv:2505.10819 [cs] External Links: Link, Document Cited by: §4. J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov (2017) Proximal Policy Optimization Algorithms. arXiv. Note: arXiv:1707.06347 External Links: Link Cited by: §1. T. Silver, A. Athalye, J. B. Tenenbaum, T. Lozano-Pérez, and L. P. Kaelbling (2023) Learning Neuro-Symbolic Skills for Bilevel Planning. In Proceedings of The 6th Conference on Robot Learning, p. 701–714 (en). External Links: ISSN 2640-3498, Link Cited by: §4. T. Silver, R. Chitnis, J. Tenenbaum, L. P. Kaelbling, and T. Lozano-Pérez (2021) Learning Symbolic Operators for Task and Motion Planning. In 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), p. 3182–3189. External Links: ISSN 2153-0866, Link, Document Cited by: §4. L. D. Smet, G. Venturato, L. D. Raedt, and G. Marra (2025) Relational Neurosymbolic Markov Models. Proceedings of the AAAI Conference on Artificial Intelligence 39 (15), p. 16181–16189 (en). External Links: ISSN 2374-3468, Link, Document Cited by: §1, §5. R. S. Sutton and A. G. Barto (2018) Reinforcement Learning: An Introduction. A Bradford Book, Cambridge, MA, USA. External Links: ISBN 978-0-262-03924-6 Cited by: §1, §1. D. Varghese, D. Cyrus, S. Patsantzis, J. Trewern, A. A. Treloar, A. Hunter, and A. Tamaddoni-Nezhad (2025) One-Shot Learning of Autonomous Behaviour: A Meta Inverse Entailment Approach. In Learning and Reasoning: 4th International Joint Conference on Learning and Reasoning, IJCLR 2024, and 33rd International Conference on Inductive Logic Programming, ILP 2024, Nanjing, China, September 20–22, 2024, Proceedings, Berlin, Heidelberg, p. 48–65. External Links: ISBN 978-3-032-09086-7, Link, Document Cited by: §4. Z. Yu, J. Ruan, and D. Xing (2023) Explainable Reinforcement Learning via a Causal World Model. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, Macau, SAR China, p. 4540–4548 (en). External Links: Link, Document Cited by: §1. H. Zhang and T. Yu (2020) AlphaZero. In Deep Reinforcement Learning: Fundamentals, Research and Applications, H. Dong, Z. Ding, and S. Zhang (Eds.), p. 391–415 (en). External Links: ISBN 978-981-15-4095-0, Link, Document Cited by: §1. Appendix A Theoretical Guarantees This section analyzes the completeness of the search procedure and compares the computational complexity of this lifted inference approach with that of propositional methods. A.1 Lattice-Based Refinement The classification metrics map directly to operators on the subset lattice, see 3: • Specialization (Handling FPFP): When the hypothesis is overly general (predicting events that do not occur), the system prunes the incorrect clauses from the Top Program. This reduces the entailment set, effectively moving down the lattice. • generalization (Handling FNFN): When the hypothesis is overly specific (failing to predict observed events), the system invokes the metarule engine to induce (add) new clauses. This expands the entailment set to cover the unexplained observations, effectively moving up the lattice. ∅ ⊥ (Specific)⊤ ⊤ (General)H (Hypothesis)Generalization(Abduction from E+E^+)Specialization(Pruning via E−E^-)⊤=C1,C2,C3,…,CnH=C1,C3⊂⊤⊥=∅ aligned &=\C_1,C_2,C_3,…,C_n\\\ H&=\C_1,C_3\⊂ \\ &= aligned Figure 3: Lattice traversal dynamics. Prediction errors trigger Generalization (moving to ⊤ ) or Specialization (pruning to H). The search for a hypothesis H corresponds to a traversal of the refinement graph defined by the metarules ℳM and background knowledge ℬB. We define the expressible hypothesis space ℋℳ,dH_M,d as the set of all logic programs derivable by composing metarules from ℳM up to a maximum derivation depth d. A.2 Completeness and Expressivity Proposition (Completeness): If there exists a target hypothesis H∗∈ℋℳ,dH^* _M,d that correctly entails the observed state transitions, the algorithm is guaranteed to find it. Proof: The proof follows the properties of Top Program Construction established in (Patsantzis and Muggleton, 2021), adapted to our depth-bounded search: 1. Completeness of generalization (Moving Up): The AbduceChain procedure exhaustively generates all metarule instantiations that entail the current observation O within depth d. If the target hypothesis H∗H^* exists in ℋℳ,dH_M,d, then every clause C∈H∗C∈ H^* is technically derivable. Consequently, during the generalization phase, all clauses constituting H∗H^* are added to the initial Top Program ⊤init _init. Thus, H∗⊆⊤initH^* _init. 2. Soundness of specialization (Moving Down): The refinement phase iterates through ⊤init _init and removes any clause C such that C∧ℬ⊧E−C E^-. By definition, the target hypothesis H∗H^* is consistent with the environment, meaning no clause in H∗H^* entails a negative example. Therefore, the pruning operator never removes a clause belonging to H∗H^*. 3. Convergence: Since H∗H^* is captured during generalization and preserved during Specialization, the final hypothesis ⊤final _final satisfies H∗⊆⊤finalH^* _final. Because H∗H^* entails the positive examples, ⊤final _final necessarily entails them as well. □ Appendix B Algorithms 1 Input : Stream of states S0,S1,…S_0,S_1,…, Metarules ℳM, Background Knowledge ℬB Output : Evolving Hypothesis H=⟨Abs,Dyn,Con⟩H= Abs,Dyn,Con 2 3H←⟨∅,∅,∅⟩H← , , ; 4 Context←S0Context← S_0; 5 6for t←1t← 1 to ∞ do 7 Receive StS_t; // Derive Examples via Set Difference E+←St∖St−1E^+← S_t S_t-1 ; // Observed Additions E−←St−1∖StE^-← S_t-1 S_t ; // Observed Removals 8 // Phase 1: Predict (using compiled H) 9 Padd←Predict(H,Context)P_add (H,Context); 10 Prem←DeriveRemovals(Padd,H)P_rem (P_add,H); 11 // Phase 2: Verify and Calculate Error 12 FPadd←Padd∖E+FP_add← P_add E^+; 13 FNadd←E+∖PaddFN_add← E^+ P_add; 14 FPrem←Prem∖E−FP_rem← P_rem E^-; 15 FNrem←E−∖PremFN_rem← E^- P_rem; 16 // Phase 3: Refine 17 if FPadd≠∅FP_add≠ then 18 Dyn←Prune(Dyn,FPadd)Dyn (Dyn,FP_add); 19 20 21 if FPrem≠∅FP_rem≠ then 22 Con←Prune(Con,FPrem)Con (Con,FP_rem); 23 24 25 if FNadd≠∅FN_add≠ then 26 ⟨ΔDyn,ΔAbs⟩←MetaruleInduction(FNadd,Context,ℳ,ℬ) Dyn, Abs (FN_add,Context,M,B); 27 Dyn←Dyn∪ΔDynDyn← Dyn∪ Dyn; Abs←Abs∪ΔAbsAbs← Abs∪ Abs; 28 29 if FNrem≠∅FN_rem≠ then 30 ⟨ΔCon,ΔAbs′⟩←MetaruleInduction(FNrem,Context,ℳ,ℬ) Con, Abs (FN_rem,Context,M,B); 31 Con←Con∪ΔConCon← Con∪ Con; Abs←Abs∪ΔAbs′Abs← Abs∪ Abs ; 32 33 // Maintenance 34 H←CompressAndGC(H)H (H); 35 Context←StContext← S_t; 36 Algorithm 2 Self-Supervised Online MIL Loop