Relativity #kerr

Gravitational lensing by a spinning black hole

An accretion disk of hot gas orbits a spinning black hole, its light bending over and under the black hole's shadow.

Gauge theory gravity represents curved spacetime on a flat background by adding a single light-like rank-one map, a null dyad, to the flat identity map Antivector. Because that null dyad squares to zero, subtracting it gives the exact inverse geometry in closed form, and the same formulation compiles straight to a WebGPU ray tracer:

# null dyad and exact inverse geometry
null_plane = -null.dual()
dyad = profile * null * (null_plane & Antivector)
gauge = Antivector + dyad
gauge_inverse = Antivector - dyad

# ray tangent and momentum rate from the Hamiltonian
local_null = gauge(-momentum.dual())
tangent = gauge(local_null)
overlap = momentum & null
overlap_gradient = null_gradient.adjugate()(momentum)
momentum_rate = -(profile_gradient * overlap.squared()
    + 2 * profile * overlap * overlap_gradient)
Thermodynamics #snowflake

Dendritic growth of a snowflake in undercooled water

An ice seed in undercooled water grows into a six-armed snowflake from heat flow, phase change and surface energy alone.

Here the algebra of a 2D plane is joined with a thermodynamic state space of volume, ice and heat. On every triangle, combining each side with all three quantity directions gives a purely spatial simplex gradient that measures slopes across the triangle. Freezing itself is a single direction in state space pairing ice growth with latent heat release; an energy plane keeps energy & freezing == 0 conserved by construction, while an entropy-slope plane entropy_slope & freezing drives crystal growth:

# spatial simplex gradients in the joined algebra
quantities = volume & ice & heat
double_areas = (sides[0] & sides[1]) & quantities
gradients = (sides & quantities) / double_areas

# six-fold crystal anisotropy from a sixth power
steepness = (gradients * (corners * phase)).sum(0)
turn = steepness * axis
six_fold = (turn ** 3).scalar_product(turn ** 3)
anisotropy = 6 * axis * turn ** 5

# freezing direction: conserved energy and entropy drive
freezing = ice + latent_heat * heat
energy = h - latent_heat * i
heat_drives = -gradients ^ h
push = cells * (entropy_slope & freezing)
Geometry & surfaces #spin-transformations

Conformal curvature flow of a cow into a sphere

Spot the cow rounds into a sphere under conformal curvature flow, preserving every angle of a checkerboard texture as local sizes change.

Each conformal step rotates and rescales every triangle using a scaled 3D rotation (a rotor) at each vertex. In 3D geometric algebra, triangle edges and 3D rotors multiply directly under one geometric product. Weighting each triangle's incidence on its corners by its opposite edge vectors sides / (2 * areas) builds the discrete Dirac operator directly, and minimizing its curvature-shifted residual energy solves for vertex rotors that carry Spot smoothly toward a sphere:

# triangle edges and discrete Dirac operator
edges = topology.d[0] * vertices
sides = topology.boundary[2, 1] * edges
areas = (sides[0] & sides[1]).norm() / 2
corners = topology.incidence[2, 0]
dirac = (spdiag(sides / (2 * areas)) * corners).sum(0)

# curvature-shifted residual and vertex rotors
faces = corners.mean(0)
residual = dirac - spdiag(shift * volume) * faces
energy = (~residual * spdiag(areas) * residual) * Even
values, rotors = energy.eigh(vertex_areas * Even, 1)

# spin edges by vertex rotors for the new surface
midpoint = (edge_means * rotors) << edges
endpoints = (edge_means * (rotors << Point))(edges)
deformed_edges = (endpoints + 2 * midpoint) / 3
Mechanics #rattleback

Spin reversals of a rattleback toy

A rattleback spinning on a flat table reverses its spin back and forth, rocking on one reversal and tilting on the other.

In 3D projective geometric algebra, its ellipsoidal hull is a linear map shape that sends any tangent plane to its contact point, so evaluating shape(normal) on the table plane directly locates the lowest point on the hull. Translating body rotations from the centre of mass to that contact point builds a linear rolling map from spins to full rigid-body motions that hold the contact instantaneously at rest. Because a table reaction force through a resting contact does no work on rolling motions, the transpose-like adjugate rolling.adjugate() removes that unknown reaction force analytically and pulls the free rigid-body inertia straight onto spins:

# lowest point on the ellipsoidal hull
normal = (motor << up).dual_inverse()
height = (normal & shape(normal)).square_root()
support = -shape(normal) / height

# no-slip rolling map at the contact point
shift = ((centre + support) * origin.inverse() / 2).exp()
rolling = shift >> Spin

# constrained inertia eliminates the contact force
rate = rolling(spin)
effective_inertia = rolling.adjugate()(inertia(rolling))
torque = force - inertia(rate).commutator(rate)
energy = (rate & inertia(rate)) / 2 + potential
Quantum #condensate

Quantized vortices in a rotating Bose–Einstein condensate

Ultracold atoms stirred in a rotating trap share one quantum wave, drawing quantized vortices in from the rim into a triangular lattice.

Here the algebra of the 2D trap plane is joined with an internal phase plane, so the quantum wave is modelled as a real 2D vector field with no imaginary unit. Two commuting rotation planes build the rotating-frame Gross–Pitaevskii operator. The trap plane xy turns positions by a quarter turn into rotational drag velocity, while the internal plane ab turns the wave by a quarter turn for quantum phase rotation:

# simplex gradients in the joined algebra
double_areas = (sides[0] & sides[1]) & wave_plane
areas = double_areas.antinorm() / 2
gradients = (wave_plane & sides) / double_areas

# rotating-frame Gross-Pitaevskii operator
flux = gradients[None, :].dual()
kinetic = (areas / 2) * (gradients[:, None] & flux)
drag = (corners.mean(0) * vertices).commutator(xy)
advection = (areas / 3) * (gradients & drag)[None, :]
operator = kinetic * Wave - omega * advection * (Wave * ab)

# exact integer vortex winding around each triangle
tail, head = topology.incidence[1, 0] * wave
turns = (tail * head).normalized().log()
winding = (topology.boundary[2, 1] * turns).sum(0)
Mechanics #elastica

Dynamics of a helical Kirchhoff elastic rod

Coupled bending and torsional waves race along a coiled telephone cord clamped at both ends.

Each segment of the cord is placed by a 3D motor, an element of projective geometric algebra that encodes rotation and translation together. Taking the logarithm of the relative motor between neighbouring segments away from their coiled rest step reads bending, shear and twist in one geometric object, and the derivative of the motor exponential maps local elastic stiffness loads back into exact energy-conserving forces and torques:

# relative motor logarithm at every elastic joint
deviation = (~rest * ~frames[:-1] * frames[1:]).log() * 2
load = stiffness(deviation / length)

# exact exponential derivative into restoring forques
first = deviation.commutator(load)
second = deviation.commutator(first)
world = frames[1:] >> (load - first / 2 + second / 12)

# step each segment's momentum and placement
segments = frames[1:-1]
forces = segments << (world[:-1] - world[1:])
momentum = inertia(rates)
torque = forces - momentum.commutator(rates)
acceleration = inertia.solve(torque)
frames = frames * (rates * (-step / 2)).exp()
Electromagnetism #dynamo

Field reversals in a magnetohydrodynamic dynamo

Flowing liquid metal in a planet's core winds up a magnetic field until its poles flip back and forth.

In spacetime geometric algebra, moving liquid metal meets the magnetic field to induce an electric field that drives conduction currents. Pairing the magnetic field back with those currents gives the Lorentz braking force on the fluid, and associativity of the pairing guarantees that mechanical power lost by the flow equals electrical power gained by the field. Across each tetrahedron, wedging corner simplex gradients builds the curl, motional induction and magnetic stiffness:

# tetrahedral simplex gradients and edge curls
gradients = (face_patches & time) / (3 * prisms)
curls = 2 * (gradients[tails] ^ gradients[heads])
curl = (spdiag(curls * Scalar) * oriented).sum(0)

# motional electric field and magnetic stiffness
induction = ((velocities & Magnetic) ^ t)(curl)
excitation = volumes * Magnetic.dual()
stiffness = curl.adjugate()(excitation(curl))

# conduction current and Lorentz braking force
field = curl(potential)
electric = ((velocities & field) ^ t) - potential_rate
conductance = volumes * conductivity
currents = -conductance * (electric & time).dual()
lorentz_forces = ((field & currents) & modes).sites.sum()
Geometry & surfaces #origami

