Neuro-Symbolic Frameworks: Conceptual Characterization and Empirical Comparative Analysis

Abstract

Neurosymbolic (NeSy) frameworks combine neural representations and learning with symbolic representations and reasoning. Combining the reasoning capacities, explainability, and interpretability of symbolic processing with the flexibility and power of neural computing allows us to solve complex problems with more reliability while being data-efficient. However, this recently growing topic poses a challenge to developers with its learning curve, lack of user-friendly tools, libraries, and unifying frameworks. In this paper, we characterize the technical facets of existing NeSy frameworks, such as the symbolic representation language, integration with neural models, and the underlying algorithms. A majority of the NeSy research focuses on algorithms instead of providing generic frameworks for declarative problem specification to leverage problem solving. To highlight the key aspects of NeSy modeling, we showcase three generic NeSy frameworks—DeepProbLog, Scallop, and DomiKnowS. We identify the challenges within each facet that lay the foundation for identifying the expressivity of each framework in solving a variety of problems. Building on this foundation, we aim to drive transformative action and encourage the community to rethink this problem in novel ways.

1. Introduction

Symbolic or good old-fashioned artificial intelligence (AI) focused on creating rule-based reasoning systems (Hayes-Roth, 1985) exemplified by early works such as the Physical Symbol System (Augusto, 2021; Newell, 1980) and ELIZA (Weizenbaum, 1966). However, drawbacks such as limited scalability due to the need to explicitly define domain predicates and rules for each task, lack of robustness in handling messy real-world data, and low computational efficiency led to a decline in the popularity of this paradigm, shifting the focus toward neural computing and deep learning. Deep Learning (Ahmad et al., 2019; LeCun et al., 2015) revolutionized AI, as nuanced relationships in data could be learned by backpropagation through multiple layers of processing and creating abstract representations of data. However, it led to a loss of explainability (Li et al., 2023a), dependence on large amounts of data, lack of generalizability for unobserved situations, and rising concerns about its environmental sustainability (Bender et al., 2021). Neurosymbolic (NeSy) AI (Bhuyan et al., 2024; Hitzler & Sarker, 2021), a combination of symbolic AI and reasoning with neural networks, attempts to incorporate the capabilities of both worlds and create systems that are data and time efficient, generalizable, and explainable. NeSy models have been applied to several real-world applications (Bouneffouf & Aggarwal, 2022) in safety-critical areas (Lu et al., 2024) such as healthcare (Hossain & Chen, 2025) and autonomous driving (Sun et al., 2021). Several techniques have been proposed for this integration (Jayasingha et al., 2025; Kautz, 2022), trying to combine the advantages and mitigate the disadvantages of both symbolic and neural methods. However, due to the lack of unified libraries to facilitate this research and the focus on specific algorithms rather than generic frameworks, this research becomes less impactful. Moreover, the few generic frameworks tend to vary in problem formulation, implementation, algorithms, and flexibility of use. This poses a challenge in being able to compare their performance uniformly or identify a research direction that improves on previous work. To alleviate this issue, we provide a comparative study with the following key contributions, (a) Identifying the main components of existing NeSy frameworks, (b) Comparison of frameworks across the identified facets, (c) Highlighting the requirements for the next generation of NeSy frameworks, building upon the drawbacks of the current systems and the possible interplays between the neural and symbolic components. We plan to expand this study to cover more frameworks, while the three selected ones are used to explain the aspects of our characterization. These frameworks are demonstrated with four example tasks detailed in this paper tying the comparative facets concretely with a technical implementation. ¹

2. NeSy Frameworks

