One multiplication, three geometries

This is an introductory blog post for people curious about the underlying algebra and intuition. Start with a pair of numbers and one rule for multiplying them. That rule gives us rotations, shears and squeezes, depending on a single choice.

I came to this through AI research. I was trying to understand how a model could remember, change and forget, and ended up learning a fair bit of algebra. This is the part of that work I keep coming back to.

Revision 3, 4 October 2026. The pairs, multiplication and three geometries now come first; the research connections come later. Figures start still, with playback where useful, and the interval example distinguishes crossed bounds from the null axes. The Song update covers the gen2 → gen3 transition, the rename to Iota and the assembly proof boundary added in Revision 2.

§Two numbers for one point

§Numbers on a line

point

1.500

value

3/2

kind

a fraction

Counting gives 0, 1, 2, 3 and on. Running a count backwards gives the negatives. Sharing gives fractions. Filling every gap between the fractions gives the real numbers: one number for every point of a line.

§A point is a pair of numbers

red point z

(1.500, 0.800), written 1.500 + 0.800·x

gold point w

(−0.600, 1.400)

z + w

(0.900, 2.200)

Cross two number lines at their zeros, and every point is found by two numbers: a across and b up (coordinates). We can write that pair as

Adding two points adds slot to slot, which is walking one arrow and then the other:

§Multiplying needs one decision

Multiply two pairs the way brackets are multiplied at school: every part by every part. Four products appear: a·c, a·d·x, b·c·x and b·d·x·x (the dot means times; letters stand for numbers). The first three are fine. The last contains x·x, and nothing so far says what that is.

That is the one decision. Choose a real number σ and declare x·x = σ (x squared is σ). Worked with σ = −1:

and in general

Order and grouping do not matter, and 1 + 0·x changes nothing. This is the algebra ℝ[x]/(x² − σ); the formula is forced by x·x = σ rather than chosen (mul_eq_quotient_mul).

§Multiplication as a map

Ellipticx² = −1Parabolicx² = 0Hyperbolicx² = +1

a

1.300

b

0.600

z

1.300 + 0.600·x

N(z)

2.050

area of image

2.050

orientation

kept

Fix one point z and multiply every point of the plane by it. Straight lines stay straight, the centre stays put, and the square becomes a slanted box. That holds on every face.

Multiplication by z = a + b·x is a linear map. As a matrix it has rows (a, σb) and (b, a), and its determinant is the area scale in the figure:

That is the norm. Negative N mirrors the plane; zero N flattens it onto a line. Multiplying by z then by w is multiplying by zw, and area scales compose, so

The elements with N = 1 keep every area without mirroring, and they form a group.

§Faces

Ellipticx² = −1Parabolicx² = 0Hyperbolicx² = +1

σ

face

elliptic

σ

−1.000

flow(σ, t)

0.622 + 0.783·x

N

1.000

Rescaling x by 1/√|σ| reduces every σ to −1, 0 or +1: only the sign matters. Each figure multiplies the whole plane by a norm-1 element, continuously in t. Gold curves are the level sets of N; every point stays on its own.

§σ = −1: rotation

t

0.500

Play

flow(σ, t)

0.878 + 0.479·x

red point

1.077 + 1.158·x

its N

2.500

x² = −1: the complex numbers. Norm-1 elements are cos t + x·sin t (cos, sin), the level sets are circles, and multiplication rotates. Every non-zero element is invertible: a field.

§σ = 0: shear

t

0.500

Play

flow(σ, t)

1.000 + 0.500·x

red point

1.500 + 1.250·x

its N

2.250

x² = 0: the dual numbers. Norm-1 elements are 1 + t·x, sending (a, b) to (a, b + t·a): a shear along the vertical level lines a = const. Because x·x = 0, putting a + x into a polynomial f gives an exact result with two parts:

For example, with f(y) = y·y: (3 + x)(3 + x) = 9 + 6x, and 6 is the slope of y·y at 3. This is forward-mode automatic differentiation.

§σ = +1: squeeze

t

0.500

Play

flow(σ, t)

1.128 + 0.521·x

red point

1.952 + 1.345·x

its N

2.000

