Paper deep dive
Rule-Based Languages for Neurosymbolic AI
Stefania Dumbrava, Efthymia Tsamoura
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 10/7/2026, 9:07:21 AM
Summary
This paper surveys rule-based languages used as the symbolic component in neurosymbolic AI systems. It analyzes Datalog, Answer Set Programming (ASP), and probabilistic logic programs across four axes: semantics, expressiveness, neural integration, and evaluation mechanisms. The authors review over 50 systems, comparing their usage in databases, machine learning, vision, and robotics, and provide a decision matrix for selecting formalisms based on application requirements.
Entities (10)
Relation Signals (9)
Datalog → usedin → Neurosymbolic AI
confidence 98% · Logic programming is increasingly used as the symbolic component of neurosymbolic AI systems. We survey the main rule-based languages in this setting, namely Datalog...
Answer Set Programming → usedin → Neurosymbolic AI
confidence 97% · We survey the main rule-based languages in this setting, namely Datalog, answer set, and probabilistic logic programs...
Probabilistic Logic Programming → usedin → Neurosymbolic AI
confidence 96% · We survey the main rule-based languages in this setting, namely Datalog, answer set, and probabilistic logic programs...
DeepProbLog → implements → Probabilistic Logic Programming
confidence 95% · DeepProbLog [50] extends this with neural predicates... DeepProbLog is the canonical example.
Scallop → implements → Differentiable Provenance Semirings
confidence 94% · Scallop [28, 43] achieves this with a differentiable provenance semiring...
NeurASP → implements → Answer Set Programming
confidence 94% · Stable model semantics [21] underlies ASP and enables non-monotonic reasoning, as exploited by... NeurASP [95].
Logic Tensor Networks → implements → Fuzzy Semantics
confidence 93% · Logic Tensor Networks [2]... evaluate programs over fuzzy interpretations rather than distributions over worlds.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Logic programming is increasingly used as the symbolic component of neurosymbolic AI systems. We survey the main rule-based languages in this setting, namely Datalog, answer set, and probabilistic logic programs, along four axes: semantics, expressiveness, neural integration, and evaluation mechanism. We analyse over 50 recent systems and applications, comparing formalism usage across four research areas: databases and programming languages, machine learning, vision, and robotics. We provide a decision matrix mapping application scenarios to required features and close by outlining open problems.
Tags
Links
- Source: https://arxiv.org/abs/2610.07313v1
- Canonical: https://arxiv.org/abs/2610.07313v1
Trouble viewing inline? Open PDF directly →
Full Text
62,995 characters extracted from source content.
Expand or collapse full text
Rule-Based Languages for Neurosymbolic AI Stefania Dumbrava Affiliation: ENSIIE, SAMOVAR, Télécom SudParis, Inria, IRIF, France E-mail stefania.dumbrava@ensiie.fr Efthymia Tsamoura Affiliation: Huawei Labs, United Kingdom E-mail efthymia.tsamoura@huawei.com Abstract Logic programming is increasingly used as the symbolic component of neurosymbolic AI systems. We survey the main rule-based languages in this setting, namely Datalog, answer set, and probabilistic logic programs, along four axes: semantics, expressiveness, neural integration, and evaluation mechanism. We analyse over 50 recent systems and applications, comparing formalism usage across four research areas: databases and programming languages, machine learning, vision, and robotics. We provide a decision matrix mapping application scenarios to required features and close by outlining open problems. Keywords: Datalog Answer Set Programming Probabilistic Logic Programming Neurosymbolic AI Provenance Semirings. 1 Introduction Recent progress in deep learning and large language models (LLMs) has driven what Kautz [35] calls the “third AI summer”. LLMs, however, remain logically inconsistent, rely on shortcut features rather than robust generalisation [97], and offer no formal guarantees. Neurosymbolic (NeSy) AI addresses these weaknesses by coupling neural learning with symbolic reasoning [54, 76]. For the symbolic component, logic programming is a well-suited candidate. Beyond recursion and relational structure, it brings an evaluation theory with least-fixpoint semantics whose Datalog core has polynomial-time data complexity [1, 6, 38]. We focus on systems that reason over an explicit rule layer, namely Datalog and its extensions, answer set programs (ASP), Prolog-style (probabilistic) logic programs, and the inductive logic-programming (ILP) methods that learn such rules. Purely sub-symbolic models, including graph neural networks, are outside the scope of this work. Our survey is structured around two aspects of the rule layer. We identify the language features a task requires, such as recursion, negation, aggregation, probabilistic semantics, or soft unification, together with the evaluation mechanism that makes their combination tractable. State-of-the-art systems extend the base language along orthogonal directions. Provenance semirings parameterise evaluation, enabling probabilistic and differentiable semantics [24, 28, 36], while soft unification replaces symbolic matching with similarity over learned embeddings [46, 68]. Other extensions add temporal operators [29] or expose foundation models as relations [42]. Each extension involves different trade-offs, which we align with application needs. Contributions. We make the following contributions: • A taxonomy of rule-based languages used in neurosymbolic AI (§3); • An analysis of recent formalism usage across four research communities, based on over 50 neurosymbolic systems and applications, most from the past six years (§4); • A decision matrix mapping application scenarios to required features (§5); • A roadmap of open problems (§6). 2 Logic-Based Languages and Their Semantics Classical Datalog. Datalog is a function-free language of definite Horn clauses evaluated under least-fixpoint semantics [1, 6]. A program is a finite set of rules h←b1,…,bnh← b_1,…,b_n over a finite relational schema and database facts are rules with empty bodies. Bottom-up evaluation iteratively applies the immediate consequence operator TPT_P up to a fixpoint, TP(I)=hσ|(h←b1,…,bn)∈P,biσ∈I for all i,MP=lfp(TP),T_P(I)= \\,hσ |(h← b_1,…,b_n)∈ P,\;b_iσ∈ I for all i\, \, M_P=lfp(T_P), (1) where σ ranges over substitutions grounding all variables of the rule. Since TPT_P is monotone over the powerset of the finite Herbrand base, its least fixpoint exists by the Knaster–Tarski theorem and the bottom-up iteration reaches it in finitely many steps. The safety condition requires every head variable to occur in a positive body atom, so each rule application produces ground facts. Modern engines (e.g., Nemo [32], Soufflé [34], RDFox [61]) scale this to billions of facts [38]. Datalog with negation. Negation in rule bodies is interpreted as negation as failure (NAF): ¬p p holds when p cannot be derived. NAF makes the TPT_P operator non-monotone in general, so a least model need not exist. Stratified negation partitions rules so that negated predicates are defined in strictly lower strata, producing a canonical minimal model, the perfect model, that is independent of the chosen stratification [1]. The well-founded semantics [20] assigns true/false/unknown to every ground atom, handling non-stratifiable programs. Stable model semantics [21] underlies ASP and enables non-monotonic reasoning, as exploited by dPASP [19], SLASH [75], and NeurASP [95]. NAF thus checks derivability, whereas classical negation simply flips the truth value of p, as in the fuzzy dialects below. Aggregation. Neurosymbolic tasks often summarise derived relations, e.g., counting objects in a scene or aggregating probabilistic outputs, which requires operators such as count, sum, and min/max [69]. The challenge is their interaction with recursion. Restricting to aggregates monotone under a suitable order on their values preserves least-fixpoint evaluation. Probabilistic logic programming. Further extensions attach probabilities to facts or rules. ProbLog [67] instantiates the distribution semantics of Sato [71]. Each probabilistic fact f in a finite set F is an independent Bernoulli choice with probability pfp_f, and each total choice ω⊆Fω F determines a possible world, the least model of ω together with the rules P of the program. The probability of a query q sums the weights of the worlds that entail it, Pr(q)=∑ω⊆FP∪ω⊧q∏f∈ωpf∏f∈F∖ω(1−pf), (q)\;=\; _ subarraycω F\\ P\,∪\,ω\, \,q subarray\; _f∈ωp_f _f∈ F ω (1-p_f ), (2) and is computed in practice by weighted model counting (WMC) over a propositional encoding of the program [15]. DeepProbLog [50] extends this with neural predicates, implemented as neural annotated disjunctions whose probabilities are the output distribution of a network trained end-to-end through the WMC objective. Generative Datalog [3] adds sampling from discrete distributions, defining a distribution over instances that is independent of execution order. Provenance semirings: a unifying algebra. Green, Karvounarakis, and Tannen [24] showed that the evaluation of positive relational algebra can be parameterised by any commutative semiring (K,⊕,⊗,0,1)(K, , ,0,1), and that the construction extends to recursive Datalog when K is ω-continuous. An output tuple’s annotation is a sum over its derivation trees, where each tree contributes the product of the annotations of the input facts at its leaves, counted with multiplicity: ann(t)=⨁τ∈Trees(t)⨂ℓ∈leaves(τ)ann(ℓ),ann(t)\;=\; _τ (t)\; _ (τ)ann( ), (3) where leaves(τ)leaves(τ) denotes the multiset of leaf occurrences in τ. For recursive programs the set Trees(t)Trees(t) may be infinite, so ω-continuity ensures that the sum in Eq. 3 is well-defined, with convergence over general (pre-)semirings characterised in [36]. Instantiating K with the Boolean semiring recovers set semantics, and with ℕN bag semantics [24, 36]. Possible-world probabilities, by contrast, do not arise from a direct semiring homomorphism (derivations may share facts, breaking independence), but from weighted model counting over the Boolean provenance polynomial [24, 15]. This algebra is the foundation on which the differentiable engines below parameterise their evaluation. Differentiable evaluation. To enable end-to-end learning, gradients must flow from a symbolic loss back to network parameters. Scallop [28, 43] achieves this with a differentiable provenance semiring, computing annotations in the forward pass and propagating gradients in the backward pass. Exact WMC is intractable, so in practice it runs approximate semirings (§3.4). Soft unification. Classical unification matches two constants if and only if they are the same symbol, whereas in knowledge graphs and text distinct symbols can denote the same entity [22]. The Neural Theorem Prover [68] relaxes symbolic matching to a differentiable similarity over learned embeddings, used as a proof score. DeepSoftLog [46] gives soft unification a probabilistic semantics, Pr(a≈b)=exp(−d(ea,eb)), (a≈ b)\;=\; (-d(e_a,e_b) ), (4) where eae_a and ebe_b are the learned embeddings of a and b and d is a metric on the embedding space, so the value lies in (0,1](0,1] and Pr(a≈a)=1 (a≈ a)=1. Treating these pairwise probabilities as independent facts, however, admits worlds in which ≈ is not transitive. The equivalence semantics of Maene and Tsamoura [47] repairs this by placing a distribution over equivalence relations instead. Fuzzy and t-norm semantics. Fuzzy dialects assign truth values in [0,1][0,1] and compose them with a t-norm T for conjunction (e.g., the product t-norm T(x,y)=xyT(x,y)=xy or the Gödel t-norm min(x,y) (x,y)) and a t-conorm for disjunction. Logic Tensor Networks [2], Logical Neural Networks (LNNs) [72], and Lifted Relational Neural Networks [78] evaluate programs over fuzzy interpretations rather than distributions over worlds. LNNs additionally track lower and upper bounds on each truth value, but no dialect in this family defines a probability distribution over possible worlds, so degrees of truth and belief are conflated. The choice also affects trainability. The probabilistic (WMC) objective is multilinear in the per-atom marginals and depends only on the models of the constraint, not on its syntactic form. T-norm relaxations are instead syntax-sensitive, as logically equivalent formulas can induce different losses, and several operator families suffer from vanishing or single-argument gradients [85]. Semantic loss [92] was introduced to restore syntax independence by computing the constraint probability exactly. 3 A Taxonomy of Rule-Based Neurosymbolic Languages We categorise rule-based neurosymbolic languages along four axes (Fig. 1). The axes make explicit the choices involved in selecting a dialect for a given task. Rule-based NeSy languages Semantics Expressiveness Neural integration Evaluation Boolean / probabilistic [24, 50, 67] Differentiable [28, 43, 57] Stable-model [75, 95] Fuzzy [2, 64, 72] Embedding [46, 47] Recursion [1, 3, 38] Negation [1, 20, 21] Disjunction [11, 21] Aggregation [43, 69] Temporal [23, 29] Neural predicates [43, 50, 95] Foreign-function interfaces [42] Soft unification [46, 68] Specification alignment [29, 92] Architectural compilation [4, 10] Exact WMC via knowledge compilation [15, 50] Approximate provenance semirings [24, 28, 36] Algebraic circuits [10, 75] GPU acceleration [4, 44, 57] Sampling [3, 86, 45] Figure 1: The four-axis taxonomy of rule-based neurosymbolic languages. 3.1 Axis 1: Semantics The first axis concerns how truth values, probabilities, or belief degrees are assigned and propagated (Table 1). Boolean-probabilistic dialects evaluate under possible-world semantics with WMC (Eq. 2). DeepProbLog is the canonical example.11 1 ProbLog programs admit function symbols. We place DeepProbLog in Fig. 2a by the semantics of its function-free core, whose distribution semantics requires each total choice to induce a two-valued well-founded model. Scallop recovers the same semantics as one instantiation of its provenance framework, although in practice it runs approximate configurations. The limitation is scalability (§3.4). Differentiable-probabilistic dialects relax exactness for gradient flow, and Scallop’s top-k semiring is the standard choice. Stable-model dialects (NeurASP, SLASH, dPASP) place the distribution over answer sets rather than over least models, importing the non-monotonic reasoning of ASP into the neural pipeline at a higher inference cost. Soft-unification dialects replace symbolic identity with embedding similarity (Eq. 4), interpreted under probabilistic (DeepSoftLog) or equivalence semantics. Fuzzy/t-norm dialects operate on a single [0,1][0,1] interpretation (LTN, LNN). Algebraic-circuit dialects, notably DeepLog [10, 49], make the algebraic structure itself a parameter. By instantiating the algebra appropriately, DeepLog’s compiled circuits emulate DeepProbLog, LTN, or NeurASP. This generality is achieved at the circuit level rather than at the language level, so DeepLog serves as a compilation target rather than as a source language. Table 1: Axis 1: semantic foundation of rule-based neurosymbolic dialects. Category Semantics Representative system(s) Boolean-probabilistic possible-world distribution (WMC) DeepProbLog, Scallop Differentiable-prob. approx. WMC / fuzzy provenance Scallop, DOLPHIN Stable-model (ASP) distribution over answer sets NeurASP, SLASH, dPASP Soft-unif./embedding probabilistic embedding equality DeepSoftLog Fuzzy / t-norm [0,1][0,1] degrees, no world distribution LTN, LNN, NeuPSL Algebraic-circuit algebra as circuit parameter DeepLog 3.2 Axis 2: Expressiveness The second axis concerns which syntactic features a dialect supports, since these determine the reasoning patterns it can express. Figure 2 captures the main dialects, while Table 2 classifies formalism families and their features. The Venn diagram (Fig. 2a) illustrates the inclusions among these dialects, so a task can be placed in the innermost ring that supports it. Negation moves a task from the positive to the stratified ring, recursion through negation to the well-founded one, non-monotonicity to the stable one, and head disjunction to the outermost ring. The inner inclusions are syntactic, whereas the well-founded and stable rings distinguish alternative semantics for normal programs, which coincide on stratified ones [20, 21]. The probabilistic semantics attached to each ring (top-k, possible worlds, weighted stable models) are not themselves ordered, so a system can inherit a sublanguage’s expressiveness without inheriting a comparable inference cost. Fig. 2b collects families outside any such inclusion order. Fuzzy logic and Markov logic share only a weighted first-order basis. Propositional SAT, though expressively weaker, is kept separate, as its differentiable solver forms a distinct computational paradigm rather than a sublanguage. Positive Datalog is expressive enough for digit recognition and simple planning in the original Scallop prototype [28] but cannot encode an interpreter for CLEVR’s functional query language [33, 43]. Stratified negation and aggregation lift this limitation [43]. Foreign-function interfaces (FFI) let programs invoke external computations, including foundation-model calls, as relational predicates [42]. Such calls are non-deterministic and potentially stateful, which the Vieira system controls by treating models as stateless relations (§3.3). Temporal extensions add operators over time: LASER’s spatio-temporal specification language (STSL) [29] builds on finite-trace linear temporal logic (LTLf) [23]. Recursive probabilistic programs, formalised in Generative Datalog [3], subsume both deterministic recursion and probabilistic generation, the most expressive combination on the probabilistic side of the hierarchy. Differentiable rule learning (ILP) lies outside this hierarchy: ∂ [12], α [73], and DiffLog [74] learn Boolean rules via a [0,1][0,1] relaxation used only during training. DisjunctiveDatalogDatalog withStable NegationNeurASP, SLASH, dPASPWell-foundedDatalogDeepProbLogStratifiedDatalogScallop, Lobster, DOLPHINDatalogTensorLog (chain-rule)Scallop v0 (a) Datalog-based dialects for NeSy. Non-Datalog formalismsWeighted FOLFuzzy FOLLTN, LNN, NeuPSLMarkov logicpLogicNet, ExpressGNNFunctional DSLNS-CL, LEFTTemporal(LTL/STL)LASERPropositional SATSATNet (b) Other formalisms for NeSy. Figure 2: Rule-based languages for neurosymbolic (NeSy) AI. Table 2: Axis 2: formalism families and the features they support (above the rule: the Datalog/ASP hierarchy of Fig. 2a; below it: formalisms outside it, Fig. 2b). Family Systems Rec. Neg. Agg. Uncert. Datalog (positive) Scallop v0 ✓ – – top-k Datalog (chain-rule) TensorLog, NeuralLP, DRUM bnd – partial soft Datalog (neg+agg) Scallop, Lobster, DOLPHIN ✓ strat. ✓ semiring ProbLog (+neural) DeepProbLog ✓ NAF – worlds Prolog (SDCG/soft) DeepStochLog, DeepSoftLog ✓ – – der./worlds ASP (prob./circuits) NeurASP, SLASH, dPASP ✓ n.m. ✓ multiple ILP (differentiable) ∂ , α , DiffLog bnd – – relax. Fuzzy FOL LTN, LNN, NeuPSL – class. – [0,1][0,1] Markov logic pLogicNet, ExpressGNN – – – MLN Functional DSL NS-CL, LEFT – partial partial soft Temporal (LTL/STL) LASER n.a. n.a. n.a. quant. Propositional SAT SATNet – – – relax. bnd = bounded; strat. = stratified; n.m. = non-monotonic; class. = classical; der. = derivations; quant. = quantitative satisfaction; relax. = continuous relaxation; MLN = Markov-logic weights; SDCG = stochastic definite clause grammars. 3.3 Axis 3: Neural Integration The third axis describes how the rule layer interfaces with neural components. Neural predicates inject a network’s output distribution as probabilistic facts, and the network is trained end-to-end by differentiating through evaluation [43, 50]. Foreign-function interfaces instead treat foundation models as stateless relational functions, invoked with zero or few in-context examples and never fine-tuned [42]. Soft unification modifies the inference mechanism itself, associating each constant with a learned embedding [46, 68]. Abduction runs the interface in the reverse direction (Fig. 3). From a target output, the symbolic component abduces the proofs, i.e., the combinations of hidden labels that entail the target. Compiling these proofs into a differentiable function, e.g., a WMC circuit, a top-k provenance semiring, or a fuzzy relaxation, produces the loss that trains the network. NeuroLog constructs this coupling compositionally [83], and Wang et al. [87] characterise the weak-supervision settings under which such learning is possible. Specification alignment uses the program as a supervision signal. In LASER, an LLM extracts temporal specifications and a differentiable checker scores predicted scene graphs against them [29]. Finally, architecture-level integration compiles programs to low-level execution targets. Lobster [4] emits GPU kernels (§3.4), while DeepLog [10] compiles to algebraic circuits. Target output y→ y (e.g. sum =2=2) Symbolic proofs entailing y→ y under P Differentiable function WMC, top-k, fuzzy relaxation Neural component gradient update of N abducecompileloss, ∇ Figure 3: Abduction-based neural integration [83, 87]. Proofs of the target are abduced from the program and compiled into a differentiable training loss. Beyond the explicit rule layer. The integration mechanisms discussed so far expose an inspectable Datalog/ASP rule layer. A large, complementary family instead pairs the network with a lifted graphical model or a fuzzy loss, a composite design surveyed by Feldstein et al. [14]. In these systems, the symbolic side regularises training rather than carrying the reasoning itself. Two schemes recur (Fig. 4(a)). Parallel supervision penalises the divergence between the distributions P,PℒP_N,P_L induced by the neural and logical components N and ℒL, which presupposes a logical theory blended with an uncertainty formalism such as probability theory or fuzzy sets. Stratified supervision, by contrast, treats the predictions of the neural component as atoms and adds a satisfiability term over them. Semantic loss [92] instantiates this scheme and collapses to standard weighted model counting once the constraint is compiled rather than approximated. The composite architectures of Fig. 4(b) (Teacher–Student, Deep Probabilistic Logic, Concordia) build on Markov logic or probabilistic soft logic (PSL), the weighted-FOL region of Fig. 2b, and thus provide no auditable rule layer. Teacher–Student and DPL use ℒL only during training and return y^→ y_N, whereas Concordia retains ℒL at inference, using a learned gate G to return a mixture y^→C y_C. x→ [rgb]0.1172,0.1602,0.2305 xℒ [rgb]0.1445,0.3867,0.9219L [rgb]0.8516,0.4648,0.0234Ny^→ [rgb]0.0859,0.6406,0.2891 y+ [rgb]0.0859,0.6406,0.2891+P [rgb]0.8516,0.4648,0.0234P_NPℒ [rgb]0.1445,0.3867,0.9219P_Lx→ [rgb]0.1172,0.1602,0.2305 xℒ [rgb]0.1445,0.3867,0.9219L [rgb]0.8516,0.4648,0.0234Ny^→ [rgb]0.8516,0.4648,0.0234 y (a) Parallel (left) and stratified (right) architectures. In the parallel scheme, the divergence between P_N and PℒP_L regularises the network and y^→ y composes both predictions. In the stratified scheme, a satisfiability term over the neural predictions penalises violations, the construction behind the semantic loss [92]. x→ [rgb]0.1172,0.1602,0.2305 xP [rgb]0.8516,0.4648,0.0234P_NPℒ [rgb]0.1445,0.3867,0.9219P_Lℒ [rgb]0.1445,0.3867,0.9219L [rgb]0.8516,0.4648,0.0234Nx→ [rgb]0.1172,0.1602,0.2305 xy^→ [rgb]0.8516,0.4648,0.0234 y_NPℒ [rgb]0.1445,0.3867,0.9219P_LG [rgb]0.0859,0.6406,0.2891Gℒ [rgb]0.1445,0.3867,0.9219L [rgb]0.8516,0.4648,0.0234Ny^→C [rgb]0.0859,0.6406,0.2891 y_Cq [rgb]0.0859,0.6406,0.2891qy^→ [rgb]0.8516,0.4648,0.0234 y_Nx→ [rgb]0.1172,0.1602,0.2305 xP [rgb]0.8516,0.4648,0.0234P_NPℒ [rgb]0.1445,0.3867,0.9219P_Lℒ [rgb]0.1445,0.3867,0.9219L [rgb]0.8516,0.4648,0.0234Nq [rgb]0.0859,0.6406,0.2891qy^→ [rgb]0.8516,0.4648,0.0234 y_NP [rgb]0.8516,0.4648,0.0234P_NPℒ [rgb]0.1445,0.3867,0.9219P_L (b) Teacher–Student, Deep Probabilistic Logic (DPL), and Concordia architectures (left to right). Each couples a neural model N with a lifted graphical model ℒL. Figure 4: Regularisation-based composite systems; architectures adapted from [14]. Exact WMCd-DNNF compilationDeepProbLog#P\#P-hardDeterministic approx.top-k semiringsScalloppolynomial, biasedStochastic approx.sampling or searchWeightME, A-NeSI, ISED, ABLunbiased, amortised, search-basedexactapproximateInference exactnessExecution targetLobster: Datalog compiled to GPU kernelsDOLPHIN: symbolic layer on CPU, probabilistic and gradient computation on GPU Figure 5: Inference exactness versus execution target. 3.4 Axis 4: Evaluation Mechanism The final axis analyses how programs are evaluated, based on how the answer probability is obtained and on the target hardware layer (Fig. 5). What is computed ranges over a spectrum of exactness. At one end, exact weighted model counting sums the contribution of every model. In practice, the program is compiled into a deterministic decomposable negation normal form (d-DNNF) circuit on which weighted counting is linear-time, the standard approach in the ProbLog family [15, 50]. Exactness is costly, as WMC is #P\#P-hard and the circuit can be exponential in the treewidth of the ground program. Approximation relaxes this in two ways. Deterministic approximation truncates the computation. Scallop’s top-k provenance semiring retains only the k most likely derivations of each tuple, reducing the exponential proof set to a polynomial one at the cost of a biased estimate [28, 43]. Stochastic approximation instead estimates the count or its gradient by sampling. WeightME [45] estimates the WMC gradient without bias and, under mild assumptions, attains probabilistic guarantees with logarithmically many SAT-oracle calls. A-NeSI [86] amortises inference, training a network to approximate the WMC. ISED [77] extends sampling to neural programs whose symbolic component is a black box, estimating gradients from symbol assignments sampled from the networks’ outputs. Softened symbol grounding samples symbol states from a Boltzmann distribution via projection-based Markov chain Monte Carlo [40], while abductive learning (ABL) searches for pseudo-labels that minimally revise the networks’ predictions to satisfy the knowledge base [9]. ABL thus approximates the learning signal through search rather than estimating the count itself. All three operate only on the networks’ outputs. CLIPPER [59], a plug-in compatible with each, exploits the latent representation space: an integer linear program prunes abduced label combinations inconsistent with representation-level similarity, guaranteeing that each sample retains a logically consistent candidate. Where it is computed is an orthogonal choice: the same degree of exactness can target different layers, and GPU co-design scales evaluation without changing what is computed. Lobster [4] compiles Datalog evaluation to data-parallel GPU kernels through Lobster’s APM intermediate language, whereas DOLPHIN [57] keeps the symbolic layer on the CPU and vectorises the probabilistic and gradient computation on the GPU. Since acceleration targets the hardware layer, it is orthogonal to the exactness choice, although both systems currently pair it with approximate inference. KLay [44] covers the exact side, restructuring compiled arithmetic circuits into layered representations that parallelise on GPUs. The two also differ in the algebra they accelerate. DOLPHIN uses its own two vectorised provenances: DAMP, a fuzzy add-mult semantics, and DTKP-AM, an add-mult approximation of top-k proofs [57]. Across its benchmarks, DAMP is the faster option, and the more accurate one when the proof space outgrows top-k truncation. Lobster likewise compiles its library of provenance semirings through the APM abstraction [4]. The mechanism also interacts with learning imbalances. Even under balanced data, the symbolic program itself can induce large differences in class-specific risks, and plain likelihood (WMC) maximisation does not correct them. A more effective strategy is to estimate the marginal of the hidden labels and enforce it as a constraint at training and testing time [84] (see §5). Overall, scalability is determined by the inference mechanism rather than by the language, since a program scales only if the chosen approximation can capture its proof space. 4 Corpus and Domain Analysis To ground the taxonomy, we organise a curated corpus of over 50 systems, methods, and applications, mostly from the past six years, into four domains by primary research community: databases and programming languages (DB/PL), core machine learning and AI, computer vision, and robotics. Table 3 summarises representative entries. AI dominates the corpus, DB/PL contributes much of the theoretical core, and vision and robotics are less represented. For six recurring scenarios, we then identify the language features on which systems rely. Table 3: Representative domain summary of the surveyed corpus. Formalism family System/Approach DB/PL Stratified Datalog Scallop [41, 43], Lobster [4] Datalog theory [24] Datalog∘ [36], trigger graphs [82] Relational query DSL TorchQL [58] AI Positive / chain-rule Datalog Scallop v0 [28], TensorLog [8], NeuralLP [94], DRUM [70], numerical NeuralLP [89], EduCe [93], RNNLogic [65] Stratified Datalog DOLPHIN [57], Vieira [42], ESCA [30], DSR-LM [98] Probabilistic logic / WMC DeepProbLog [50], A-NeSI [86], VAEL [56] Stable-model ASP NeurASP [95], SLASH [75], dPASP [19] Prolog (SDCG / soft unif.) DeepStochLog [90], DeepSoftLog [46] ILP (diff. / symbolic) ∂ [12], α [73], DiffLog [74], NeurRL [16], DFORL [17], MaxSynth [25] Fuzzy FOL LTN [2], LNN [72], NeuPSL [64] Markov logic pLogicNet [66], ExpressGNN [101] Solver / black-box / circuits ABL [9], ISED [77], SATNet [88], LLM rule extraction [13], DeepLog [10] Vision Functional DSL NS-CL [51], LEFT [27], NGS [39] Temporal logic / relational LASER [29], NSVS-TL [7] Abductive ASP / Boolean online abduction [79], softened symbol grounding [40], CLIPPER [59] Knowledge graph rules NeSyVQA [37] Robotics Temporal LTL/STL [23, 48] formal N training [81], pSTL-Diffusion [55] OWL ++ Datalog/SWRL [26] Deep-Onto [60] Visual perception and reasoning. Extracting symbolic structure from pixels and composing it with rules often requires differentiable probabilistic reasoning with aggregation and negation. Scallop [43] is evaluated on MNIST-R, handwritten-formula recognition, CLEVR, and PacMan-Maze. As noted in §3, expressing the CLEVR interpreter requires stratified negation and aggregation [43]. Spatio-temporal scene-graph learning. Extracting relations across video frames requires a temporal-relational specification language with differentiable probabilistic reasoning. LASER [29] pairs an LLM that extracts STSL specifications, a neural model that predicts scene graphs, and a differentiable alignment checker built on Scallop. The alignment loss turns the extracted specifications into a weak supervision signal for the perception model. Knowledge graph completion. Open-vocabulary knowledge-graph completion benefits from soft unification or embedding-based equivalence. TensorLog [8] evaluates restricted chain-rule Datalog differentiably, rule learners built on this scheme induce such rules end-to-end [70, 94], and DeepSoftLog [46] adds unification in embedding space. Treating pairwise similarities as independent facts, however, does not guarantee that the induced equality is transitive. The equivalence semantics of Maene and Tsamoura [47] repairs this defect and outperforms soft-unification baselines on standard benchmarks. Natural-language reasoning. Here, a foundation model may be invoked as a component rather than trained as a neural predicate through the rule layer. Vieira [42] exposes foundation models through foreign predicates (§3.3) and is evaluated on language, vision, and structured-data tasks. Related solver-backed LLM-logic systems include Logic-LM [63] and SatLM [96]. Planning, program analysis, and bioinformatics. These scenarios require recursive Datalog over probabilistic or large-scale fact bases. In Scallop’s PacMan-Maze [43], a neural network extracts the grid contents from pixels and the rule layer computes enemy-free reachable paths by transitive closure. Trained end-to-end through the rule layer, the resulting agent outperforms purely neural baselines. Lobster [4] extends Datalog’s classical workloads [6, 38] to the neurosymbolic setting. It compiles evaluation to GPU kernels via the APM intermediate language and is experimentally evaluated at scale on benchmarks including program reasoning, bioinformatics, and planning. 5 Cross-Cutting Analysis This section cuts across the axes: §5.1 covers uncertainty from training to deployment and §5.2 maps scenarios to features. 5.1 Inference versus Training At inference, propagating uncertainty is optional. The Boolean “neuro-then-symbolic” strategy asserts neural maximum-a-posteriori (MAP) predictions as symbolic input and runs a fixed solver, such as least-fixpoint Datalog, to obtain one answer. For function-free Datalog, data complexity is polynomial, but uncertainty is discarded and an incorrect MAP fact cannot be revised. Training removes this freedom. A hard argmax has zero gradient almost everywhere, so the discarded uncertainty must be reintroduced, by differentiating the soft semantics directly [43, 57], compiling the constraint into a loss term [92], or keeping a probabilistic objective without differentiating the circuit, via sampling [45], amortisation [86], or a marginal constraint over the hidden labels [84]. Deploying the logic in Boolean form leaves two options: confine the relaxation to training, as differentiable ILP does by extracting Boolean rules from a [0,1][0,1] relaxation [12, 74], or keep the logic off the gradient path, as in abductive learning [9]. SATNet [88] fits neither, as its semidefinite relaxation of maximum satisfiability is the inference mechanism at both training and test time. Probabilistic inference DeepProbLog, Scallop, DOLPHIN, WeightME, A-NeSI, DeepSoftLog Fixed symbolic solver Logic-LM, SatLM, ABL Differentiable rule learning ∂ , α , DiffLog Continuous relaxation SATNet, LTN, LNN Probabilistic training with MAP inference (common in practice) PBRdeploy state ⟶ ⟵ train state Figure 6: Train → deploy grid (P: probabilistic, B: Boolean/MAP, R: relaxation). Figure 6 classifies the surveyed families by their uncertainty representation at training and deployment into probability distribution (P), Boolean/MAP value (B), or continuous relaxation, i.e., [0,1][0,1] values instead of Boolean ones (R). P → P systems (DeepProbLog [50], Scallop [28, 43], DOLPHIN [57], WeightME [45], A-NeSI [86], and DeepSoftLog [46], whose soft unification has possible-world semantics) retain an answer distribution, so the rule layer can revise low-confidence neural predictions, at the cost of intractable exact inference (§3.4). B → B systems (Logic-LM [63], SatLM [96], abductive learning (ABL) [9]) keep fixed rules off every gradient path, with purely Boolean inference and no probabilistic machinery. NeuroLog-style abduction (Fig. 3), by contrast, differentiates through the compiled proofs and belongs to the P → P family. R → R systems (LTN [2], LNN [72], SATNet [88]) stay differentiable throughout, but operate on relaxed truth values rather than on a distribution over possible worlds, so their output scores have no probabilistic interpretation. Differentiable ILP (∂ [12], α [73], DiffLog [74]; R → B) relaxes the rule space during training and deploys a purely symbolic program. The P → B cell does not correspond to a dedicated system family but to a common deployment practice, namely training through a probabilistic objective and asserting only the MAP predictions at inference, which trades the revision ability of the P column for cheaper Boolean inference. 5.2 Feature Coverage across Scenarios Table 4 maps each scenario to its required features, and no single dialect covers them all. Perception-driven tasks need probabilistic semantics to propagate neural uncertainty into the rule layer. Visual reasoning also needs aggregation and negation, spatio-temporal tasks need temporal operators, knowledge graphs rely on soft unification, and NL reasoning relies on foreign-function interfaces. Table 4: Mapping applications to language features (✓ required, (✓)( ) beneficial). Scenario Prob. Rec. Neg. Agg. Temp. Soft FFI Diff. Visual reasoning ✓ (✓)( ) ✓ ✓ – – – ✓ Spatio-temporal ✓ ✓ (✓)( ) – ✓ (✓)( ) – ✓ Knowledge graphs (✓)( ) ✓ – – – ✓ – ✓ NL reasoning (✓)( ) (✓)( ) (✓)( ) – – – ✓ (✓)( ) Planning / RL ✓ ✓ – (✓)( ) – – – ✓ Program analysis (✓)( ) ✓ (✓)( ) ✓ – – (✓)( ) (✓)( ) Prob. = probabilistic; Rec. = recursion; Neg. = negation; Agg. = aggregation; Temp. = temporal; Soft = soft unification; FFI = foreign-function interface; Diff. = differentiable. Provenance semirings as the unifying abstraction. The provenance semiring (§2) is the common algebra underlying the surveyed systems. Changing the semiring changes the semantics without changing the program, so one engine can support several of the dialects that the decision matrix distinguishes. Concretely, a single stratified Datalog engine with a differentiable semiring (Scallop, Lobster, DOLPHIN) already covers the visual-reasoning, planning, and program-analysis rows of Table 4. The temporal and soft-unification columns, however, have no obvious semiring formulation, the foreign-function column is orthogonal to the semiring choice, and probabilistic inference remains the scalability bottleneck (§6). Reliability and reasoning shortcuts. A NeSy model can satisfy the symbolic constraints while assigning unintended meanings to the learned concepts, a reasoning shortcut that degrades generalisation and calibration. Ensembling over models with conflicting interpretations exposes which concepts are ambiguous and improves reliability [53]. Together with imbalance-aware training (§3.4), these mechanisms are largely orthogonal to language design. A companion survey systematises reasoning shortcuts, their causes, and mitigations, including incorrect symbol grounding in foundation models [52]. Wang et al. [87] delimit when the latent concepts are identifiable at all under abduction-based training, a precondition for any downstream reliability guarantee. Concept bottleneck LLMs reveal the concepts the model uses [80], so one can check its symbol grounding directly. 6 Open Problems We identify five open problems, as stated below. Can LLM-generated rule sets be statically analysed and repaired? For rule-based systems, the bottleneck is often writing the rules, and three couplings of LLMs with logic have emerged. In the authoring direction, the LLM acts as an autoformaliser, by parsing premises into logic programs or solver inputs [91, 62, 18, 63, 96] or by generating answer set programs [31]. In the calling direction, the model is a relation invoked from within the rules [42, 29], and a rigorous semantics for this abstraction, accounting for hallucination, non-determinism, and cost, is itself open. In the constraining direction, logical constraints are enforced on the LLM, at decoding time or through fine-tuning [5, 99, 100]. Can a dialect unify Boolean, probabilistic, fuzzy, and embedding semantics? The semantic families of §3 are currently split across separate languages. Provenance semirings unify several of these semantics (§2, §5.2), and DeepLog [10] compiles specifications to parameterised algebraic circuits. Unification at the source level remains open. It requires reconciling closed-world Datalog with open-world soft unification [46, 47] under one type system, and identifying which semantics can be captured by a commutative semiring. Embedding equivalence and temporal operators lack a semiring formulation. Can Datalog and ASP be bridged in one differentiable system? Stratified Datalog is a fragment of ASP, and the well-founded semantics [20] is a polynomial-time, three-valued approximation of the stable model semantics that coincides with it on stratified programs [21], whereas stable-model reasoning is intractable in general. A differentiable engine spanning the hierarchy of Fig. 2a could therefore let a single program move along the well-founded/stable axis, paying the higher inference cost only where non-monotonic reasoning is required. The open question is whether one relaxation can remain faithful to both the least-fixpoint and the stable-model reading without committing to either at compile time. How far can probabilistic inference scale? Exact WMC relies on compiled circuits whose size can be exponential in the treewidth of the ground program (§3.4). Current systems either improve the estimators, via unbiased gradient estimates with guarantees from logarithmically many SAT calls [45] or amortised by a trained inference network [86], or compile evaluation to GPU kernels [4, 44, 57]. All return point estimates without error bounds. Deriving computable bounds for top-k truncation and sampling, e.g., from semiring convergence theory [36], would make approximate inference certifiable for safety-critical deployment. Can we verify neurosymbolic programs? A function-free rule layer is decidable and can, in principle, be certified, with neural outputs treated as bounded or probabilistic inputs. Trigger-graph materialisation [82] provides completeness- and termination-preserving execution plans for rule materialisation. Lifting it to the neurosymbolic setting means propagating input intervals or label distributions through materialisation, bounding the output distribution rather than verifying a single run. A program is thus trustworthy only when its rules and concept groundings are certified together (§5). 7 Conclusion We examined rule-based languages for neurosymbolic AI along four axes: semantics, expressiveness, neural integration, and evaluation mechanism. We then reviewed state-of-the-art systems across four domains, spanning databases and programming languages, machine learning, vision, and robotics, and presented a decision matrix mapping six application scenarios to the features they require. Our analysis shows that no single dialect covers every scenario, with provenance semirings coming closest to a common foundation. We close by identifying open problems and future research directions that build on this declarative core. Disclosure of Interests. The authors have no competing interests to declare that are relevant to the content of this article. References [1] S. Abiteboul, R. Hull, and V. Vianu (1995) Foundations of databases. Addison-Wesley. External Links: Link Cited by: §1, §2, §2, Figure 1, Figure 1. [2] S. Badreddine, A. S. d’Avila Garcez, L. Serafini, and M. Spranger (2022) Logic tensor networks. Artif. Intell. 303, p. 103649. External Links: Document Cited by: §2, Figure 1, Table 3, §5.1. [3] V. Bárány, B. ten Cate, B. Kimelfeld, D. Olteanu, and Z. Vagena (2016) Declarative probabilistic programming with Datalog. In ICDT, LIPIcs, Vol. 48, p. 7:1–7:19. External Links: Document Cited by: §2, Figure 1, Figure 1, §3.2. [4] P. Biberstein, Z. Li, J. Devietti, and M. Naik (2026) Lobster: A GPU-accelerated framework for neurosymbolic programming. In ASPLOS (1), p. 147–162. External Links: Document Cited by: Figure 1, Figure 1, §3.3, §3.4, §3.4, §4, Table 3, §6. [5] D. Calanzone, S. Teso, and A. Vergari (2025) Logically consistent language models via neuro-symbolic integration. In ICLR, External Links: Link Cited by: §6. [6] S. Ceri, G. Gottlob, and L. Tanca (1989) What you always wanted to know about Datalog (and never dared to ask). IEEE Trans. Knowl. Data Eng. 1 (1), p. 146–166. External Links: Document Cited by: §1, §2, §4. [7] M. Choi, H. Goel, M. Omama, Y. Yang, S. Shah, and S. Chinchali (2024) Towards neuro-symbolic video understanding. In ECCV (78), Lecture Notes in Computer Science, Vol. 15136, p. 220–236. External Links: Document Cited by: Table 3. [8] W. W. Cohen, F. Yang, and K. Mazaitis (2020) TensorLog: A probabilistic database implemented using deep-learning infrastructure. J. Artif. Intell. Res. 67, p. 285–325. External Links: Document Cited by: §4, Table 3. [9] W. Dai, Q. Xu, Y. Yu, and Z. Zhou (2019) Bridging machine learning and logical reasoning by abductive learning. In NeurIPS, External Links: Link Cited by: §3.4, Table 3, §5.1, §5.1. [10] V. Derkinderen, R. Manhaeve, R. Adriaensen, L. V. Praet, L. D. Smet, G. Marra, and L. D. Raedt (2025) The DeepLog neurosymbolic machine. CoRR abs/2508.13697. External Links: Document Cited by: Figure 1, Figure 1, §3.1, §3.3, Table 3, §6. [11] T. Eiter, G. Gottlob, and H. Mannila (1997) Disjunctive Datalog. ACM Trans. Database Syst. 22 (3), p. 364–418. External Links: Document Cited by: Figure 1. [12] R. Evans and E. Grefenstette (2018) Learning explanatory rules from noisy data. J. Artif. Intell. Res. 61, p. 1–64. External Links: Document Cited by: §3.2, Table 3, §5.1, §5.1. [13] M. Fang, S. Deng, Y. Zhang, Z. Shi, L. Chen, M. Pechenizkiy, and J. Wang (2024) Large language models are neurosymbolic reasoners. In AAAI, p. 17985–17993. External Links: Document Cited by: Table 3. [14] J. Feldstein, P. Dilkas, V. Belle, and E. Tsamoura (2024) Mapping the neuro-symbolic AI landscape by architectures: A handbook on augmenting deep learning through symbolic reasoning. CoRR abs/2410.22077. External Links: Document Cited by: Figure 4, Figure 4, §3.3. [15] D. Fierens, G. V. den Broeck, J. Renkens, D. Shterionov, B. Gutmann, I. Thon, G. Janssens, and L. D. Raedt (2015) Inference and learning in probabilistic logic programs using weighted Boolean formulas. Theory Pract. Log. Program. 15 (3), p. 358–401. External Links: Document Cited by: §2, §2, Figure 1, §3.4. [16] K. Gao, K. Inoue, Y. Cao, H. Wang, and Y. Feng (2025) Differentiable rule induction from raw sequence inputs. In ICLR, External Links: Link Cited by: Table 3. [17] K. Gao, K. Inoue, Y. Cao, and H. Wang (2024) A differentiable first-order rule learner for inductive logic programming. Artif. Intell. 331, p. 104108. External Links: Document Cited by: Table 3. [18] L. Gao, A. Madaan, S. Zhou, U. Alon, P. Liu, Y. Yang, J. Callan, and G. Neubig (2023) PAL: program-aided language models. In ICML, Proceedings of Machine Learning Research, Vol. 202, p. 10764–10799. External Links: Link Cited by: §6. [19] R. L. Geh, J. Gonçalves, I. C. Silveira, D. D. Mauá, and F. G. Cozman (2024) dPASP: A probabilistic logic programming environment for neurosymbolic learning and reasoning. In KR, External Links: Document Cited by: §2, Table 3. [20] A. V. Gelder, K. A. Ross, and J. S. Schlipf (1991) The well-founded semantics for general logic programs. J. ACM 38 (3), p. 620–650. External Links: Document Cited by: §2, Figure 1, §3.2, §6. [21] M. Gelfond and V. Lifschitz (1988) The stable model semantics for logic programming. In ICLP/SLP, p. 1070–1080. Cited by: §2, Figure 1, Figure 1, §3.2, §6. [22] L. Getoor and A. Machanavajjhala (2012) Entity resolution: theory, practice & open challenges. Proc. VLDB Endow. 5 (12), p. 2018–2019. External Links: Document Cited by: §2. [23] G. D. Giacomo and M. Y. Vardi (2013) Linear temporal logic and linear dynamic logic on finite traces. In IJCAI, p. 854–860. External Links: Link Cited by: Figure 1, §3.2, Table 3. [24] T. J. Green, G. Karvounarakis, and V. Tannen (2007) Provenance semirings. In PODS, p. 31–40. External Links: Document Cited by: §1, §2, §2, Figure 1, Figure 1, Table 3. [25] C. Hocquette, A. Niskanen, M. Järvisalo, and A. Cropper (2024) Learning MDL logic programs from noisy data. In AAAI, p. 10553–10561. External Links: Document Cited by: Table 3. [26] I. Horrocks, P. F. Patel-Schneider, H. Boley, S. Tabet, B. Grosof, and M. Dean (2004) SWRL: a semantic web rule language combining OWL and RuleML. Note: W3C Member Submission Cited by: Table 3. [27] J. Hsu, J. Mao, J. B. Tenenbaum, and J. Wu (2023) What’s left? concept grounding with logic-enhanced foundation models. In NeurIPS, Cited by: Table 3. [28] J. Huang, Z. Li, B. Chen, K. Samel, M. Naik, L. Song, and X. Si (2021) Scallop: from probabilistic deductive databases to scalable differentiable reasoning. In NeurIPS, p. 25134–25145. External Links: Link Cited by: §1, §2, Figure 1, Figure 1, §3.2, §3.4, Table 3, §5.1. [29] J. Huang, Z. Li, M. Naik, and S. Lim (2025) LASER: A neuro-symbolic framework for learning spatio-temporal scene graphs with weak supervision. In ICLR, External Links: Link Cited by: §1, Figure 1, Figure 1, §3.2, §3.3, §4, Table 3, §6. [30] J. Huang, A. Sethi, M. Kuo, M. Keoliya, N. Velingker, J. Jung, S. Lim, Z. Li, and M. Naik (2025) ESCA: contextualizing embodied agents via scene-graph generation. CoRR abs/2510.15963. External Links: Document Cited by: Table 3. [31] A. Ishay, Z. Yang, and J. Lee (2023) Leveraging large language models to generate answer set programs. In KR, p. 374–383. External Links: Document Cited by: §6. [32] A. Ivliev, L. Gerlach, S. Meusel, J. Steinberg, and M. Krötzsch (2024) Nemo: your friendly and versatile rule reasoning toolkit. In KR, External Links: Document Cited by: §2. [33] J. Johnson, B. Hariharan, L. van der Maaten, L. Fei-Fei, C. L. Zitnick, and R. B. Girshick (2017) CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, p. 1988–1997. External Links: Document Cited by: §3.2. [34] H. Jordan, B. Scholz, and P. Subotic (2016) Soufflé: on synthesis of program analyzers. In CAV (2), Lecture Notes in Computer Science, Vol. 9780, p. 422–430. External Links: Document Cited by: §2. [35] H. A. Kautz (2022) The third AI summer: AAAI Robert S. Engelmore Memorial Lecture. AI Mag. 43 (1), p. 93–104. External Links: Document Cited by: §1. [36] M. A. Khamis, H. Q. Ngo, R. Pichler, D. Suciu, and Y. R. Wang (2024) Convergence of Datalog over (pre-) semirings. J. ACM 71 (2), p. 8:1–8:55. External Links: Document Cited by: §1, §2, Figure 1, Table 3, §6. [37] M. J. Khan, J. G. Breslin, and E. Curry (2026) NeSyVQA: neurosymbolic visual question answering with knowledge-enriched scene graphs. IEEE Access 14, p. 3229–3244. External Links: Document Cited by: Table 3. [38] M. Krötzsch (2025) Modern Datalog: concepts, methods, applications (invited paper). In RW, OASIcs, Vol. 138, p. 7:1–7:41. External Links: Document Cited by: §1, §2, Figure 1, §4. [39] Q. Li, S. Huang, Y. Hong, Y. Chen, Y. N. Wu, and S. Zhu (2020) Closed loop neural-symbolic learning via integrating neural perception, grammar parsing, and symbolic reasoning. In ICML, Proceedings of Machine Learning Research, Vol. 119, p. 5884–5894. External Links: Link Cited by: Table 3. [40] Z. Li, Y. Yao, T. Chen, J. Xu, C. Cao, X. Ma, and J. Lü (2023) Softened symbol grounding for neuro-symbolic systems. In ICLR, External Links: Link Cited by: §3.4, Table 3. [41] Z. Li, J. Huang, J. Liu, and M. Naik (2024) Neurosymbolic programming in Scallop: principles and practice. Found. Trends Program. Lang. 8 (2), p. 118–249. External Links: Document Cited by: Table 3. [42] Z. Li, J. Huang, J. Liu, F. Zhu, E. Zhao, W. Dodds, N. Velingker, R. Alur, and M. Naik (2024) Relational programming with foundational models. In AAAI, p. 10635–10644. External Links: Document Cited by: §1, Figure 1, §3.2, §3.3, §4, Table 3, §6. [43] Z. Li, J. Huang, and M. Naik (2023) Scallop: A language for neurosymbolic programming. Proc. ACM Program. Lang. 7 (PLDI), p. 1463–1487. External Links: Document Cited by: §2, Figure 1, Figure 1, Figure 1, §3.2, §3.3, §3.4, §4, §4, Table 3, §5.1, §5.1. [44] J. Maene, V. Derkinderen, and P. Z. D. Martires (2025) KLay: accelerating arithmetic circuits for neurosymbolic AI. In ICLR, External Links: Link Cited by: Figure 1, §3.4, §6. [45] J. Maene, V. Derkinderen, and L. D. Raedt (2024) On the hardness of probabilistic neurosymbolic learning. In ICML, Proceedings of Machine Learning Research, Vol. 235, p. 34203–34218. External Links: Link Cited by: Figure 1, §3.4, §5.1, §5.1, §6. [46] J. Maene and L. D. Raedt (2023) Soft-unification in deep probabilistic logic. In NeurIPS, External Links: Link Cited by: §1, §2, Figure 1, Figure 1, §3.3, §4, Table 3, §5.1, §6. [47] J. Maene and E. Tsamoura (2025) Embeddings as probabilistic equivalence in logic programs. In NeurIPS, Cited by: §2, Figure 1, §4, §6. [48] O. Maler and D. Nickovic (2004) Monitoring temporal properties of continuous signals. In FORMATS/FTRTFT, Lecture Notes in Computer Science, Vol. 3253, p. 152–166. External Links: Document Cited by: Table 3. [49] R. Manhaeve, S. Colamonaco, V. Derkinderen, R. Adriaensen, L. V. Praet, L. D. Raedt, and G. Marra (2026) DeepLog: A software framework for modular neurosymbolic AI. CoRR abs/2605.10279. External Links: Document Cited by: §3.1. [50] R. Manhaeve, S. Dumančić, A. Kimmig, T. Demeester, and L. D. Raedt (2021) Neural probabilistic logic programming in DeepProbLog. Artif. Intell. 298, p. 103504. External Links: Document Cited by: §2, Figure 1, Figure 1, Figure 1, §3.3, §3.4, Table 3, §5.1. [51] J. Mao, C. Gan, P. Kohli, J. B. Tenenbaum, and J. Wu (2019) The neuro-symbolic concept learner: interpreting scenes, words, and sentences from natural supervision. In ICLR, External Links: Link Cited by: Table 3. [52] E. Marconato, S. Bortolotti, E. van Krieken, P. Morettin, E. Umili, A. Vergari, E. Tsamoura, A. Passerini, and S. Teso (2025) Symbol grounding in neuro-symbolic AI: A gentle introduction to reasoning shortcuts. CoRR abs/2510.14538. External Links: Document Cited by: §5.2. [53] E. Marconato, S. Bortolotti, E. van Krieken, A. Vergari, A. Passerini, and S. Teso (2024) BEARS make neuro-symbolic models aware of their reasoning shortcuts. In UAI, PMLR, Vol. 244, p. 2399–2433. External Links: Link Cited by: §5.2. [54] G. Marra, S. Dumančić, R. Manhaeve, and L. D. Raedt (2024) From statistical relational to neurosymbolic artificial intelligence: A survey. Artif. Intell. 328, p. 104062. External Links: Document Cited by: §1. [55] Y. Meng and C. Fan (2024) Diverse controllable diffusion policy with signal temporal logic. IEEE Robotics Autom. Lett. 9 (10), p. 8354–8361. External Links: Document Cited by: Table 3. [56] E. Misino, G. Marra, and E. Sansone (2023) VAEL: bridging variational autoencoders and probabilistic logic programming. In NeSy, CEUR Workshop Proceedings, Vol. 3432, p. 434–435. External Links: Link Cited by: Table 3. [57] A. Naik, J. Liu, C. Wang, A. Sethi, S. Dutta, M. Naik, and E. Wong (2025) DOLPHIN: A programmable framework for scalable neurosymbolic learning. In ICML, Proceedings of Machine Learning Research, Vol. 267. Cited by: Figure 1, Figure 1, §3.4, §3.4, Table 3, §5.1, §5.1, §6. [58] A. Naik, A. Stein, Y. Wu, M. Naik, and E. Wong (2024) TorchQL: A programming framework for integrity constraints in machine learning. Proc. ACM Program. Lang. 8 (OOPSLA1), p. 833–863. External Links: Document Cited by: Table 3. [59] A. Naik, E. Tsamoura, S. Jin, M. Naik, and D. Roth (2026) On improving neurosymbolic learning by exploiting the representation space. CoRR abs/2602.07973. External Links: Document Cited by: §3.4, Table 3. [60] H. Nakawala, R. Bianchi, L. E. Pescatori, O. D. Cobelli, G. Ferrigno, and E. D. Momi (2019) Deep-Onto network for surgical workflow and context recognition. Int. J. Comput. Assist. Radiol. Surg. 14 (4), p. 685–696. External Links: Document Cited by: Table 3. [61] Y. Nenov, R. Piro, B. Motik, I. Horrocks, Z. Wu, and J. Banerjee (2015) RDFox: A highly-scalable RDF store. In ISWC (2), Lecture Notes in Computer Science, Vol. 9367, p. 3–20. External Links: Document Cited by: §2. [62] T. Olausson, A. Gu, B. Lipkin, C. E. Zhang, A. Solar-Lezama, J. B. Tenenbaum, and R. Levy (2023) LINC: A neurosymbolic approach for logical reasoning by combining language models with first-order logic provers. In EMNLP, p. 5153–5176. External Links: Document Cited by: §6. [63] L. Pan, A. Albalak, X. Wang, and W. Y. Wang (2023) Logic-LM: empowering large language models with symbolic solvers for faithful logical reasoning. In EMNLP (Findings), Findings of ACL, Vol. EMNLP 2023, p. 3806–3824. External Links: Document Cited by: §4, §5.1, §6. [64] C. Pryor, C. Dickens, E. Augustine, A. Albalak, W. Y. Wang, and L. Getoor (2023) NeuPSL: neural probabilistic soft logic. In IJCAI, p. 4145–4153. External Links: Document Cited by: Figure 1, Table 3. [65] M. Qu, J. Chen, L. A. C. Xhonneux, Y. Bengio, and J. Tang (2021) RNNLogic: learning logic rules for reasoning on knowledge graphs. In ICLR, External Links: Link Cited by: Table 3. [66] M. Qu and J. Tang (2019) Probabilistic logic neural networks for reasoning. In NeurIPS, External Links: Link Cited by: Table 3. [67] L. D. Raedt, A. Kimmig, and H. Toivonen (2007) ProbLog: A probabilistic Prolog and its application in link discovery. In IJCAI, p. 2462–2467. External Links: Link Cited by: §2, Figure 1. [68] T. Rocktäschel and S. Riedel (2017) End-to-end differentiable proving. In NIPS, p. 3788–3800. External Links: Link Cited by: §1, §2, Figure 1, §3.3. [69] K. A. Ross and Y. Sagiv (1992) Monotonic aggregation in deductive databases. In PODS, p. 114–126. External Links: Document Cited by: §2, Figure 1. [70] A. Sadeghian, M. Armandpour, P. Ding, and D. Z. Wang (2019) DRUM: end-to-end differentiable rule mining on knowledge graphs. In NeurIPS, External Links: Link Cited by: §4, Table 3. [71] T. Sato (1995) A statistical learning method for logic programs with distribution semantics. In ICLP, p. 715–729. Cited by: §2. [72] P. Sen, B. W. S. R. de Carvalho, R. Riegel, and A. Gray (2022) Neuro-symbolic inductive logic programming with logical neural networks. In AAAI, Vol. 36, p. 8212–8219. External Links: Document Cited by: §2, Figure 1, Table 3, §5.1. [73] H. Shindo, V. Pfanschilling, D. S. Dhami, and K. Kersting (2023) α : thinking visual scenes as differentiable logic programs. Mach. Learn. 112 (5), p. 1465–1497. External Links: Document Cited by: §3.2, Table 3, §5.1. [74] X. Si, M. Raghothaman, K. Heo, and M. Naik (2019) Synthesizing Datalog programs using numerical relaxation. In IJCAI, p. 6117–6124. External Links: Document Cited by: §3.2, Table 3, §5.1, §5.1. [75] A. Skryagin, W. Stammer, D. Ochs, D. S. Dhami, and K. Kersting (2022) SLASH: embracing probabilistic circuits into neural answer set programming. In KR, External Links: Document Cited by: §2, Figure 1, Figure 1, Table 3. [76] L. D. Smet and L. D. Raedt (2025) Defining neurosymbolic AI. CoRR abs/2507.11127. External Links: Document Cited by: §1. [77] A. Solko-Breslin, S. Choi, Z. Li, N. Velingker, R. Alur, M. Naik, and E. Wong (2024) Data-efficient learning with neural programs. In NeurIPS, External Links: Link Cited by: §3.4, Table 3. [78] G. Šourek, V. Aschenbrenner, F. Železný, S. Schockaert, and O. Kuželka (2018) Lifted relational neural networks: efficient learning of latent relational structures. J. Artif. Intell. Res. 62, p. 69–100. External Links: Document Cited by: §2. [79] J. Suchan, M. Bhatt, and S. Varadarajan (2021) Commonsense visual sensemaking for autonomous driving - on generalised neurosymbolic online abduction integrating vision and semantics. Artif. Intell. 299, p. 103522. External Links: Document Cited by: Table 3. [80] C. Sun, T. P. Oikarinen, B. Ustun, and T. Weng (2025) Concept bottleneck large language models. In ICLR, External Links: Link Cited by: §5.2. [81] X. Sun and Y. Shoukry (2024) Neurosymbolic motion and task planning for linear temporal logic tasks. IEEE Trans. Robotics 40, p. 2749–2768. External Links: Document Cited by: Table 3. [82] E. Tsamoura, D. Carral, E. Malizia, and J. Urbani (2021) Materializing knowledge bases via trigger graphs. Proc. VLDB Endow. 14 (6), p. 943–956. External Links: Document Cited by: Table 3, §6. [83] E. Tsamoura, T. M. Hospedales, and L. Michael (2021) Neural-symbolic integration: A compositional perspective. In AAAI, p. 5051–5060. External Links: Document Cited by: Figure 3, Figure 3, §3.3. [84] E. Tsamoura, K. Wang, and D. Roth (2025) Imbalances in neurosymbolic learning: characterization and mitigating strategies. In NeurIPS, External Links: Link Cited by: §3.4, §5.1. [85] E. van Krieken, E. Acar, and F. van Harmelen (2022) Analyzing differentiable fuzzy logic operators. Artif. Intell. 302, p. 103602. External Links: Document Cited by: §2. [86] E. van Krieken, T. Thanapalasingam, J. M. Tomczak, F. van Harmelen, and A. ten Teije (2023) A-NeSI: A scalable approximate method for probabilistic neurosymbolic inference. In NeurIPS, Cited by: Figure 1, §3.4, Table 3, §5.1, §5.1, §6. [87] K. Wang, E. Tsamoura, and D. Roth (2023) On learning latent models with multi-instance weak supervision. In NeurIPS, External Links: Link Cited by: Figure 3, Figure 3, §3.3, §5.2. [88] P. Wang, P. L. Donti, B. Wilder, and J. Z. Kolter (2019) SATNet: bridging deep learning and logical reasoning using a differentiable satisfiability solver. In ICML, PMLR, Vol. 97, p. 6545–6554. External Links: Link Cited by: Table 3, §5.1, §5.1. [89] P. Wang, D. Stepanova, C. Domokos, and J. Z. Kolter (2020) Differentiable learning of numerical rules in knowledge graphs. In ICLR, External Links: Link Cited by: Table 3. [90] T. Winters, G. Marra, R. Manhaeve, and L. D. Raedt (2022) DeepStochLog: neural stochastic logic programming. In AAAI, p. 10090–10100. External Links: Document Cited by: Table 3. [91] Y. Wu, A. Q. Jiang, W. Li, M. N. Rabe, C. Staats, M. Jamnik, and C. Szegedy (2022) Autoformalization with large language models. In NeurIPS, External Links: Link Cited by: §6. [92] J. Xu, Z. Zhang, T. Friedman, Y. Liang, and G. V. den Broeck (2018) A semantic loss function for deep learning with symbolic knowledge. In ICML, PMLR, Vol. 80, p. 5498–5507. External Links: Link Cited by: §2, Figure 1, 4(a), 4(a), §3.3, §5.1. [93] Z. Xu, P. Ye, J. Li, H. Chen, and W. Zhang (2023) Differentiable learning of rules with constants in knowledge graph. Knowl. Based Syst. 275, p. 110686. Cited by: Table 3. [94] F. Yang, Z. Yang, and W. W. Cohen (2017) Differentiable learning of logical rules for knowledge base reasoning. In NeurIPS, External Links: Link Cited by: §4, Table 3. [95] Z. Yang, A. Ishay, and J. Lee (2020) NeurASP: embracing neural networks into answer set programming. In IJCAI, p. 1755–1762. External Links: Document Cited by: §2, Figure 1, Figure 1, Table 3. [96] X. Ye, Q. Chen, I. Dillig, and G. Durrett (2023) SatLM: satisfiability-aided language models using declarative prompting. In NeurIPS, Vol. 36. External Links: Link Cited by: §4, §5.1, §6. [97] Y. Yuan, L. Zhao, K. Zhang, G. Zheng, and Q. Liu (2024) Do LLMs overcome shortcut learning? an evaluation of shortcut challenges in large language models. In Proc. EMNLP, p. 12188–12200. External Links: Document Cited by: §1. [98] H. Zhang, J. Huang, Z. Li, M. Naik, and E. P. Xing (2023) Improved logical reasoning of language models via differentiable symbolic programming. In ACL (Findings), Findings of ACL, Vol. ACL 2023, p. 3062–3077. External Links: Document Cited by: Table 3. [99] H. Zhang, M. Dang, N. Peng, and G. V. den Broeck (2023) Tractable control for autoregressive language generation. In ICML, Proceedings of Machine Learning Research, Vol. 202, p. 40932–40945. External Links: Link Cited by: §6. [100] H. Zhang, P. Kung, M. Yoshida, G. V. den Broeck, and N. Peng (2024) Adaptable logical control for large language models. In NeurIPS, External Links: Link Cited by: §6. [101] Y. Zhang, X. Chen, Y. Yang, A. Ramamurthy, B. Li, Y. Qi, and L. Song (2020) Efficient probabilistic logic reasoning with graph neural networks. In ICLR, Cited by: Table 3.