Reviewer has chosen to be Anonymous

Overall Impression: Weak

Content:
Technical Quality of the paper: Weak
Originality of the paper: Yes
Adequacy of the bibliography: No

Presentation:
Adequacy of the abstract: Yes
Introduction: background and motivation: Good
Organization of the paper: Satisfactory
Level of English: Satisfactory
Overall presentation: Average

Detailed Comments:

The main point of this paper can be summerised as a proposal to turn linear algebra into a programming language. Since linear algebra is the mathematical basis for much of AI, this would provide a programming language to support much of AI. (And actually, by virtue of its title, the paper claims this to be a programming language for all of AI).

A key sentence from the abstract is that “The sole construct in tensor logic is the tensor equation, based on the observation that logical rules and Einstein summation are essentially the same operation, and all else can be reduced to them.”, followed by the claim that this will “implement key forms of neural, symbolic and statistical AI in tensor logic” and allow for “sound reasoning in embedding space” (the latter being a much sought after functionality in current-day AI).

In principle, the idea to turn linear algebra into a programming language makes sense, and deserves a well-worked out proposal, including a careful argument why this would apply to broad sets of AI, and backed up by an implementation of such a proposal and by experiments to show its practical validity. Unfortunately, the paper falls short on all of these

I have three main concerns about the current state of the paper, that lead me to reject the paper for publication: (i) unfounded claims in many places; (ii) fundamental limitations of the proposal w.r.t. symbolic inference; and (iii) the lack of any empirical underpinning of the claims I’ve considered a “major revision”, but since my concern also touches on fundamental limitations of the proposal this would require essentially a new paper, not a revision that repairs the current version.

1. The introduction claims that “Neurosymbolic AI seeks to [combine] deep learning modules with symbolic AI ones, but often winds up having the shortcomings of both”. This is a strong claim that needs to be backed up with arguments or at least examples. The single reference to Hitzler and Sarker (2021) certainly does not back up this claim, and is a careless generic reference to an entire book (that actually argues in favour of neuro-symbolic AI).

2. The introduction claims that the proposal of the paper “is based on the observation that essentially all neural networks can be constructed using tensor algebra, all symbolic AI using logic programming, and the two are fundamentally equivalent, differing only in the atomic data types used. ”. There is much to say about this claim, but at the very least it is not true that “all of symbolic Ai can be constructed using logic programming”. Later in the paper it turns out that the paper restricts the term “logic programming” to Datalog, and then this claim simply false (see point 4 below), but even when taking logic programming to mean some Turing complete version of it, and when making the same idealised interpretation of neural networks, the two are only “equivalent” in the boring sense of both being Turing complete. As the paper itself points out in its motivational paragraphs, the whole point of finding the right language for a field of computing is not its expressivity (otherwise we need look not beyond Turing Machines), but rather the way in which algorithms are expressed naturally. So summarising: (i) not all symbolic AI is logic programming (and certainly not when this is narrowed to Datalog), and (ii) NNs and LP are not meaningfully “equivalent” in the sense that the paper itselfs claims to pursue.

3. “this [sound treatment of uncertainty] contrasts with neurosymbolic representations like logic tensor networks, which are based on fuzzy logic (Badreddine et al. 2022).” This is a flawed argument, since besides systems like LTN that use fuzzy logic, there are plenty of substantial approaches in neuro-symbolic AI that are based on proper probabilistic accounts (e.g. the entire family of ProbLog, DeepProbLog, the work of Guy van den Broeck, etc). So dismissing neuro-symbolic representations because of their use of fuzzy logic is simply misleading.