x² = +1: the split-complex numbers. Norm-1 elements are cosh t + x·sinh t (cosh, sinh); points slide along hyperbolas and the diagonals stretch by eᵗ and e⁻ᵗ (eᵗ): a squeeze, the Lorentz boost of 1+1-dimensional relativity with rapidity t.

For σ ≥ 0 the diagonals themselves have N = 0, and a non-zero element with N = 0 is a zero divisor:

u

0.600

multiplier

1.000 + 0.600·x

N = area scale

0.640

Each factor flattens the plane onto a line, and the second sends the first one's line to the origin.

Found separately: ℂ by Bombelli (1572) and Gauss (1831), split-complex numbers by Cockle (1849), dual numbers by Clifford (1873).

§Only three

p

0.500

q

1.000

σ = p + q²/4

0.750

real roots

2

face

hyperbolic

Every number system made of pairs, with a 1 that changes nothing, is one of the three (classification). Take any element w that is not a plain number. With only two slots, w·w has to be made of 1 and w, so w·w = p + q·w for some numbers p and q. Sliding w by half of q removes the w part:

This is completing the square, the same step as in the school formula for quadratics. The sign of σ fixes how many real roots λ·λ − q·λ − p has (two, one or none), and that is the number of null lines.

§The flow

Ellipticx² = −1Parabolicx² = 0Hyperbolicx² = +1

s

0.900

t

0.600

red area

0.450

gold area

0.300

z · w

0.071 + 0.997·x

flow(σ, s + t)

0.071 + 0.997·x

The point flow(σ, t) runs along the gold curve from 1, and the line from the centre to it sweeps out area at a steady rate. Writing the point as (C, S):

Multiplying by flow(σ, s) rotates, shears or squeezes the region swept by flow(σ, t) so that it starts where the first one ends. The two statements

are what the figure shows. So moving along the flow is a one-parameter group: every step is the same multiplication, and at the start that multiplication is by x. It is defined by two rates of change (derivatives):

One formula covers all three rows. Each of C and S is an endless sum of simple pieces, a power series:

The numbers underneath are 2 = 1·2, 6 = 1·2·3, 24 = 1·2·3·4 and so on, written k! ("k factorial"). With Σ meaning "add up all of these", the same two sums read:

Put σ = −1 and the sums are cos t and sin t. Put σ = +1 and they are cosh t and sinh t. Put σ = 0 and every piece after the first vanishes, leaving 1 and t. Nothing in the sums divides by σ or takes its square root, so they change smoothly as σ passes through zero (they are analytic in σ). The σ slider in the first figure shows it: the circle opens through the parallel lines into the hyperbola without a jump.

§Periodic flows

13/22/5√2

ω

1.500

closes

after 2 turns

Only the elliptic flow returns (flow_returns_iff_disc_neg). Two independent elliptic flows are a point on a torus; the path closes iff the ratio of their rates is rational, and is dense otherwise.

C and S depend on σ only through σt², so σ ↦ −σ is t ↦ it up to a factor i on S: Wick rotation. The closing of the elliptic flow is the periodicity in imaginary time that thermal field theory reads as a temperature.

§From numbers back to rules

We've used numbers to see what the multiplication does. There is another question underneath it: how do we build numbers, choices and computation out of rules? This next part follows that route. The applications come after it.

§From nothing

Place a pointEmpty it

now

the point is 0; one ring, chosen as the unit of distance, is 1

distance of the moving point

1.000

Start with nothing: no numbers, no rules, no things. Picture it as a blank plane, the bulk everything else happens in. With nothing in it, every place and every direction looks the same.

Put down one point. Now there is one difference, and one thing becomes measurable: how far a place is from the point. One point has no direction, so distance is the same all the way round, and the only shapes it defines are circles around it.

That's the elliptic face (σ = −1) of the algebra we've just used, where a point's size is its squared distance from the centre. The only motion that keeps distance is turning: the moving point in the figure, the elliptic flow(σ, t).

The point is 0, the one place at distance zero. Pick one ring as the unit of distance and that's 1. They are the only ordinary numbers that don't change when multiplied by themselves (x·x = x).

§Where x·x = x splits

Boole's rule x·x = x has two solutions in ordinary numbers, 0 and 1. On one number line, logic only has yes and no.

In a two-slot algebra it depends on the face. On the elliptic face (σ < 0), 0 and 1 are still the only solutions. On the hyperbolic face (σ > 0) there are two more, the diagonal projectors e_+ and e_-.

