A plain-language walkthrough of the framework that makes logic programs and tensor equations mathematically identical.
For decades, AI has been split between two worlds: symbolic AI, which reasons rigorously with rules and facts but struggles to learn from raw data, and deep learning, which scales effortlessly but stays an opaque "black box." At ODSC AI East 2026, Pedro Domingos proposed Tensor Logic as the language that finally closes this gap.
The bridge is a single idea: a logical relation — a fact like parent(Bob, Chris) — is nothing more than a compact way of writing down a sparse Boolean tensor. Once facts are tensors, logic rules become Einstein Summation equations, database operations generalize into tensor projection and tensor join, and — because the whole system is built from one recurring construct, the tensor equation — gradients (and therefore learning) fall out for free via backpropagation through structure. The section below walks through that chain of ideas in the order the keynote builds it.
“Fields only truly take off when they find their definitive language.”
— Pedro Domingos, ODSC AI East 2026 keynote
Each prior medium of expression for AI offered rigor or scale, never both at once — the gap Tensor Logic sets out to close.
Strength: rigorous symbolic reasoning over facts and rules.
Limitation: limited ability to learn from raw data or scale with gradient-based methods.
Strength: structured probabilistic reasoning over relationships between variables.
Limitation: still struggled to balance rigorous reasoning with scalability.
Strength: excels at gradient descent and scales effortlessly with modern hardware.
Limitation: lacks native automated logical reasoning; no built-in logical structure.
Six ideas, built one on top of the next, turn logic programs and tensor computation into a single mathematical construct.
A logical relation, such as parent(Bob, Chris), is a compact representation of a sparse Boolean tensor: a "1" marks a true fact, a "0" marks its absence. Storing only the non-zero entries lets a whole database of facts be treated directly as tensor data. Enables: logic-program facts stored and manipulated using the same sparse-tensor structures deep learning already relies on.
A notation that implicitly sums over any index repeated within a term, removing explicit summation signs — already in NumPy and PyTorch, but rarely used to its full potential. A logic rule (e.g. defining an "aunt" relation) becomes a single EinSum tensor equation over Boolean tensors, using a step function as the nonlinearity. Enables: a symbolic logic rule and its tensor computation become mathematically identical, not two separate processes.
Generalizes the database "projection" operation: summing a tensor's elements across specific indices to collapse dimensions, such as projecting a matrix onto a vector. Enables: database-style queries running over the same structures used for learning.
Generalizes the database "join": when two tensors share common indices, their corresponding values are multiplied. If the tensors are Boolean, this reduces exactly to a standard database join. Enables: a join operator provably identical to relational-database join in the Boolean case, extending smoothly to continuous-valued tensors.
Because a Tensor Logic program is built from one recurring construct, its gradient is simply another Tensor Logic program. "Backpropagation through structure" generalizes backpropagation through time (used in RNNs) so gradients compute correctly even when the network of rules and facts changes per example. Enables: gradient-based learning of symbolic structures on standard deep-learning hardware.
Because the language is so concise, complex modern architectures reduce to just one or two equations each — logic-based tensor equations that are easier to debug, experiment with, and generate automatically. Enables: a full architecture's computation is legible as a handful of equations, not opaque layer-by-layer code.
Architecture Compression (principle 6 above) applies directly to the neural networks practitioners already use:
A one-layer perceptron is defined in a single line combining a step function and a dot product.
Expressed by accounting for time indices and previous hidden states within the tensor join.
Convolution and pooling layers are represented using offset indices and summation.
Multi-head attention and residual streams are captured in a handful of tensor equations.
As AI moves deeper into critical infrastructure, this is the payoff: neural networks gain the reliability of symbolic AI, and symbolic systems gain the learnability of deep learning — reasoning in embedding spaces that is both sound and transparent.
The formal source behind the ODSC keynote is Pedro Domingos's arXiv paper (2510.12269, October 2025). No reference implementation from Domingos himself is known to be published. Three independent, community-built reimplementations exist based on that paper — none official:
Community implementation treating relations as sparse Boolean tensors and Datalog rules as Einstein summations. Built by Zeke Bass with Claude Opus 4.5, December 2025. Source →
Production-oriented C++ implementation of the same sparse-Boolean-tensor framework, by harshaljanjani. Source →
Python implementation by Kocoro-lab, discussed in a companion blog post (Oct 21, 2025). Source →
Disambiguation: "Logic Tensor Networks" (LTNtorch) is a separate, pre-existing PyTorch neuro-symbolic framework unrelated to Domingos's Tensor Logic, despite the similar name.
Professor Emeritus at the University of Washington, author of 'The Master Algorithm', and originator of Tensor Logic, presented as a keynote at ODSC AI East 2026.
Open Data Science Conference organization; publisher of the Medium recap article and organizer of the ODSC AI East 2026 conference where Pedro Domingos delivered the Tensor Logic keynote.
Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.
Query this knowledge graph on URIBurner. The editor opens on the canonical SAMPLE entity-type summary (DAV named graph). Pick a recipe, edit freely, then run live or copy.
Tensor Logic is a framework proposed by Pedro Domingos that unifies symbolic AI and deep learning by treating logical relations as sparse Boolean tensors, so that logic programs and tensor algebra become mathematically identical rather than two separate systems bolted together.
Pedro Domingos argues that fields only truly take off once they find their definitive language — a shared notation precise enough for rigorous reasoning yet flexible enough to scale. AI has lacked that until now, oscillating between symbolic languages (rigorous but not scalable) and deep-learning frameworks (scalable but not reasoning-native).
The historical fragmentation between symbolic AI, which reasons rigorously but struggles to learn from raw data, and deep learning, which scales effortlessly but remains an opaque, logic-free 'black box'.
As a non-zero entry in a sparse Boolean tensor. A relation is treated as a compact representation of that tensor: a '1' marks a true fact (e.g. a connection between two people) and a '0' marks its absence, so a whole database of facts becomes tensor data.
EinSum is a notation that implicitly sums over any index repeated within a term, removing explicit summation signs. It is already built into NumPy and PyTorch but underused. Tensor Logic uses EinSum to rewrite logic rules as tensor equations, making logic programming and tensor manipulation mathematically the same operation.
A generalization of the database projection operation: summing a tensor's elements across specific indices to collapse one or more dimensions, such as reducing a matrix down to a vector.
Tensor join generalizes the database join: when two tensors share common indices, their corresponding values are multiplied. If both tensors are Boolean, this operation reduces exactly to a standard database join — the numerical operation and the relational-database operation are the same thing in that special case.
A generalization of backpropagation through time (used to train RNNs) that lets gradients be computed even when the network of rules and facts differs for every training example. It allows symbolic structures themselves — not just fixed-shape neural weights — to be learned via gradient descent.
Because every Tensor Logic program is built from a single recurring construct — the tensor equation — differentiating it mechanically produces another set of tensor equations, keeping the entire system inside the same formalism rather than requiring a separate symbolic differentiation layer.
According to the keynote, yes: because Tensor Logic is so concise, even a Transformer's multi-head attention and residual streams can be captured in a handful of tensor equations, in contrast to the many lines of framework-specific code typically needed.
NumPy and PyTorch already implement Einstein Summation (EinSum), one of Tensor Logic's core mechanisms — but the keynote argues its full potential is rarely realized by practitioners today.
As AI increasingly runs critical infrastructure, models must be both high-performing and interpretable. Tensor Logic aims to let neural networks gain the reliability of symbolic AI while symbolic systems gain the learnability of deep learning — enabling reasoning in embedding spaces that is both sound and transparent.
Pedro Domingos is Professor Emeritus at the University of Washington, author of 'The Master Algorithm', and the originator of Tensor Logic, which he introduced in his ODSC AI East 2026 keynote.
Lisp and Prolog (1950s-70s symbolic reasoning languages), 1990s graphical models, and the modern Python/PyTorch stack — each offered either rigorous reasoning or scalability, but historically not both at once.
No official implementation from Pedro Domingos himself is known to be published, and no widely-adopted production system is known to run on Tensor Logic — the formal arXiv paper (2510.12269) is barely a year old. Three independent community reimplementations exist based on that paper: a Julia implementation (github.com/zekebass/tensor-logic), a C++ implementation (github.com/harshaljanjani/tensor-logic-cpp), and a Python implementation (github.com/Kocoro-lab/tensorlogic). None are official releases. Note also that "Logic Tensor Networks" (LTNtorch) is a separate, pre-existing, unrelated PyTorch framework despite the similar name.
A framework proposed by Pedro Domingos that merges tensor algebra and logic programming by treating relations as sparse Boolean tensors, so that logic rules and tensor equations become mathematically identical, unifying symbolic reasoning with gradient-based deep learning.
A generalization of vectors and matrices to arbitrary dimensions, defined by its type and shape; the fundamental data structure of deep learning.
A tensor whose entries are mostly zero, storing only the non-zero (true) entries — the representation Tensor Logic uses to encode logical relations and facts efficiently.
A tensor-algebra notation in which any index repeated within a term is implicitly summed over, eliminating explicit summation signs; implemented in NumPy and PyTorch.
Summing a tensor's elements across specific indices to collapse dimensions — the tensor-domain generalization of the database projection operation.
Multiplying corresponding values where two tensors share indices — the tensor-domain generalization of the database join operation; reduces to a standard join when both tensors are Boolean.
A generalization of backpropagation through time that computes gradients even when the network of rules and facts differs per example, enabling gradient-based learning of symbolic structure itself.
The broader research field combining neural networks with symbolic reasoning; Tensor Logic is presented as fulfilling the long-elusive goal of merging logical transparency with tensor scalability within this field.
AI built on explicit logical rules and facts, capable of rigorous reasoning but historically limited in learning from raw data.
Gradient-based neural network learning that scales effortlessly with data and compute, but is often criticized as an opaque 'black box' lacking logical structure.
The relational-database operation of combining rows from two tables based on shared keys; tensor join reduces exactly to this operation when applied to Boolean tensors.
A nonlinearity that outputs a discrete value change at a threshold; used in Tensor Logic as the nonlinearity applied to EinSum-based tensor equations when encoding logic rules.