A NeSy framework should provide flexibility for modeling both neural and symbolic components and their interplay in a unified declarative framework, going beyond specific underlying algorithms and techniques (Kordjamshidi et al., 2016, 2015). On the symbolic side, a generic framework should support a symbolic representation language that can be seamlessly connected to neural components and cover various underlying symbolic reasoning mechanisms. On the neural side, we need to have the flexibility of connecting to various architectures, including various loss functions, sources of supervision, and training paradigms. More importantly, a NeSy framework should provide a modeling language for seamless integration of these two paradigms in building pipelines, joint decision-making models, and, in general, for arbitrary configurations of multiple models. Such a NeSy framework should support NeSy training and inference beyond specific integration algorithms. We distinguish between NeSy techniques and NeSy frameworks. By techniques, we mean when problem-specific algorithms are provided (Burattini et al., 2002; Lample & Charton, 2020). For example, AlphaGo (Silver et al., 2016) introduced a reinforcement learning solution to Go, using Monte Carlo Tree Search as a symbolic component inside a neural network. Another example is NS-CL (Mao et al., 2019) (NeSy Concept Learner) that integrates neural perception with symbolic reasoning to learn visual concepts and compositional language grounding for VQA tasks. Many other techniques and algorithms are proposed for the interplay between the two paradigms (Badreddine et al., 2022(@; Cohen et al., 2017; Lamb et al., 2020(@; Lima et al., 2005; Sathasivam, 2011; Serafini and d’Avila Garcez, 2016; Smolensky et al., 2016; Zhang et al., 2024) some of which are employed in the generic frameworks, such as Inference Masked Loss (Guo et al., 2020), Semantic Loss (Xu et al., 2018), Primal-Dual (Nandwani et al., 2019). NeSy techniques often lack the generality of frameworks, which are designed as broader tools intended for practical use and extensibility with new integration algorithms and with the capability of programming and configuring the two parts and their interplay.

In this work, we illustrate these components by focusing on a selection of representative, generic NeSy frameworks. These frameworks are chosen for their contribution to advancing the development of general-purpose approaches. DeepProbLog (Manhaeve et al., 2021) is a probabilistic logic programming language that incorporates neural predicates in logic programming with an underlying differentiable translation of logical reasoning. The probabilistic logic programming component is built on top of ProbLog (De Raedt et al., 2007). DomiKnowS (Faghihi et al., 2024, 2023; Rajaby Faghihi et al., 2021) is a declarative learning-based programming framework (Kordjamshidi et al., 2022) that integrates symbolic domain knowledge into deep learning. It is a Python framework that facilitates the incorporation of logical constraints that represent domain knowledge with neural learning in PyTorch. Scallop (Huang et al., 2021; Li et al., 2024, 2023b) is a framework that includes a flexible symbolic representation based on relational data modeling, using declarative logic programming similar to DeepProbLog while it is based on Datalog (Abiteboul et al., 1995) instead of Prolog. We also point to less general frameworks such as LEFT (Hsu et al., 2023) that is designed for grounding language in visual modality and compositional reasoning over concepts. The framework consists of a large language model (LLM) interpreter that converts natural language to logical programs. The generated programs are directed to a differentiable, domain-independent, and soft first-order logic-based executor. LEFT is limited to tasks requiring grounding language in vision such as visual question answering (Johnson et al., 2017; Liu et al., 2019; Yi et al., 2018). Building on this foundation, NeSyCoCo, (Kamali et al., 2025) has been introduced to address the limitations of LEFT, particularly the challenge of lexical variety of natural language and alleviating the issue of non-canonical predicate logic representations for handling unseen concepts. NeSyCoCo extends LEFT’s approach by using distributed word representations to connect a wide variety of linguistically motivated predicates to neural modules, thus alleviating the reliance on a predefined predicate vocabulary. PyReason (Aditya et al., 2023) is a library built to support reasoning on top of outputs from neural networks. The neural component produces outputs such as labels or concept scores, while the symbolic component does graph-based reasoning with logical rules declared in a graph structure. It can produce an explanation trace for inference and has a memory-efficient implementation. PLoT (Wong et al., 2023) (Probabilistic Language of Thought) is a proposed framework leveraging neural and probabilistic modeling for generative world modeling. It models thinking with probabilistic programs and meaning construction with neural programs. The goal is to provide a language-driven unified thinking interface. CCN+ (Giunchiglia et al., 2024) is a framework that modifies the output layer of a neural network to make results compliant with requirements that can be expressed in propositional logic. A requirement neural layer, ReqL, is built on top of the neural network. The standard cross-entropy loss is adapted into a ReqLoss to learn from the constraints in the ReqL layer. While CCN+ is a general framework, the underlying NeSy technique follows similar ideas that integrate logic in the architecture in (Li & Srikumar, 2019). DeepLog (Derkinderen et al., 2025) is another proposed NeSy AI framework that unifies logic and neural computation using a declarative paradigm. It introduces the DeepLog language, an annotated neural extension of grounded first-order logic that can abstract over various logics and apply them either within the model architecture or in the loss function. It employs computational algebraic circuits implemented on GPUs, forming a NeSy abstract machine. DeepLog allows efficient specification and execution of diverse NeSy models and inference tasks in a declarative fashion.

In this paper, we characterize the more generic NeSy frameworks based on: (a) Symbolic knowledge representation language, (b) Representation and flexibility of Neural Modeling, (c) Model Declaration, (d) Interplay between symbolic and sub-symbolic systems, and (e) The usage of LLMs. Figure 1 shows the connection between these aspects. The neural representations and the symbolic representations are the two main components of a NeSy framework. The neural representation guides learning and obtains supervision from the data, while the symbolic representations leverage symbolic reasoning and exploit symbolic knowledge during training or inference. Table 1 shows an overview of the frameworks across selected factors. In the next sections, we focus on DomiKnowS, DeepProbLog, and Scallop to provide a deeper investigation of the challenges in each component. Depending on the framework, certain tasks are easier to implement, while others require more effort. The chosen frameworks enable us to solve the same task in multiple frameworks.

Figure 1.

An overview of various components of a NeuroSymbolic artificial intelligence (AI) framework. NeuroSymbolic AI is at the intersection of symbolic reasoning and neural learning, depicted in green and purple, respectively. The interplay techniques can be classified into six types, shown in the middle. Arrows indicate the connections between components (not the computation flow).

Table 1.

Comparison of Frameworks and Key Factors.

	Symbolic			Interplay
Framework	Lang	Knowledge Rep	Model Dec	Algorithm	Eff	LLM
CCN+	None	Propositional Logic	✗	Learning from constraints	✗	✗
DomiKnowS	None	Concepts & Relations graph, FOL	$✓$	Learning from constraints	✗	Faghihi et al. (2024)
DeepProbLog	ProbLog	FOL	✗	Deductive Reasoning	✗	✗
LEFT	None	FOL	✗	Differentiable soft logic	✗	Hsu et al. (2023)
PyReason	None	FOL	✗	Graph Reasoning	$✓$	✗
Scallop	DataLog	FOL	✗	Deductive Reasoning	$✓$	Li et al. (2024)

Lang: external language required; Knowledge Rep: knowledge representation; Model Dec: model declaration flexibility; Algorithm: supported algorithm(s) for learning and inference; Eff: computational efficiency considerations; LLM: use of large language models, FOL: first order logic.

3. Symbolic Knowledge Representation

Generic NeSy systems and frameworks use symbolic knowledge representation languages to encode constraints, facts, probabilities, and rules. Frameworks vary in how they represent and integrate this symbolic knowledge. Many employ classical formal logic, grounded in well-defined syntax and semantics, and adapt these representations and reasoning mechanisms within a unified integration framework. Some frameworks build on established formalisms such as logic programming or constraint satisfaction. In contrast, others take an entirely new hybrid semantics, while preserving conventional symbolic syntax. Table 2 compares the implementation of symbolic knowledge (concepts or facts) for the MNIST Sum task. In general, the domain knowledge consists of the two concepts of digits and the sum.

Table 2.

Comparison of Symbolic Representation Across Frameworks.

As can be seen, DomiKnowS represents a part of symbolic domain knowledge as a graph $G(V,E)$ , where the nodes are the concepts in the domain and the edges are the relationships between them. Each node can have properties. More complex knowledge beyond entities and relations is expressed with a pseudo first-order logical language with quantifiers designed in Python. DomiKnowS mostly interprets the symbolic knowledge as logical constraints, such as the implementation of sum_combinations in the given example. Unlike the other frameworks, DomiKnowS does not build on predefined formal semantics. It follows a FOL-like syntax for symbolic logical representations, making it independent of the formal semantics of an underlying formal language and allows more flexibility of representations and adaptation to underlying algorithms in the framework. DeepProbLog, on the other hand, utilizes logical predicates that are originally a part of the probabilistic logic programs (Ng & Subrahmanian, 1992) of ProbLog (De Raedt et al., 2007), for its symbolic representation. These neural predicates obtain their probability distributions from the underlying neural models. Probabilistic facts, neural facts, and neural annotated disjunctions (nADs) whose probabilities are supplied by the neural component of the program can be added. Here, digit is a neural predicate as indicated by the use of nn( $\cdots$ ). DeepProbLog follows the formal semantics of Prolog (Clocksin & Mellish, 2003), followed by ProbLog, its probabilistic extension. Finally, Scallop adopts a relational data model for symbolic knowledge representation (Kolaitis & Vardi, 1990). Scallop is built on top of the syntax and formal semantics of Datalog and its probabilistic extensions, relaxing the exact semantics of ProbLog. It allows for the expression of common reasoning, such as aggregation, negation, and recursion. Similar to DeepProbLog, some of these predicates in the symbolic part obtain their probability distribution from neural models, such as digit_1 and digit_2. Additionally, while ProbLog requires exhaustive search for computations, Datalog can use top-k results and exploit database optimizations, making Scallop algorithmically more time-efficient than DeepProbLog.

4. Neural Models Representations

The other core component of a NeSy system is the neural modeling that is integrated with the symbolic knowledge discussed above. The neural models are mostly wrapped up under the logical predicate names in most of the frameworks that have an explicit logical knowledge representation language. To best leverage the reasoning capabilities of the symbolic system available and the ability of neural models to learn abstract representations from data, the neural models are used as abstract concept learners for the concepts defined as logical predicates in the symbolic representation. The neural model representation is often used to predict probability distributions for the symbolic concepts based on raw sensory inputs. Given that NeSy frameworks are explicit about the symbolic concepts and relations, reading data into the symbolic representation requires special considerations for processing raw data, putting data into structure, and Data Modeling. The aspect of data modeling is often ignored in current Nesy frameworks and it is done by the programmers in an ad hoc pre-processing step. The neural modeling is often written using standard deep learning libraries, such as PyTorch (Paszke et al., 2019).

Table 3 shows snippets of neural modeling expressions across frameworks, highlighting differences in implementation. Scallop utilizes relatively standard neural modeling using PyTorch, while needing an added context of symbolic rules. Although integrated into Python, the context relation and rule setup are verbatim from DataLog and only passed as a parameter to a function, which requires familiarity with DataLog and its semantics. DeepProbLog, on the other hand, needs manual configuration of the raw data and processing into queries built for ProbLog, on top of other standard neural components. This processed data is passed into the neural network which is then connected to a ProbLog program, such as addition.pl in the figure. DomiKnowS’s neural component is built in PyTorch. Unlike other frameworks, DomiKnowS has built-in components called Readers, Sensors and Module learners for a more transparent data modeling, making the connection to neural components and feeding data into them explicitly in the program. This provides more flexibility in connecting the concepts to deterministic or probabilistic functions that can interact with other symbolic concepts. The module learner can also use custom models. This makes the interaction with raw data structured, transparent, and controllable.

Table 3.

For Neural Integration, DomiKnowS Utilizes Sensors and Readers for Reading in Data, while a Learner Connects to a Network.

5. Model Declaration

Most frameworks utilize neural components as abstract concept learners and use a symbolic component to reason over the learned concepts. Each learner is a model and model declaration refers to the flexibility of modularizing and connecting different learners. Each learner can receive supervision independently. In most NeSy frameworks, the supervision from data is usually provided based on the final output of the end-to-end model. For example, in an MNIST Sum task used throughout and detailed in Section 8, the neural and symbolic components are trained based on the final output of the sum, without access to individual digit labels in a semi-supervised setting. The task loss, for example, a Cross-Entropy Loss, is computed, and errors are backpropagated through the differentiable operations that led to the output generation. For example, in DeepProbLog, we can declare a single loss function associated with the entire neural component. Gradient computations differ across frameworks depending on whether losses are defined individually for each neural output or specified as a single global loss function. However, there remains a need for models capable of incorporating supervision at multiple levels of their symbolic representations. In DomiKnowS, loss computation can be defined for each symbol. Since each concept is linked to both learning modules and ground-truth labels, their losses can be integrated seamlessly. This enables joint training of all concepts alongside the target task, allowing each concept to be optimized more effectively—leveraging available data without relying solely on the target task’s output. In other words, it provides the flexibility of building pipelines of decision making, obtaining distant supervision in addition to joint training and inference. Model declaration is very well manifested in modern tools and libraries for building agentic frameworks, where multiple agents are structured into pipelines or graphs to make communicative decisions by passing the output of one agent as input to another (Plaat et al., 2025).

6. Interplay Between Symbolic and Subsymbolic

Kautz (2022) provides a characterization of the possible interplays between symbolic and sub-symbolic components. This interplay of NeSy can be explained by the concept of System 1 and System 2 thinking described in Kahneman (2011). Research in this field aims to create an ideal integration that seamlessly supports “thinking fast and slow” (Booch et al., 2021; Fabiano et al., 2023). Here, System 1 refers to the fast neural processing, while System 2 corresponds to the slower, more deliberate symbolic reasoning. Different methods for the integration of symbolic reasoning and neural programming have been explored such as employing logical constraint satisfaction, integer linear programming (ILP), differentiable reasoning, and probabilistic logic programming. In this section, we will discuss a system-level algorithmic comparison of the different frameworks.

DomiKnowS models the inference as an ILP problem to enforce the model to follow constraints expressed in first-order logical form (Van Hentenryck et al., 1992). The objective of the program is guided by the neural components, and the framework supports multiple training algorithms for learning from constraints. The Primal-Dual formulation (Nandwani et al., 2019) converts the constrained optimization problem into a min-max optimization with Lagrangian multipliers for each constraint, augmenting the original loss with a soft logic surrogate to minimize constraint violations. Sampling-Loss (Ahmed et al., 2022), inspired by semantic loss (Xu et al., 2018) and samples a set of assignments for each variable based on the probability distribution of the neural modules’ output. ILP(Cropper & Dumančić, 2022) formulates an optimization objective based on Inference-Masked Loss(Guo et al., 2020) to constrain the model during training. The training goal is to adjust the neural models to produce legitimate outputs that adhere to the given constraints. At prediction time, ILP can also be applied to enforce final predictions that comply with given constraints. DomiKnowS relies on the off-the-shelf optimization solver Gurobi (Gurobi Optimization, LLC, 2024). DeepProbLog models each problem as a probabilistic logical program that consists of neural facts, probabilistic facts, neural predicates, and a set of logical rules. A joint optimization of the parameters of the logic program is done alongside the parameters of the neural component. Neural network training is done using learning from entailment (Frazier & Pitt, 1993) while in ProbLog, gradient-based optimization is performed on the underlying generated Arithmetic Circuits (Shpilka & Yehudayoff, 2010), which is a differentiable structure. The Arithmetic Circuits are transformed from a Sentential Decision Diagram (Darwiche, 2011) generated by ProbLog. Algebraic ProbLog (Kimmig et al., 2011) is used to compute the gradient alongside probabilities using semirings (Eisner, 2002). Scallop is similar in its setup to DeepProbLog, where it creates an end-to-end differentiable framework combining a symbolic reasoning component with a neural modeling component. They aim to relax the formal semantics required by the use of ProbLog in DeepProbLog and instead rely on a symbolic reasoning language extending DataLog, built into their framework. They have a customizable provenance semiring framework (Green et al., 2007), where different provenance semirings, such as the extended max-min semiring and the top-k proofs semiring, allow learning using different types of heuristics for gradient calculations. Table 4 compares the computational efficiency of these models at training and inference time on a single training/testing example. As theoretically suggested, Scallop is expected to outperform other frameworks in inference and training speed, owing to its memory and time-efficient implementation in Rust. The results in Table 4 support this expectation, with Scallop achieving the fastest inference time, on par with DomiKnowS. In practice, DeepProbLog achieves slightly faster training performance than Scallop. This discrepancy may be due to overhead unrelated to the core algorithmic complexity. DomiKnowS exhibits slower training due to the overhead of uploading the entire graph of data into memory.

Table 4.

Time and Space Efficiency for Each Framework Across 4 Tasks.

	MNIST Sum			Toy-NER
Framework	Training Time (ms)	Testing Time (ms)	Memory (MB)	Training Time (ms)	Testing Time (ms)	Memory (MB)
DomiKnowS	37.72	2.34	573.80	14.86	14.29	576.82
DeepProbLog	5.84	3.24	739.72	20.74	20.47	3767.08
Scallop	6.50	2.35	581.36	1.50	1.05	297.1
	Math-Inference			Simple VQA
Framework	Training Time (ms)	Testing Time (ms)	Memory (MB)	Training Time (ms)	Testing Time (ms)	Memory (MB)
DomiKnowS	77.46	69.58	1039.30	81.02	60.52	1413.44
DeepProbLog	5.54	5.07	1588.30	755.13	363.81	1346.23
Scallop	0.948	0.223	345.48	13.17	22.66	768.4
LEFT	N/A	N/A	N/A	6.19	3.44	755.1

Time and memory records are averaged over 5 runs. Times are in milliseconds per sample. Memory utilization is in megabytes and indicates the overall memory for training.

7. Role of LLMs

Large foundation models hold significant promise for overcoming the bottleneck of acquiring symbolic representations, which are essential for symbolic reasoning and consequently in NeSy frameworks.

Source of Symbolic Knowledge: The symbolic knowledge in NeSy systems, which is integrated with the neural component, can originate from several distinct sources. While most systems require explicit, hand-crafted symbolic knowledge, earlier classical logic-based learning research can be used for automatically learning rules from data by using inductive logic programming (Bratko & Muggleton, 1995; Nienhuys-Cheng & de Wolf, 1997) or mining constraints. Nowadays, even LLMs can be utilized to generate symbolic knowledge (Acharya et al., 2024; Mirzaee & Kordjamshidi, 2023; Pan et al., 2023a; Xu et al., 2024a). Several NeSy frameworks and systems have tried utilizing large foundation models to generate the symbolic knowledge, based on the task or query, to overcome the labor-intensive nature of hand-crafting rules for every single task and the time required in the automatic learning of symbolic knowledge from data (Ishay et al., 2023; Xu et al., 2024a; Yang et al., 2024). Extraction of symbolic representations from Foundation Models has become possible given the vast implicit knowledge stored within these models, such as LLMs and multimodal models, which are trained on massive and diverse corpora (Li et al., 2024; Petroni et al., 2019). These models can generate symbolic content (e.g., candidate rules, knowledge graph triples, or logic statements), perform reasoning that mimics symbolic inference, or act as components alongside symbolic modules (Fang & Yu, 2024). For example, LLMs can be prompted to extract facts from unstructured text, effectively populating a symbolic knowledge graph (Yao et al., 2025). Techniques like Symbolic Chain-of-Thought inject formal logic into the LLM’s reasoning process, improving accuracy and explainability on logical reasoning tasks (Xu et al., 2024b). However, foundation models are prone to hallucinations and lack the strict logical guarantees of traditional symbolic systems (Zheng et al., 2024). Therefore, integrating foundation models often requires careful prompting, verification steps to ensure reliability (Xu et al., 2024b). Generation of inputs to symbolic engines: LLMs have also been used to generate translations from raw inputs, specially natural language, to symbolic language that is then fed into a symbolic reasoner. In examples such as Logic-LM (Pan et al., 2023b), LLMs are leveraged to convert a natural language query into symbolic language that is then solved by a symbolic reasoner. This method improves the performance of unfinetuned LLMs on logical reasoning-based tasks. DomiKnowS (Faghihi et al., 2024) takes this a step further by enabling users to describe problems in natural language, which LLMs then use to generate relevant concepts and relationships. Through a user-interactive process, these concepts and relationships are refined iteratively. Finally, the LLM translates the user-defined constraints from natural language into first-order logic representations before converting them into DomiKnowS syntax. Some systems use LLMs in multiple capacities. In VIERA (Li et al., 2024), which is built on top of Scallop, 12 foundation models can be used as plugins. These models are treated as stateless functions with relational inputs and outputs. These foundation models can be either language models like GPT (OpenA et al., 2024) and LLaMA (Touvron et al., 2023), vision models such as OWL-ViT (Minderer et al., 2022) and SAM (Kirillov et al., 2023), or multimodal models such as CLIP (Radford et al., 2021). These models can be used to extract facts, assign probabilities, or for classification, and are treated as “foreign predicates” in their interface. An older version, DSR-LM (Zhang et al., 2023) of this utilized BERT-based language models for perception and relation extraction, combined with a symbolic reasoner for question answering. LEFT, on the other hand, uses LLMs both for the generation of the concepts that are used for grounding and as an interpreter to generate the first-order logic program corresponding to a natural language query, that is solved by the symbolic executor.

8. Example Tasks

NeSy frameworks formulate problems in various ways based on their implementation and symbolic interpretation. In DomiKnowS, the symbolic reasoning part is formulated as a logical constraint solving problem. The domain is represented as a graph $G(V,E)$ , where the nodes are the concepts in the domain and the edges are the relationships between them. Each node can have properties. The final logical constraints apply to the graph concepts. In DeepProbLog, the symbolic reasoning problem is interpreted as probabilistic logic programs in ProbLog. In Scallop, similarly, the problem is viewed as a combination of the neural and the symbolic components, where the symbolic part is a probabilistic logical program similar to DeepProblog with further optimized inference. In LEFT, the problem is limited to the application of concept learning and grounding language into the visual modality. Here, the neural model is composed of feature extractors, object and relation classifiers (concept learners), and a first-order logic program generator for a given question. In this section, we will compare the problem formulations in each of these frameworks for a set of tasks. Note that we only include LEFT for the visual question answering task due to the domain-specific nature of the framework. All code associated with these tasks and referenced in this section is maintained publicly on GitHub.¹

8.1. MNIST Sum

The MNIST Sum task is an extension of the classic MNIST handwritten digit recognition task (Lecun et al., 1998), where given two images of digits, the task is to output their sum that is a whole number. The training examples consist of the two images of the digits and the ground-truth label of their sum. The individual labels of the digits are not available for training.

8.1.1. DomiKnowS

Problem Specification

DomiKnowS formulates the problem using graph representations of concepts, relations, and logic. For performing the MNIST Sum task in DomiKnowS, the first concept defined is image concept representing visual information. The digit concept, a subclass of image, is introduced to represent the output class, ranging from 0 to 9. To establish relationships between digit images, the image pair concept is defined as an edge connecting two digit concepts. The sum concept is then introduced under the image pair to represent the summation of the two digit concepts and the ground-truth output of the program. For this task, three constraints are defined. The first two constraints utilize exactL to ensure that the predicted digit and sum values belong to only one valid class. Another constraint enforces that the expected sum value matches the sum of the two digit predictions. This is implemented using ifL constraints, which verify whether the predicted digits form one of the possible solutions for a valid sum. If multiple solutions exist, the orL constraint ensures that at least one of the answers corresponds to the predicted digits.

Neural Modeling

The model declaration comprises standard neural modeling components, including data loading, pre-processing, neural network definition, and loss function specification. The process begins with the ReaderSensor, which reads the input image. Next, a relation concept is defined using another sensor, JointSensor, to establish connections between images. The module learner is then employed to generate an initial prediction for the digit concept, which is subsequently passed to another sensor, FunctionalSensor, to compute the sum of two images.

8.1.2. DeepProbLog

Problem Specification

DeepProbLog formulates a problem regarding probabilistic facts, neural facts, and nADs. In the MNIST Sum task, the fact $X$ is defined to represent the input image. A neural network function is then introduced to map $X$ to its corresponding digit, denoted as digit( $X,Y$ ). To enforce constraints about the summation and the ground-truth sum, a function is defined to compute the sum of two digits.

Neural Modeling

The neural modeling follows a standard neural network setup, such as a CNN-based classifier. It is preceded by data loading and pre-processing, which are performed separately from the ProbLog program. Thus, the neural model used in DeepProbLog can be initialized independently of the DeepProbLog model. Once the neural model is initialized, the framework passes it along with a probabilistic program as input.

8.1.3. Scallop

Problem Specification

Scallop formulates the problem in terms of relations, values, and (Horn) rules derived from Datalog. As discussed earlier, the concepts and constraints defined in this framework are similar to those in DeepProbLog. However, these rules can be directly embedded into a Scallop program through its API. The process begins by establishing the concepts digit1 and digit2 to represent the digit values of two given images. Based on the summation of these two values, it must be equal to the $sum\mathrm{\_}2$ logical reasoning module, which serves as the ground truth for this task.

Neural Modeling

Unlike DeepProbLog, the neural modeling is integrated with Scallop’s relation and rule declaration. The neural modeling remains a standard neural network.

8.2. Shapes

The Shapes dataset is a synthetic VQA benchmark designed to evaluate elementary spatial reasoning. Each sample consists of a $128\times 128$ pixel image where the task is to answer the fixed question: “Is there a red shape above a blue circle?”. The primary rationale for using a synthetic dataset is to create a controlled experimental environment. This approach allows us to isolate specific reasoning skills—such as attribute binding and relational understanding—from the perceptual complexities and spurious correlations.

Positive examples are generated by programmatically placing a red object (circle, square, or triangle) above a blue circle. In negative examples, this specific spatial configuration is absent. To increase task complexity, every image also contains one to three randomly placed, non-overlapping distractor objects with varying shapes and colors. The dataset comprises 2,000 images, divided into perfectly balanced training and testing sets of 1,000 samples each. Examples of this benchmark are shown in Figure 2.

Figure 2.

Examples from the shapes dataset for the question “Is there a red shape above a blue circle?” True example: A red triangle is above a blue circle and False example: No red shape is above a blue circle.

8.2.1. Common Perception—Reasoning Interface

We decompose the system into: (i) a neural perception unit producing distributions over object attributes and pairwise relations; and (ii) a symbolic reasoning unit that consumes these as soft facts over the object domain and evaluates a single existential rule encoding the query. Supervision is a binary yes/no label optimized via a cross-entropy loss on the final answer distribution.

8.2.2. DomiKnowS

Problem Specification

DomiKnowS formulates the problem as a graph representation. It first declares the image concept to represent the visual input. The objects concept is then defined to represent the individual objects contained within the image. An explicit connection declaration is established in the framework between images and objects, indicating that each image may contain multiple objects. Under the image concept, two additional concepts—color and shape—are introduced to represent the attributes of each object for each shape and color considered. These two concepts serve as the outputs of the neural modeling component. Next, DomiKnowS defines a relation concept between pairs of objects to capture their relational structure within the same image. Finally, symbolic reasoning is expressed using existsL, which denotes the existence of a particular combination of queries. The inference takes the following form:

$$\mathtt{\text{existsL(is\_red(X), is\_blue(Y), is\_circle(Y), relation(Rel))}}$$

where the $X$ and $Y$ represent the first object and the second object, $Rel$ represent the relation of $X$ and $Y$ .

Neural Modeling

DomiKnowS uses a class of functions called ReaderSensors to process the raw input data. A ModuleLearner is then employed to query the object-centric encoder, producing representations of the objects within the image. These representations are subsequently passed to three ModuleLearner to predict the color (red and blue) and shape (circle) attributes of the objects. A CompositionCandidateSensor is used to connect pairs of objects within the image, providing the information needed to compute their relations. Finally, the framework aggregates all information through predefined logical expressions, which are used to infer the final output.

8.2.3. DeepProbLog

Problem Specification

We use a ProbLog program with nADs for color(Image,O,C), shape(Image,O,S), and relation(Image,O1,O2,R). The decision rule is:

$$\begin{array}{rl}& \mathtt{\text{answer(Image, yes) :- obj(O1), obj(O2),}}\\ & \mathtt{\text{ O1 /= O2,}}\\ & \mathtt{\text{ color(Image,O1,red),}}\\ & \mathtt{\text{ color(Image,O2,blue),}}\\ & \mathtt{\text{ shape(Image,O2,circle),}}\\ & \mathtt{\text{ relation(Image,O1,O2,R).}}\end{array}$$

A complementary answer(Image, no) ensures a normalized binary outcome. The object domain $\mathtt{\text{obj/1}}$ is declared up to $n_{max}$ derived from annotations. Batched queries are issued as answer(tensor(batch(I)), Y) and solved with an exact engine.

Neural Modeling

An object-centric encoder crops and embeds objects; heads output categorical distributions for color and shape per object and for relation per ordered object pair. These heads are wrapped as DeepProbLog networks and bound to the program’s neural predicates, enabling end-to-end training from the answer predicate.

8.2.4. Scallop

Problem Specification

We declare unary predicates over object indices for attributes (red(i), blue(j), circle(j)) and a binary predicate for the chosen spatial relation R(i,j). The query is encoded as a Horn rule:

$$\mathtt{\text{ans()}}:-\mathtt{\text{red(i)}},\mathtt{\text{blue(j)}},\mathtt{\text{circle(j)}},\mathtt{\text{above(i, j)}}.$$

Scallop maps soft facts to weighted relations under a differentiable provenance and produces a normalized {yes,no} answer.

Neural Modeling

Per-object (color, shape) and per-pair (relation) distributions from the encoder are converted to Scallop facts, respecting masks for padded objects and pairs. The Scallop context composes these facts with the rule to yield the answer distribution, providing gradients to the neural unit.

8.2.5. LEFT

Problem Specification

We express the query in first-order logic executed by LEFT’s generalized FOL executor:

$$\begin{array}{r}\mathtt{\text{exists(Object, lambda x: exists(Object, lambda y:}}\\ \mathtt{\text{ above(y, x) and red(x) and circle(y) and blue(y)))}}\end{array}$$

The executor grounds over the object domain and evaluates the formula using attribute predicates for unary properties and a binary predicate for the relation, returning a scalar decision consistent with the query.

Neural Modeling

The object-centric encoder yields per-object attribute scores (for color/shape) and per-pair relation scores. These tensors parameterize the executor’s predicates, forming a differentiable perception–reasoning pipeline trained on the binary supervision.

8.3. Toy NER

For a simplified, toy version of the Named-Entity Recognition task (Tjong Kim Sang and De Meulder, 2003), we create a dataset of randomly generated embeddings representing persons and locations. The objective is to learn the concepts of “works_in,” that is, whether a person works in a location, and “is_real_person,” that is, whether a given embedding is a person or not. These concepts are learned using indirect supervision on two queries, that compose the atomic concepts.

$$\begin{array}{rl}& \mathtt{\text{constraint1 = is\_real\_person(P1) AND works\_in(P1,L1) AND is\_real\_person(P2)}}\\ & \mathtt{\text{AND works\_in(P2,L2)}}\\ & \mathtt{\text{constraint2 = is\_real\_person(P2) AND works\_in(P2,L2)}}\\ & \mathtt{\text{OR is\_real\_person(P3) AND works\_in(P3,L3)}}\end{array}$$

Here, $P1,P2,P3,L1,L2,L3$ are input embeddings with Ps representing persons and Ls representing locations. Thus, the final task is to predict the output of these two constraints (true or false), given 6 embeddings corresponding to 3 persons and 3 locations.

8.3.1. DomiKnowS

Problem Specification

To perform the Toy NER task, DomiKnowS begins by constructing a graph representation of the problem. It first defines the person and location concepts to represent the entity types of interest. Under the person concept, three sub-concepts are declared to represent three individual persons, and under the location concept, three sub-concepts are introduced to represent distinct locations. A pair relation is then defined to connect a person and a location. This relation is used to create three separate work_in[i] concepts, each representing the output relation between person $i$ and location $i$ . Finally, the inference queries are expressed in a form-based manner, using andL to represent logical conjunctions (AND) between concepts and orL to represent logical disjunctions (OR) in the desired queries above.

Neural Modeling

The model declaration follows the standard pipeline of neural components. It begins with a ReaderSensor to process the raw input data. A ModuleLearner is then invoked, using the embeddings of either person or location to generate predictions based on the given representations. A JointSensor is subsequently employed to connect the person and location concepts in order to form the work_in[i] relation specified in the problem definition. Finally, model inference is carried out based on predefined queries, yielding the final output.

8.3.2. DeepProbLog

Problem Specification

DeepProbLog declares 6 concepts, is_real_person[i] for each person i and works_in[i] for each location $i$ . These concepts are used to formulate the two constraints with the final query, check, being the conjunction of the two. Note that DeepProbLog does not support multiple simultaneous queries and hence, the two constraints cannot be trained with individual supervision for labels of each.

Neural Modeling

DeepProbLog uses two neural networks for the classification of the two concepts. The main challenge is the creation of the dataloader that reads from the raw data and converts it into the format necessary to send queries with the appropriate value substitutions for variables. This integration with ProbLog needs to be done by the user from scratch.

8.3.3. Scallop

Problem Specification

Scallop utilizes 6 concepts similar to DeepProbLog. The value of the two constraints is merged using a final module check(P1* P2 * W1 * W2 + P3 * W3). Here, the results of concepts is_real_person[i] (P1, P2, P3) and works_in[i] (W1, W2, W3) are passed instead of the embeddings themselves. This context is passed through Python itself, instead of a separate Datalog file.

Neural Modeling

The neural modeling component is standard with flexible loss declarations. To adapt from the raw data, an embedding generator NERDataset is created which is the same as the JSONDataset utilized in the DeepProbLog solution. However, there is no need to manually adapt the data to generate queries to the datalog component, as the forward function of the neural network is the final query and only requires the outputs of the neural networks passed to it.

8.4. Math Equation Inference

The Math Equation Inference task is designed to evaluate whether a neural network can learn local mathematical concepts from global supervision. The input to this task consists of two lists, each containing six real numbers sampled uniformly from the range $[-1,1]$ . The objective is to determine whether the model can learn from a global condition that encompasses the properties of the first list, the properties of the second list, and the relationship between them. We consider two properties, that is, $\sum _{i=0}^8{x}_i>0$ and $\sum _{i=0}^8|x_i|>0.5$ . For relations between the two lists, we examine two cases: (i) whether the first elements of the lists have the same sign, and (ii) whether their last elements have opposite signs. These concepts are learned through indirect supervision using global queries that compose the atomic concepts, expressed as follows:

property1(L1) AND property2(L2) AND relation(L1, L2)

where $L1,L2$ are randomly generated lists of six real numbers, property1 and property2 are drawn from the set of considered properties, and relation is drawn from the set of considered relations.

8.4.1. DomiKnowS

Problem Specification

For implementing this task in DomiKnowS, the first concept defined is the problem concept, which represents the overall mathematical inference problem. Next, the lst concept is introduced to represent a list of considered numbers. Under this lst concept, all possible condition concepts–is_cond1 and is_cond2–are defined to represent the output class of each list. Subsequently, two relation concepts, is_relation1 and is_relation2, are introduced between pairs of lst instances to capture the two relational conditions described in the problem statement. Importantly, all possible conditions and relations must be defined, even if some are not ultimately used in the final inference. To define the inference query, the logical operator andL is employed to combine the three relevant concepts. For example: andL(is_cond1(L1), is_relation1(L1, L2), is_cond2(L2)). This query corresponds to the case where the sum of $L1$ is greater than 0 (is_cond1), the first elements of $L1$ and $L2$ share the same sign (is_relation1), and the sum of the absolute values of $L2$ is greater than 0.5 (is_cond2).

Neural Modeling

DomiKnowS begins with a ReaderSensor to process the two input lists of numbers. Then, CompositionCandidateSensor is employed to connect the two lists, forming the intermediate representation required for relation prediction in later stages. Four neural networks are instantiated using ModuleLearner—two dedicated to property concepts and two to relation concepts. These networks are trained to predict the respective properties and relations. The predicted concepts are subsequently integrated into the final query, which specifies the target relation for the given problem and serves as the prediction label during training and evaluation. It is important to note that DomiKnowS requires all possible inference queries to be explicitly represented in the graph. Each query is set as either active or inactive to obtain the correct prediction during inference.

8.4.2. DeepProbLog

Problem Specification

In this task, DeepProbLog defines four neural predicates: Two for the considered properties (is_property[i]_nn for object property $i$ ), and two for the considered relations (is_relation[i]_nn for relation $i$ ). These four neural predicates are then combined to define the final query concept, inference. One inference concept is created for each possible combination of the condition of $L$ 1 (2 possibilities), the condition of $L$ 2 (2 possibilities), and the relation between $L1$ and $L2$ (2 possibilities). In total, eight inference concepts are formulated. During evaluation, only the relevant concept corresponding to the input configuration is activated and used to produce the final prediction for the problem.

Neural Modeling

DeepProbLog employs four neural networks, corresponding to the defined concepts: Two for property concepts and two for relation concepts. The pipeline then proceeds with data loading, where all possible candidate lists of numbers are read separately and pre-processed to obtain the required model inputs. This also includes manually connecting the list of numbers within the same problem. Then, all defined neural networks are called to obtain all possible relations and properties output. Lastly, the query must be constructed in the exact predefined pattern to ensure that the system produces the correct output aligned with the desired inference condition.

8.4.3. Scallop

Problem Specification

Similar to DomiKnowS and DeepProbLog on this task, Scallop begins with the declaration of four concepts, that is, two property concepts and two relation concepts. However, Scallop only defines the one final module, inference(P1 * P2 * R), that accumulates the probability based on the output of the properties of $L1$ and $L2$ , and the relation between $L1$ and $L2$ . The output is defined in the neural modeling part to get the connection between the final module and the defined concept.

Neural Modeling

The neural modeling component in Scallop follows the standard pipeline. However, Scallop requires a manually defined connection between the model output and the declared final module. This requirement arises because the final module is specified in a general form, rather than being tied to a particular combination of inference concepts. In contrast, other frameworks explicitly define every possible query corresponding to a combination of properties and relations and refer only to those queries during inference.

9. Discussion and Future Direction

Table 1 summarizes the comparative aspects of existing frameworks and outlines future directions for optimizing, as we observe many columns marked with “✗,” implying most frameworks present challenges that hinder the application and flexibility of the frameworks. While current frameworks are functional, future developments should take a more holistic approach that considers all aspects from an end-user perspective, aiming to improve usability as general-purpose libraries and foster wider adoption of NeSy methods.

Symbolic Representation The generic NeSy frameworks provide a formal knowledge representation language of their choice. The selected languages are often based on pure logical formalisms with established formal semantics, for example, Datalog or Prolog. However, we argue that knowledge representation for NeSy frameworks needs to be an innovative language designed for this integration purpose with adaptable semantics with learning as the pivotal concept (Kordjamshidi et al., 2022). Restricting these frameworks to classical AI formalisms and formal semantics limits the level of extension that can be made and restricts the support of various algorithms and types of integration.

Neural Modeling Most of the examined frameworks leave neural modeling and the task of connecting the symbolic and sub-symbolic components, up to the user. This connection usually requires low-level data pre-processing, which is time consuming to implement. A lack of user-friendly libraries discourages developers from using NeSy methods to solve downstream tasks. There is a need for abstractions in these frameworks (Kordjamshidi et al., 2022) that improve user experience and remove the need for users to implement such data processing from scratch.

Model Declaration. There is a need to be explicit about the low-level components of the neural architecture, enabling us to design interactions between neural and symbolic components and connect them as intended. The goal is to provide flexibility in designing arbitrary loss functions and connecting them to data for supervising concepts at various neural layers, which will allow any symbol to be learnable.

Types of Interplay. Considering Kautz (2022)’s classification, current frameworks are limited in supporting one or two ways of interactions. DeepProbLog and Scallop utilize one form of implementation, while DomiKnowS has multiple settings as detailed in Section 6. One of the key challenges is determining the appropriate level of abstraction in a neural model after which reasoning should occur. The classification types demonstrate how a neural model can identify the relevant symbolic representations and suggest that NeSy frameworks could leverage these models to learn and route inputs to the corresponding symbolic reasoning system. However, it remains unclear what level of abstraction is most effective for solving the end task in practice.

LLM. Drawbacks often associated with employing symbolic AI into neural computing, such as the creation of symbolic knowledge for integration, can be mediated with the use of LLMs and foundation models. LLMs have the potential to alleviate the classical issues in symbolic processing. Their vast knowledge can also be utilized to reduce the need for rebuilding neural components, allowing for flexible connections with different symbolic components.

10. Conclusion

NeSy AI presents a promising path forward in addressing the limitations of purely symbolic or neural approaches to AI. By integrating symbolic reasoning with neural learning, NeSy frameworks offer a balance between interpretability, data usage, time efficiency, and generalization. In this paper, we characterize the core components of NeSy frameworks and provide an analysis of some existing ones—DeepProbLog, Scallop, and DomiKnowS, illustrating their comparative facets. We identified a number of facets, such as symbolic knowledge and data representation, neural modeling, model declaration, their method of integrating the symbolic and sub-symbolic systems, and LLMs integration. We identify key challenges in each facet that can guide us toward building the next generation of NeSy frameworks. Unifying ideas in the field and building flexible frameworks by incorporating strengths in every facet will ease the learning curve associated with NeSy systems and improve their application. Future NeSy frameworks should aim to provide user-friendly interfaces, scalability, algorithm coverage, and seamless integrations with foundation models. Recent advances in LLMs and vision language models provide promising solutions to longstanding knowledge engineering challenges, fostering more effective and scalable integration of symbolic representations, and advancing research in NeSy AI.