4. A strange sleight of hand happens in the Background section on Logic Programming. Whereas first, the claim was that “all of symbolic Ai can be constructed using logic programming”, now the claim is that “the most widely used formalism in symbolic AI is logic programming”. This second claim is certainly more plausible, but the next sentence immediately narrows logic programming down to Datalog, and then the previous sentence is no longer true. Datalog is a much impoverished version of logic programming. It is not Turing complete, and many widely used AI formalisms cannot be expressed in Datalog: The popular SHOIQ variant of Description Logic, used for expressing ontologies, cannot be encoded in Datalog; first-order logic cannot be expressed, modal logics cannot in in general be expressed in Datalog, etc. The remainder of the paper that deals with symbolic reasoning is based on the Datalog fragment, and therefore the paper falls very much short of its central claim to be a (or even “the”) language for AI. Furtermore, this is not easily fixed. The entire enterprise of mapping everything into linear algebra is in jeopardy as soon as negation, disjunction or infinite domains need to be considered.

5. A similar concern is raised by the sentence “This suffices to implement many symbolic systems, including reasoning and planning in function-free domains”, in the section on Symbolic AI. The restriction to function-free domains is a major limitation that puts in doubt the claim for Tensor Logic to be “the” language for AI. The impact of this limitation is not discussed in the paper, similar to how the other effects of the restriction to Datalog are not discussed (see previous point).

6. In the section on “Reasoning in Embedding Space”, an observation is made on the standard devision for vector encodings, which is claimed to be sqrt(N/D), where N is the cardinality of the set and D is the embedding dimension. I am confused by this since in typical embedding architectures, the cardinality of the set is much larger than the embedding dimension (ie. N >> D), which would make the standard deviation very large. The (implicit) claim that N << D would certainly need more justification.

7. A major claim of the paper is that Tensor Logic allows for “sound reasoning in embedding space”. However, the algorithm outlined in the section on “Reasoning in Embedding Space” gives “approximately the correct result” in the words of the paper. Approximately correct is hardly the same as the promised sound reasoning. Little is said about the precision of the approximation, apart from the comment that “The error probability decreases with the embedding dimension”, but then the same question of point 6 above also applies here.

8. Last, but certainly not least, the section on Scaling Up the paper is very sketchy on the efficiency of any implementation of Tensor Logic. The proposed separation of concerns (dense vectors on GPUs and sparse vectors on a database engine) is only sketched, and the same is true for the GPU-only approach.

9. Any journal paper submission for a (or even “the”) language for AI should come not only with a sketch of the language, but at the very least with a full implementation, as well as substantial experiments with this implementation that test both functionality (e.g. the effects of the approximations in point 67above) and efficiency.

Answering some of the points above might be a simple issue of clarification, while others would require a major redesign (e.g. going beyond the Datalog restriction) or substantial amounts of technical work (e.g. a full implementation and experiments). Based on these shortcomings I must recommend rejection of the current paper. and I’m looking forward to a new paper that addresses the points above.

Reviewer has chosen to be Anonymous

Overall Impression: Bad

Content:
Technical Quality of the paper: Bad
Originality of the paper: No
Adequacy of the bibliography: No

Presentation:
Adequacy of the abstract: Yes
Introduction: background and motivation: Bad
Organization of the paper: Satisfactory
Level of English: Satisfactory
Overall presentation: Weak

Detailed Comments:

The paper proposes Tensor Logic as a unifying language for AI.
It exploits connections between Einsums and Datalog, and uses tensor equations as the basic construct.
The author makes strong statements and builds a lot of hype around it.

While mixing tensors and logic is interesting, it is disturbing that the author simply ignores the rich literature
on this topic, and at least gives the impression that all of this is rather new.
This also implies that the paper must be rejected. Below I give a list of pointers to relevant work on this topic.

Even the term Tensor Logic is already in use, it is the name a of well-known
system by William Cohen that also mixes Datalog and Tensors.

Another clear weakness of the paper is that it does neither report on an implementation nor on experiments.

List of references on these topics.

