Logical Computation Graphs Overview

• Logical Computation Graphs are graph-structured representations that compile logical expressions into explicit computational objects for precise and efficient query evaluation.
• They employ various structures—such as dependency DAGs, query trees, and path-based transformer models—to address complex logical queries and optimize computation.
• Empirical evaluations across methods like GQE, CaQR, QTO, and Pathformer show significant performance gains and scalability in diverse query answering settings.

Searching arXiv for recent and foundational papers on logical computation graphs and related query computation graph methods. arxiv_search(query="logical computation graph knowledge graph query computation tree Pathformer CaQR GQE QTO", max_results=10) arxiv_search(query="Pathformer recursive path query encoding complex logical query answering", max_results=5) Logical computation graphs are graph-structured representations in which logical expressions are compiled into explicit computational objects. In knowledge-graph reasoning, a First-Order-Logic query can be represented as a directed acyclic query graph $G_q=(V_q,E_q)$, a dependency graph $D_q$, or a directed rooted query computation tree whose leaves are anchor entities or constants and whose root is the free answer variable (Kim et al., 2024, Hamilton et al., 2018, Bai et al., 2022). In other settings, computational objects are expressed as graphs with interfaces, proofs of multiplicative linear logic are interpreted as interaction graphs, and arbitrary undirected graphs are treated as generalized Boolean formulas in Boolean Graph Logic (Dixon et al., 2010, Seiller, 2012, Calk et al., 2020). A plausible unifying description is that logical structure is made explicit as graph topology, and evaluation proceeds by composing local operators attached to nodes, edges, or paths.

1. Query graphs, dependency DAGs, and computation trees

In complex logical query answering over knowledge graphs, the basic formal object is a graph representation of a FOL query. CaQR defines a FOL conjunctive/disjunctive query as a directed acyclic query graph $G_q=(V_q,E_q)$ with $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$, where $V_{\text{anchor}}\subseteq\mathcal V$ are fixed entities, $V_{\text{exist}}=\{V_1,\dots,V_k\}$ are existentially quantified intermediate variables, and $V_?$ is the target answer variable; each edge $(u,r,v)$ encodes an atomic formula $r(u,v)$ or its inverse (Kim et al., 2024). GQE gives the equivalent dependency-graph view: a $k$-ary conjunctive query with one free variable is associated with a dependency graph $D_q$0, a directed acyclic graph whose nodes are anchor nodes, bound variables, and the free variable $D_q$1, and whose edges are relational atoms (Hamilton et al., 2018).

The query computation tree is a stricter tree-shaped compilation. In QTO, a FOL query with conjunction, disjunction, negation, and existential quantifiers is rewritten in Disjunctive Normal Form, and the resulting query computation tree $D_q$2 has leaf nodes that are constant entities and internal nodes of four types: relational projection, anti-relational projection, intersection, and union; its edges point from children up toward the root $D_q$3 (Bai et al., 2022). Pathformer uses a closely related query computation tree $D_q$4 for Existential First-Order Logic queries with a single free variable, where nodes are leaf anchor entities or branch-variable nodes and edges are decorated with relational projection $D_q$5 or atomic negation $D_q$6; the root $D_q$7 holds the final answer set (Zhang et al., 2024).

These formulations differ in granularity but agree on the role of topology. Prior embedding-based methods compile $D_q$8 into a tree-shaped computation graph where each edge applies a learned projection or a set operation, whereas Pathformer emphasizes a tree-like computation graph with branch structure and QTO emphasizes a tree that exposes conditional independence for optimization (Kim et al., 2024, Zhang et al., 2024, Bai et al., 2022).

2. Core operators and evaluation semantics

GQE formulates logical computation directly in a shared $D_q$9-dimensional Euclidean space. Graph nodes are embedded as

$G_q=(V_q,E_q)$0

and two differentiable operators are composed over the dependency DAG: a relation-specific projection $G_q=(V_q,E_q)$1, instantiated either as $G_q=(V_q,E_q)$2 or, in a TransE-style version, $G_q=(V_q,E_q)$3, and a symmetric intersection operator

$G_q=(V_q,E_q)$4

