💻 computer science

Fully Geometric Multi-Hop Reasoning on Knowledge Graphs with Transitive Relations

The paper introduces GeometrE, a geometric embedding method for multi-hop reasoning on knowledge graphs that maps all logical operations to pure geometric transformations and employs a novel transitive loss function to preserve logical rules, achieving superior performance over existing geometric approaches while maintaining competitive results with neural-based methods.

Original authors: Fernando Zhapa-Camacho, Robert Hoehndorf

Published 2026-06-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Fernando Zhapa-Camacho, Robert Hoehndorf

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 a massive library where every book is connected to every other book by invisible strings. These strings represent facts: "The cat is on the mat," "The mat is red," or "Red things are warm." This library is a Knowledge Graph.

Sometimes, you ask a simple question like, "What is red?" (a one-hop question). But often, you ask complex questions like, "Find me something that is on a red mat, but is not a cat." This is a multi-hop reasoning task. You have to follow the strings, combine clues, and filter out the wrong answers.

The paper introduces a new tool called GeometrE to solve these complex puzzles. Here is how it works, explained simply:

1. The Old Way: The "Black Box" vs. The "Geometric Map"

Previously, computers tried to solve these puzzles in two ways:

The Neural Network Way: Think of this as a magic black box. You feed it a question, and it spits out an answer. It works very well, but you have no idea how it decided. It's like a wizard casting a spell; you get the result, but you don't understand the magic.
The Geometric Way: This tries to draw a map. It turns facts into shapes (like boxes) on a grid. If you ask "What is red?", the computer draws a box around all red things. This is great because you can see the logic. However, old geometric maps had a problem: when they tried to do complex math (like "A and B, but not C"), they had to sneak a little bit of that "black box" magic inside the shapes to make it work. This broke the "pure map" idea.

GeometrE's Big Idea: It creates a purely geometric map. It claims you don't need any "black box" magic at all. Every logical step (AND, OR, NOT) is just a simple, clean geometric move, like sliding a box or cutting a piece of paper.

2. How GeometrE Draws the Map

Instead of turning facts into single dots, GeometrE turns them into boxes (like 3D cardboard boxes).

The "Box" Concept: Imagine a box representing "European Countries."
Intersection (AND): If you want "European Countries AND Countries with a King," GeometrE simply takes the two boxes and finds the overlapping area where they touch. It's like stacking two transparent boxes and looking at the space where both exist.
Negation (NOT): This is the tricky part. You can't easily draw "everything that is NOT a box" using just boxes. GeometrE solves this with a clever trick: The Exclusion Zone. Instead of drawing the "not" shape, it just says, "The answer must be inside the 'European' box, but it must stay away from the 'King' box." It pushes the answer out of the forbidden zone without needing to draw the entire rest of the universe.

3. The "Transitive" Chain (The Domino Effect)

Some facts are transitive. This means if A is related to B, and B is related to C, then A is automatically related to C.

Example: "Grandfather is father of Father" and "Father is father of Son" implies "Grandfather is father of Son."

The paper noticed that previous geometric maps often broke this chain. They couldn't guarantee that the "Grandfather" box would logically connect to the "Son" box just by following the rules.

GeometrE's Solution: It adds a special "Transitive Loss" (a rule for the computer to follow while learning).

Imagine a staircase. If you step from the bottom to the middle, and the middle to the top, you must end up at the top.
GeometrE forces the computer to arrange the boxes on this "staircase" so that the order is always preserved. It ensures that if you follow the chain of boxes, the logic holds up perfectly, just like a row of falling dominoes.

4. The Results: Better Maps, No Magic

The authors tested GeometrE on standard "library" datasets (like WN18RR, NELL, and FB15k-237).