- The connection between tensor networks and probabilistic graphical models discussed on page 14 is well-known [1].
- There have been several attempts at representing logic relations as tensor and performing inference on this, see e.g. [2, 3, 12, 13].
- There are also works using tensor networks for logical and probabilistic inference in the form of (weighted) model counting [4].
- There is also a rich literature on using embedding as decompositions of logical relations, as discussed on page 15. For instance, [5] improves query tractability by an appropriate choice of the decomposition. There is also work on this in the context of e.g. neurosymbolic learning. There are also work analysing the relation between tensor decomposition techniques and other established representations such tractable circuits [7, 8].
- On the first paragraph of page 3, it is noted that neurosymbolic methods do not have a probabilistic semantics, while this is the case for fuzzy logics, many are based on probabilistic logics. [9, 10]
- The section on scaling up mentions that sparse and dense tensor should be optimised by a database query engine, but does not cite any works that attempted this, such as [11]

[1] Elina Robeva and Anna Seigal. Duality of Graphical Models and Tensor Networks. Information and Inference: A Journal of the IMA, 8(2):273–288, 06 2018.

[2] Cohen, William, Fan Yang, and Kathryn Rivard Mazaitis. "Tensorlog: A probabilistic database implemented using deep-learning infrastructure." Journal of Artificial Intelligence Research 67 (2020): 285-325.

[3]: Nguyen, Tuan Quoc, Katsumi Inoue, and Chiaki Sakama. "Enhancing linear algebraic computation of logic programs using sparse representation." New Generation Computing 40.1 (2022): 225-254.

[4] Dudek, Jeffrey M., and Moshe Y. Vardi. "Parallel weighted model counting with tensor networks." arXiv:2006.15512 (2020).

[5] Friedman, Tal, and Guy Van den Broeck. "Symbolic querying of vector spaces: Probabilistic databases meets relational embeddings." Conference on Uncertainty in Artificial Intelligence. PMLR, 2020.

[6] Choi, Seewon, et al. "CTSketch: Compositional Tensor Sketching for Scalable Neurosymbolic Learning." The Thirty-ninth Annual Conference on Neural Information Processing Systems.

[7] Onaka, Ryoma, et al. "Tensor Decomposition Meets Knowledge Compilation: A Study Comparing Tensor Trains with OBDDs." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 39. No. 14. 2025.

[8] Loconte, Lorenzo, et al. "What is the Relationship between Tensor Factorizations and Circuits (and How Can We Exploit it)?." Transactions on Machine Learning Research.

[9] Yang, Zhun, Adam Ishay, and Joohyung Lee. "NeurASP: embracing neural networks into answer set programming." Proceedings of the Twenty-Ninth International Conference on International Joint Conferences on Artificial Intelligence. 2021.

[10] Manhaeve, Robin, et al. "Neural probabilistic logic programming in DeepProbLog." Artificial Intelligence 298 (2021): 103504.

[11] Staudt, Christoph, et al. "Exploiting Dynamic Sparsity in Einsum." The Thirty-ninth Annual Conference on Neural Information Processing Systems. 2025.

[12] Ryosuke Kojima, Taisuke Sato, "A tensorized logic programming language for large-scale data", https://arxiv.org/pdf/1901.08548

[13] Sakama, Chiaki, Katsumi Inoue, and Taisuke Sato. "Logic programming in tensor spaces." Annals of Mathematics and Artificial Intelligence 89.12 (2021): 1133-1153.

Reviewer has chosen to be Anonymous

Overall Impression: Good

Content:
Technical Quality of the paper: Good
Originality of the paper: Yes
Adequacy of the bibliography: Yes, but see detailed comments

Presentation:
Adequacy of the abstract: Yes
Introduction: background and motivation: Good
Organization of the paper: Satisfactory
Level of English: Satisfactory
Overall presentation: Good

Detailed Comments:

This paper introduces Tensor Logic, a unified programming language for AI.
It is based on the observation that Datalog rules and Einstein summation are similar and
the same operation applied to different data types.
The author derives compact implementations of transformers, graph neural networks, recurrent networks, kernel machines, probabilistic graphical models, and a new form of reasoning in embedding space with temperature controlled analogical inference.
The paper is well-written; the core unification insight is possibly promising, but will need further research.
In the current form the paper has gaps in experimental validation, formal specification, and relationship with the neurosymbolic
literature that should be addressed before publication.
---
The mathematical observation of the paper (that a Datalog rule is an einsum over Boolean tensors with a Heaviside step function applied element-wise) is insightful and non-trivial.
The transformer implementation in "a dozen tensor equations (Table 2) '' and the graph neural network (Table 1) suggest
that a wide range of AI architectures can be expressed compactly.
The formalized "reasoning in embedding space", in which relations and rules are embedded as superpositions of tensor products and the inference proceeds via forward or backward chaining over embedded rules is another relevant contribution.
The claim that this approach is sound, transparent, and resistant to hallucination at low temperature is theoretically motivated and worth considering further research, even though the discussion is limited in the paper.
A point that this reviewer considers relevant is that the use of Python libraries, logic programming systems, and different
probabilistic frameworks imposes costs, and that a unified language could reduce them.
However, getting to unified languages and I would say perhaps more relevant - finding the right abstractions for computer science (and AI) remains challenging. Even in programming languages, as research has shown over 60 years, unification is hard to achieve: think of the number of functional programming languages we have today. Shouldn't functional programming languages (arguably the most mathematically well-founded subarea of programming languages) have already been unified thus far? Why, even in the most well-founded area of programming languages research, have we not achieved unification?
As AI still seeks the right abstractions, there is value in this work (undoubtedly) but maybe the author is overoptimistic. This, however, does not take anything away from this submission.
----
Points to improve:
The paper empirical evaluation is mostly left to future work (the last section is devoted to the author's comment on building the tools around Tensor Logic).
The author suggests " implementing tensor logic directly in CUDA, using it in a
wide range of applications, developing libraries and extensions, and pursuing the
new research directions it makes possible." Domingos also invites the reader to access information on ''tensor-logic.org''
Again, this is not to say that the paper has no merits, but at least some toy problem tackling would made Domingo's claims stronger.
A proof-of-concept experiment demonstrating one claimed advantage would be welcome.
For instance, how hard it is to illustrate learning a logic program from relational data in Tensor Logic?
How hard is forward chaining over tensor logic programs? Is it tractable?
The statement that reasoning in embedding space is immune to hallucinations at sufficiently low temperature
conflates deductive soundness over approximate embeddings with knowledge completeness.
The paper contextualization with the existing neurosymbolic literature is limited.
The neurosymbolic AI research program is represented by a single citation (Badreddine et al. 2022, Logic tensor networks)
that is oversimplified as being "based on fuzzy logic."
LTNs provide a grounded real-logic semantics in which the satisfaction of logical formulas by real-world objects is explicitly defined.
LTNs can handle open-world reasoning more naturally than the closed-world assumption of Datalog.
Given that tensor logic and LTNs support differentiable reasoning over relations, in what sense tensor logic goes beyond more compact notation?
Further, in neurosymbolic AI, principled connectionist treatments of modal logics (K, T, S4, S5) and temporal logics (LTL, CTL) with soundness results have been investigated and soundness results have been proved.
In connectionist temporal logic [1,2], architecture guarantees temporal properties by construction and
verification is tied to the logical semantics (including empirical validation in software engineering benchmarks).
Tensor logic's RNN implementation captures temporal sequences; but expressibility is not the same as native support with semantic guarantees.
Datalog's restriction to function-free Horn clauses can be a barrier to representing a proper Kripke semantics and temporal operators, if one aims at generalization across multimodal reasoning, specially regarding proper representation of time and knowledge.
The original GNN formulation by Gori, Monfardini, Scarselli (2005) is not cited, despite the paper's GNN section recapitulating their core architecture (essentially). The paper tensor logic GNN implementation seems like a standard message-passing architecture.
The relationship between the two frameworks could be discussed.
The paper states that tensor decomposition in tensor logic "is effectively a generalization of predicate invention." This seems to be informal. Predicate invention in ILP discovers new relation symbols with defined semantics; Tucker decomposition does not seem to guarantee to correspond to meaningful predicates.
References:
[1]Garcez, A.S. and Lamb, L.C. (2003). Reasoning about time and knowledge in neural-symbolic learning systems. NIPS 2003.
[2] d'Avila Garcez, A.S., Lamb, L.C., and Gabbay, D.M. (2007). Connectionist modal logic: Representing modalities in neural networks. Theoretical Computer Science 371(1–2): 34–53.
[3]Scarselli, F., Gori, M., Tsoi, A.C., Hagenbuchner, M., and Monfardini, G. (2009). The graph neural network model. IEEE Transactions on Neural Networks 20(1): 61–80.
Summary:
The core insight of tensor logic is insightful, the notation is elegant, and the embedding-space reasoning can lead to new research streams. The author makes a visionary contribution at the conceptual level.
However, the author should provide improved subsidies regarding the experimentation section,
better explain the hallucination-free guarantees offered by tensor logic. The paper is a fwell-founded position paper, with an initial language proposal and, with some changes, it would be a welcome publication.

Reviewer has chosen to be Anonymous

Overall Impression: Weak

Content:
Technical Quality of the paper: Weak
Originality of the paper: Yes
Adequacy of the bibliography: Yes

Presentation:
Adequacy of the abstract: Yes
Introduction: background and motivation: Good
Organization of the paper: Satisfactory
Level of English: Satisfactory
Overall presentation: Excellent

Detailed Comments:

This paper is relevant to the journal, and interesting in a number of ways: it proposes a new language that captures many aspects of symbolic reasoning and of neural computation; it also shows a number of intriguing pieces of code that unify both topics. The paper is well written; the text is very easy to follow. The writing contains a number of bold claims that sometimes feel exaggerated, but nothing is offensive (and those points could be easily fixed). The real problem here is that the paper is a relatively vague proposal without too much discussion of implementation issues; I am not against papers that propose new ideas and this may be a good one at that, but I think the level of the discussion is too abstract when it comes to real operation, and the reader is left without a clear understanding of the path to real application. The paper mentions a website with more material, but that website contains a version of the paper, an interview, and slides about the paper. It would be nice to have at least some tangible path to actual use, and the presented material sounds a bit too preliminary in that respect, containing many promises that are not clearly articulated. I believe a more detailed discussion of such matters would actually increase the impact of the paper quite a bit.

As one example of a bold statement in that Introduction, the author writes that "AI has not found its language yet". Should AI aim at a single language? Some have argued that many tasks should directly rely on natural language --- and there are several such languages. This is somewhat outlandish, of course, as the author probably means "a single formal language". But in the end, there is a question as to whether we should concentrate solely on formal languages. And whether it is possible to find a single formal language to address all relevant AI tasks. I do not think the author should discuss this whole issue; rather, my point is that the sentence I mentioned is unnecessarily controversial.

In any case, the question is relevant: does it make sense to try to find a single language for AI? The author put together an amazingly clever way to mix several ideas with a few constructs; this is the strong side of the paper. But does it address everything? How about the sort of nonmonotonic reasoning that is central to knowledge representation (for instance, to handle computational argumentation); is it handled? If so, how? One usually needs negation as failure to do that. And disjunctive heads are often useful, are they possible here? Argumentation is itself an example to address, can one deal say with probabilistic argumentation frameworks in their bewildering variety? And some people like fuzzy logic, is this in, or not? How? And so on.

Actually, I do not think it makes sense to criticize the paper because it cannot do X or Y. The formalism does a number of things well. But the paper itself puts itself in this corner with some bold assertions. I think that kind of tone should be changed. Or the author should really go all the way and show that AI as a whole can be addressed (a very difficult task, I think).

Now, of course if the language is to focus on a set of topics, then its expected scope should be stated from the outset, to make the reader's life a lot easier.

A question: the paper uses "Boolean" values to mean values that are (apparently) actually zeros or ones. It seems to me better to write "binary" in that case.

A key question (to me at least): how novel is the idea that rules can be expressed using tensors? To me this was the most interesting insight here, but it seems to be a trick that might be known? Are there previous references? Or is this a new trick --- in which case it could be better advertised? In any case, to me the key insight is that a language that can handle tensors in a particularly effective way is indeed a very powerful language, much more than one might guess at first.

Question about the text at the bottom of Page 7: it seems to say that summation allows one to represent disjunction. How is this done exactly? In fact, there are several paragraphs in the paper that some statements are made as to how "easy" it is to represent various structures, but the reader has difficulty understanding how exactly to do it... more detailed examples, together with working code snippets, would be very helpful.

One example of a vague statement that seems weird appears at the top of Page 9: the choice for forward/backward depends on applications, fine, but are they any ideas about it? The top of Page 10 is really vague, too...

Page 9, bottom, formula for Loss: there should be a summation there, right?

Another point that seems somewhat weird is the commentary about predicate invention in Page 10: this is strange, it does not seem that predicates are really invented as it seems the tensors are given within the structure of the expressions. Please clarify.

Page 10, expression A]i,j,k] --- shouldn't it be A[i,j,k]?