Folding an origami kabuto helmet

A flat square of paper folds into a traditional samurai helmet.

In 3D projective geometric algebra, the crease plane that folds one corner onto another is their perpendicular bisector. Meeting that plane with the paper gives the hinge line, and exponentiating half the fold angle turns the moving layers rigidly:

# crease plane folding a corner or line onto another
crease = ((a & b) | (a + b)).normalized()
bisector = ((line1 + line2) | crossing).normalized()

# split polygon edges where they cross the crease
crossings = (tails & heads) ^ crease
cut_points = crossings / (w & crossings)

# hinge line on the sheet and rigid fold motor
hinge = (crease ^ sheet).normalized()
motor = (hinge * (angle / 2)).exp()
folded_points = motor >> points

A gravitational wave in a closed universe

Flying near light speed once around a closed 600-cell universe as a gravitational wave stretches and rings three spring-bound crystals. Because space closes on itself, a straight flight loops back to those same crystals from behind while relativistic aberration swings distant great circles forward.

Rather than patching coordinate charts over the three-sphere, a single smooth frame motor frame carries tangent directions at every point back to one shared origin with no poles. Discrete Regge-calculus metric perturbations on the 600-cell pull into those frames, blend across tetrahedra by simplex gradients and build a curved motor connection that rolls light rays, crystals and the flying camera live in WebGPU:

# smooth frame motor at every point of the three-sphere
frame = ((1 + xyzw) * (place / origin) + (1 - xyzw)) / 2

# pull Regge strain into frames and blend across corners
strains = frame.inverse() >> metric(frame >> Step)
weights = (gradients & place) / (gradients.sum(0) & place)
planes = frame.inverse() >> gradients
curl = (planes ^ strains).sum(0) / 2

# wave connection rolls light and crystals in motors
stretch = translating(strain(Step))
connection = moving(Step + stretch / 2) + curl(Step)
connection = connection + turning(Step - 2 * stretch)
motion = frame * (moving(velocity) * (-step / 2)).exp()
place = motion >> origin

# relativistic aberration boost at the eye
boost = ((ahead & time).dual() * (rapidity / 2)).exp()
ray = boost >> sightline
Relativity #twistors

Linked light rays in a twistor hopfion

A pulse of light whose electric field lines are closed linked loops contracts and expands without any two loops cutting through each other, looping forward in time where future infinity meets past infinity in conformal spacetime.

In this exact vacuum solution of Maxwell's equations, every point on every loop travels in a straight line at light speed along a twisting family of light rays (the Robinson congruence) fixed by a single twistor. At each event in spacetime, a spatial rotation spinor twists a travelling light wave while the spacetime volume element mixes electric and magnetic planes inside a decaying pulse envelope. Applying the resulting electromagnetic field directly to the time direction, field >> time, yields the pulse's energy-momentum flow and points straight along those same twistor rays:

# Bateman spinor turns polarization at each spacetime event
elapsed = t & event
offset = event - elapsed * (time + y.dual())
position = conformal_time.inverse() | offset
spinor = 1 + position * helicity
polarization = spinor >> ((t + y) ^ x)

# inverse phase envelope yields the exact Maxwell field
phase = 1 + event.squared() + 2 * xyzt * elapsed
envelope = phase.inverse()
field = polarization * envelope.squared() * envelope

# Maxwell energy-momentum flow along twistor rays
energy_flow = field >> time
Quantum #skyrmions

Phase transitions of magnetic skyrmions

Chiral atomic spins in a magnetic film undergo phase transitions between compact skyrmions, labyrinthine stripes and a uniform magnet as an applied field varies.

At each time step, exponentiating a field of rotation-plane rates builds 3D rotors that turn every spin directly while preserving unit spin length everywhere. Around any triangle with corner spins a, b and c, multiplying the three shortest-arc rotations from corner to corner gives the net loop rotation around that face, and taking its logarithm paired with a measures the spherical solid angle spanned by those three spins to sum into an exact integer skyrmion count:

# chiral bond exchange across neighbour rotors
tails, heads = topology.incidence[1, 0] * spins
exchange = Spin.dual()
tail_fields = exchange(carriers << heads)
head_fields = exchange(carriers >> tails)

