Neuro-Symbolic Predicate Framework

• Neuro-Symbolic Predicates are formal models that integrate neural function approximation with symbolic abstraction, enabling uncertainty-aware inference and decision making.
• NSPs bridge perception and logic by mapping raw inputs to probabilistic symbolic facts via neural encoders and probabilistic circuits, facilitating robust reasoning.
• Practical implementations leverage NSPs in visual question answering, planning under uncertainty, and compositional generalization, with end-to-end differentiable learning.

A Neuro-Symbolic Predicate (NSP) is a formalism that integrates subsymbolic (neural) function approximation with symbolic (logic-based) predicate abstraction, enabling end-to-end systems that jointly perform perception, uncertainty-aware inference, and symbolic reasoning. NSPs are central to modern neuro-symbolic frameworks, appearing under various architectures and theoretical forms—often as “Neural-Probabilistic Predicates” (NPPs) in logic programming languages such as SLASH, as differentiable predicate modules in vision-language reasoning, or as robust symbolic interfaces for perception-driven planning. The NSP bridges data-driven feature extraction and logical program construction, allowing neural models to output symbolic facts with probabilistic or fuzzy semantics, which are then composed and reasoned over with formal logics such as Answer Set Programming (ASP) or first-order logic.

1. Formal Definition and Representation

An NSP generalizes the notion of a logic predicate by parameterizing it with neural or (generally) differentiable probabilistic models. Formally, given an input domain $X$ (e.g., images, object encodings) and a symbolic value set $S$ (e.g., classes, objects, relations), an NSP (in the NPP variant) is a mapping

$P_\theta : X \times S \to [0,1]$

where $P_\theta(x, s)$ denotes the estimated probability (or degree of belief) that predicate $P$ holds for input $x$ and symbol $s$ (Kamali et al., 2024, Skryagin et al., 2021, Hinnerichs et al., 2024).

NSPs appear in three principal architectures:

• Pure neural predicates, e.g., deep nets with Softmax outputs for classification tasks, providing $P_\theta(C \mid X)$.
• Probabilistic circuit (PC) predicates, e.g., Einsum or SPN-based models, enabling tractable joint, marginal, or conditional probability computations over $(X, S)$.
• Neural encoder plus PC, where an input $x$ is mapped through a neural encoder to a latent $S$0, then modeled jointly (or conditionally) with a PC to support structured uncertainty and inference (Skryagin et al., 2021, Skryagin et al., 2023).

Extensions such as (Hinnerichs et al., 2024) formalize NSPs as fully declarative binary relations, equipping each symbol $S$1 with a learned latent prototype vector $S$2 and defining probabilistic relations via learned similarities between input encodings and prototypes.

2. Inference and Integration with Symbolic Reasoning

Neuro-Symbolic Predicates are integrated with logic programming frameworks—most notably, SLASH, DeepProbLog, NeurASP, and related ASP-based approaches. The key mechanism is the replacement of fully-symbolic ground facts with choice rules whose probabilities are supplied by the outputs of NPPs/NSPs: $S$3 meaning exactly one symbolic value holds per input (Skryagin et al., 2021, Skryagin et al., 2023).

Inference consists of:

1. Grounding the logic program, instantiating all NPPs as probabilistic choices with neural/PC-supplied probabilities.
2. Model enumeration, typically via answer set solvers, to yield all stable models consistent with logic structure and NSP outputs.
3. Weighted model counting, assigning each model a probability as the product (or normalized product) of NSP outputs for the selected ground facts (Skryagin et al., 2021).
4. Query answering, by aggregating model probabilities for those models that entail the desired logical query (Skryagin et al., 2023).

Advanced frameworks support fully declarative, direction-agnostic queries: given a predicate $S$4, the inference engine can marginalize or existentially quantify either argument, enabling queries of the form $S$5, $S$6, or even higher-order constraints, without architectural changes or retraining (Hinnerichs et al., 2024).

Probabilistic circuit-backed NSPs allow tractable linear-time computation for marginals and conditionals, supporting queries over missing or uncertain data natively, which is essential for robust reasoning under incomplete perception (Skryagin et al., 2021, Skryagin et al., 2023).

3. Differentiable Composition and Learning

End-to-end differentiable neuro-symbolic systems are made possible by propagating gradients through all stages of NSP evaluation and symbolic reasoning. Composition mechanisms include:

• Soft functional composition: logical connectives ($S$7, $S$8, $S$9, $P_\theta : X \times S \to [0,1]$0, $P_\theta : X \times S \to [0,1]$1) are implemented as differentiable pooling and arithmetic over predicate scores, e.g.,
  • $P_\theta : X \times S \to [0,1]$2: ⊙ (element-wise multiplication)
  • $P_\theta : X \times S \to [0,1]$3: $P_\theta : X \times S \to [0,1]$4
  • $P_\theta : X \times S \to [0,1]$5: $P_\theta : X \times S \to [0,1]$6
  • $P_\theta : X \times S \to [0,1]$7 (Kamali et al., 2024)
• Min–max normalization: variable binding operators (e.g., $P_\theta : X \times S \to [0,1]$8) employ linear normalization to prevent score collapse and preserve gradients during backpropagation (Kamali et al., 2024).
• Gradient-based learning: parameter updates are driven by minimizing composite losses, typically a sum of negative log-likelihood for NPP outputs and cross-entropy/logical entailment losses on global task queries (Skryagin et al., 2021, Skryagin et al., 2023, Hinnerichs et al., 2024). For ASP-based reasoning, explicit formulas propagate gradients from query-level success probabilities to individual predicate beliefs.
• Joint training: Neural/PC parameters and logic-layer weights are updated in either coordinate descent or joint SGD steps, allowing structured feedback from symbolic error signals to refine neural components (Skryagin et al., 2021).