Table 1: writing "etc" is not very helpful, please give more details about the missing expressions.

Actually, looking at Table 1 I wonder whether this language is actually better than a more diverse language (with different operators for logical and neural operations) as a more diverse language might be a lot more readable. Is it really easy to read a program in Tensor Logic? The examples do not present a very good case.

The top of Page 15 seems to be repeating some facts in the literature, but it is hard to see how they actually apply in any detail here.

Overall, the Discussion section presents several bold statements that feel more like thoughts than concrete assertions that can be verified even in a prototype. How do these ideas perform in practice? How can Tensor Logic fix problems with hallucinations in LLMs? And so on. A revised text would leave the reader more informed about the concrete features of the language.

Reviewer has chosen to be Anonymous

Overall Impression: Bad

Content:
Technical Quality of the paper: Weak
Originality of the paper: No
Adequacy of the bibliography: No

Presentation:
Adequacy of the abstract: No
Introduction: background and motivation: Bad
Organization of the paper: Needs improvement
Level of English: Satisfactory
Overall presentation: Weak

Detailed Comments:

This paper's excellent surface-level presentation makes it difficult for outsiders to see how problematic it is. None of its claims appear to be novel, and given the author's past work, the author must be aware of this fact and willfully ignoring prior work that established all these ideas before. Between Eisner's Dyna, the well-established pipeline of interpreting (probabilistic/neural) logic programs (which include datalog) as probabilistic circuits which then run as tensorized computation using einsum operators on the GPU, as well as the work on semiring datalog, there is really nothing covered by this paper that is not already well-known in the field. There is simply a lack of novelty that cannot be addressed by a revision with related work discussion. Given the extremely poor scholarship, I believe the editors should take measures to avoid this type of submission from happening again in future.