A topological pass initializes each anchor to its node embedding, propagates projected messages along edges, applies intersection when all incoming edges to a node have arrived, and produces a query embedding $G_q=(V_q,E_q)$5 at $G_q=(V_q,E_q)$6. Candidate answers are ranked by cosine score $G_q=(V_q,E_q)$7, and training uses max-margin ranking with hard negatives for intersection queries (Hamilton et al., 2018).

CaQR summarizes the standard per-branch operators used by the main embedding families. In Q2B, a set of entities is represented by a box with center $G_q=(V_q,E_q)$8 and offset $G_q=(V_q,E_q)$9, projection is

$$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$0

intersection uses the mean of centers and the maximum of offsets, and scoring uses $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$1. In ConE, a set is encoded as 2-D cones with axis $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$2 and aperture $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$3, with relation projection by rotation and scaling and scoring by angular distance plus radial distance to axis. In BetaE, each variable set is a product of independent Beta distributions parameterized by $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$4, projection is given by relation-specific MLPs $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$5 and $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$6, intersection is point-wise product, and scoring uses $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$7 (Kim et al., 2024).

QTO replaces learned geometric composition with a forward-backward optimization over truth-score vectors. Each node $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$8 receives $$V_q = V_{\text{anchor}} \cup V_{\text{exist}} \cup \{V_?\}$$9, where $V_{\text{anchor}}\subseteq\mathcal V$0 is the maximal probability of the subquery at $V_{\text{anchor}}\subseteq\mathcal V$1 conditioned on $V_{\text{anchor}}\subseteq\mathcal V$2. Intersection uses elementwise products, union uses $V_{\text{anchor}}\subseteq\mathcal V$3, relational projection uses

$V_{\text{anchor}}\subseteq\mathcal V$4

and anti-relational projection replaces $V_{\text{anchor}}\subseteq\mathcal V$5 by $V_{\text{anchor}}\subseteq\mathcal V$6. After a forward pass to the root and a backward pass to recover intermediate assignments, QTO returns $V_{\text{anchor}}\subseteq\mathcal V$7 (Bai et al., 2022).

3. Path decomposition, bidirectional encoding, and context injection

Pathformer addresses the mismatch between sequence models and branch-structured logical queries by decomposing the query computation tree into path queries. Because $V_{\text{anchor}}\subseteq\mathcal V$8 is a tree, each non-leaf node is a fork node with two or more children; a depth-first traversal from every leaf anchor toward the root, cut whenever a fork is reached, yields branch paths of the form

$V_{\text{anchor}}\subseteq\mathcal V$9

with $V_{\text{exist}}=\{V_1,\dots,V_k\}$0. Each path is turned into a token sequence consisting of the start-node embedding, learned relation vectors $V_{\text{exist}}=\{V_1,\dots,V_k\}$1, and a special token $V_{\text{exist}}=\{V_1,\dots,V_k\}$2 for negation. A standard Transformer encoder with $V_{\text{exist}}=\{V_1,\dots,V_k\}$3 layers, multi-head self-attention, and position encoding then produces a path-query embedding

$V_{\text{exist}}=\{V_1,\dots,V_k\}$4

where the bidirectional attention mechanism allows future operators and relations to influence earlier tokens. At fork nodes, Pathformer fuses incoming path embeddings by an MLP intersection network,

$V_{\text{exist}}=\{V_1,\dots,V_k\}$5

applied pairwise when there are more than two branches, and recursively assembles a final one-point embedding $V_{\text{exist}}=\{V_1,\dots,V_k\}$6. Answer scoring uses $V_{\text{exist}}=\{V_1,\dots,V_k\}$7 distance,

$V_{\text{exist}}=\{V_1,\dots,V_k\}$8

and training uses a margin-based logistic loss with positive and negative answers (Zhang et al., 2024).

CaQR keeps the base operator family unchanged and instead augments each intermediate node with two explicit context vectors. The structural context $V_{\text{exist}}=\{V_1,\dots,V_k\}$9 combines a position embedding $V_?$0, a role embedding $V_?$1, and a query-type embedding $V_?$2 obtained from a normalized $V_?$3 count table of $V_?$4 pairs, followed by an $V_?$5. The relation-induced context $V_?$6 is computed by sampling up to $V_?$7 entities from KG head and tail neighborhoods associated with the incident query relations, aggregating frozen entity embeddings into $V_?$8 and $V_?$9, and averaging them. Fusion is model-agnostic: $(u,r,v)$0 and $(u,r,v)$1 replaces the original intermediate representation for subsequent logical operators (Kim et al., 2024).