4. Practical Implementations and Use Cases

NSPs have been instantiated in a wide spectrum of tasks:

• Visual question answering and compositional generalization: LLMs extract symbolic forms from NL queries, which are translated to module calls over differentiable predicate modules. NeSyCoCo demonstrates high compositional accuracy on ReaSCAN (97.5%) and splits of CLEVR-CoGenT (99.6%/78.8%) (Kamali et al., 2024).
• Perception-to-symbolic pipelines: Systems extract probabilistic predicates from raw perception (images, fMRI, point clouds) using neural or GNN architectures, then ground these as predicates for logic-based planning and reasoning (Wu et al., 18 Nov 2025, Wang et al., 22 Feb 2026).
• Long-horizon and uncertainty-aware planning: NSP-calibrated symbolic states, coupled with explicit state/planner-level uncertainty estimates, enable systems to plan robustly under perceptual noise and to actively gather information as required (Wu et al., 18 Nov 2025, Skryagin et al., 2021).
• Predicate invention and abstraction: VisualPredicator implements online invention and selection of NSPs, building abstract world models and lifted planners compositional in the invented predicates. This supports out-of-distribution generalization and interpretable, symbolic planning (Liang et al., 2024).
• Abductive imitation learning: NSPs serve as the perception-to-symbolic interface in frameworks such as ABIL, enabling bi-level optimization (perception and abductive structure-consistent symbolic traces) that supports efficient, generalization-driven policy ensembles for sequential tasks (Shao et al., 2024).

5. NSPs versus Earlier Neuro-Symbolic Predicate Models

Earlier DPPLs and logic-neural hybrids (e.g., DeepProbLog, NeurASP) restricted neural predicates to conditional probabilities $P_\theta : X \times S \to [0,1]$9, limiting expressivity and query patterns. These systems generally lacked the ability to represent joint densities, perform marginalizations, or handle missing data natively.

Contemporary NSPs (notably as NPPs in SLASH) generalize neural predicates by:

1. Enabling the modeling of full joint probability distributions $P_\theta(x, s)$0.
2. Supporting any query direction—joint, marginal, conditional, or generative—by directly manipulating probabilistic relations (Skryagin et al., 2021, Hinnerichs et al., 2024).
3. Seamlessly integrating with logic programming interfaces, typically using a choice rule and $P_\theta(x, s)$1 argument annotation syntax for discriminative and generative queries.
4. Enabling declarative, direction-agnostic inference, such that new queries not encountered during training can be supported without retraining or reengineering (Hinnerichs et al., 2024).

A plausible implication is that NSPs, as formalized in recent literature, are a unifying abstraction for neuro-symbolic interfaces that encompass both flexible, direction-agnostic reasoning and efficient, probabilistic learning under uncertainty.

6. Theoretical Properties and Scalability

NSPs inherit expressive power from their neural and symbolic components:

• Expressivity: Arbitrary first-order logic structures, differentiable modules for perception, and tractable density estimation via PCs.
• Soundness of inference: Weighted model counting and probabilistic graphical models underpin exact and approximate reasoning schemes, with theoretical guarantees for convergence and uncertainty calibration (Skryagin et al., 2021, Wu et al., 18 Nov 2025).
• Scalability: Techniques such as probabilistic circuit inference (linear-time marginalization) and pruning of stochastically insignificant models (“SAME” in SLASH) enable reasoning to scale to large program graphs, high-dimensional input spaces, and complex rule systems (Skryagin et al., 2023, Skryagin et al., 2021).

Empirically, NSP-driven systems demonstrate improved accuracy, calibrated uncertainty, data efficiency, and robust OOD generalization across perception, reasoning, and planning tasks.

7. Limitations, Open Questions, and Future Directions

Current challenges include:

• The need for semantic calibration and interpretable failure modes when neural backends are uncertain or adversarially perturbed.
• Complexity in the joint learning of predicate spaces, especially for online predicate invention and abstraction hierarchy formation (Liang et al., 2024).
• Computational tractability for very high-arity predicates or deeply nested symbolic queries.

Research in declarative NSP frameworks suggests promising directions for embedding fully bi-directional, template-driven neural predicates within logical systems, thereby matching or superseding the versatility of classical logic programming while leveraging the power and robustness of modern neural architectures (Hinnerichs et al., 2024, Skryagin et al., 2021).

---

References

• (Skryagin et al., 2021) SLASH: Embracing Probabilistic Circuits into Neural Answer Set Programming
• (Skryagin et al., 2023) Scalable Neural-Probabilistic Answer Set Programming
• (Kamali et al., 2024) NeSyCoCo: A Neuro-Symbolic Concept Composer for Compositional Generalization
• (Hinnerichs et al., 2024) Declarative Design of Neural Predicates in Neuro-Symbolic Systems
• (Wu et al., 18 Nov 2025) A Neuro-Symbolic Framework for Reasoning under Perceptual Uncertainty: Bridging Continuous Perception and Discrete Symbolic Planning
• (Shao et al., 2024) Learning for Long-Horizon Planning via Neuro-Symbolic Abductive Imitation
• (Liang et al., 2024) VisualPredicator: Learning Abstract World Models with Neuro-Symbolic Predicates for Robot Planning
• (Wang et al., 22 Feb 2026) Neuro-Symbolic Decoding of Neural Activity
• (Kiruluta, 19 Aug 2025) A Fully Spectral Neuro-Symbolic Reasoning Architecture with Graph Signal Processing as the Computational Backbone