Writing up in detail the related work that has all the ideas already would amount to me writing a survey of the field, which I don't have time for. Luckily the issue is so blatant that even AI can spot it easily and identify all the relevant work. See below for a summary.

—

Differentiable Datalog / neurosymbolic systems

TensorLog (Cohen 2016; Cohen, Yang & Mazaitis, JAIR 2020). https://scholar.google.com/scholar?q=TensorLog+differentiable+deductive+... — Compiles Datalog clauses into differentiable tensor operations, with predicates as sparse matrices and inference as matrix products. This is the central correspondence the paper claims as its foundational observation, published a decade earlier and with the same name. Reduces novelty of the "Representation" and "Inference" sections to near zero.

Neural Theorem Provers (Rocktäschel & Riedel, NeurIPS 2017). https://scholar.google.com/scholar?q=end-to-end+differentiable+proving+R... — Differentiable backward chaining over embedded symbols, with soft unification via vector similarity. Directly anticipates the "reasoning in embedding space" section, including the analogical-reasoning-via-embedding-similarity story.

NeuralLP (Yang, Yang & Cohen, NeurIPS 2017). https://scholar.google.com/scholar?q=Differentiable+learning+logical+rul... — End-to-end differentiable learning of first-order rules built on TensorLog operators. Reduces the novelty of the rule-learning claim.