# damped rotor step preserves unit spin length
torque = field + damping * field.commutator(spins.dual())
rate = torque / (1 + damping ** 2)
spins = (rate * (-step / 2)).exp() >> spins

# exact integer skyrmion charge on every triangle
a, b, c = topology.incidence[2, 0] * spins
loop = (1 + a * c) * (1 + c * b) * (1 + b * a)
charge = -2 * (loop.normalized().log() & a) / (4 * pi)
Electromagnetism #superconductor

The Meissner effect in a superconducting rod

Cooled in a magnetic field, a superconductor expels magnetic flux, while a zero-resistance conductor traps it even after that field is turned off.

In spacetime geometric algebra, London's two equations are the time-space and spatial parts of gradient ^ (momentum + charge * potential) == 0, which vanishes because the superconducting electrons share a single quantum phase. The time-space part accelerates supercurrent without resistance, while the spatial part locks supercurrent to the electromagnetic potential and expels magnetic flux. Across the rod's cross-section, wedging corner simplex gradients builds the magnetic stiffness through vacuum, while the London screening term locks supercurrent to the potential:

# simplex gradients across the rod's cross-section
double_areas = ((sides[0] & sides[1]) & rod) & time
areas = double_areas.norm() / 2
gradients = (rod & time & sides) / double_areas

# vacuum magnetic stiffness from corner field bivectors
vacuum = Field.dual()
fields = gradients ^ z
excitation = vacuum(fields[None, :])
local_stiffness = (fields[:, None] & excitation) * areas

# London screening locks supercurrent to potential
london = spdiag(cells * rod_mask * share / depth ** 2)
operator = conduction + stiffness + london
supercurrent = -(share / depth ** 2) * (potential - offset)
Electromagnetism #beltrami

Relaxation of a magnetic field to a Beltrami state

Tangled magnetic field lines inside a toroidal conducting cavity relax into evenly twisted windings.

On each tetrahedron in spacetime, wedging the simplex gradients at the two endpoints of an edge builds its magnetic curl. Both magnetic energy and magnetic helicity pull back onto the edges through the adjugate curl.adjugate(). Energy depends on lengths and angles through the metric duality map Field.dual(), whereas helicity is purely topological, wedging potential planes with signed volumes to measure field-line linkage:

# simplex gradients, potential map and edge curls
prisms = volumes & time
gradients = (face_patches & time) / (3 * prisms)
edges = topology.oriented[3, 1]
forms = (gradients[heads] - gradients[tails]) / 4
potential = (spdiag(forms * Scalar) * edges).sum(0)
curls = 2 * (gradients[tails] ^ gradients[heads])
curl = (spdiag(curls * Scalar) * edges).sum(0)

# metric magnetic energy vs. topological helicity
vacuum = prisms.norm() * Field.dual()
energy = curl.adjugate()(vacuum(curl))
helicity = curl.adjugate()((Plane ^ volumes)(potential))

Half-turn defects in an active liquid crystal

An active liquid-crystal film drives itself into chaotic flow as +1/2 and -1/2 defects pair up, annihilate and stream across the film.

Because the rod-like molecules have no head or tail, local alignment is modelled as a symmetric map on directions that is unchanged when an axis reverses and vanishes smoothly at half-turn defect cores. Differentiating that map with respect to a rotation plane Turn gives the rotational energy slope, and rotating it with a rotor preserves the degree of order:

# head-tail-symmetric alignment map vanishes at cores
projection = directors * (directors.dual_inverse() & Point)
order = strength * (projection - Point / 2)

# differentiate alignment directly on bivector turns
tangent = (order.commutator(Turn)
           - order(Point.commutator(Turn)))
slope = -molecular(tangent).batch().trace(0, 1).field()

# rotate alignment by a rotor preserving order
rotated_order = rotor >> order(rotor << Point)
Mechanics #tennis-racket

The Dzhanibekov effect on a tennis racket and a T-handle

Spun about their intermediate axis, a tennis racket and a space-station T-handle repeatedly flip half a turn over in mid-flight.

In geometric algebra, rotation happens in oriented planes (bivectors) and carries complementary angular momentum (antibivectors). Joining each mass point with its velocity under a rotation rate Rate and summing over the body builds its full inertia map in one line, and torque-free motion then evolves unchanged in any dimension and metric signature:

# body inertia map summed over mass points
inertia = points.regressive(points.commutator(Rate)).sum()
inverse_inertia = inertia.inverse()

# torque-free Euler equation in any dimension
momentum = inertia(rate)
rate_change = inverse_inertia(-momentum.commutator(rate))

# evolve orientation rotor and world-frame momentum
motor = motor * (rate * (-step / 2)).exp()
world_momentum = motor >> inertia(rate)
Fluids #eigen-fluids

Navier–Stokes on the surface of the Stanford bunny

A two-dimensional fluid flows on the surface of the Stanford bunny under the nonlinear Navier–Stokes equations.

On a triangulated surface in 3D space, a scalar field's simplex gradient on each triangle is a slope plane, and combining corner gradients with triangle areas through the adjugate gradient.adjugate() assembles the surface Laplacian in one line. Wedging each Laplacian eigenmode's gradient with each triangle's oriented area patches turns it directly into a divergence-free flow along level curves in 3D space, and pairing gradients with those flows builds an antisymmetric advection bracket that steps nonlinear fluid motion while conserving kinetic energy:

# surface Laplacian from corner simplex gradients
patches = (sides[0] & sides[1]) / 2
gradients = (sides | patches.inverse()) / 2
gradient = (spdiag(gradients) * corners).sum(0)
metric = areas * Plane.dual()
stiffness = gradient.adjugate()(metric(gradient))

# divergence-free eigenmode flows and surface Jacobian
face_gradients = gradient(modes)
flows = face_gradients ^ patches
jacobians = face_gradients[:, None] & flows[None, :]

# energy-conserving modal advection rate
stream = vorticity / eigenvalues
damping = viscosity * eigenvalues * vorticity
rate = structure(stream, vorticity) - damping
Thermodynamics #rubber-band

A rubber band heat engine and the Gough–Joule effect

Warmed by a lamp, a hanging rubber band shrinks and lifts its weight; beside it, an identical band warms when pulled down and cools below room temperature when released.

Here the algebra of a 2D plane is joined with a null entropy direction, placing each vertex's position and entropy in one point and its elastic force and temperature in one potential plane. Because both derive from a single energy function, heat-driven tension and stretch-driven warming obey Maxwell's reciprocity automatically. Wedging corner simplex gradients with the entropy plane conducts heat through a symmetric sum of transport dyads, so heat flow obeys Onsager symmetry by construction:

# spatial simplex gradients in the x+ y+ s0 algebra
double_areas = (sides[0] & sides[1]) & entropy
gradients = (entropy & sides) / double_areas

# isotropic conduction dyads obey Onsager symmetry
drives = -gradients ^ s
sweeps = directions & entropy
conductivity = (sweeps * (sweeps & Drive)).sum(0)
flux = conductivity(drives[None, :])
conduction = areas * (s & (gradients[:, None] ^ flux))

# temperature and force combine in one potential plane
potentials = temperatures * s - forces
Mechanics #hollow-top

Spin-dependent inversion of an asymmetric hollow spinning top

Two identical asymmetric hollow tops are spun in opposite directions on a flat table. One rocks wider and flips upside down onto its stem, while the other stays upright. Precisely which geometric and frictional conditions make a chiral spinning top invert for only one spin direction remains an open problem in rigid-body mechanics.

In 3D projective geometric algebra, each piece of a top, its outer shell, offset tilted cavity, stem and rounded tip, is a quadric, a linear map from points to planes whose pairing with a point is negative inside the solid. The same four maps carve interior mass samples, evaluate floor contact depth and ray trace the surfaces on the GPU. Joining each carved mass sample with its velocity under a rotation rate Rate sums the full rigid-body inertia about any origin, and pulling a floor contact line contact & normal into the body frame maps unit impulses directly to resulting twists:

# four quadrics carve the asymmetric hollow body
inside = (parts[:, None](samples) & samples) <= 0
shell, cavity, stem, tip = inside
masses = ((shell & ~cavity) | stem | tip) * volume

# rigid-body inertia summed directly about any origin
velocities = samples.commutator(Rate)
inertia = (masses * samples).regressive(velocities).sum()
inverse_inertia = inertia.inverse()

# floor penetration depth and contact line compliance
plane = ground(contact)
depth = -(plane & contact) / (2 * plane.norm())
twists = inverse_inertia(motor << (contact & normal))