Benjamin Peirce (1870) showed they split the algebra into two independent channels, the Peirce decomposition:

the_razor in Apeiron's DotToTorus.lean collects three facts about them:

1. The product is zero: e_+ · e_- = 0 (null_times_mirror).
2. The pairing is not: ⟨e_+, e_-⟩ = 2 under the hyperbolic metric (nNull_pairing). Multiplying erases them; the metric still tells them apart.
3. The sum is one: e_+ + e_- = 1 (arms_sum_to_unit).

So every point is a pair of independent channels, (u, v) = u·e_+ + v·e_-. Multiplying by e_+ keeps the first and zeroes the second, (u·e_+ + v·e_-)·e_+ = u·e_+ (proj_keeps_first_channel), and multiplying by e_- keeps v. That is linear projection.

Projection is not the combinator K. Projection drops one coordinate of a vector; K drops a whole argument, and no bilinear product over ℝ can do that: bilinearity forces (K·a)·0 = 0, so K·a·b = a would make every a zero. Apeiron proves the meet cannot host K (idem_no_K and no_K_of_comm_assoc in Implicative.lean): no commutative, associative operation has a discarding combinator over arbitrary terms.

So universal computation lives in a separate term-rewriting calculus (Substrate/Ski/TermCore.lean), where application builds a tree instead of multiplying. The algebra gives the two channels and projection; the calculus gives evaluation.

§One rule

I x

I x → xK a b → aS f g x → f x (g x)S K K x → xS K K (I x) → x

StepPlayResetSpeed 0.5×1×2×

Press Step to follow the highlighted rewrite.

steps

0

next rule

I hands back what it is given

A combinator is a rule for rearranging whatever it is given. It holds no numbers. Writing two things side by side, f x, means "give x to f" (f x), and each fork in the tree means the same thing. Two rules are enough for any computation (Schönfinkel, 1924):

ι ι x

ι ι xι (ι (ι ι)) a bι (ι (ι (ι ι))) f g xι (ι ι) a b

StepPlayResetSpeed 0.5×1×2×

Press Step to follow the highlighted rewrite.

steps

0

next rule

ι hands what it is given S and K

K keeps; S shares. Chris Barker found in 2001 that a single rule produces both, ι:

Given to itself, ι behaves as the do-nothing rule I; three deep it behaves as K, and four deep as S. Step runs one → at a time. In Apeiron these are iota_is_I, iota_is_K and iota_is_S.

§Pairs and choices

S (S I (K a)) (K b) K

pair a b, then Kpair a b, then K Iι Kι (K I)

StepPlayResetSpeed 0.5×1×2×

Press Step to follow the highlighted rewrite.

steps

0

next rule

S gives the last to both, then applies

The smallest structure is a pair: it holds two things and hands both, in order, to whatever it meets.

Given K, a pair answers with its first thing; given K I, its second. K and K I are yes and no, so reading a pair is a choice. ι itself is the pair holding S and K (iota_eq_pack, true by definition).

§Counting

K I f x

0 f x1 f x2 f x3 f x

StepPlayResetSpeed 0.5×1×2×

Press Step to follow the highlighted rewrite.

steps

0

next rule

K keeps the first and drops the second

Counting is doing something again. The number n is the rule that, given f and x, applies f to x n times. Numbers need nothing but S and K: 0 = K I, and "one more" is S (S (K S) K).

One rule gives a pair, a choice and counting. Combinators, Church's λ-calculus and Turing's machines compute the same functions (Turing, 1937).

§The machine has limits

Combinatory logic describes rules without committing to a particular machine. A physical computer has a finite amount of memory and a finite amount of time. I want the model of a programme to include those limits, so the implementation has to account for the space and work it uses.

§CSS

WRITING

Ellipticx² = −1Parabolicx² = 0Hyperbolicx² = +1

t

−0.240

contents multiplied by flow(σ, −t)

panel

matrix(1,0,-0.24,1,0,0)

contents

matrix(1,0,0.24,1,0,0)

product

matrix(1,0,0,1,0,0)

A CSS matrix() is the same 2×2 map. With the screen x axis carrying b and the y axis carrying a, multiplication by (C, S) is matrix(C, σS, S, C, 0, 0). From src/algebra/cell.ts:

export const mul = (s: Sigma, [a, b]: Cell, [c, d]: Cell): Cell =>
  [a * c + s * b * d, a * d + b * c];

export const norm = (s: Sigma, [a, b]: Cell): number => a * a - s * b * b;

export const flow = (s: Sigma, t: number): Cell => {
  const r = Math.sqrt(Math.abs(s));
  return s < 0 ? [Math.cos(r * t), Math.sin(r * t) / r]
    : s > 0 ? [Math.cosh(r * t), Math.sinh(r * t) / r]
    : [1, t];
};

export const act = (s: Sigma, [c, sn]: Cell): string =>
  `matrix(${fx(c)},${fx(s * sn)},${fx(sn)},${fx(c)},0,0)`;

fx rounds to four places. On this site: σ = 0, t = −0.24 for every panel, tab and tag, with contents at flow(0, +0.24), the inverse; σ = −1, |t| ≤ 0.08 for the letters of the name; σ = +1, t = 0.03 for card hover. src/algebra/algebra.test.ts checks the laws above at seven values of σ; the Lean statements in Apeiron are normForm_mul, normForm_flow, flow_add and flow_returns_iff_disc_neg.

§Why this matters

§Machines that do not fit in the universe

log₁₀ bits

40

bits on the tape

10⁴⁰

smallest region

7.6e-16 m

light across it and back

5.1e-24 s

fits inside the horizon

yes

