DeepProbLog: Neural Probabilistic Logic

• DeepProbLog is a neural probabilistic logic programming framework that integrates neural network outputs into logic programs via neural predicates.
• It employs neural annotated disjunctions and weighted model counting to jointly process high-dimensional perceptual data and structured logical rules.
• The framework supports end-to-end differentiable learning, achieving empirical success in tasks such as digit addition, event detection, and program induction.

DeepProbLog is a neural probabilistic logic programming framework that extends ProbLog by integrating deep learning through neural predicates. Its architecture allows neural networks to produce probabilistic outputs that are incorporated directly into symbolic logic programs, enabling joint reasoning over subsymbolic data (images, signals) and high-level logic, and supporting end-to-end learning via differentiable inference and training techniques.

1. Foundational Principles

DeepProbLog builds on the distribution semantics of ProbLog, wherein each probabilistic fact in a logic program is treated as an independent random variable. For a set of probabilistically labeled facts $L_T$, a subprogram $L \subseteq L_T$ corresponds to a sampled interpretation, with the probability

$$P(L|T) = \prod_{c_i \in L} p_i \cdot \prod_{c_i \in L_T \setminus L} (1-p_i)$$

Queries are evaluated by either aggregating probabilities over all subprograms that entail the query (success probability, $P_s(q|T)$), or finding the most likely explanation (explanation probability, $P_x(q|T)$), where

$$P_s(q|T) = \sum_{L \subseteq L_T,\, L \models q} P(L|T) \qquad P_x(q|T) = \max_{E \in E(q)} \prod_{c_i \in E} p_i$$

DeepProbLog extends this foundation by allowing neural predicates, whose probabilistic outputs are derived from neural networks, to take the place of static probabilities in the logic program (Manhaeve et al., 2018).

2. Neural Predicates and Annotated Disjunctions

A key innovation is the concept of neural predicates, which are syntactically defined as neural annotated disjunctions (nADs). For example,

$$\text{nn}(m_{\text{digit}}, X, [0,\ldots,9]) :: \text{digit}(X,0);\ldots;\text{digit}(X,9)$$

Here, neural module $m_{\text{digit}}$ takes an input $X$ (e.g., an input image) and produces a probability distribution over digits $0$–$9$ via softmax. The neural outputs are assigned directly as probabilities to the facts in the annotated disjunction. When the program grounds a predicate such as $\text{digit}(X,d)$, it queries the neural network for its probability, which is then used by the logic program in probabilistic inference (Manhaeve et al., 2019).

This mechanism enables DeepProbLog to treat perceptual inputs as part of its probabilistic reasoning infrastructure, bridging the representation gap between subsymbolic and symbolic domains.

3. Inference and End-to-End Learning

DeepProbLog performs probabilistic inference by adapting weighted model counting (WMC) to account for neural predicates. The inference process follows:

• Grounding with respect to a query
• Compilation into a logical formula (e.g., Sentential Decision Diagram)
• Conversion to an arithmetic circuit (AC) for exact probability computation

During inference, neural predicates are instantiated by evaluating the corresponding neural networks on their inputs, so the arithmetic circuit comprises both static probabilities and neural outputs.

End-to-end learning is facilitated by differentiability of both neural networks and the arithmetic circuit. For parameter learning, the framework utilizes the gradient semiring from aProbLog, enabling the propagation of derivatives with respect to probabilistic facts and neural network weights:

$$\frac{d\mathcal{L}}{d\theta_k} = (\partial \mathcal{L}/\partial P(q)) \cdot \sum_{i} (\partial P(q)/\partial \hat{p}_i)(\partial \hat{p}_i/\partial \theta_k)$$

where $\mathcal{L}$ is the negative log-likelihood over query probabilities, $\hat{p}_i$ are neural predicate probabilities, $\theta_k$ are neural parameters, and $P(q)$ is the probability of the query. This approach enables simultaneous optimization of both neural and logical parameters (Manhaeve et al., 2019).

4. Representation and Expressivity

DeepProbLog natively supports both symbolic and subsymbolic representations:

• Symbolic: facts, background knowledge, and rules encoded in logic programming language; supports arbitrary first-order logic
• Subsymbolic: neural modules integrated via annotated disjunctions, parameterizing facts with learnable outputs

