# Standard Neural Computation Alone Is Insufficient for Logical Intelligence
**Authors**: Youngsung Kim
## Abstract
Neural networks, as currently designed, fall short of achieving true logical intelligence. Modern AI models rely on standard neural computation âinner-product-based transformations and nonlinear activationsâto approximate patterns from data. While effective for inductive learning, this architecture lacks the structural guarantees necessary for deductive inference and logical consistency. As a result, deep networks struggle with rule-based reasoning, structured generalization, and interpretability without extensive post-hoc modifications. This position paper argues that standard neural layers must be fundamentally rethought to integrate logical reasoning. We advocate for Logical Neural Units (LNUs) âmodular components that embed differentiable approximations of logical operations (e.g., AND, OR, NOT) directly within neural architectures. We critique existing neurosymbolic approaches, highlight the limitations of standard neural computation for logical inference, and present LNUs as a necessary paradigm shift in AI. Finally, we outline a roadmap for implementation, discussing theoretical foundations, architectural integration, and key challenges for future research.
Machine Learning, ICML
## 1 Introduction
Artificial Intelligence (AI) aims to emulate human intelligence, yet its development has oscillated between two dominant paradigms: symbolic AI and connectionism. Since the 1956 Dartmouth workshop, symbolic AI has emphasized logical rules and structured inference, whereas connectionist models, such as neural networks, have focused on learning from data (McCulloch & Pitts, 1943; Kautz, 2022). Modern large-scale neural models trained on symbolic data, such as natural language, can appear to perform deductive reasoning, but they do not robustly replicate human-like logical inference (Tian et al., 2021). The challenge lies in their reliance on statistical approximations rather than explicit rule-based deduction (HĂślldobler & Kalinke, 1994; Bader & Hitzler, 2005; Seda, 2006; Serafini & Garcez, 2016).
Symbolic AI, rooted in formal logic and computational rules, enables structured reasoning and systematic problem-solving. However, it faces the symbol grounding problem âsymbols remain abstract and lack intrinsic meaning unless anchored to real-world sensory experiences (Harnad, 1990; Barsalou, 1999). In contrast, connectionist models excel at pattern recognition from raw data but struggle with systematic reasoning, logical rule generalization, and interpretability (McClelland & Rumelhart, 1986; Rumelhart & McClelland, 1986). These complementary strengths and weaknesses suggest that neither approach alone is sufficient for achieving robust, human-like reasoning.
Neuro-symbolic AI seeks to bridge the gap between connectionist learning and symbolic computation by embedding structured reasoning within neural architectures (Hilario, 1995; Hatzilygeroudis & Prentzas, 2000; dâAvila Garcez & Lamb, 2023). While symbolic theories suggest that structured formal systems provide meaning (Dennett, 1969; Newell & Simon, 1972; Fodor, 1975; Haugeland, 1985), perceptual symbol theories argue for cognition grounded in sensory-motor experience (Barsalou, 1999). This distinction extends to AI methodologies, where symbolic systems provide formal inference but lack the adaptability of neural models, while neural networks learn representations flexibly but lack explicit symbolic reasoning (dâAvila Garcez et al., 2019).
Recent neuro-symbolic approaches embed symbolic inference within deep learning architectures or integrate learned representations into reasoning engines (Wang et al., 2019; Yang et al., 2020; Manhaeve et al., 2018; dâAvila Garcez et al., 2019; Besold et al., 2017; Yang et al., 2019; Bader & Hitzler, 2005), yet aligning continuous neural representations with discrete logic remains a challenge. Large language models (LLMs) employ structured reasoning techniques like chain-of-thought prompting (Wei et al., 2022), tree-based reasoning (Yao et al., 2023), and graph-based inference (Cai et al., 2023) to enhance multi-step reasoning (Sun et al., 2024). However, their probabilistic nature causes hallucinations, contradictions, and imprecise fact retrieval, limiting their reliability for strict logical inference (Bubeck et al., 2023; Kambhampati et al., 2024). Despite approximating logical reasoning, LLMs lack formal guarantees for symbolic inference, highlighting the need for architectures that embed explicit logical structures to bridge statistical learning and rule-based reasoning (Kambhampati et al., 2024; Rae et al., 2021; Creswell et al., 2022).
This paper argues that purely arithmetic-based neural layersâthose relying on inner products and nonlinear activationsâare insufficient for robust logical intelligence. While neural networks excel at function approximation through inductive learning, they lack inherent support for deductive reasoning and symbolic consistency. Building on early AI logic units and recent neuro-symbolic advances, we propose Logical Neural Units (LNUs), which embed differentiable approximations of logical operations (e.g., fuzzy AND/OR) directly within neural layers. Unlike external symbolic engines or loosely integrated reasoning modules, LNUs seamlessly incorporate logical inference into the sub-symbolic learning process, unifying structured reasoning with modern deep learning architectures.
Structure. We position our argument within existing research by first reviewing human intelligence and learning strategies (Section 2). We then examine classical, real-valued, and fuzzy logic approaches to illustrate how logical operations extend beyond Boolean domains (Section 3). Next, we revisit universal approximation theorems, highlighting why neural networks, despite their expressive power, do not inherently enable systematic logical reasoning (Section 4). A survey of neurosymbolic frameworks (Section 5) contextualizes the role of LNUs, which we introduce and illustrate through a toy example (Section 6). Finally, we discuss open challenges and future directions for integrating logical reasoning into neural networks (Section 7).
## 2 Foundations of Logical Reasoning in Neural Systems
Human Intelligence has been studied throughout history, yet no single, universally accepted definition exists, despite extensive efforts to characterize it through various intellectual frameworks (Minsky, 1961; Newell, 1965). Since Aristotle, logic has been regarded as a fundamental tool for scientific inquiry, often referred to as the Organon (Aristotle, 4th century BCE). Rooted in symbolic reasoning (McCarthy & Hayes, 1969), logic contrasts with perceptual learning, which does not require explicit symbolic knowledge and is acquired through experience (Newell & Simon, 1956; Whitehead & Russell, 1910; Tarski, 1944). Humans develop logical reasoning abilities even without formal training, often through structured learning and knowledge transfer.
Cognitive science distinguishes two complementary domains of intelligence (Cattell, 1943, 1963): fluid intelligence, which enables rapid pattern recognition and adaptability, and crystallized intelligence, which relies on accumulated knowledge and rule-based reasoning. Together, these support both flexible learning and structured problem-solving.
To achieve intelligence, modern AI systems primarily rely on inductive learning, which generalizes patterns from data, enabling adaptation to new scenarios. Neural networks exemplify this approach by identifying statistical associations without predefined rules. Techniques such as statistical machine learning and inductive logic programming (ILP) derive general rules from examples. In contrast, deductive reasoning applies established axioms to derive conclusions with certainty. Systems such as theorem provers ensure logical soundness but lack adaptability. While deduction does not inherently involve learning, it can simulate knowledge accumulation by deriving and storing new facts (McCarthy & Hayes, 1969; Newell & Simon, 1956).
Hybrid approaches in neurosymbolic AI (Bader & Hitzler, 2005; Besold et al., 2017; dâAvila Garcez & Lamb, 2023; Marra et al., 2024; Wang et al., 2025) integrate inductive learningâs adaptability with deductive reasoningâs precision. Induction discovers patterns, while deduction ensures their logical validity (Nilsson, 1980; Russell & Norvig, 2020). This fusion enhances flexibility through data-driven learning, soundness via rule-based inference, and interpretability by leveraging explicit logical rules.
Logical reasoning unites deduction and induction, enabling structured thought akin to human System 2 reasoning (Kahneman, 2011). Logical operations such as AND, OR, and NOT are fundamental to compositional and hierarchical inference. While neural networks can approximate these operations (McCulloch & Pitts, 1943; Newell & Simon, 1956; Besold et al., 2017), they lack explicit logical representations unless specifically designed to integrate them.
## 3 Extending Logical Operators Beyond Classical Rules
Classical symbolic AI relies on propositional and predicate logic for knowledge representation (Newell & Simon, 1956; McCarthy & Hayes, 1969; Bader & Hitzler, 2005). Propositional logic operates on Boolean variables ( $0 0$ or $1$ ) and applies logical operators such as AND, OR, NOT, and implication to derive conclusions. However, strict Boolean operations often fall short when dealing with real-world scenarios that involve uncertainty, continuous-valued information, or partial truths. Such rigid structures limit expressiveness, making it difficult to integrate symbolic logic with modern neural models that inherently operate over continuous feature spaces.
To address these limitations, several extensions to classical logic have been developed. Real-valued logic generalizes Boolean truth values by extending them to the interval $[0,1]$ , allowing for continuous operators such as t-norms and t-conorms (Menger, 1942; Schweizer & Sklar, 1961, 1983; Klement et al., 2000). These operators provide smooth approximations of AND and OR functions, enabling reasoning over continuous-valued domains (Tarski, 1944; Kleene, 1952). Similarly, fuzzy logic introduces the concept of partial membership, where truth values represent degrees of belonging rather than strict binary assignments. For instance, the concept of âhotâ may be assigned a membership value of $0.7$ rather than being forced into a rigid true or false classification. Logical operations in fuzzy logic, including min, max, and product t-norms, allow for approximate AND and OR computations, making the system more robust to vagueness and imprecise data (Zadeh, 1965; Dubois & Prade, 1980; Hajek, 1998).
Another critical extension is many-valued logic, such as GĂśdel and Ĺukasiewicz logic, which allows discrete or continuous truth values beyond $\{0,1\}$ . These frameworks support reasoning over intermediate truth levels, making them particularly useful for modeling uncertainty and graded reasoning (Rescher, 1969; Smith, 1988; Ĺukasiewicz, 1920; Cignoli et al., 2013). Probabilistic logic further extends classical reasoning by assigning probabilities to logical statements, allowing AI systems to quantify uncertainty rather than relying strictly on binary logic (Pearl, 1988; Nilsson, 1986; Fagin & Halpern, 1990). This probabilistic approach has been widely adopted in Statistical Relational Artificial Intelligence (StarAI), which integrates logic with probabilistic graphical models to manage structured and uncertain domains (Getoor & Taskar, 2007; Raedt et al., 2020).
The integration of these extended logical frameworks is central to our position that purely arithmetic-based neural networks are insufficient for robust logical intelligence. Neural activations operate over continuous domains, yet classical logic assumes discrete, well-defined truths. By incorporating differentiable approximations of logical operations, such as those found in real-valued, fuzzy, many-valued, and probabilistic logic, we can bridge the gap between sub-symbolic learning and symbolic reasoning. These extended operators form the basis for Logical Neural Units (LNUs), which embed logical computation within deep neural architectures. Rather than treating logic as an external rule-based system, LNUs integrate flexible logical reasoning directly within neural computations, addressing the expressiveness limitations of traditional neural models. The following sections further develop this argument by analyzing why universal approximation alone does not guarantee logical consistency and by positioning LNUs within the broader landscape of neurosymbolic AI.
## 4 Theoretical Limits of Standard Neural Computation for Logic
The previous section examined real-valued, fuzzy, and many-valued logic as extensions that generalize classical Boolean operators for handling uncertainty and graded reasoning. While these approaches introduce flexibility, their integration into neural networks remains an approximation rather than an exact logical representation. Neural networks, by design, operate over continuous spaces and optimize for statistical associations rather than strict logical inference. This fundamental difference raises the question: Can standard neural architectures inherently support logical reasoning, or are they fundamentally constrained in their ability to model symbolic computation?
### 4.1 Universal Approximation Theorem (UAT)
The Universal Approximation Theorem (UAT) states that a feedforward neural network with a single hidden layer and a sufficient number of neurons can approximate any continuous function on a compact subset of $\mathbb{R}^{n}$ to arbitrary precision, given a suitable activation function (Hornik et al., 1989). Formally, for a compact set $K\subseteq\mathbb{R}^{n}$ and a continuous function $f:K\to\mathbb{R}$ , for any $\epsilon>0$ , there exists a neural network $\phi(x)$ such that:
$$
\textstyle\sup_{x\in K}|f(x)-\phi(x)|<\epsilon. \tag{1}
$$
While UAT ensures that neural networks can approximate any continuous function, it does not guarantee efficient learning, interpretability, or logical consistency (Cybenko, 1989; Hornik et al., 1989). Moreover, it assumes that $f$ is continuous, which is a critical limitation when applied to discrete logical operations.
### 4.2 Limitations of UAT for Logical Reasoning
Logical reasoning tasks, such as theorem proving and symbolic inference, reveal fundamental shortcomings in applying UAT to logic-based computations. The key issue lies in the nature of logical rules, which require exact, discrete outputs. While neural networks can approximate logical operators such as AND, OR, and XOR using continuous activations, these approximations are computationally inefficient and lack the precision necessary for formal inference.
Moreover, logical reasoning demands deterministic conclusions. Standard neural networks, optimized via gradient-based learning, introduce approximations that may cause outputs to oscillate near correct logical values without strictly converging. This contrasts with formal symbolic systems, where rule-based computations guarantee correctness. The problem is further exacerbated by logical inference operating over unbounded domains, such as universal quantifiers ( $\forall x$ ), whereas UAT is constrained to compact subsets of $\mathbb{R}^{n}$ . This mismatch limits neural networksâ ability to ensure global consistency, which is crucial for systematic reasoning.
Another significant limitation is interpretability. Symbolic reasoning systems produce explicit inference chains that can be traced and verified, while neural networks trained under the UAT framework rely on distributed representations that are inherently opaque. The lack of explicit reasoning steps makes it difficult to validate logical consistency, posing challenges for domains requiring explainability.
### 4.3 How UAT Constraints Affect Logical Computation
Although UAT highlights the expressive power of neural networks, it also exposes fundamental challenges in logical computation. Logical reasoning requires exact, discrete, and symbolic representations, which are not naturally supported by continuous approximations. While inductive reasoning in neural networks can approximate logical functions, it does not guarantee soundness, completeness, or consistency in a formal sense. Consequently, additional mechanismsâsuch as neurosymbolic models incorporating explicit logical rules ( $\land$ , $\lor$ , $\neg$ ) or fuzzy t-normsâare needed to bridge the gap between statistical learning and symbolic reasoning.
### 4.4 Motivation for Logic-Based Architectures
The limitations of UAT for logical reasoning highlight the need for hybrid architectures that integrate symbolic constraints within neural networks. Standard neural models struggle with discrete logical computation, global consistency, and interpretabilityâkey elements of systematic reasoning. By embedding logical structures into neural computations, hybrid models improve consistency and explainability.
Existing neurosymbolic approaches attempt to bridge neural learning and symbolic inference using hard-coded rules or differentiable approximations of logical operators (Bader & Hitzler, 2005; Wang et al., 2025). However, many depend on external reasoning modules, reducing scalability and architectural cohesion. A more integrated solution requires embedding trainable logical operators (e.g., differentiable AND, OR, and NOT) directly within neural layers, allowing for seamless interpolation between symbolic and sub-symbolic reasoning.
The next section reviews existing neurosymbolic frameworks and introduces a novel extension that enhances logic-based computation within neural architectures.
## 5 Shortcomings in Existing Neural Logic Approaches
Neurosymbolic AI combines sub-symbolic learning (e.g., neural networks) with symbolic reasoning (e.g., logic-based inference), aiming to unify the efficiency of neural methods and the interpretability of symbolic systems (Kautz, 2022; Bader & Hitzler, 2005; Sarker et al., 2021; Wang et al., 2025). Existing taxonomies (e.g., (Kautz, 2022)) categorize these methods by how tightly neural and symbolic components are intertwined, from loosely coupled pipelines to deeply integrated architectures. Here, we focus on four representative frameworksâ Neural Logic Networks (NLNs), Logical Neural Networks (LNNs), Logic Tensor Networks (LTNs), and Neural Logic Machines (NLMs) âeach of which approximates logical operations or embeds logical structures into neural models.
### 5.1 Parameterized Logic Representations: Multi-Ary Atoms
Both NLNs and LNNs seek to generalize classical AND/OR with learnable weights, making logical operations differentiable and enabling partial-truth inputs in $[0,1]$ . This reveals a shared philosophy of embedding logical structure directly into network computations, thereby preserving some interpretability at the operator level.
Neural Logic Networks (NLNs) (Yang et al., 2019) map Boolean operators (e.g., AND, OR, XOR) into weighted, many-valued logic, frequently using product -based formulations:
$$
\displaystyle\textstyle y_{\text{AND}} \displaystyle=\textstyle\prod_{i=1}^{n}\Bigl{[}1-w_{i}\,(1-x_{i})\Bigr{]}, \displaystyle\textstyle y_{\text{OR}} \displaystyle=\textstyle 1-\prod_{i=1}^{n}\Bigl{[}1-w_{i}\,x_{i}\Bigr{]}, \tag{2}
$$
where $w_{i}\in[0,1]$ are membership weights. This approach can excel at discrete algorithmic tasks (e.g., addition, sorting). However, product-based logic can lead to near-zero outputs when multiple inputs $x_{i}<1$ , potentially undermining stability in high-dimensional or uncertain settings.
Logical Neural Networks (LNNs) (Riegel et al., 2020), in contrast, implement AND/OR with weighted summations:
$$
\displaystyle\textstyle y_{\text{AND}} \displaystyle=\textstyle f\!\Bigl{(}\beta-\!\sum_{i\in I}w_{i}\,(1-x_{i})\Bigr
{)}, \displaystyle\textstyle y_{\text{OR}} \displaystyle=\textstyle f\!\Bigl{(}1-\beta+\!\sum_{i\in I}w_{i}\,x_{i}\Bigr{)}, \tag{4}
$$
where $x_{i}\in[0,1]$ are partial-truth inputs, $I$ represents the input set, $w_{i}\geq 0$ are learnable weights, $\beta\geq 0$ is a bias term, and $f(\cdot)$ is typically a clipping function or a ReLU-like activation ensuring $y\in[0,1]$ . This sum -based formulation can be more robust than a pure product, but calibrating weights/biases in deeper networks may be complex, and LNNs often focus on higher-level rule constraints rather than layer-by-layer embedding.
### 5.2 Neural Approximation of Logical Quantifiers via Perceptrons
Logic Tensor Networks (LTNs) (Serafini & Garcez, 2016) embed first-order logic into tensor-based neural systems by mapping logical predicates to continuous embeddings, then applying fuzzy t-norms for AND/OR. They unify multiple tasks (e.g., classification, clustering, relational reasoning) yet can become complex in deep architectures where large numbers of predicates and constraints must be managed.
Neural Logic Machines (NLMs) (Dong et al., 2019) extend multi-valued logic with iterative layers for multi-hop inference. They use MLP modules to approximate quantifiers ( $\forall,\exists$ ), enabling advanced relational reasoning (e.g., family-tree or grid-world tasks). Although powerful, NLMs can be challenging to scale due to their reliance on standard MLP blocks for quantifier operations, which can hinder full interpretability in large domains.
## 6 Introducing Logical Neural Units (LNUs) for Modular and Scalable Logical Reasoning
Existing neurosymbolic approaches incorporate logical operations in various ways but face several limitations. Some rely on product-based fuzzy logic for Boolean connectives, which can become numerically unstable in high-dimensional settings (Yang et al., 2019). Others inherit the constraints of perceptron-based architectures, limiting their expressivity for structured reasoning (Riegel et al., 2020). While some methods extend to first-order logic or multi-hop relational quantifiers, they often require additional modules or iterative mechanisms, impacting scalability and interpretability (Serafini & Garcez, 2016; Dong et al., 2019).
### 6.1 Core Principles for Logical Neural Units (LNUs)
These challenges motivate the development of Logical Neural Units (LNUs), a framework that embeds logical operations directly into deep networks, ensuring stable and scalable neurosymbolic reasoning. LNUs enable smooth interpolation between soft and hard logic, allowing adaptation across tasks and domains.
Scalability is a key consideration. Product-based logic can suffer from vanishing gradients, while MLP-based quantifiers often lack interpretability. LNUs must balance numerical stability with effective layering in deep networks. A hierarchical design that stacks multiple LNUs while maintaining transparent parameters offers both efficiency and clarity.
LNUs integrate seamlessly with existing architectures. Instead of replacing all neural components, LNUs selectively substitute dense layers while retaining standard MLP or attention-based modules for feature extraction. This hybrid approach maintains compatibility with established architectures such as Transformers while minimizing design overhead.
### 6.2 Illustrative LNU Architecture
LNUs generalize and unify prior differentiable logic methods within a single neural unit. Instead of standard Linear + ReLU layers, we define an LNU block as:
$$
\mathrm{LNU}(x_{1},\dots,x_{n};\theta)=\Bigl{[}T_{\land}(g_{1}(x);\theta_{1}),
T_{\lor}(g_{2}(x);\theta_{2}),\dots\Bigr{]}, \tag{6}
$$
where $T_{\land}$ and $T_{\lor}$ are learnable t-norm and t-conorm operators approximating logical AND and OR functions. The functions $g_{i}(x)$ map the input vector $x=(x_{1},\dots,x_{n})$ to real-valued logic features. The parameter set $\theta$ consists of adaptive weights that dynamically adjust logical compositions during training, allowing LNUs to learn task-specific dependencies.
### 6.3 LNU Layer Composition
Each input feature, interpreted as a truth degree in $[0,1]$ , is combined via learnable logic (e.g., softmin, softmax, or polynomial expansions) to approximate logic operations.
#### Differentiable Logic Approximation.
Classical Boolean and fuzzy logic operations, such as AND and OR, are often computed using $\min$ and $\max$ functions, as in GĂśdel T-norm and T-conorm (Hajek, 1998; van Krieken et al., 2022). To facilitate smooth gradient-based learning, LNUs approximate these operations using softmin and softmax:
$$
\text{softmax}(\beta\mathbf{z})_{i}\approx\max(\mathbf{z}),~{}\text{softmin}(
\beta\mathbf{z})_{j}\approx\min(\mathbf{z})~{}\text{as }\beta\to\infty.
$$
Here, each input $z_{i}$ is defined as a weighted feature:
$$
z_{i}=x_{i}\cdot w_{i},\quad\text{where }x_{i}\in\mathbf{x},~{}w_{i}\in\mathbf
{w},~{}i=1,\dots,d. \tag{7}
$$
The parameter $\beta\geq 0$ controls the sharpness of the approximation, with larger values making the function more Boolean-like. The softmin function is efficiently computed via: $\text{softmin}(\beta\mathbf{z})=\text{softmax}(-\beta\mathbf{z}).$
#### Locally Gated Logical Consistency.
To ensure logical consistency, each featureâs contribution is weighted via learned importance factors. Given an input vector $\mathbf{z}=(z_{1},\dots,z_{d})$ , the differentiable logic functions are:
$$
\displaystyle\texttt{soft-OR}(\mathbf{z}) \displaystyle=\textstyle\sum_{i=1}^{d}\bigl{[}\text{softmax}(\beta\mathbf{z})
\bigr{]}_{i}\cdot z_{i}, \displaystyle\texttt{soft-AND}(\mathbf{z}) \displaystyle=\textstyle\sum_{i=1}^{d}\bigl{[}\text{softmin}(\beta\mathbf{z})
\bigr{]}_{i}\cdot z_{i}. \tag{8}
$$
For high-dimensional inputs, normalizing outputs by $\sqrt{d}$ mitigates activation scaling issues and ensures numerical stability. Additionally, the negation operator is defined as: $\texttt{soft-NOT}(x)=1-x,~{}~{}~{}\text{or}~{}~{}~{}1-\sigma(W_{\mathrm{not}}x),$ where $\sigma$ is the sigmoid function and $W_{\mathrm{not}}$ is a learnable parameter.
#### LNU Layer Architecture.
LNUs replace standard dense layers by embedding differentiable logical operators instead of matrix multiplication and activation functions. Given an input matrix $\mathbf{X}\in\mathbb{R}^{n\times d}$ and trainable parameter matrices $\mathbf{W}_{\text{AND}},\mathbf{W}_{\text{OR}}\in\mathbb{R}^{d\times o}$ , we apply broadcasted element-wise multiplication to implement the Locally Gated Logical Consistency mechanism (details in Appendix B).
#### Deep Logical Networks with LNU Stacking.
Stacking multiple LNU layers enables a deep hierarchical architecture where each layer progressively refines logical inferences at increasing levels of abstraction:
$$
\mathbf{X}^{(\ell)}=\mathrm{LNU}(\mathbf{X}^{(\ell-1)}),\quad\ell=1,\dots,L. \tag{10}
$$
To enhance gradient flow and iterative logical refinement, we incorporate logical residual connections:
$$
\mathbf{X}_{\mathrm{res}}=\texttt{soft-IMPLY}(\mathbf{X},F(\mathbf{X})), \tag{11}
$$
where $\texttt{soft-IMPLY}(A,B)=\texttt{soft-OR}(1-A,B)$ , ensuring stable logical propagation across layers. Additionally, other logical connectives can be incorporated using soft-AND and soft-OR, enabling more expressive reasoning within deep architectures.
<details>
<summary>extracted/6177073/decision_boundaries.png Details</summary>
### Visual Description
## Heatmap Comparison: Decision Boundaries of Logical Functions
### Overview
The image is a composite figure containing six subplots arranged in a 3x2 grid. It visually compares the decision boundaries and output intensities of three different computational modelsâHard Logic, a Neural Logic Unit (NLU), and a simple Dense layer with ReLU activationâfor implementing the logical OR and AND functions. A shared color bar on the right indicates the "Decision Output Intensity" from 0.000 (dark purple) to 1.000 (bright yellow).
### Components/Axes
* **Main Title:** "Comparison of Hard Logic, NLU, and MLP (Dense + ReLU) Decision Boundaries"
* **Subplot Titles (in reading order, left-to-right, top-to-bottom):**
1. "Hard Logic OR"
2. "Hard Logic AND"
3. "NLU Soft-OR (β=100, w=(0.5,0.5))"
4. "NLU Soft-AND (β=100, w=(0.5,0.5))"
5. "Dense+ReLU (Bias=0.0, w=(0.5,0.5))"
6. "Dense+ReLU (Bias=-0.5, w=(0.5,0.5))"
* **Axes:** All six subplots share identical axes.
* **X-axis:** Labeled `xâ`. Scale ranges from 0.0 to 1.0 with tick marks at 0.0, 0.2, 0.4, 0.6, 0.8, 1.0.
* **Y-axis:** Labeled `xâ`. Scale ranges from 0.0 to 1.0 with tick marks at 0.0, 0.2, 0.4, 0.6, 0.8, 1.0.
* **Color Bar (Right side):**
* **Label:** "Decision Output Intensity"
* **Scale:** Continuous gradient from 0.000 to 1.000.
* **Discrete Tick Values:** 0.000, 0.111, 0.222, 0.333, 0.444, 0.556, 0.667, 0.778, 0.889, 1.000.
### Detailed Analysis
**1. Hard Logic OR (Top-Left):**
* **Trend/Pattern:** Exhibits a sharp, step-function boundary. The output is 0.0 (purple) in the bottom-left quadrant and 1.0 (yellow) everywhere else.
* **Boundary:** The decision boundary is an L-shape formed by the lines `xâ = 0.5` (for `xâ < 0.5`) and `xâ = 0.5` (for `xâ < 0.5`). The output is 1.0 if `xâ >= 0.5` OR `xâ >= 0.5`.
**2. Hard Logic AND (Top-Right):**
* **Trend/Pattern:** Also a sharp step-function. The output is 1.0 (yellow) only in the top-right quadrant and 0.0 (purple) everywhere else.
* **Boundary:** The decision boundary is an L-shape formed by the lines `xâ = 0.5` (for `xâ >= 0.5`) and `xâ = 0.5` (for `xâ >= 0.5`). The output is 1.0 only if `xâ >= 0.5` AND `xâ >= 0.5`.
**3. NLU Soft-OR (Middle-Left):**
* **Trend/Pattern:** Shows a smooth, non-linear gradient. Output intensity increases as either `xâ` or `xâ` (or both) increase. The lowest values (dark purple) are at the origin (0,0), and the highest (yellow-green) are along the top and right edges.
* **Boundary:** No sharp boundary. The transition from low to high output is gradual, approximating the OR function softly. The parameters are β=100 (likely a steepness parameter) and weights w=(0.5, 0.5).
**4. NLU Soft-AND (Middle-Right):**
* **Trend/Pattern:** Shows a smooth, non-linear gradient. Output intensity increases only when both `xâ` and `xâ` are high. The lowest values (purple) cover most of the plot, with higher values (teal/green) concentrated in the top-right corner.
* **Boundary:** No sharp boundary. The transition is gradual, approximating the AND function softly. Uses the same parameters (β=100, w=(0.5,0.5)) as the Soft-OR.
**5. Dense+ReLU, Bias=0.0 (Bottom-Left):**
* **Trend/Pattern:** Displays a linear gradient with diagonal contour lines. Output intensity increases linearly from the bottom-left corner (0,0) to the top-right corner (1,1).
* **Boundary:** The decision boundary (where output crosses zero before ReLU) is the line `0.5*xâ + 0.5*xâ + 0.0 = 0`, which simplifies to `xâ + xâ = 0`. This line passes through the origin. The ReLU activation creates the visible linear ramp in the positive quadrant.
**6. Dense+ReLU, Bias=-0.5 (Bottom-Right):**
* **Trend/Pattern:** Similar linear gradient to the previous plot, but shifted. A large triangular region in the bottom-left (where `0.5*xâ + 0.5*xâ - 0.5 <= 0`) has an output of 0.0 (purple). The output increases linearly in the remaining top-right triangular region.
* **Boundary:** The decision boundary is the line `0.5*xâ + 0.5*xâ - 0.5 = 0`, or `xâ + xâ = 1.0`. This line runs diagonally from (0,1) to (1,0). The negative bias (-0.5) shifts the active region.
### Key Observations
1. **Discrete vs. Continuous:** Hard Logic produces binary, crisp decision boundaries. Both NLU and Dense+ReLU produce continuous, graded outputs.
2. **Shape of Boundaries:** The Hard Logic boundaries are axis-aligned (vertical/horizontal). The NLU boundaries are smooth and curved. The Dense+ReLU boundaries are linear and diagonal.
3. **Effect of Bias:** In the Dense+ReLU model, changing the bias from 0.0 to -0.5 dramatically shifts the decision boundary from `xâ + xâ = 0` to `xâ + xâ = 1`, altering the region of non-zero output.
4. **Function Approximation:** The NLU with high β (100) creates a steep but smooth transition, closely mimicking the hard logic functions. The Dense+ReLU with a single neuron can only create a linear decision boundary, which is a poor approximation for the non-linear OR/AND functions.
### Interpretation
This figure serves as a pedagogical comparison of how different computational models represent logical operations. It demonstrates the fundamental difference between symbolic (hard logic) and sub-symbolic (neural network) approaches.
* **Hard Logic** represents the ideal, mathematical definition of OR and AND with perfect precision but no tolerance for uncertainty or partial truth.
* **The NLU** acts as a "soft" logic gate. Its parameters (β, w) allow it to approximate the hard logic functions smoothly, which can be useful in differentiable computing contexts where gradients are needed for learning. The high β value makes it a very close approximation.
* **The Dense+ReLU neuron** represents the simplest neural network unit. Its linear decision boundary reveals its inherent limitation: a single neuron cannot model non-linearly separable functions like AND or OR perfectly. The bias term controls the threshold of activation but does not change the linear nature of the boundary.
The visualization argues that while simple neural units (Dense+ReLU) are limited, more specialized neuro-symbolic components like the NLU can effectively bridge the gap between crisp logical rules and smooth, learnable representations. The choice of model involves a trade-off between interpretability (hard logic), differentiability (NLU), and simplicity (Dense+ReLU).
</details>
Figure 1: Comparison of logical function approximations across different models. The first row represents Hard Logic, where AND and OR operations are applied to binarized inputs ( $x_{i}>0.5,\forall i$ ). The second row shows LNUs with fixed weights ( $w_{i}=0.5,\forall i$ ) and a sharp gating parameter $\beta=100$ . The third row presents an inner-product unit with ReLU activation, using the same fixed weights ( $w_{i}=0.5,\forall i$ ) and different biases ( $0.0\text{ or }-0.5$ ) over the input domain $(x_{1},x_{2})\in[0,1]$ . LNUs closely approximate discrete logical functions, resembling the behavior of hard logic in the first row. Since inputs range over $[0,1]$ , LNU outputs remain continuous, allowing for an adjustable decision boundary around the corresponding hard logic outputs. In contrast, the inner-product unit, which relies on summation-based arithmetic, does not exhibit logical function behavior. Additional results for varying values of $\beta$ in LNUs are provided in Appendix A.
### 6.4 Evaluating LNU Interpretability and Decision Boundaries
Logical operations such as AND and OR follow explicit compositional rules, making their decisions inherently transparent. Neural Logic Units (NLUs) enhance interpretability by structuring decisions through learned logical operations. To assess this interpretability, we analyze decision boundaries and compare them against standard inner-product-based layers.
Visualizing decision boundaries is a common approach to understanding model behavior. Here, we constrain input data to the range $[0,1]$ and fix the weights for both NLUs and dense (inner-product) layers, ensuring an even distribution that aligns with hard AND/OR logic. This setup allows us to evaluate whether decision-making can be explained at the level of a single computation unitâs output. Specifically, we examine how NLUs approximate hard logic functions such as AND and OR.
As shown in Figure 1, NLUs exhibit decision boundaries that closely align with logical structures, whereas inner-product-based layers rely on learned decision surfaces that are harder to interpret. The key advantage of NLUs is their structured decision-making, which inherently follows predefined logical rules, unlike traditional dense layers that require additional interpretation.
When irrelevant features are present, NLUs can filter them out through a gating mechanism, similar to self-attention in a learnable weight setting. This interpretability arises from two key properties: (1) the gating process highlights dominant features, enhancing transparency in the decision process, and (2) predefined logical operations provide structured reasoning, reducing the need for post-hoc interpretation. These properties contribute to NLUsâ ability to offer more explainable and structured decision-making compared to conventional neural models.
### 6.5 Toy Example: Learning a Logical Function
To evaluate the potential of logic-friendly modules, we conduct experiments on a toy logical task. This example showcases the advantages of the LNU Layer in capturing discrete logical patterns, particularly in low-data regimes.
#### Toy Logical Functions.
We test a simple logical expression to assess the modelâs ability to perform logical inference.
Task: Given the logical function: $f(x_{1},x_{2},x_{3})=(x_{1}\lor x_{2})\land\lnot(x_{3})$ , the goal is to learn this function from a subset of possible $(x_{1},x_{2},x_{3})$ combinations. We generate random input values in the range $[0,1]$ , using 20 samples for training and 200 samples for testing. In data generation, inputs are binarized such that $x_{i}>0.5$ is mapped to 1, and otherwise 0. This ensures that the target outputs adhere strictly to logical evaluations in the set $\{0,1\}$ .
For comparison, we benchmark Logicron (LNU-based model) against a standard perceptron. Both models consist of a single hidden unit, where Logicron uses an LNU layer and Perceptrons use an inner-product-based linear unit with non-linear activation functions (Sigmoid, ReLU, and GeLU). The output layer in both models consists of a dense layer with a linear transformation followed by a sigmoid activation. These models are referred to as Logicron and Perceptron in Figure 2.
Observation: In the toy logical function task, Logicron generalizes more reliably during testing, likely due to its built-in logical gating mechanisms. In contrast, Perceptrons exhibit lower test accuracy, even though all models achieve 100% training accuracy. To ensure a fair comparison, we maintain a similar number of parameters across models: (Perceptron with 97, Logicron with 90, Logicrons +negation unit with 110). At the final epoch (30), the test accuracy (mean $\pm$ standard deviation) for each model is as follows, MLP-Sigmoid: 77.4 $\$ $\pm$ 1.6, MLP-ReLU : 80.2 $\$ $\pm$ 1.6, MLP-GeLU : 80.3 $\$ $\pm$ 1.4, Logicron (softmax) : 84.7 $\$ $\pm$ 1.7, Logicron neg (softmax): 84.7 $\$ $\pm$ 1.8.
<details>
<summary>extracted/6177073/Figure_1_.png Details</summary>
### Visual Description
## Line Chart: Model Comparison (Avg.Acc. ÂąStd over 5 Runs)
### Overview
The image is a line chart comparing the test accuracy of five different machine learning models over 25 training epochs. The chart displays the average accuracy across 5 runs, with shaded regions representing the standard deviation for each model. The overall trend shows all models improving accuracy over time, with two distinct performance tiers emerging.
### Components/Axes
* **Title:** "Model Comparison (Avg.Acc. ÂąStd over 5 Runs)" located at the top center.
* **X-Axis:** Labeled "Epoch". The scale runs from 0 to 25, with major tick marks at intervals of 5 (0, 5, 10, 15, 20, 25).
* **Y-Axis:** Labeled "Test Accuracy". The scale runs from 60 to 90, with major tick marks at intervals of 5 (60, 65, 70, 75, 80, 85, 90).
* **Legend:** Located in the bottom-right quadrant of the chart area. It contains five entries, each with a colored line sample and a label:
1. **Black Line:** Perceptrons (Sigmoid)
2. **Dark Gray Line:** Perceptrons (ReLU)
3. **Light Gray Line:** Perceptrons (GeLU)
4. **Bright Green Line:** Logicrons
5. **Dark Green Line:** Logicrons(+Negation)
* **Data Series:** Five lines with associated shaded error bands (standard deviation regions).
### Detailed Analysis
**Trend Verification & Data Points (Approximate):**
* **Perceptrons (Sigmoid) - Black Line:** Starts at ~65 accuracy at epoch 0. Shows a steady, moderate upward slope, plateauing around epoch 15. Ends at approximately 77-78 accuracy at epoch 25. The standard deviation band is moderately wide throughout.
* **Perceptrons (ReLU) - Dark Gray Line:** Starts at ~65. Rises more steeply than the Sigmoid variant initially, crossing 75 accuracy by epoch 5. Plateaus around epoch 10-15. Ends at approximately 80-81 accuracy at epoch 25. Its error band is similar in width to the Sigmoid model.
* **Perceptrons (GeLU) - Light Gray Line:** Follows a nearly identical trajectory to the ReLU model. Starts at ~65, rises steeply, and plateaus at a very similar level, ending at approximately 80-81 accuracy at epoch 25. Its line and error band closely overlap with the ReLU model's.
* **Logicrons - Bright Green Line:** Starts the lowest, at ~60 accuracy at epoch 0. Exhibits the steepest initial learning curve, surpassing all Perceptron models by epoch 7-8. Reaches a high plateau around epoch 12-13. Ends at the highest accuracy, approximately 85, at epoch 25. The standard deviation band is notably wide in the early epochs (0-10), indicating high variance between runs, but narrows significantly as training progresses.
* **Logicrons(+Negation) - Dark Green Line:** Starts at ~65. Follows a similar steep ascent as the standard Logicrons model but maintains a slight lead throughout most of the training. It also plateaus around epoch 12-13 and ends at approximately 85 accuracy at epoch 25, virtually indistinguishable from the standard Logicrons model in the final epochs. Its error band is also wide early on and narrows later.
**Spatial Grounding:** The legend is positioned in the bottom-right, overlapping the lower portion of the error bands for the Perceptron models but not obscuring the primary trend lines. The two green Logicrons lines occupy the top portion of the chart from epoch 10 onward, while the three gray/black Perceptron lines form a distinct cluster below them.
### Key Observations
1. **Performance Tiers:** A clear separation occurs after epoch ~8. The two Logicrons variants form a high-performance tier (~85 accuracy), while the three Perceptron variants form a lower tier (~77-81 accuracy).
2. **Activation Function Impact:** Among Perceptrons, using ReLU or GeLU activation functions yields nearly identical and superior performance (~80-81) compared to the Sigmoid function (~77-78).
3. **Logicrons Advantage:** Both Logicrons models significantly outperform all Perceptron models in final accuracy.
4. **Negation Effect:** Adding "Negation" to the Logicrons model provides a minor, consistent accuracy boost during the learning phase (epochs 0-12), but the final converged performance is essentially the same as the standard Logicrons model.
5. **Variance Pattern:** All models show higher variance (wider error bands) during the initial learning phase (epochs 0-10). The variance decreases for all models as they converge, but remains slightly more pronounced for the Perceptron models even at plateau.
### Interpretation
The data suggests a fundamental architectural or algorithmic advantage of the "Logicrons" approach over standard Perceptron networks for this specific task, as evidenced by both a faster learning rate and a higher final accuracy ceiling. The near-identical performance of ReLU and GeLU activations indicates the task is not sensitive to the choice between these two modern activation functions, but is sensitive to the older Sigmoid function, which performs worse.
The high initial variance for Logicrons implies their learning process is more sensitive to initial conditions or data sampling in early epochs, but this instability resolves as training progresses. The negligible final difference between "Logicrons" and "Logicrons(+Negation)" suggests the negation component may aid in faster convergence or robustness during learning but does not increase the ultimate capacity of the model for this problem. The chart effectively demonstrates that model architecture (Logicrons vs. Perceptrons) is a more significant factor for final accuracy than the choice of activation function within the Perceptron family.
</details>
Figure 2: Test accuracy (mean $\pm$ standard deviation, with shading) across epochs for different models, including Perceptrons with various activation functions and Logicrons (LNU layer + dense output layer). Logicron with an additional negation unit is marked as â+Negationâ.
## 7 Discussion and Future Directions
### 7.1 Position Summary
We have demonstrated that while standard inner-product-based neural networks excel at sub-symbolic pattern recognition, they inherently lack the capacity for structured logical reasoning. As a result, achieving consistent logical inference often requires large datasets, extensive parameter tuning, and auxiliary learning strategies.
Modern AI models have followed a scaling law, which describes how system performance improves as model and data sizes increase, often following a power-law relationship (Bahri et al., 2024; Kaplan et al., 2020). This trend is grounded in the universal approximation theorem, which states that sufficiently large neural networks can approximate a broad range of functions. Consequently, current inductive learning frameworks rely on ever-increasing model size and data volume to capture complex relationships across different domains. However, while scaling enhances function approximation, it does not inherently enable structured, rule-based reasoning.
This paper argues for integrating logic-friendly modules into large-scale neural models to enable implicit logical reasoning. By explicitly incorporating deductive reasoning, these modules enhance logical inference without requiring fundamental architectural changes. We extend existing neurosymbolic frameworks by introducing Logical Neural Units (LNUs), which embed approximate logical operations (e.g., AND, OR, NOT) directly into neural architectures using weighted real-valued logic. These units bridge the gap between sub-symbolic efficiency and symbolic reasoning, providing a scalable alternative to brute-force model expansion. By unifying neural and logical reasoning, we propose a shift away from continuous scaling, which consumes vast computational resources and energy, towards a more structured and efficient approach to AI development.
### 7.2 Critical Limitations and Challenges
LNUs provide a promising bridge between sub-symbolic learning and symbolic reasoning, yet several challenges must be addressed to enhance their effectiveness. One major limitation is their current focus on propositional logic, which restricts their ability to handle more expressive reasoning frameworks. LNUs do not yet incorporate first-order logic constructs such as quantifiers ( $\forall,\exists$ ) or domain iteration. Extending LNUs to inductive reasoning frameworks, such as Inductive Logic Programming (ILP) (Muggleton, 1996) or differentiable logical networks (Sen et al., 2022), could significantly improve their ability to capture structured relationships while maintaining scalability.
Another challenge is ensuring logical soundness and completeness. Traditional symbolic reasoning systems guarantee that every derived statement is valid (soundness) and that all logically entailed statements can be derived (completeness). Neural networks, however, rely on approximate optimization and do not inherently provide formal correctness guarantees. While LNUs introduce logical biases into learning, future research should explore differentiable proof-checking mechanisms to enforce logical validity in neural architectures.
The symbol grounding problem remains a fundamental issue in neurosymbolic AI. Learned representations in neural networks often fail to meaningfully align with symbolic concepts, leading to inconsistencies between learned models and human-interpretable logical reasoning. The challenge of mapping abstract symbols to real-world meaning (Harnad, 1990) necessitates structured constraints or hybrid approaches that integrate both perceptual and logical representations (dâAvila Garcez & Lamb, 2023; Barsalou, 1999). Ensuring that real-valued embeddings preserve logical consistency is critical for effective reasoning.
Computational complexity is another challenge. Logical gating mechanisms, such as weighted t-norms with elementwise products, introduce additional overhead, especially in deep architectures. Efficient approximations, such as polynomial expansions as alternatives to softmax-based formulations, can help mitigate these costs while preserving interpretability.
### 7.3 Alternative Views
Despite the advantages of modular neural logic units (e.g., LNUs), alternative perspectives question their necessity. One argument is that sufficiently large MLPs can approximate logical functions without explicitly embedding logical operations. Given sufficient data and computational resources, neural networks can learn complex nonlinear functions that approximate logical inference. However, this approach is inefficient, requiring significantly larger datasets and lacking interpretability. The absence of interpretability makes debugging and improving specific weaknesses in large models challenging. Addressing localized errors may require retraining the entire model, potentially disrupting global reasoning outcomes.
Another perspective suggests that classical fuzzy logic and GĂśdelâs $\min/\max$ operators already provide logical approximations without modifying network architectures. While these methods capture partial truth values, they lack trainable feature weighting and smooth differentiability, making seamless integration with neural models difficult. Modular neural logic units extend these ideas by embedding logical operations directly into neural computations, allowing for greater adaptability.
Chain-of-thought prompting in transformers has demonstrated that structured reasoning can emerge through large-scale training and carefully designed prompts. However, this remains a heuristic rather than an architectural guarantee of logical consistency and often requires additional optimization during model training. Modular neural logic units complement such approaches by embedding structured logical operations within the network itself, reducing reliance on post-hoc prompt engineering.
Logical constraint learning, as exemplified by SATNet (Wang et al., 2019) and neural theorem proving (Rocktäschel & Riedel, 2017), explicitly encodes logical rules within neural models. While effective, these methods often require manually specified rules, limiting scalability. Modular neural logic units aim to internalize logical inference within neural networks, balancing adaptability with the ability to perform formal reasoning without external supervision.
### 7.4 Future Directions
Several research directions remain for advancing modular neural logic units (e.g., LNUs). One key area is extending LNUs beyond propositional logic by incorporating quantifiers and domain-specific rule induction. This would enable higher-order reasoning, bridging the gap between propositional and first-order logic. Another important step is integrating LNUs with sequence-based models, such as Transformers and RNNs, to enhance structured reasoning in natural language processing and decision-making tasks.
Empirical benchmarking in real-world applications, such as legal reasoning, medical diagnostics, and scientific discovery, is essential to demonstrate the practical effectiveness of LNUs. Additionally, rigorous evaluation frameworks for logical consistency are needed. Establishing soundness and completeness benchmarks for neuro-symbolic reasoning will ensure that LNU-based models adhere to formal logical principles while maintaining the flexibility of neural learning.
### 7.5 Concluding Remarks
This paper has argued that the arithmetic foundations of standard neural networksâinner products and non-linear activationsâare insufficient for achieving robust logical intelligence. While large-scale models can approximate logical functions, they fail to ensure logical consistency, interpretability, or rule-based deduction without auxiliary reasoning mechanisms. By seamlessly integrating neural logic units into the core of neural networks, large-scale models may mitigate the challenges associated with scaling while improving their reasoning capabilities.
## Impact Statement
This paper presents work whose goal is to advance the field of Machine Learning. There are many potential societal consequences of our work, none which we feel must be specifically highlighted here.
## References
- Aristotle (4th century BCE) Aristotle. Organon, 4th century BCE.
- Bader & Hitzler (2005) Bader, S. and Hitzler, P. Dimensions of neural-symbolic integration â a structured survey. In Artemov, S., Barringer, H., Garcez, A. S. d., Lamb, L. C., and Woods, J. (eds.), We Will Show Them: Essays in Honour of Dov Gabbay, volume 1, pp. 167â194. Kingâs College Publications, 2005.
- Bahri et al. (2024) Bahri, Y., Dyer, E., Kaplan, J., Lee, J., and Sharma, U. Explaining neural scaling laws. Proceedings of the National Academy of Sciences, 121(27):e2311878121, 2024. doi: 10.1073/pnas.2311878121. URL https://www.pnas.org/doi/abs/10.1073/pnas.2311878121.
- Barsalou (1999) Barsalou, L. W. Perceptual symbol systems. Behavioral and Brain Sciences, 22(4):577â660, 1999.
- Besold et al. (2017) Besold, T. R., dâAvila Garcez, A., Bader, S., Bowman, H., Domingos, P., Hitzler, P., KĂźhnberger, K.-U., Lamb, L. C., Lowd, D., Lima, P. M. V., de Penning, L., Pinkas, G., Poon, H., and Zaverucha, G. Neural-symbolic learning and reasoning: A survey and interpretation. arXiv preprint arXiv:1711.03902, 2017. URL https://arxiv.org/abs/1711.03902.
- Bubeck et al. (2023) Bubeck, S., Chandrasekaran, V., Eldan, R., Gehrke, J., Horvitz, E., Kamar, E., Lee, P., Lee, Y. T., Li, Y., Lundberg, S., Nori, H., Palangi, H., Ribeiro, M. T., and Zhang, Y. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint arXiv:2303.12712, 2023.
- Cai et al. (2023) Cai, T., Liu, H., Liu, Z., Abbeel, P., Song, D., and Mordatch, I. Large language models can be easily distracted by irrelevant context. In International Conference on Machine Learning (ICML), 2023.
- Cattell (1943) Cattell, R. B. The measurement of adult intelligence. Psychological Bulletin, 40(3):153â193, 1943.
- Cattell (1963) Cattell, R. B. Theory of fluid and crystallized intelligence: A critical experiment. Journal of Educational Psychology, 54:1â22, 1963.
- Cignoli et al. (2013) Cignoli, R., Dubuc, E., and Mundici, D. Algebraic Foundations of Many-Valued Reasoning. Springer Science & Business Media, 2013.
- Creswell et al. (2022) Creswell, A., Shanahan, M., and Higgins, I. Selection-inference: Exploiting large language models for interpretable logical reasoning. In International Conference on Learning Representations (ICLR), 2022. URL https://openreview.net/forum?id=3Pf3Wg6o-A4.
- Cybenko (1989) Cybenko, G. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems, 2(4):303â314, 1989.
- dâAvila Garcez et al. (2019) dâAvila Garcez, A., Gori, M., Lamb, L. C., Serafini, L., Spranger, M., and Tran, S. N. Neural-symbolic computing: An effective methodology for principled integration of machine learning and reasoning. arXiv preprint arXiv:1905.06088, 2019. URL https://arxiv.org/abs/1905.06088.
- Dennett (1969) Dennett, D. C. The nature of images and the introspective trap. In Content and Consciousness, pp. 132â146. Routledge, London, 1969.
- Dong et al. (2019) Dong, H., Mao, J., Lin, T., Wang, C., Li, L., and Zhou, D. Neural logic machines. arXiv preprint arXiv:1904.11694, 2019.
- Dubois & Prade (1980) Dubois, D. and Prade, H. Fuzzy sets and systems: Theory and applications. Academic Press, 1980.
- dâAvila Garcez & Lamb (2023) dâAvila Garcez, A. and Lamb, L. C. Neurosymbolic ai: The 3rd wave. Artificial Intelligence Review, 56(11):12387â12406, nov 2023.
- Fagin & Halpern (1990) Fagin, R. and Halpern, J. Y. Uncertainty, belief, and probability. Computational Intelligence, 7(1):160â173, 1990.
- Fodor (1975) Fodor, J. A. The Language of Thought. Harvard University Press, Cambridge, MA, 1975.
- Getoor & Taskar (2007) Getoor, L. and Taskar, B. (eds.). Introduction to Statistical Relational Learning. Adaptive Computation and Machine Learning. The MIT Press, 2007. ISBN 978-0-262-07286-1. URL https://doi.org/10.7551/mitpress/7432.001.0001.
- Hajek (1998) Hajek, P. Metamathematics of Fuzzy Logic. Springer Science & Business Media, 1998.
- Harnad (1990) Harnad, S. The symbol grounding problem. Physica D: Nonlinear Phenomena, 42(1-3):335â346, 1990.
- Hatzilygeroudis & Prentzas (2000) Hatzilygeroudis, I. and Prentzas, J. Neurules: Integrating symbolic rules and neurocomputing. In Fotiades, D. and Nikolopoulos, S. (eds.), Advances in Informatics, pp. 122â133. World Scientific, Singapore, 2000.
- Haugeland (1985) Haugeland, J. Artificial Intelligence: The Very Idea. MIT Press, Cambridge, MA, 1985.
- Hilario (1995) Hilario, M. An overview of strategies for neurosymbolic integration. In Proceedings of the Workshop on Connectionist-Symbolic Integration: From Unified to Hybrid Approaches, Montreal, Canada, 1995.
- Hornik et al. (1989) Hornik, K., Stinchcombe, M., and White, H. Multilayer feedforward networks are universal approximators. Neural Networks, 2(5):359â366, 1989.
- HĂślldobler & Kalinke (1994) HĂślldobler, S. and Kalinke, Y. Towards a massively parallel computational model for logic programming. In Proceedings of the ECAIâ94 Workshop on Combining Symbolic and Connectionist Processing, pp. 68â77, 1994.
- Kahneman (2011) Kahneman, D. Thinking, Fast and Slow. Farrar, Straus and Giroux, 2011.
- Kambhampati et al. (2024) Kambhampati, S., Valmeekam, K., Guan, L., Verma, M., Stechly, K., Bhambri, S., Saldyt, L. P., and B Murthy, A. Position: LLMs canât plan, but can help planning in LLM-modulo frameworks. In Salakhutdinov, R., Kolter, Z., Heller, K., Weller, A., Oliver, N., Scarlett, J., and Berkenkamp, F. (eds.), Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 22895â22907. PMLR, 21â27 Jul 2024.
- Kaplan et al. (2020) Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., and Amodei, D. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.
- Kautz (2022) Kautz, H. The third ai summer: Aaai robert s. engelmore memorial lecture. AI Magazine, 43(1):105â125, 2022.
- Kleene (1952) Kleene, S. C. Introduction to Metamathematics. North-Holland Publishing Company, 1952.
- Klement et al. (2000) Klement, E. P., Mesiar, R., and Pap, E. Triangular Norms. Springer, 2000.
- Manhaeve et al. (2018) Manhaeve, R., DumanÄiÄ, S., Kimmig, A., Demeester, T., and Raedt, L. D. Deepproblog: Neural probabilistic logic programming. In Advances in Neural Information Processing Systems 31 (NeurIPS 2018), pp. 3749â3759, 2018.
- Marra et al. (2024) Marra, G., DumanÄiÄ, S., Manhaeve, R., and De Raedt, L. From statistical relational to neurosymbolic artificial intelligence: A survey. Artificial Intelligence, 328:104062, 2024.
- McCarthy & Hayes (1969) McCarthy, J. and Hayes, P. J. Some philosophical problems from the standpoint of artificial intelligence. Machine Intelligence, 4:463â502, 1969.
- McClelland & Rumelhart (1986) McClelland, J. L. and Rumelhart, D. E. Parallel Distributed Processing: Explorations in the Microstructure of Cognition, Volume 2: Psychological and Biological Models. MIT Press, Cambridge, MA, 1986.
- McCulloch & Pitts (1943) McCulloch, W. S. and Pitts, W. A logical calculus of the ideas immanent in nervous activity. Bulletin of Mathematical Biophysics, 5:115â133, 1943.
- Menger (1942) Menger, K. Statistical metrics. Proceedings of the National Academy of Sciences of the United States of America, 28(12):535â537, 1942.
- Minsky (1961) Minsky, M. Steps toward artificial intelligence. Proceedings of the IRE, 49(1):8â30, 1961. doi: 10.1109/JRPROC.1961.287775. URL https://ieeexplore.ieee.org/document/4066245.
- Muggleton (1996) Muggleton, S. Learning from positive data. In Proceedings of the 6th International Workshop on Inductive Logic Programming (ILP), pp. 358â376, 1996.
- Newell (1965) Newell, A. Limitations of the current stock of ideas about problem solving. In Kent, A. and Taulbee, O. (eds.), Proceedings of the Conference on Electronic Information Handling, pp. 195â208, New York, 1965. Spartan Books.
- Newell & Simon (1956) Newell, A. and Simon, H. The logic theory machineâa complex information processing system. IRE Transactions on Information Theory, 2(3):61â79, 1956.
- Newell & Simon (1972) Newell, A. and Simon, H. A. Human Problem Solving. Prentice-Hall, Englewood Cliffs, NJ, 1972.
- Nilsson (1980) Nilsson, N. J. Principles of Artificial Intelligence. Tioga Publishing, 1980.
- Nilsson (1986) Nilsson, N. J. Probabilistic logic. Artificial Intelligence, 28(1):71â87, 1986.
- Pearl (1988) Pearl, J. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988.
- Rae et al. (2021) Rae, J. W., Borgeaud, S., Cai, T., Millican, K., Hoffmann, J., Song, F., Aslanides, J., Henderson, S., Ring, R., Young, S., Rutherford, E., Hennigan, T., Menick, J., Cassirer, A., Powell, R., van den Driessche, G., Hendricks, L. A., Rauh, M., Huang, P.-S., Glaese, A., Welbl, J., Dathathri, S., Huang, S., Uesato, J., Mellor, J., Higgins, I., Creswell, A., McAleese, N., Wu, A., Elsen, E., Jayakumar, S., Buchatskaya, E., Budden, D., Sutherland, E., Simonyan, K., Paganini, M., Sifre, L., Martens, L., Li, X. L., Kuncoro, A., Nematzadeh, A., Gribovskaya, E., Donato, D., Lazaridou, A., Mensch, A., Lespiau, J.-B., Tsimpoukelli, M., Grigorev, N., Fritz, D., Sottiaux, T., Pajarskas, M., Pohlen, T., Gong, Z., Toyama, D., de Masson dâAutume, C., Li, Y., Terzi, T., Mikulik, V., Babuschkin, I., Clark, A., de Las Casas, D., Guy, A., Jones, C., Bradbury, J., Johnson, M., Hechtman, B., Weidinger, L., Gabriel, I., Isaac, W., Lockhart, E., Osindero, S., Rimell, L., Dyer, C., Vinyals, O., Ayoub, K., Stanway, J., Bennett, L., Hassabis, D., Kavukcuoglu, K., and Irving, G. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446, 2021. URL https://arxiv.org/abs/2112.11446.
- Raedt et al. (2020) Raedt, L. D., DumanÄiÄ, S., Manhaeve, R., and Marra, G. From statistical relational to neuro-symbolic artificial intelligence. In Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence (IJCAI-20), pp. 4943â4950, 2020.
- Rescher (1969) Rescher, N. Many-Valued Logic. McGraw-Hill, New York, 1969.
- Riegel et al. (2020) Riegel, R., Gray, A., and Laird, J. E. Logical neural networks. arXiv preprint arXiv:2006.13155, 2020.
- Rocktäschel & Riedel (2017) Rocktäschel, T. and Riedel, S. End-to-end differentiable proving. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R. (eds.), Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.
- Rumelhart & McClelland (1986) Rumelhart, D. E. and McClelland, J. L. Parallel Distributed Processing: Explorations in the Microstructure of Cognition, Volume 1: Foundations. MIT Press, Cambridge, MA, 1986.
- Russell & Norvig (2020) Russell, S. and Norvig, P. Artificial Intelligence: A Modern Approach. Pearson, 4th edition, 2020.
- Sarker et al. (2021) Sarker, M. K., Zhou, L., Eberhart, A., and Hitzler, P. Neuro-symbolic artificial intelligence. AI Commun., 34(3):197â209, January 2021. ISSN 0921-7126.
- Schweizer & Sklar (1961) Schweizer, B. and Sklar, A. Associative functions and statistical triangle inequalities. Publications of the Mathematical Society of Japan, 8:169â186, 1961.
- Schweizer & Sklar (1983) Schweizer, B. and Sklar, A. Probabilistic Metric Spaces. Elsevier, 1983.
- Seda (2006) Seda, A. K. On the integration of connectionist and logic-based systems. Electronic Notes in Theoretical Computer Science, 161:109â130, 2006. ISSN 1571-0661. doi: https://doi.org/10.1016/j.entcs.2006.04.028. URL https://www.sciencedirect.com/science/article/pii/S1571066106004038. Proceedings of the Third Irish Conference on the Mathematical Foundations of Computer Science and Information Technology (MFCSIT 2004).
- Sen et al. (2022) Sen, P., de Carvalho, B. W. S. R., Riegel, R., and Gray, A. Neuro-symbolic inductive logic programming with logical neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, pp. 8212â8219, 2022.
- Serafini & Garcez (2016) Serafini, L. and Garcez, A. d. Logic tensor networks: Deep learning and logical reasoning from data and knowledge. In Conference of the Italian Association for Artificial Intelligence, pp. 334â348. Springer, 2016.
- Smith (1988) Smith, K. C. Multiple-valued logic: A tutorial and appreciation. Computer, 21(4):17â27, 1988.
- Sun et al. (2024) Sun, H., Xu, W., Liu, W., Luan, J., Wang, B., Shang, S., Wen, J.-R., and Yan, R. DetermLR: Augmenting LLM-based logical reasoning from indeterminacy to determinacy. In Ku, L.-W., Martins, A., and Srikumar, V. (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 9828â9862, Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.acl-long.531. URL https://aclanthology.org/2024.acl-long.531/.
- Tarski (1944) Tarski, A. The semantic conception of truth. Philosophy and Phenomenological Research, 4:341â376, 1944.
- Tian et al. (2021) Tian, J., Li, Y., Chen, W., Xiao, L., He, H., and Jin, Y. Diagnosing the first-order logical reasoning ability through LogicNLI. In Moens, M.-F., Huang, X., Specia, L., and Yih, S. W.-t. (eds.), Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 3738â3747, Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. doi: 10.18653/v1/2021.emnlp-main.303. URL https://aclanthology.org/2021.emnlp-main.303/.
- van Krieken et al. (2022) van Krieken, E., Acar, E., and van Harmelen, F. Analyzing differentiable fuzzy logic operators. Artificial Intelligence, 302:103602, 2022. ISSN 0004-3702. doi: https://doi.org/10.1016/j.artint.2021.103602. URL https://www.sciencedirect.com/science/article/pii/S0004370221001533.
- Wang et al. (2019) Wang, P.-W., Donti, P., Wilder, B., and Kolter, Z. Satnet: Bridging deep learning and logical reasoning using a differentiable satisfiability solver. In Proceedings of the International Conference on Machine Learning (ICML), pp. 6545â6554. PMLR, 2019.
- Wang et al. (2025) Wang, W., Yang, Y., and Wu, F. Towards data-and knowledge-driven ai: A survey on neuro-symbolic computing. IEEE Transactions on Pattern Analysis and Machine Intelligence, 47(2):878â899, 2025.
- Wei et al. (2022) Wei, J., Wang, X., Schuurmans, D., Bosma, M., Chi, E., Le, Q., and Zhou, D. Chain of thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems (NeurIPS), 2022. URL https://arxiv.org/abs/2201.11903.
- Whitehead & Russell (1910) Whitehead, A. N. and Russell, B. Principia Mathematica. Cambridge University Press, 1910.
- Yang et al. (2019) Yang, F., Song, L., and Zhang, M. Learning algorithms via neural logic networks. arXiv preprint arXiv:1904.01554, 2019.
- Yang et al. (2020) Yang, Z., Ishay, A., and Lee, J. Neurasp: Embracing neural networks into answer set programming. In Bessiere, C. (ed.), Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence, IJCAI-20, pp. 1755â1762. International Joint Conferences on Artificial Intelligence Organization, 7 2020.
- Yao et al. (2023) Yao, S., Yu, D., Zhao, J., Shafran, I., Griffiths, T., Cao, Y., and Narasimhan, K. Tree of thoughts: Deliberate problem solving with large language models. In Advances in Neural Information Processing Systems (NeurIPS), 2023.
- Zadeh (1965) Zadeh, L. A. Fuzzy sets. Information and Control, 8(3):338â353, 1965.
- Ĺukasiewicz (1920) Ĺukasiewicz, J. O logice trĂłjwartoĹciowej. Ruch Filozoficzny, 5:169â171, 1920.
## Appendix A Observations on Decision Boundary
Expanding on Figure 1, we analyze the effect of different gating parameters $\beta\in\{1,10,100\}$ on LNU decision boundaries. As $\beta$ increases, the boundaries transition from smooth to sharper logical separations, demonstrating a controllable interpolation between continuous and discrete decision-making within a single neural computation unit, such as AND/OR.
<details>
<summary>extracted/6177073/decision_boundaries_more.png Details</summary>
### Visual Description
## Heatmap Comparison: Decision Boundaries of Logic Gates and Neural Models
### Overview
The image is a composite figure containing ten individual heatmap subplots arranged in a 5-row by 2-column grid. The overall title is "Comparison of Hard Logic, NLU, and MLP (Dense + ReLU) Decision Boundaries." Each subplot visualizes the decision boundary of a specific logical function or neural network model over a 2D input space defined by variables \(x_1\) and \(x_2\), both ranging from 0.0 to 1.0. A vertical color bar on the right side of the figure provides a legend for the "Decision Output Intensity," mapping colors to numerical values from 0.000 (dark purple) to 1.000 (bright yellow).
### Components/Axes
* **Main Title:** "Comparison of Hard Logic, NLU, and MLP (Dense + ReLU) Decision Boundaries"
* **Subplot Titles (Row-wise, Left to Right):**
1. "Hard Logic OR", "Hard Logic AND"
2. "NLU Soft-OR (β=1, w=(0.5,0.5))", "NLU Soft-AND (β=1, w=(0.5,0.5))"
3. "NLU Soft-OR (β=10, w=(0.5,0.5))", "NLU Soft-AND (β=10, w=(0.5,0.5))"
4. "NLU Soft-OR (β=100, w=(0.5,0.5))", "NLU Soft-AND (β=100, w=(0.5,0.5))"
5. "Dense+ReLU (Bias=0.0, w=(0.5,0.5))", "Dense+ReLU (Bias=-0.5, w=(0.5,0.5))"
* **Axes (for all subplots):**
* **X-axis:** Label is "\(x_1\)". Ticks are at 0.0, 0.2, 0.4, 0.6, 0.8, 1.0.
* **Y-axis:** Label is "\(x_2\)". Ticks are at 0.0, 0.2, 0.4, 0.6, 0.8, 1.0.
* **Color Bar (Right side, spanning full height):**
* **Label:** "Decision Output Intensity"
* **Scale:** Linear, from 0.000 at the bottom to 1.000 at the top.
* **Tick Values:** 0.000, 0.111, 0.222, 0.333, 0.444, 0.556, 0.667, 0.778, 0.889, 1.000.
* **Color Gradient:** Transitions from dark purple (0.000) through blue, teal, and green to bright yellow (1.000).
### Detailed Analysis
**Row 1: Hard Logic Gates**
* **Left (Hard Logic OR):** Shows a sharp, step-function boundary. The region where \(x_1 > 0.5\) OR \(x_2 > 0.5\) is bright yellow (output â 1.0). The region where both \(x_1 ⤠0.5\) and \(x_2 ⤠0.5\) is dark purple (output â 0.0). The boundary forms an "L" shape.
* **Right (Hard Logic AND):** Shows a sharp, step-function boundary. The region where \(x_1 > 0.5\) AND \(x_2 > 0.5\) is bright yellow (output â 1.0). All other regions are dark purple (output â 0.0). The boundary forms a square in the top-right quadrant.
**Rows 2-4: NLU (Neural Logic Unit) Soft Gates**
These plots show smooth, continuous approximations of the hard logic gates. The parameter β controls the sharpness of the transition. The weight vector w is fixed at (0.5, 0.5).
* **Row 2 (β=1):** Boundaries are very diffuse. For Soft-OR, the output increases gradually from the bottom-left corner. For Soft-AND, the output increases gradually towards the top-right corner. The transition zone is wide.
* **Row 3 (β=10):** Boundaries become more defined. The transition from low to high output is sharper than at β=1, but still smooth. The shape begins to resemble the hard logic counterparts.
* **Row 4 (β=100):** Boundaries are very sharp, closely approximating the hard logic gates. The transition from purple to teal/green is abrupt, mimicking the step function. The Soft-OR boundary is a sharp "L", and the Soft-AND boundary is a sharp square in the top-right.
**Row 5: Dense Layer + ReLU Activation**
These plots show the decision boundary of a single-layer neural network with a linear (Dense) layer followed by a Rectified Linear Unit (ReLU) activation. The weight vector w is (0.5, 0.5).
* **Left (Bias=0.0):** The output is a linear plane clipped at zero by the ReLU. The boundary is a straight diagonal line from (0,1) to (1,0). The output is 0.0 (purple) in the bottom-left triangle and increases linearly to 1.0 (yellow) in the top-right triangle.
* **Right (Bias=-0.5):** The negative bias shifts the linear plane downward. The ReLU clips a larger region to zero. The decision boundary (where output > 0) is now a diagonal line shifted towards the top-right corner. The output is 0.0 (purple) over most of the space, rising to a maximum of ~0.5 (teal) only in the extreme top-right corner.
### Key Observations
1. **Sharpness Progression:** The NLU models demonstrate a clear progression from very soft, diffuse decision boundaries (β=1) to very sharp, near-binary boundaries (β=100) that closely mimic the hard logic gates.
2. **Boundary Shape:** The fundamental shape of the decision boundary is determined by the logical operation (OR vs. AND). OR boundaries are "L"-shaped, encompassing the top and right. AND boundaries are square, confined to the top-right.
3. **ReLU Limitation:** The single Dense+ReLU unit with these weights cannot perfectly replicate the hard AND or OR boundaries. It can only produce a linear diagonal boundary. The bias term shifts this boundary but does not change its fundamental linear nature.
4. **Color-Value Consistency:** The color mapping is consistent across all plots. Bright yellow always corresponds to an output near 1.0, and dark purple to an output near 0.0. The intermediate colors (teal, green) represent the smooth transition zones in the soft models.
### Interpretation
This figure is a pedagogical comparison of how different computational models represent logical decisions.
* **Hard Logic** represents the classical, binary ideal: a decision is either fully true (1) or fully false (0) with an instantaneous switch.
* **NLU (Soft Logic)** provides a differentiable, continuous approximation of hard logic. The parameter β acts as a "temperature" or "sharpness" control. Low β creates a very gradual, uncertain transition (useful for gradient-based learning), while high β recovers the crisp, confident decision of hard logic. This illustrates how neural networks can learn to implement logical rules in a smooth, optimizable way.
* **Dense+ReLU** represents the standard building block of deep learning. The figure shows its inherent limitation: a single unit with a ReLU activation can only create a linear decision boundary. To approximate the more complex "L" or square boundaries of OR/AND logic, multiple such units (i.e., a deeper network) would be required to combine several linear boundaries.
**In summary,** the visualization argues that specialized "soft logic" units (like the NLU) can efficiently and intuitively model logical operations with a controllable degree of fuzziness, whereas standard neural network components require more complexity (more units/layers) to achieve the same functional representation. The progression of β elegantly shows the continuum between probabilistic/fuzzy reasoning and deterministic logic.
</details>
Figure 3: Effect of gating parameter $\beta\in\{1,10,100\}$ on LNU decision boundaries with fixed weights ( $w_{i}=0.5,\forall i$ ). Increasing $\beta$ sharpens the boundary, approaching hard logic.
## Appendix B Matrix operations
Given an input matrix $\mathbf{X}\in\mathbb{R}^{n\times d}$ and trainable parameter matrices $\mathbf{W}_{\text{AND}},\mathbf{W}_{\text{OR}}\in\mathbb{R}^{d\times o}$ , we apply broadcasted element-wise multiplication to implement the Locally Gated Logical Consistency mechanism
$$
\mathbf{Z}_{\text{AND}}=\mathbf{X}\odot\mathbf{W}_{\text{AND}},\quad\mathbf{Z}
_{\text{OR}}=\mathbf{X}\odot\mathbf{W}_{\text{OR}}.
$$
Here, broadcasting ensures:
$$
z_{ijk}=x_{ij}\cdot w_{jk},\quad x_{ij}\text{ is shared across }k,\quad w_{jk}
\text{ is shared across }i.
$$
Logical transformations are then applied to produce the final outputs:
$$
\mathbf{X}_{\mathrm{AND}}=\texttt{soft-AND}(\mathbf{Z}_{\mathrm{AND}}),~{}~{}~
{}\mathbf{X}_{\mathrm{OR}}=\texttt{soft-OR}(\mathbf{Z}_{\mathrm{OR}}).
$$
The final LNU layer output is formed by concatenating these logical transformations:
$$
\mathbf{X}_{\mathrm{out}}=\bigl{[}\mathbf{X}_{\mathrm{AND}}\;\|\;\mathbf{X}_{
\mathrm{OR}}\bigr{]}.
$$
Optionally, soft-NOT transformations can be included to enhance representational flexibility.