A universal Turing machine has an unbounded tape (Turing, 1936). Physical memory does not. The information a region can hold is bounded by its surface area, the holographic bound (Bekenstein, 1981; 't Hooft, 1993; Susskind, 1995), and reaching a cell at distance R takes at least R/c. Lloyd (2000) works out the resulting limits on speed and memory for a 1 kg computer.

§The valid program cone

Numbers fit1.0 ≤ x ≤ 1.2 Contradiction2.5 ≤ x ≤ 0.8

Step

4

interval [lo, hi]

[1.000, 1.200]

Does a number fit?

1.1 satisfies every bound.

Requirement

Choose x = 1.1: it meets all three requirements.

Suppose a value must be at least 1 and at most 1.2. We can choose 1.1. Now suppose it must be at least 2.5 and at most 0.8. No number can do both. The lower and upper bounds have crossed.

Song gen2 used this kind of bound propagation as part of its decider. Each pair of bounds can be drawn as a point in the plane. The diagonal lo = hi separates intervals that contain numbers from intervals that don't.

That diagonal is different from the null axes. In null coordinates the norm is lo·hi, which vanishes when either coordinate is zero. The contradictory pair (2.5, 0.8) has positive norm, 2.0. Its problem is the ordering of its bounds.

This example uses one variable. A real checker also has to establish that its constraints describe the programme being checked. Running out of checking time is not evidence that a programme is safe or impossible.

§Unbounded memory in practice

Song gen2sandbox layoutRustchecked writeCunchecked write

bytes

11

result

bytes 8–10 land beyond the payload, inside the sandbox; masking alone does not make that safe

An unchecked C write can go past its buffer and corrupt neighbouring data, which can include the return address (Aleph One, 1996). About 70% of the vulnerabilities Microsoft fixes and assigns a CVE are memory-safety bugs (MSRC, 2019).

Safe Rust checks bounds at run time and rules out aliasing mistakes at compile time, but an out-of-bounds index still panic!s ; .get() lets the programme handle a missing element instead.

Song gen2 used Software Fault Isolation (SFI; Wahbe et al., 1993): an address was masked to b + (index & (2ᴷ − 1)) to select a location inside a power-of-two sandbox. Its wrapped-access design used a 3-buffer staging ring (buffer 0 payload, buffer 1 staging, buffer 2 sink), with faults recorded for inspection. That addressing rule alone does not establish authority over the whole accessed range. Gen3 carries extent, authority, initialisation and preservation through actual machine accesses as proof obligations. The register-only multiplication slice below does not yet establish buffer or kernel isolation.

The references are seL4 (Klein et al., 2009) and CHERI (Watson et al., 2015; 2020). Their results concern their own implementations and assumptions; Song's corresponding obligations need their own proofs.

Apeiron and Song pass σ explicitly to every operation, so whether a quantity rotates (bounded, periodic), shears, or grows and decays is fixed by the system, not by accident of the code.

§Physics

• Contraction. Lohmiller and Slotine (1998): if a system's update shrinks the distance between any two states, it forgets its initial conditions exponentially fast. On the elliptic face (σ = −1), N(z) = a² + b² is the squared Euclidean length, so multiplying by an element with N < 1 is a strict contraction. For σ ≥ 0, N is not a length, and contraction needs the Euclidean operator norm below 1. See the last figure.
• The quadratic window. Apeiron's Lean work follows Lohmiller and Slotine (2024), who argued the Schrödinger equation can be solved from classical action, and the exchange with Vattay (2026) (reply). The physical reading is still argued over. The maths underneath is a clean theorem: the semiclassical Van Vleck propagator is exact if and only if the Hamiltonian is at most quadratic in position and momentum. Quadratic Hamiltonians generate sl(2, ℝ), whose one-parameter subgroups are elliptic, parabolic or hyperbolic. This algebra classifies what is inside that window, where the classical and quantum descriptions agree.
• Holography. The half-planes over the three faces are the Poincaré half-plane (hyperbolic geometry, despite the names), the Galilean plane and the Minkowski plane (Yaglom, 1979; Kisil, 2005). In the Poincaré half-plane the Ryu–Takayanagi formula (2006) reads a boundary region's entanglement from a bulk geodesic, and that bulk can be made discrete (Gubser et al., 2016; Heydeman, Marcolli and Saberi, 2016). Apeiron's discrete bulk has the same shape; it gets its own post.
• Predictions. Cosmological predictions from the discrete bulk are pre-registered with explicit kill conditions (Zenodo, 2026), including constraints on a normal neutrino mass hierarchy checked against the current dynamical dark-energy parameters (w_0, w_a).

§AI

tokens

0

Play

attention memory

0 entries

SSM memory

16 entries

work for the next token

attention ∝ n, SSM constant

Attention (Vaswani et al., 2017) keeps every past token, so memory grows with the context and so does the work per token: the unbounded tape again, inside the model. Linear attention (Katharopoulos et al., 2020) rewrote it as a recurrence with a fixed-size state. Structured state space models (Gu, Goel and Ré, 2021; Gu and Dao, 2023) and Mamba-2's state space duality (Dao and Gu, 2024) made that competitive, and DeltaNet (Yang et al., 2024; 2024b) made the update a step of online regression, the fast-weight view of Schlag, Irie and Schmidhuber (2021).

λ

0.900

θ

0.350

step

40

distance between states

λᵏ · starting distance

Mamba-3 (Lahoti et al., 2026) makes the state complex-valued and proves the update equivalent to a data-dependent rotary embedding (Su et al., 2021). In this algebra each state pair is updated by

a rotation on the elliptic face, shrunk by λ. With λ < 1 its norm is below 1 and the update is a contraction: two states fed the same tokens converge, which is Lohmiller–Slotine stability applied to memory.

§What I work on

The same object turns up in security (bounded memory, capability boundaries), compilers and operating systems (Song), physics (the quadratic window, holography), simulation (world generation, fluids and weather, artificial life) and AI (state updates as flows). The engineering targets are a growable table to replace std::collections::HashMap and hashbrown, and a Rust training and inference stack on SPIR-V and Vulkan instead of CUDA and PyTorch.

Each operation has to do what its Lean definition says. Charon and Aeneas carry Apeiron's Rust into Lean so the two can be checked against each other. Song generates its own native code. A kernel that is fast but unproven, or proven but slow, does not pass.

§Song gen3 and Iota

In the transition from Song gen2 to gen3 I renamed the language from Slang to Iota, after learning that Slang was already a shader language. Iota takes its name from the combinator introduced above.

Gen3 carries the proof down to assembly and the bytes the processor executes. For the first example, cell multiplication, the proof follows the operation through the generated instructions and their bytes. seL4 proves from a specification through C and, on supported platforms, to the binary. Song builds its instruction generator into that chain.

Gen2's checked Ring 0 foundation stopped above its unverified assembly core. Gen3 brings native instruction generation into that foundation too. Song's rings show how the libraries, applications and interfaces build on it.

The rest of the compiler and operating system is ahead.

For the measured results behind this work, I’ve put together a results page with the records and their conditions.