Rotors, Reflections and Rigid Motions

This is the seventh post in Knowledge Graphs as Geometry, a weekly series that develops a single idea one chapter at a time: every relation in a knowledge graph is an operation in space, and the named models are that operation in different guises. The previous chapter wrote rotation as an algebraic product. This chapter completes the construction by expressing translation as a product as well, then fuses the two into a single operator. Every numerical value reported below is produced by the companion code linked at the end.

The previous chapter (https://agussudjianto.substack.com/p/geometric-algebra-from-linear-algebra) ended with an unfinished construction. We had learned to write a rotation as an algebraic product: place a point between a rotor and its reverse , and the point rotates. That product composes as rotations compose and inverts as rotations invert, and it never leaves the rotation group. This behavior was the motivation for introducing geometric algebra in the first place.

One limitation remained, and the family graph makes it concrete. Consider the query (Ann, parentOf, ?). Moving from a parent to a child requires the relation parentOf to carry Ann to a different location rather than to rotate her about the origin. That operation is a translation. A rotor sandwich, for a reason we make precise below, cannot translate: any rotor fixes the origin, sending it to itself. The most basic relational move, stepping from one location to another, therefore lies outside the algebra constructed so far.

This chapter removes that limitation. We first show that a rotation is a composition of two reflections, which is the source of the composability of rotors. We then state the translation obstacle precisely, resolve it by extending the space with two additional directions and conclude with a single operator, the motor, that rotates and translates within one product. The motor is the geometric content of models such as DualE and deCal, and it is the richest invertible relation operator available.

Begin with the most elementary geometric operation, a reflection. Fix a mirror, a line through the origin in two dimensions or a plane in three, and reflect every point across it. In the algebra, reflecting a point 𝐱 in the hyperplane orthogonal to a unit vector 𝐮 is the sandwich

𝐱 ↦ −𝐮 𝐱 𝐮.

Composing two reflections, first across mirror 1 and then across mirror 2, the two sign changes cancel and the result is

𝐱 ↦ (𝐯𝐮) 𝐱 (𝐮𝐯) = R 𝐱 R̃, R = 𝐯𝐮.

Here R = 𝐯𝐮 is a rotor and R̃ = 𝐮𝐯 is its reverse. The composition of two reflections is a rotation, and the angle of that rotation is twice the angle between the two mirrors. Two mirrors separated by 0.6 radians produce a rotation of 1.2 radians. The effect is visible on a single point.

This is not specific to two dimensions. The Cartan–Dieudonné theorem states that every rotation and reflection in n dimensions is a product of at most n reflections. Reflections are the primitive operations and rotors are built from them. This also explains why rotors compose by multiplication: composing rotations amounts to concatenating reflections, and concatenating reflections corresponds to multiplying the unit vectors that define them. The composability used in the previous chapter follows directly from this fact.

Why can this construction not represent a translation?

A rotor sandwich ρ_R(𝐱) = R 𝐱 R̃ is linear in 𝐱, and every linear map fixes the origin. Sending 𝟎 through the sandwich returns 𝟎 for any rotor R. The companion notebook verifies this directly: passing the zero vector through any rotor returns zero to full numerical precision.

A translation is of a different kind. The map τ(𝐱) = 𝐱 + 𝐚 sends the origin to 𝐚, which is its defining property. It is affine rather than linear, and no reformulation expresses an origin-moving map as an origin-fixing one within the same space. The sandwich construction applies to linear maps, and translation is not linear.

This obstacle is not peculiar to geometric algebra; it arises wherever affine maps appear, and there is a standard response: lift the problem. If a map is affine in a given space, one passes to a larger space in which it becomes linear, performs the linear operation there and projects back. Computer graphics applies this idea through homogeneous coordinates, appending a constant entry to each vector so that translation becomes a matrix multiplication. Geometric algebra uses a related construction, adding not one extra direction but two and making both of them null.

A null vector is a nonzero vector that squares to zero, 𝐧·𝐧 = 0. This cannot occur in ordinary Euclidean space, where 𝐧·𝐧 = ‖𝐧‖² is positive for any nonzero 𝐧. It becomes possible only when the space has mixed signature, with some directions squaring to +1 and others to −1, so that positive and negative contributions cancel.

We therefore take the Euclidean plane of interest and adjoin two new generators, one squaring to +1 and one to −1. This is the conformal model, the algebra Cl(3,1) when the base space is two-dimensional. From the two new generators we construct two null vectors,

nₒ = ½(e₋ − e₊), n∞ = e₋ + e₊.

These satisfy nₒ² = n∞² = 0 and nₒ·n∞ = −1, which the notebook confirms to six decimal places. The vector nₒ represents the point at the origin and n∞ the point at infinity. A Euclidean point 𝐱 is lifted into the larger space as

X(𝐱) = nₒ + 𝐱 + ½‖𝐱‖² n∞.

Every lifted point lies on a surface called the null cone, defined by X(𝐱)² = 0, which is again verified numerically. The embedding has a second property that we use later: the inner product of two lifted points recovers the Euclidean distance between the originals,

X(𝐱)·X(𝐲) = −½‖𝐱 − 𝐲‖²,

so the bilinear form of the algebra already encodes the distance by which facts are to be ranked. Embedding (1, 2) and (−0.5, 0.5) and taking the inner product returns −2.25, which is exactly −½ of the squared distance. The metric is intrinsic to the construction.

The motivation for this apparatus is a property of the null direction n∞. Because n∞² = 0, the product 𝐚 n∞ squares to zero, so the exponential of a bivector built from n∞ terminates after the first-order term, with no higher-order contributions. Since a versor is constructed as the exponential of a bivector, the translator takes a particularly simple form,

T(𝐚) = exp(−½ 𝐚 n∞) = 1 − ½ 𝐚 n∞.

The series terminates, leaving a scalar minus one bivector term. This T is a genuine versor, satisfying T T̃ = 1, and its sandwich translates a lifted point exactly,

T(𝐚) X(𝐱) T̃ = X(𝐱 + 𝐚).

Taking the point (1, 2), constructing the translator for 𝐚 = (0.5, −0.4) and applying the sandwich yields the lift of (1.5, 1.6) to floating-point precision. The obstacle is resolved. In the conformal space, translation is a sandwich of the same kind as rotation. The cost is two additional dimensions, and in exchange we obtain an exact multiplicative translation.

Both operations now reside in the same algebra. A rotor R rotates and a translator T(𝐚) shifts. Their product is a motor,

M = T(𝐚) R, ρ_M(X) = M X M̃.

A single sandwich by M rotates a point and then translates it. Because M M̃ = 1, a motor is itself a versor, so every property established for rotors carries over unchanged: the inverse of a motor is its reverse and the composition of two motors is their product. Motors are the rigid motions, the group SE(n) of all rotations and translations, the transformations that move a rigid body without deforming it. They now reside within one associative algebra, in which performing one motion followed by another is multiplication.

A motor acting on a point can be shown alongside its simpler counterparts.

Each of these identities holds by construction rather than because an optimizer adjusted the weights toward it.

The practical consequence is that a relation represented as a motor cannot cease to be a rigid motion during training, in the way that an unconstrained matrix can drift into a transformation with no clean inverse.

This construction is the geometric content of two models in the literature. DualE represents each relation as a unit dual quaternion, which is a motor expressed in dual-number form; the dual unit ε with ε² = 0 plays the role occupied here by the null direction n∞. deCal goes further and learns a degenerate Clifford signature directly, adding generators that square to zero. The companion library reaches the same construction through a single interface, CliffordAlgebra(p, q, r) with r > 0, which produces r nilpotent generators, a more economical variant of the conformal lift. The organizing claim of the series applies here as well: DualE and deCal are not separate inventions but two configurations of one operator.

A qualification on what is and is not being claimed. Geometric algebra is the design language that makes the motor natural: reflections compose into rotations, null directions turn translation into a product and a motor is the product of a rotor and a translator. None of this executes as geometric algebra at training time. The motor reduces to ordinary batched linear algebra on a GPU, the same matrix multiplications and the same automatic differentiation, which is the source of its efficiency. The algebra determines which operator to build; linear algebra determines how it is built.

A relation modeled as a motor lies between two extremes already encountered and inherits desirable properties from each.

Like TransE, it can translate, so it can carry a head across the embedding space rather than only rotating it in place. Like RotatE, it is an isometry with an exact inverse and an exact composition law, so the structural diagnostics developed later in the book can read its inverse and composition behavior without approximation. A motor interpolates between the two: removing the translation leaves a pure rotation and removing the rotation leaves a pure translation.

Invertibility, however, is also a constraint, and the limitation is as informative as the capability. A versor sandwich is invertible by construction and therefore injective: it cannot send two distinct heads to the same tail. The notebook makes this concrete, showing that two distinct points passed through a motor always produce distinct outputs. This behavior is appropriate for a one-to-one relation but not for a genuinely many-to-one relation. Consider parentOf read in reverse: the parents of Carol are both Ann and Bob, two distinct heads that must map to a single tail. No motor can represent this exactly, because collapsing two points to one is precisely what an invertible map excludes. A many-to-one relation requires a singular operator, one permitted to collapse a direction, which is the subject of a later chapter. The motor is the richest invertible operator available, and identifying where invertibility fails is a substantial part of its value.

The properties above are exact identities that hold for an untrained model. To show that the rotor construction also trains, we rebuild the family graph from Chapter 1 and fit a small RotorModel to it. Each relation becomes a learned rotor and the model scores a triple by the proximity of the rotated head to the tail. Querying (Ann, parentOf, ?) and reading the scores over all six candidates gives the following.

When the unit and composition identities are re-checked on the trained weights, they continue to hold to order 10⁻⁷. Training moved the rotors within the rotation group without ever leaving it.

The conformal construction requires only a few lines: lift a point onto the null cone, build a translator, build a motor and apply the sandwich.

import torch
from kge.clifford import CliffordAlgebra
cl = CliffordAlgebra(3, 1)              # 2 Euclidean dims + a null pair
E1, E2, EP, EM = 1, 2, 4, 8            # blade integers of the generators
def ninf():                            # n_inf = e+ + e-   (null)
    n = torch.zeros(cl.m); n[EP] = 1.0; n[EM] = 1.0; return n
def embed(x1, x2):                     # X(x) = n_o + x + (1/2)|x|^2 n_inf
    X = torch.zeros(cl.m); X[EM] = 0.5; X[EP] = -0.5
    X[E1] = x1; X[E2] = x2
    s = 0.5 * (x1**2 + x2**2); X[EP] += s; X[EM] += s; return X
def translator(a1, a2):                # T(a) = 1 - (1/2) a n_inf
    a = torch.zeros(cl.m); a[E1] = a1; a[E2] = a2
    T = torch.zeros(cl.m); T[0] = 1.0
    return T - 0.5 * cl.geometric_product(a, ninf())
moved = cl.sandwich(translator(0.5, -0.4), embed(1.0, 2.0))
torch.allclose(moved, embed(1.5, 1.6), atol=1e-5)   # -> True

The companion notebook contains the full construction: two reflections forming a rotor, the null-vector relations, a point on the null cone, the exact translator, a motor that rotates and then translates and a RotorModel trained end to end on the family graph with the identities re-checked on the trained weights.

▶ Run the notebook in Colab (no installation required): [open in Colab]
📦 Code: github.com/asudjianto-xml/Knowledge-Graph-Geometry — pip install "kge-geometric @ git+https://github.com/asudjianto-xml/Knowledge-Graph-Geometry.git"

A rotation is a composition of two reflections, which is why rotors multiply. A translation is not a versor in ordinary space, but lifting the space with two null directions makes it one, expressed as a single bivector term. The product of a rotor and a translator is a motor: one operation that rotates and translates, with an exact inverse and an exact composition law, the richest invertible operator a relation can be. Its single limitation is also its most informative feature: being invertible, it can never collapse two heads onto one tail. The next chapter applies this construction across the Clifford model family.

Knowledge Graphs as Geometry is a free weekly series adapted from my book Knowledge Graph Embeddings as Geometric Operators. The posts carry the intuition and the runnable code; the book carries the full derivations. Subscribe to follow the complete argument, from a single translation to one operator that contains the entire model family.