DeepProbLog (Manhaeve, Dumančić, Kimmig, Demeester & De Raedt, NeurIPS 2018; AIJ 2021). https://scholar.google.com/scholar?q=DeepProbLog+neural+probabilistic+lo... — Integrates neural predicates into probabilistic logic programming with exact, sound probabilistic semantics. Directly addresses "sound treatment of uncertainty" combined with neural learning, which the paper claims as a distinguishing feature.

Scallop (Huang et al., NeurIPS 2021; PLDI 2023). https://scholar.google.com/scholar?q=Scallop+neurosymbolic+programming+D... — Provenance-semiring-based differentiable Datalog with a working compiler and GPU backend. Directly competes with the proposed system and has actually been implemented.

NeurASP (Yang, Ishay & Lee, IJCAI 2020). https://scholar.google.com/scholar?q=NeurASP+neural+networks+answer+set+... — Combines ASP with neural networks. Another neurosymbolic system the paper would need to position against.

Differentiable ILP / ∂ILP (Evans & Grefenstette, JAIR 2018). https://scholar.google.com/scholar?q=Learning+explanatory+rules+noisy+da... — Learns Datalog programs by gradient descent through a differentiable relaxation. Predates the paper's claim that tensor decomposition in tensor logic is a "generalization of predicate invention."

Semiring Datalog and weighted logic programming

Provenance semirings (Green, Karvounarakis & Tannen, PODS 2007). https://scholar.google.com/scholar?q=Provenance+semirings+Green+Karvouna... — Foundational result that positive Datalog evaluation generalizes to any commutative semiring. The general framework predates the paper by ~20 years.

Dyna (Eisner & Filardo, Datalog Reloaded 2011; earlier Eisner et al. 2005). https://scholar.google.com/scholar?q=Dyna+weighted+logic+programming+Eisner — Weighted Datalog with semiring aggregation, designed explicitly for ML and inference. Has the "single-construct equational" feel tensor logic aspires to, including recursion and aggregation. Probably the closest prior art on the language-design side.

FAQ — Functional Aggregate Queries (Abo Khamis, Ngo & Rudra, PODS 2016). https://scholar.google.com/scholar?q=FAQ+questions+asked+frequently+Kham... — Unified framework for sum-product queries over arbitrary semirings, subsuming CSPs, probabilistic inference, matrix chain multiplication, and database joins. Provides the worst-case-optimal algorithms tensor logic would need for its "scaling up" section to be more than a sketch.

Datalog° (Abo Khamis, Ngo, Pichler, Suciu & Wang). https://scholar.google.com/scholar?q=Datalogo+recursive+aggregates+semir... — Recursive Datalog with aggregation over (pre-)semirings, with clean fixed-point semantics. The proper formal setting for recursive real-valued tensor equations, which tensor logic uses (e.g., RNN and message-passing examples) without addressing the semantic issues. Also identified "a sum-product expression is a tensor expression, sometimes called an Einsum".

Tensor implementations of database queries / tensor query languages

Tensor Relational Algebra (Yuan, Jankov, Cai, Gao, Jermaine, PVLDB 2021). https://scholar.google.com/scholar?q=Tensor+relational+algebra+distribut... — Defines a relational algebra whose tuples are tensors, designed explicitly to unify tensor computation and relational query processing for ML systems. Directly anticipates the "tensors as relations / einsum as join" framing as the basis of a programming system, with an actual implementation and optimizer.

LaraDB / Lara (Hutchison, Howe & Suciu, 2017). https://scholar.google.com/scholar?q=Lara+key-value+algebra+arrays+relat... — A three-operator algebra that subsumes both linear algebra and relational algebra over associative arrays. Same unification goal as tensor logic, with formal expressiveness results.

Expressive power of linear algebra query languages (Geerts, Muñoz, Riveros & Vrgoč, PODS 2021). https://scholar.google.com/scholar?q=Expressive+power+linear+algebra+que... — Formal characterization of which relational queries are expressible as linear/tensor algebra. Directly relevant to the paper's claims about Datalog-as-tensor-equations, with precise expressiveness results the paper does not engage with.