The two methods differ in where they introduce global information. Pathformer pushes future context into each branch by bidirectional self-attention over path sequences, whereas CaQR injects structural context and relation-induced context at every projection step of an existing base model. This suggests two distinct strategies for logical computation graphs: reparameterizing the computation graph itself, or enriching node states while retaining the original operators (Zhang et al., 2024, Kim et al., 2024).

4. Locality, independence, and algorithmic complexity

A central motivation for logical computation graphs is to avoid exhaustive enumeration over existential assignments. GQE makes this explicit in its complexity analysis. If $(u,r,v)$2 is the number of edges in the query DAG $(u,r,v)$3, Algorithm 1 performs exactly $(u,r,v)$4 calls to $(u,r,v)$5 and at most $(u,r,v)$6 calls to $(u,r,v)$7. A single projection costs $(u,r,v)$8, or $(u,r,v)$9 in the TransE variant, and a single intersection costs $r(u,v)$0. The total time is $r(u,v)$1, linear in the query size and independent of $r(u,v)$2, whereas naive enumeration over $r(u,v)$3 bound variables costs $r(u,v)$4 (Hamilton et al., 2018).

QTO exploits independence encoded in the query computation tree. Because $r(u,v)$5 is a tree, any two disjoint subtrees under a conjunction or disjunction are conditionally independent given the value of their common parent variable. The factorization

$r(u,v)$6

allows each subtree to be solved locally, removing the need to enumerate joint assignments and collapsing an exponential search into a sequence of $r(u,v)$7 local maximizations. In implementation terms, each $r(u,v)$8 or $r(u,v)$9 node costs $k$0, while each projection node costs $k$1 naively or $k$2 with sparse storage (Bai et al., 2022).

Pathformer offers a different locality argument. By unfolding the EFOL tree into per-branch paths, it avoids trying to encode a full graph in one pass, which would require elaborate positional schemes or graph-transformers. Every encoded sequence is a simple path, negation is represented by a single $k$3 token, and fork MLPs reassemble multiple path views of the same variable in an intersection-like fashion (Zhang et al., 2024).

These results delimit a common design space. Standard linear sequential operations are efficient but, in CaQR’s formulation, do not adapt to the global query structure or to node-specific KG context; exact tree optimization is feasible when independence is exposed; and path-based transformer encoders trade direct graph encoding for repeated sequence encoding over tree branches (Kim et al., 2024, Bai et al., 2022, Zhang et al., 2024).

5. Empirical behavior in complex logical query answering

The reported empirical results span different datasets, query families, and scoring protocols, so they are not directly interchangeable. They nonetheless show that changes to the logical computation graph—whether geometric, contextual, transformer-based, or optimization-based—alter answer quality measurably (Hamilton et al., 2018, Zhang et al., 2024, Kim et al., 2024, Bai et al., 2022).

Method	Dataset / setting	Reported result
GQE	Bio	AUC $k$4, APR $k$5
GQE	Reddit	AUC $k$6, APR $k$7
Pathformer	FB15k-237 EPFO queries	overall MRR $k$8
Pathformer	NELL995 avg MRR	$k$9
CaQR + Q2B	NELL Avg MRR	$D_q$00
CaQR + BetaE	FB15k-237	$D_q$01
QTO	3 datasets	previous best results improved by an average of $D_q$02

GQE demonstrated that training on complex queries, including paths and intersections, yields a $D_q$03 absolute AUC gain over an edge-only baseline, and that the framework scales to a biomedical graph with $D_q$04 nodes, $D_q$05 relation types, and $D_q$06 million edges as well as a Reddit graph with $D_q$07 nodes and $D_q$08 million edges (Hamilton et al., 2018).

