Satisfiability Modulo Theory Meets Inductive Logic Programming

Reading time: 6 minute
...

📝 Original Info

  • Title: Satisfiability Modulo Theory Meets Inductive Logic Programming
  • ArXiv ID: 2512.12918
  • Date: 2025-12-15
  • Authors: ** Nijesh Upreti, Vaishak Belle (The University of Edinburgh) **

📝 Abstract

Inductive Logic Programming (ILP) provides interpretable rule learning in relational domains, yet remains limited in its ability to induce and reason with numerical constraints. Classical ILP systems operate over discrete predicates and typically rely on discretisation or hand-crafted numerical predicates, making it difficult to infer thresholds or arithmetic relations that must hold jointly across examples. Recent work has begun to address these limitations through tighter integrations of ILP with Satisfiability Modulo Theories (SMT) or specialised numerical inference mechanisms. In this paper we investigate a modular alternative that couples the ILP system PyGol with the SMT solver Z3. Candidate clauses proposed by PyGol are interpreted as quantifier-free formulas over background theories such as linear or nonlinear real arithmetic, allowing numerical parameters to be instantiated and verified by the SMT solver while preserving ILP's declarative relational bias. This supports the induction of hybrid rules that combine symbolic predicates with learned numerical constraints, including thresholds, intervals, and multi-literal arithmetic relations. We formalise this SMT-ILP setting and evaluate it on a suite of synthetic datasets designed to probe linear, relational, nonlinear, and multi-hop reasoning. The results illustrate how a modular SMT-ILP architecture can extend the expressivity of symbolic rule learning, complementing prior numerical ILP approaches while providing a flexible basis for future extensions toward richer theory-aware induction.

💡 Deep Analysis

Deep Dive into Satisfiability Modulo Theory Meets Inductive Logic Programming.

Inductive Logic Programming (ILP) provides interpretable rule learning in relational domains, yet remains limited in its ability to induce and reason with numerical constraints. Classical ILP systems operate over discrete predicates and typically rely on discretisation or hand-crafted numerical predicates, making it difficult to infer thresholds or arithmetic relations that must hold jointly across examples. Recent work has begun to address these limitations through tighter integrations of ILP with Satisfiability Modulo Theories (SMT) or specialised numerical inference mechanisms. In this paper we investigate a modular alternative that couples the ILP system PyGol with the SMT solver Z3. Candidate clauses proposed by PyGol are interpreted as quantifier-free formulas over background theories such as linear or nonlinear real arithmetic, allowing numerical parameters to be instantiated and verified by the SMT solver while preserving ILP’s declarative relational bias. This supports the ind

📄 Full Content

Satisfiability Modulo Theory Meets Inductive Logic Programming Nijesh Upreti, Vaishak Belle The University of Edinburgh, 10 Crichton Street, Edinburgh EH8 9AB, UK Abstract. Inductive Logic Programming (ILP) provides interpretable rule learning in relational domains, yet remains limited in its ability to induce and reason with numerical constraints. Classical ILP systems operate over discrete predicates and typically rely on discretisation or hand-crafted numerical predicates, making it difficult to infer thresholds or arithmetic relations that must hold jointly across examples. Recent work has begun to address these limitations through tighter integra- tions of ILP with Satisfiability Modulo Theories (SMT) or specialised numerical inference mechanisms. In this paper we investigate a modular alternative that couples the ILP system PyGol with the SMT solver Z3. Candidate clauses proposed by PyGol are interpreted as quantifier-free formulas over background theories such as linear or nonlinear real arith- metic, allowing numerical parameters to be instantiated and verified by the SMT solver while preserving ILP’s declarative relational bias. This supports the induction of hybrid rules that combine symbolic predicates with learned numerical constraints, including thresholds, intervals, and multi-literal arithmetic relations. We formalise this SMT–ILP setting and evaluate it on a suite of synthetic datasets designed to probe linear, rela- tional, nonlinear, and multi-hop reasoning. The results illustrate how a modular SMT–ILP architecture can extend the expressivity of symbolic rule learning, complementing prior numerical ILP approaches while pro- viding a flexible basis for future extensions toward richer theory-aware induction. Keywords: Inductive Logic Programming (ILP), Satisfiability Modulo Theo- ries (SMT), Hybrid Reasoning, Declarative Programming, Continuous and Dis- crete Variables, Constraint Logic Programming 1 Introduction Inductive Logic Programming (ILP) provides an expressive and interpretable framework for learning symbolic rules from relational data [30,10]. By repre- senting hypotheses in first-order logic, ILP supports strong generalisation from limited supervision and allows background knowledge to be integrated declara- tively into the learning process [33,15,42]. These properties make ILP attractive for domains where relational structure, semantic transparency, and explainabil- ity are essential. arXiv:2512.12918v1 [cs.AI] 15 Dec 2025 2 N. Upreti and V. Belle Classical ILP systems based on inverse entailment [31] and bottom-clause– guided refinement [10] have been highly successful in symbolic domains. However, many real-world problems involve hybrid relational–numerical structures, where relational dependencies interact with numerical quantities, thresholds, and ge- ometric or physical constraints—settings that classical ILP systems struggle to model [39,28]. Extending ILP to such hybrid symbolic–numerical settings has proved challenging. Traditional approaches rely on discretisation, handcrafted numerical predicates, or domain-specific encodings [26,24], which often weaken declarative semantics and generalise poorly [29]. Early systems such as Aleph explore limited forms of numerical reasoning (e.g. lazy evaluation), and more re- cent systems such as NumLog [12] introduce interval-valued predicates to avoid premature threshold selection. These efforts highlight the importance of numer- ical reasoning in ILP but remain restricted in the scope of arithmetic relations they can express. A complementary direction integrates ILP with Satisfiability Modulo The- ories (SMT). SMT solvers extend the satisfiability problem (SAT) with back- ground theories such as linear and nonlinear arithmetic, difference logic, and ar- rays [3,13,16], enabling principled reasoning over continuous quantities. Recent work such as NUMSYNTH [18] demonstrates that SMT can be used to infer numerical constants and arithmetic relationships when combined with ILP-style structural search. These developments illustrate the promise of hybrid symbolic– numerical learning, but they also raise foundational questions regarding how ILP clauses should interface with theory solvers, how feedback from SMT should guide hypothesis refinement, and how to balance numerical expressivity with interpretability. In this paper, we investigate these questions through a modular SMT–ILP ar- chitecture that pairs PyGol [42] with Z3 [13]. Rather than tightly integrating the two components, we adopt a loosely coupled design: PyGol proposes candidate rule structures, and Z3 instantiates and verifies their numerical components. This preserves ILP’s declarative workflow while allowing numerical reasoning to be handled entirely by the external solver. The modularity of the approach makes it possible to inspect, modify, or replace each component independently and to explore how different forms of symbolic–numerical interaction affect learning behaviour

…(Full text truncated)…

📸 Image Gallery

cover.png page_2.webp page_3.webp

Reference

This content is AI-processed based on ArXiv data.

Start searching

Enter keywords to search articles

↑↓
ESC
⌘K Shortcut