💻 computer science

sLTN: Structural Logic Tensor Networks

This paper introduces sLTN, a neurosymbolic framework that extends Logic Tensor Networks by incorporating structural dimensions as first-class elements to enable the explicit representation and differentiable learning of temporal, sequential, and relational constraints.

Original authors: Davide Rinaldi, Luciano Serafini

Published 2026-08-12

📖 3 min read☕ Coffee break read

CC BY 4.0

Original authors: Davide Rinaldi, Luciano Serafini

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to understand the world. You have two powerful tools in your toolbox. The first is Machine Learning, which is like a super-observant apprentice that learns by looking at millions of examples. It's great at spotting patterns, like recognizing a cat in a photo, but it doesn't really "know" what a cat is or why it behaves the way it does. The second tool is Logic, which is like a strict rulebook or a set of laws. It knows that if "all cats have tails" and "Fluffy is a cat," then "Fluffy must have a tail." But logic is often rigid and struggles to learn from messy, real-world data.

For a while, scientists have been trying to combine these two tools into a single system called neurosymbolic AI. The goal is to create an AI that can learn from data and follow logical rules at the same time. One popular framework for this is called Logic Tensor Networks (LTN). Think of LTN as a translator that turns logical rules into math problems that a computer can solve using gradients (a method for improving answers step-by-step). However, the original version of LTN had a blind spot: it was designed for "flat" data. It treated everything like a giant, unorganized pile of individual items. It didn't know how to handle things that have a natural order or structure, like a sequence of events in time, a list of steps in a story, or the connections between friends in a social network. It was like trying to describe a movie by just listing the actors without mentioning the plot or the timeline.

This is where a new paper comes in, introducing sLTN (Structural Logic Tensor Networks). The authors, Davide Rinaldi and Luciano Serafini, realized that the world isn't just a pile of items; it's full of structure. Time flows forward, sentences have word orders, and graphs have connections. They built an upgrade to LTN that treats these structures as "first-class citizens." In sLTN, you can explicitly talk about "time steps," "sequence positions," or "graph nodes" right inside your logical rules.

The paper doesn't just suggest this is a good idea; it provides the full mathematical blueprint (syntax and semantics) and a working software library built on PyTorch. They show that sLTN can take a logical rule like "If a digit appears at time $t$ , it should also appear at time $t+1$ " and turn it into a math problem the computer can learn from. They demonstrated this with a video classification task where the AI had to watch a sequence of frames showing a digit being drawn. The system learned to distinguish between videos where a digit appears smoothly and those where it flickers in and out, using logical rules about time and sequence. The authors show that if you remove the structural features, sLTN falls back perfectly to the original LTN, proving it's a true extension. While the paper presents a solid framework and working code, it notes that the system is still a new library that needs more testing and real-world validation beyond these initial examples. It's a promising step toward AI that understands not just what things are, but how they are arranged in the world.

Technical Summary: Structural Logic Tensor Networks (sLTN)

Problem Statement

Logic Tensor Networks (LTN) provide a neurosymbolic framework that integrates first-order logic with neural networks by interpreting logical symbols as tensors and logical connectives as differentiable fuzzy operators. While effective for tasks involving flat collections of individuals (e.g., semantic image interpretation, recommendation systems), the original LTN formulation lacks explicit mechanisms to handle data with inherent structural organization.

In domains such as time series, sequential data, or graph-structured inputs, structural organization (temporal order, sequence position, graph connectivity) is a semantic component of the problem rather than a mere implementation detail. The original LTN framework treats data as flat collections, making it difficult to express constraints that explicitly refer to positional or relational patterns, such as temporal persistence, neighborhood constraints in graphs, or dependencies between ordered positions. This limitation restricts the framework's applicability to structured reasoning tasks where the logical language must directly reference the axes along which objects are organized.

Methodology

To address these limitations, the authors introduce Structural Logic Tensor Networks (sLTN), an extension of LTN that elevates structural dimensions to first-class elements of the logical language. The methodology is built upon three core pillars:

1. Extended Syntax and Signature

sLTN extends the standard many-sorted first-order signature to include:

Structural Dimensions ( $D$ ): Named tensor axes representing domain-specific organization (e.g., time steps $T$ , sequence positions, graph nodes).
Structural Variables ( $\Xi$ ): Variables ranging over indices of declared structural dimensions, distinct from first-order variables that range over individuals.
Structural Relations ( $R$ ): Relations over tuples of structural indices, interpreted as Boolean or fuzzy masks. For example, a relation next(t, t') can express adjacency between consecutive time steps.

The language supports structural quantification (quantifying over indices of a dimension), guarded structural quantification (evaluating formulas only where a structural relation holds), and axis annotations/selection (renaming or slicing specific structural axes).

2. Fuzzy Tensor Semantics

The semantics of sLTN are defined via annotated tensors, which explicitly track the role of each tensor axis (variable, structural, or domain).

Grounding: Symbols are grounded to tensors or tensor maps. Constants and variables carry structural axes based on their dimensional profiles. Functions and predicates are grounded as local maps that consume and produce specific structural profiles.
Structural Relations: Grounded as truth-valued masks over structural indices (e.g., a crisp mask for next where $M_{i,j} = 1$ if $j = i+1$ ).
Compositional Denotation: The denotation of terms and formulas is computed via structural recursion. Key operations include:
- Named-axis alignment: Aligning tensors by name and role before applying pointwise operations or local maps.
- Consumption and Propagation: Predicates and functions can "consume" structural axes (aggregating over them) or propagate them pointwise.
- Aggregation: Quantifiers (both first-order and structural) are interpreted as aggregation operators (e.g., mean, min, max) over the corresponding variable or structural axes. Guarded quantifiers use the guard's truth values as weights or masks during aggregation.

3. Learning and Optimization

Learning in sLTN is formulated as the optimization of a knowledge base (a set of closed clauses) to maximize their satisfaction degrees.

Multi-Objective Formulation: Since a knowledge base consists of multiple clauses, satisfaction is naturally a multi-objective problem.
Scalarized Learning: Clause satisfactions are aggregated into a single scalar loss using a configurable aggregator (e.g., power mean) before backpropagation.
Multi-Objective Learning: sLTN supports retaining per-clause losses and combining their gradients using Jacobian-descent aggregators (e.g., PCGrad) to handle conflicting objectives without premature scalarization.
Differentiability: The entire framework, including fuzzy operators and aggregation, is implemented using differentiable tensor operations in PyTorch, enabling gradient-based optimization of the interpretation parameters.

Key Contributions

The paper makes three primary contributions:

Language Extension: It extends the LTN language with structural dimensions, structural variables, and structural relations, making structural organization an explicit object of logical modeling. This allows formulas to refer directly to positional and relational patterns.
Formal Semantics: It provides a rigorous fuzzy tensor semantics for sLTN, defining how structural constructs integrate with differentiable connectives and quantifier aggregation. It demonstrates that the original LTN semantics are recovered as a special case when structural dimensions are absent.
Modular Implementation: It describes a modular Python/PyTorch implementation that separates syntax (Signatures, parsers) from semantics (Interpretations). The library supports declarative signature definition, formula parsing, and tensorial interpretation with named-axis operations.

Results and Illustrative Examples

The paper does not present large-scale empirical benchmarks but illustrates the framework's capabilities through a running video-classification example involving MNIST digits.

Task: Distinguishing between "appear" videos (a digit monotonically revealed) and "non-appear" videos (digits revealed and hidden cyclically).
Application of sLTN:
- Temporal Persistence: A formula expresses that if a digit is complete at time $t$ , it should remain complete at $t+1$ (using the next relation).
- Boundary Conditions: Formulas enforce that an appearing video starts incomplete (at $t=0$ ) and ends complete (at $t=T-1$ ) using axis selection.
- Whole-Sequence Judgement: The appear predicate consumes the entire temporal axis to make a global classification, distinct from frame-level predicates like Complete.
Implementation: The example demonstrates how to declare signatures, define derived predicates (e.g., is_appear), parse complex formulas with structural quantifiers, and train the model using the kb_backward interface with either scalarized or multi-objective optimization.

Significance and Claims

The paper positions sLTN as a necessary evolution of the LTN framework to handle the growing demand for neurosymbolic reasoning over structured data.

Expressiveness: By treating structural dimensions as first-class citizens, sLTN allows logical constraints to be expressed directly at the level of the problem's semantics (e.g., temporal order, graph topology) rather than forcing them into flat representations.
Compatibility: The framework preserves the core benefits of LTN, including differentiable fuzzy semantics and gradient-based optimization, while extending them to structured inputs.
Practical Utility: The separation of syntax and semantics, along with the provided PyTorch implementation, aims to lower the barrier for applying neurosymbolic reasoning to complex, structured domains such as temporal reasoning, sequential processing, and graph-based learning.

The authors acknowledge that sLTN is an initial framework requiring further stabilization and systematic empirical validation. They outline future work in developing domain-specific structured theories, extending the language with finitely recursive computational primitives, and investigating principled schedules for hyperparameters to improve training stability. The paper serves as a companion to the open-source sLTN library, providing the theoretical foundation for its usage.