Pathformer reports that it consistently outperforms competitive neural QE methods on standard CLQA benchmarks FB15k-237 and NELL995. On FB15k-237 EPFO queries it achieves an overall Mean Reciprocal Rank of $D_q$09, versus $D_q$10 for FuzzQE and $D_q$11 for GammaE; on NELL995 the average MRR is $D_q$12 versus $D_q$13 for MLP-Mixer. It also leads on zero-shot held-out structures such as $D_q$14, $D_q$15, $D_q$16, and $D_q$17, and compared to BIQE is described as both more accurate and easily extending to queries with negation (Zhang et al., 2024).

CaQR reports consistent gains across Q2B, BetaE, and ConE. The largest stated improvement is on NELL with Q2B, where the Avg MRR goes from $D_q$18 to $D_q$19, corresponding to $D_q$20. On FB15k-237, BetaE improves from $D_q$21 to $D_q$22 and ConE from $D_q$23 to $D_q$24. QTO, evaluated on 3 datasets, is reported to obtain state-of-the-art performance on complex query answering, outperforming previous best results by an average of $D_q$25, and to interpret the intermediate solutions for each of the one-hop atoms in the query with over $D_q$26 accuracy (Kim et al., 2024, Bai et al., 2022).

6. Expressiveness, graph logic, and broader semantic frameworks

Logical computation graphs also appear as an expressiveness lens for neural graph models. The logic $D_q$27, the $D_q$28-dimensional Weisfeiler-Leman algorithm, and higher-order message-passing GNNs form equivalent descriptions of the same isomorphism-invariant distinguishing power. For standard message-passing GNNs, any $D_q$29-layer architecture refines the $D_q$30-round color refinement $D_q$31, so no such GNN can distinguish vertices or graphs that 1-WL still considers equivalent; conversely, recurrent GNNs with sum aggregation can simulate color refinement. For higher-order models, $D_q$32-GNNs operating on $D_q$33-tuples match standard $D_q$34-WL and hence the logic $D_q$35. The paper summarizes this as a unifying computation-graph perspective: counting quantifiers map to local degree-counts, variable-reuse up to $D_q$36 corresponds to the width of tuple lifting, quantifier-rank corresponds to the number of GNN rounds, and invariance under renaming corresponds to parameter sharing across the graph (Grohe, 2021).

Outside knowledge-graph query answering, graph-based logical computation supports denotational semantics and proof theory. In interaction graphs, proofs of multiplicative linear logic are represented by directed weighted multigraphs $D_q$37, composed by plugging and analyzed through alternating paths, 1-circuits, and the measurement

$D_q$38

Projects and conducts then yield tensor, linear implication, orthogonality, truth, and ultimately a $D_q$39-autonomous category; a restricted fragment recovers Girard’s geometry of interaction in the hyperfinite factor (Seiller, 2012).

Boolean Graph Logic pushes the formula-as-graph perspective further by lifting cograph-based Boolean formulas to all finite undirected graphs. A graph $D_q$40 computes a binary relation $D_q$41 via maximal cliques and maximal stable sets, evaluation is NP-complete for arbitrary graphs, and entailment is $D_q$42-complete. The framework also provides a recursive evaluation algorithm by modular decomposition, a game-theoretic characterization in terms of static and sequential strategies, and a deep-inference-style axiomatization with soundness and completeness (Calk et al., 2020).

Open graphs provide a compositional calculus for computational objects with interfaces made of half-edges. Inputs, outputs, and boundary embeddings define interfaces; plugging is implemented by pushouts in the category of open graphs; and rewrite rules between graphs with the same boundary support algebraic reasoning about Boolean circuits and other computational models. The theory establishes soundness and completeness properties for rewriting and identifies the resulting diagrammatic systems with free symmetric strict monoidal categories generated by a signature and equations (Dixon et al., 2010).

A recurrent misconception is that logical computation graphs are necessarily trees or formula cotrees. The surveyed literature is more heterogeneous: some frameworks insist on tree structure because it exposes efficient local composition or exact optimization, while others explicitly generalize from cographs to arbitrary graphs, from formula trees to open graphs with half-edge interfaces, or from proof nets to interaction graphs with path-based semantics (Bai et al., 2022, Calk et al., 2020, Dixon et al., 2010, Seiller, 2012).