It beats the old geometric maps: By using a mix of "sliding" (additive) and "stretching" (multiplicative) moves for their boxes, GeometrE solved more puzzles correctly than previous geometric methods.
It rivals the "Black Box" wizards: It performs almost as well as the complex neural networks that use magic, but with a huge advantage: You can actually see how it solved the problem. You can look at the boxes and say, "Ah, it found the answer because it was inside this box and outside that one."

Summary

Think of GeometrE as a new way to navigate a giant maze.

Old methods either used a GPS that gave you the answer but wouldn't show you the map (Neural Networks), or they used a map that was slightly broken and needed a little magic to fix the corners (Old Geometric Methods).
GeometrE draws a perfect, clean map where every turn, every dead end, and every shortcut is a simple, logical geometric shape. It even has a special rule to make sure long chains of clues (like family trees) always lead to the right destination.

The paper claims this method is faster to understand, just as accurate as the complex methods, and keeps the logic transparent for anyone to inspect.

Technical Summary: GeometrE

Problem Statement

Multi-hop logical reasoning on Knowledge Graphs (KGs) requires faithfully mapping logical semantics into a latent space to answer complex queries involving first-order logic operations (intersection, union, negation, and existential quantification). Current approaches face a trade-off between interpretability and performance:

Geometric Methods: While they offer interpretability by mapping entities to geometric regions (e.g., boxes, cones) and operations to transformations, they often rely on neural networks to learn logical operators (like intersection or negation) rather than using pure geometric transformations. Furthermore, existing geometric methods struggle to model transitive relations effectively, failing to preserve the logical rule $\forall a, b, c : r(a, b) \land r(b, c) \rightarrow r(a, c)$ or the idempotency property of transitive relations.
Neural Methods: Purely neural-based approaches often outperform geometric methods in accuracy but lack interpretability in the latent space, treating logical operators as "black box" neural components.

The paper identifies two specific limitations in current work: (1) the lack of pure geometric interpretability for logical operators, and (2) the inability to model transitive relations that preserve chain-like structures and idempotency.

Methodology: GeometrE

The authors propose GeometrE, a box embedding model designed to map every logical operation to a purely geometric transformation in the latent space, eliminating the need for neural networks to learn logical operators.

1. Box Embeddings and Geometric Projection

