RotatE is a knowledge graph embedding model that represents each relation as a rotation in complex vector space — mapping entity pairs through element-wise phase rotations, enabling explicit and provable modeling of all four fundamental relational patterns (symmetry, antisymmetry, inversion, and composition) that characterize real-world knowledge graphs.

What Is RotatE?

• Definition: An embedding model where each relation r is a vector of unit-modulus complex numbers (rotations), and a triple (h, r, t) is plausible when t ≈ h ⊙ r — the tail entity equals the head entity after element-wise rotation by the relation vector.
• Rotation Constraint: Each relation component r_i has |r_i| = 1 — representing a pure phase rotation θ_i — the entity embedding is rotated by angle θ_i in each complex dimension.
• Sun et al. (2019): The RotatE paper provided both the geometric model and theoretical proofs that rotations can capture all four fundamental relation patterns, improving on ComplEx and TransE.
• Connection to Euler's Identity: The rotation r_i = e^(iθ_i) connects to Euler's formula — RotatE is fundamentally about angular transformations in complex vector space.

Why RotatE Matters

• Provable Pattern Coverage: RotatE is the first model proven to explicitly handle all four fundamental patterns simultaneously — previous models handle subsets.
• State-of-the-Art: RotatE achieves significantly higher MRR and Hits@K than TransE and DistMult on major benchmarks — the geometric constraint is practically beneficial.
• Interpretability: Relation vectors encode angular transformations — the "IsCapitalOf" relation corresponds to specific rotation angles that consistently map country embeddings to capital embeddings.
• Inversion Elegance: The inverse of relation r is simply -θ — relation inversion is just negating the rotation angles, making inverse relation modeling trivial.
• Composition: Rotating by r1 then r2 equals rotating by r1 + r2 — compositional reasoning maps to angle addition.

The Four Fundamental Relation Patterns

Symmetry (MarriedTo, SimilarTo):

• Requires: Score(h, r, t) = Score(t, r, h).
• RotatE: r = e^(iπ) for each dimension — rotation by π is its own inverse. h ⊙ r = t implies t ⊙ r = h.

Antisymmetry (FatherOf, LocatedIn):

• Requires: if (h, r, t) is true, (t, r, h) is false.
• RotatE: Any non-π rotation is antisymmetric — rotation by θ ≠ π maps h to t but not t back to h.

Inversion (HasChild / HasParent):

• Requires: if (h, r1, t) then (t, r2, h) for inverse relation r2.
• RotatE: r2 = -r1 (negate all angles) — perfect inverse by angle negation.

Composition (BornIn + LocatedIn → Citizen):

• Requires: if (h, r1, e) and (e, r2, t) then (h, r3, t) where r3 = r1 ∘ r2.
• RotatE: r3 = r1 ⊙ r2 (angle addition) — relation composition is complex multiplication.

RotatE vs. Predecessor Models

Benchmark Performance

Self-Adversarial Negative Sampling

RotatE introduced a novel training technique — sample negatives with probability proportional to their current model score (harder negatives get higher sampling probability), significantly improving training efficiency over uniform negative sampling.

Implementation

• PyKEEN: RotatEModel with self-adversarial sampling built-in.
• DGL-KE: Efficient distributed RotatE for large-scale knowledge graphs.
• Original Code: Authors' implementation with self-adversarial negative sampling.
• Constraint: Enforce unit modulus by normalizing relation embeddings after each update.

RotatE is geometry-compliant logic — mapping the abstract semantics of knowledge graph relations onto the precise mathematics of angular rotation, proving that the right geometric inductive bias dramatically improves the ability to reason over structured factual knowledge.