ODSC AI East 2026 — Pedro Domingos on Tensor Logic: The Language of AI

For decades, the field of AI has struggled with a fundamental fragmentation. On one side, we have the symbolic AI of the past, capable of rigorous reasoning but limited in its ability to learn from raw data. On the other hand, we have the deep learning revolution, which scales effortlessly but remains a “black box” lacking transparency and **logical structure.**

At **ODSC AI East 2026**, Pedro Domingos, Professor Emeritus at the University of Washington, said that fields only truly take off when they find their definitive language. For AI professionals today, that language is emerging as a synthesis of these two worlds: Tensor Logic: The Language of AI.

For those who missed his keynote, this is a framework that could help shape the next era of AI.

The Evolution of AI Languages

Historical attempts to find a medium of expression — from Lisp and Prolog in the 1950s-70s to 1990s graphical models — struggled to balance reasoning with scalability. While Python and libraries like **PyTorch** currently dominate, they excel at gradient descent but lack native automated reasoning.

This gap led to neuro-symbolic AI, yet a framework combining logical transparency with** tensor scalability** remained elusive until now. Tensor Logic fulfills this need by merging tensor algebra and logic programming.

Unifying Tensors and Relations

To understand how Tensor Logic functions, we must first examine how it unifies the data structures used in different AI paradigms. In symbolic AI, a logic program consists of rules and facts, where a fact represents a relation applying to objects, such as “parent(Bob, Chris)”.

In **deep learning**, everything is built upon tensors — generalizations of vectors and matrices defined by their type and shape. Domingos proposes a remarkably simple bridge: a relation is essentially a compact representation of a sparse Boolean tensor.

For instance, a social network can be viewed as a matrix where a “1” indicates a connection and a “0” indicates its absence. While this is inefficient as dimensions grow, representing it as a list of non-zero entries allows us to treat logical facts as tensor data.

This realization allows us to treat a database of facts as a series of tensors, setting the stage for more complex operations.

The Power of Einstein Summation

The core of this new language relies on Einstein Summation, or “EinSum.” This notation simplifies tensor algebra by removing explicit summation signs; whenever an index is repeated in a term, it is implicitly summed over. EinSum is already implemented in popular libraries like NumPy and PyTorch, but its full potential is rarely realized by practitioners.

In the context of Tensor Logic: The Language of AI, logic rules are transformed into EinSum operations over **Boolean tensors** using a step function as a nonlinearity. For example, a logical rule defining an “aunt” relation can be written as a single tensor equation.

This synthesis means that logic programming is no longer a separate process from tensor manipulation. Instead, the two are mathematically identical, allowing for a streamlined approach to building complex AI systems.

Generalizing Database Operations

Tensor Logic goes beyond simple rules by generalizing standard database operations into the tensor domain. Two key operations are central to this:

• Tensor Projection: This is a generalization of database projection. It involves summing elements of a tensor across specific indices, effectively “collapsing” dimensions, such as projecting a matrix onto a vector.
• Tensor Join: This generalizes the database join. When two tensors share common indices, we multiply their corresponding values. If the tensors are boolean, this operation reduces exactly to a standard database join.

By using these operations, a Tensor Logic program becomes a set of tensor equations where the join is implicit, and the left-hand side is equal to a nonlinearity applied to the right-hand side. This structure preserves the correspondence with **logic programming** while enabling the numerical flexibility of deep learning.

Learning via Backpropagation Through Structure

One of the most significant advantages for ML engineers is that Tensor Logic allows for learning symbolic structures through gradient descent. Because the language relies on a single construct — the tensor equation — calculating derivatives becomes straightforward. The gradient of a Tensor Logic program is simply another Tensor Logic program.

To handle models with varying architectures, Domingos introduces “backpropagation through structure“. This is a generalization of the backpropagation through time used in **Recurrent Neural Networks (RNNs)**.

It allows the model to perform backpropagation even when the “network” of rules and facts changes for each specific example. Consequently, we can scale the learning process using the same hardware acceleration that has made deep learning so successful

Simplifying Complex Architectures

The elegance of Tensor Logic: The Language of AI, is most visible when defining modern neural network architectures. Because the language is so concise, complex models can often be reduced to just one or two equations:

• Perceptrons: A one-layer perceptron is defined in a single line using a step function and a dot product.
• Recurrent Neural Networks (RNNs): These are expressed by accounting for time indices and previous states within the tensor join.
• Convolutional Neural Networks (CNNs): Layers for convolution and pooling are represented by offset indices and summation.
• Transformers: Even the multi-head attention mechanisms and residual streams of a transformer can be captured in a handful of equations.

Transformers in Tensor Logic

By treating these architectures as logic-based tensor equations, they become easier to debug, play with, and generate automatically.

A Unified Path Forward

As AI continues to integrate into critical infrastructure, the need for models that are both high-performing and interpretable is non-negotiable. Tensor Logic provides a framework where neural networks gain the reliability of symbolic AI, and symbolic systems gain the learnability of **deep learning**.

It allows for reasoning in embedding spaces that is both sound and transparent — a feat that was previously a significant challenge.

As agentic workflows continue to evolve, the teams that understand these tools today will be better prepared to build what comes next. To explore more expert-led sessions on AI, agents, and the future of applied data science, join us at ODSC AI West.

**Register today and take the next step in building the AI systems of tomorrow.**