Representation: Entities and queries are represented as $n$ -dimensional axis-aligned boxes defined by a center ($cen$) and an offset ($off$).
Relation Projection: Unlike previous methods (e.g., Query2Box) that use purely additive translations, GeometrE introduces a multiplicative-additive projection mechanism. A relation $r$ $r$ is represented as a 4-tuple $(r_1, r_2, r_3, r_4)$ $(r_{1}, r_{2}, r_{3}, r_{4})$ . The transformation $T_r$ $T_{r}$ on a box $B$ $B$ is defined as:
- $cen(B') = r_1 \otimes cen(B) + r_2$
- $off(B') = |r_3 \otimes off(B) + r_4|$
  Here, $\otimes$ denotes coordinate-wise multiplication. This combination enhances expressiveness while maintaining geometric interpretability.
Idempotency: The transformation is designed to be idempotent (i.e., $T_r(T_r(B)) \approx T_r(B)$ ) for specific parameter configurations, a property crucial for modeling transitive relations.

2. Geometric Logical Operations

Intersection: Computed via coordinate-wise maximum of lower bounds and minimum of upper bounds. The authors argue that despite potential disjointness issues in volume-based overlap, their distance-based optimization objective ensures stable gradients without needing neural approximations (like DeepSets).
Negation: Instead of attempting to represent the geometric complement of a box (which is not a box), GeometrE models negation as a geometric exclusion constraint. For a query "A but not B," the model minimizes the distance to the positive box $A$ while maximizing the distance from the interior of the negative box $B$ . This avoids representing non-box shapes in the latent space.

3. Transitive Relations and Loss Functions

To address the modeling of transitive relations, GeometrE introduces two key components:

Order-Preserving Function: For a transitive relation $r$ , the model enforces an ordering constraint on a specific projection dimension $i$ . If $r(a, b)$ and $r(b, c)$ hold, the embeddings must satisfy $cen(a)[i] > cen(b)[i] > cen(c)[i]$. This is achieved via a specialized distance function, $distordering$, which penalizes violations of this chain-like order.
Transitive Loss Function ( $L_{\hat{r}_i}$ ): To ensure the relation projection acts as an identity transformation (idempotency) in the transitive dimension, the model optimizes the relation embedding to approximate the identity function ( $r_1 \approx 1, r_3 \approx 1, r_2 \approx 0, r_4 \approx 0$ ) in the non-transitive dimensions, while strictly enforcing the ordering in dimension $i$ .
Theoretical Guarantee: The authors prove (Theorem 1) that under these loss functions, the model preserves the transitivity rule: if the distance for $(a, b)$ and $(b, c)$ is zero, the distance for $(a, c)$ is also zero, maintaining the correct ordering.

Key Contributions

Fully Geometric Interpretability: A query answering method where every logical operation (intersection, negation, relation projection) is a pure geometric transformation, removing the reliance on neural networks for operator learning.
Multiplicative-Additive Projection: A novel relation embedding mechanism combining additive and multiplicative components, shown to be more expressive than purely additive translations.
Transitive Loss Function: A specialized loss function and order-preserving mechanism that successfully encodes the logical form of transitivity ( $\forall a, b, c : r(a, b) \land r(b, c) \rightarrow r(a, c)$ ) and the idempotency of transitive relations.
Empirical Performance: Demonstration that GeometrE outperforms state-of-the-art geometric methods and remains competitive with neural-based methods on standard benchmarks.

Experimental Results

The method was evaluated on three datasets: WN18RR-QA, NELL-QA, and FB15k-237 (FB237).

Performance vs. Geometric Baselines: GeometrE outperformed existing geometric methods (GQE, Q2B, BETAE, ConE, LinE) across most query types (1p, 2p, 3p, 2i, 3i, pi, ip, 2u, up) and datasets. Notably, it achieved superior results in intersection queries (2i, 3i) where baselines often rely on neural approximations.
Performance vs. Neural Baselines: GeometrE approached the performance of the neural-based method NMP-QEM. In WN18RR and FB237, it was competitive, though NMP-QEM still held a slight edge in some metrics.
Negation Handling: The geometric exclusion constraint proved effective, allowing GeometrE to outperform geometric baselines on queries involving negation (2in, 3in, inp, pin, pni).
Transitivity Validation:
- On the general benchmark, the transitive loss showed a slight, statistically non-significant improvement in overall MRR, attributed to the low frequency of transitive chains in the datasets.
- However, in a targeted evaluation on transitive chains (using hypernym and has_part relations), GeometrE with the transitive loss achieved a Spearman correlation of 0.87 (vs. 0.12 without the loss), demonstrating a significant ability to preserve the ordered structure of transitive chains.
Ablation Studies:
- Removing the multiplicative components (GeometrE-m) or additive components (GeometrE-a) resulted in lower performance, confirming the benefit of the combined mechanism.
- The choice of answer embedding initialization (separate vector vs. reusing query center) varied by dataset density, with separate vectors performing better on sparse graphs (WN18RR) and reused centers performing better on denser graphs (FB237).

Significance and Claims

The paper claims that GeometrE successfully bridges the gap between geometric interpretability and high performance in multi-hop reasoning. By mapping logical operators to pure geometric transformations, it provides a framework where the reasoning process is transparent and understandable, unlike "black box" neural approaches.

The authors emphasize that while purely neural methods may still hold a slight performance advantage in some scenarios, GeometrE offers a compelling alternative that does not sacrifice interpretability. The introduction of the transitive loss function is highlighted as a significant step forward, as previous geometric methods could not effectively model the chain-like structure of transitive relations. The work suggests that with appropriate geometric constraints and loss functions, complex logical reasoning can be achieved without relying on neural approximations for logical operators.