Complex reasoning tasks are encoded by combining standard logical rules with calls to neural predicates. For example:

$$\text{addition}(X,Y,Z) :- \text{digit}(X,X2),\, \text{digit}(Y,Y2),\, Z = X2 + Y2$$

With neural predicates for digit recognition, the system automates mapping images to digits, then applies the symbolic reasoning rules for addition (Manhaeve et al., 2018).

Expressivity emerges from the ability to combine hierarchical symbolic rules with neural outputs, supporting probabilistic, relational, and inductive reasoning over noisy inputs with high-level program induction capabilities.

5. Applications and Empirical Results

DeepProbLog has demonstrated empirical success on a wide range of neuro-symbolic tasks:

• Program Induction: joint learning of neural classifiers and logical rules for tasks such as MNIST digit addition, sorting, coin-ball reasoning, and program sketching with neural “holes” (Manhaeve et al., 2018)
• Complex Event Processing: modular integration with neural networks for event detection from audio streams, with rules encoding event patterns over temporal windows. Shows robustness against noisy data and supports end-to-end learning with user-defined logic (Vilamala et al., 2021)
• Human Activity Recognition: integration with Spiking Neural Networks (SNN) for stream processing; logic rules interpret neural outputs, enhancing adaptability and interpretability, with competitive accuracy versus deep baselines (Bresciani et al., 31 Oct 2024)
• Decision Tree Structure Learning: NDTs (Neurosymbolic Decision Trees) leveraging DeepProbLog’s neural predicates for hybrid symbolic-subsymbolic splitting, outperform MLPs particularly on mixed data and show improved robustness by reusing learned neural tests (Möller et al., 11 Mar 2025)

Experimental studies consistently report high accuracy, rapid convergence due to the inductive bias from symbolic knowledge, and improved interpretability relative to pure neural methods.

6. Comparative Landscape and Limitations

Relative to other neurosymbolic approaches:

• DeepProbLog employs exact inference via WMC and knowledge compilation, preserving full probabilistic logic semantics. However, this results in exponential time complexity for inference on large or highly combinatorial domains (Krieken et al., 2022).
• DeepStochLog (Winters et al., 2021) and A-NeSI (Krieken et al., 2022) propose approximations (derivation-based semantics or factorization networks respectively) that scale polynomially, trading off exact semantics for tractability in complex domains.
• DeepSeaProbLog (Smet et al., 2023) generalizes DeepProbLog to hybrid discrete–continuous domains, enabling structured probabilistic reasoning for continuous-valued data via weighted model integration.
• DeepGraphLog (Kikaj et al., 9 Sep 2025) further extends the paradigm by allowing bidirectional layering of symbolic and neural components, supporting GNNs over graph-structured symbolic data for enhanced expressivity and recursive reasoning.

DeepProbLog’s core limitations are related to scalability (exponential inference cost), manual configuration overhead for neural–logic integration, and support restricted to discrete probability distributions (addressed by successors like DeepSeaProbLog).

7. Impact, Interpretability, and Open Research Problems

DeepProbLog is cited as a principal example of TYPE 3 neural-symbolic systems (Garcez et al., 2020), wherein neural classifiers supply probabilistic inputs to an explicit symbolic reasoning module. This paradigm fosters interpretability, trust, and accountability—enabling inspection of the logical inference chain behind decisions.

It is recognized for supporting program induction, learning from examples, and handling both high-dimensional perception and relational logic in an end-to-end differentiable fashion, with empirical validation in tasks requiring complex reasoning.

Open research directions include:

• Improving scalability and efficiency of differentiable reasoning, possibly through enhanced circuit compilation or integration with database techniques (Sinha et al., 8 Sep 2025)
• Automating data preprocessing and query generation to lower integration barriers
• Expanding support for continuous probability distributions and recursive graph reasoning (Smet et al., 2023, Kikaj et al., 9 Sep 2025)
• Developing extraction of compact, symbolic explanations from deep network components to further strengthen trust and safety

DeepProbLog has established a reference point for neuro-symbolic integration, catalyzing further research on frameworks combining statistical learning with structured, interpretable reasoning.