MATLANG (Brijder, Geerts, Van den Bussche, Weerwag). https://scholar.google.com/scholar?q=MATLANG+expressive+power+matrix+que... — A matrix-algebra query language with worked-out expressiveness vs. relational calculus. Same conceptual territory.

In-database learning with sparse tensors (Abo Khamis, Ngo, Nguyen, Olteanu & Schleich, PODS 2018). https://scholar.google.com/scholar?q=In-database+learning+sparse+tensors... — Exactly the proposed "treat sparse tensors as relations, dense as GPU tensors" idea, worked out with provable complexity bounds. Makes the paper's "scaling up" sketch look underdeveloped.

SPORES (Wang, Hutchison, Howe & Suciu, SIGMOD 2020). https://scholar.google.com/scholar?q=SPORES+sum-product+optimization+rel... — Optimizes sum-product (i.e., einsum-style) linear algebra by translating to relational algebra and back via equality saturation. Concretely demonstrates that the einsum/relational duality is a tool for query optimization, not just a notational coincidence.

AC/DC and F-IVM (Schleich, Olteanu et al.). https://scholar.google.com/scholar?q=AC%2FDC+in-database+learning+gradie... — In-database gradient computation and factorized ML, treating learning as sum-product queries.

Compilation of (neural) logic programs to probabilistic circuits → einsums on GPU

Knowledge compilation for weighted model counting (Darwiche & Marquis, JAIR 2002; Chavira & Darwiche, AIJ 2008). https://scholar.google.com/scholar?q=knowledge+compilation+map+Darwiche+... — Foundational framework: compile logical theories to tractable circuit forms (d-DNNF, SDD, etc.) on which weighted sum-product becomes linear-time. The paper's claim that tensor logic "preserves sound treatment of uncertainty" via tree-structured programs is a special case of this much more general theory, with sharper tractability results.

ProbLog → SDD/d-DNNF compilation (Fierens, Van den Broeck, Renkens et al., TPLP 2015). https://scholar.google.com/scholar?q=Inference+learning+probabilistic+lo... — Compiles probabilistic logic programs to weighted Boolean circuits for inference and learning. The canonical "logic program → circuit → tractable sum-product" pipeline. Directly anticipates the paper's framing.

Semiring programming (Belle & De Raedt, AIJ 2020). https://scholar.google.com/scholar?q=Semiring+programming+Belle+De+Raedt — Generalizes the compile-and-evaluate pipeline to arbitrary semirings, recovering WMC, MPE, gradient computation, expectations, and sensitivity analysis as instances. The unification tensor logic gestures at, formalized.

aProbLog and algebraic model counting (Kimmig, Van den Broeck & De Raedt, ECAI 2011; JAL 2017). https://scholar.google.com/scholar?q=Algebraic+model+counting+Kimmig+Van... — Logic program → circuit → semiring evaluation. Same architecture as tensor logic, with cleaner theory.

Einsum Networks (Peharz, Lang, Vergari, Stelzner, …, ICML 2020). https://scholar.google.com/scholar?q=Einsum+networks+fast+scalable+proba... — Implements probabilistic circuits as a single batched einsum operation per layer on GPU. The paper's vision of "tensor logic programs as GPU-executable sum-product computations" is what EiNets do, with implementations, scaling experiments, and a public library.

PyJuice / sparse PC GPU evaluation (Liu, Ahmed & Van den Broeck, ICML 2024). https://scholar.google.com/scholar?q=Scaling+tractable+probabilistic+cir... — State-of-the-art GPU implementation of sparse probabilistic circuits using block-sparse einsum kernels. Directly addresses the "scale up sparse tensors on GPUs" problem the paper presents as open.

Probabilistic circuits as a unifying framework (Choi, Vergari & Van den Broeck 2020). https://scholar.google.com/scholar?q=Probabilistic+circuits+unifying+fra... — Surveys the entire compile-to-circuit-evaluate-as-tensor-contraction pipeline.