One multiplication, three geometries

This post introduces the mathematical substrate underlying all the systems I build: the two-slot algebra ℝ[x]/(x² − σ), its three geometries, and the bounded state spaces they support.

After leaving my role as an application security engineer at EnergyAustralia to pursue independent systems research, I started by building Scribe: an AI roleplaying platform intended to embed intelligent minds into video games. The initial approach was classical software engineering: test-driven development, zero-trust security boundaries, OWASP test suites, and a custom native platform in Rust, Svelte and Tauri. But local open-weight models were unable to deliver the required reasoning quality, and cloud API inference costs were economically impossible without raising external venture funding, which I declined.

That economic and architectural constraint forced a deeper study of model architectures: moving past standard quadratic attention to state space models (Mamba-2 and Mamba-3, DeltaNet), test-time training (TTT), and recurrent attention (TITANS, ATLAS, Miras). Linking the Hamilton-Jacobi equation and Madelung fluid equations through Slotine-Lohmiller contraction theory and Vattay's discourse on the semiclassical quadratic window suggested an underlying spinor topology. My initial hypothesis was optimistic: "make an LLM, but hashmaps all the way down." In prototypes (such as spinor-ttl), accumulating normal equations U = X^T X, B = X^T y into a sparse count table solved linear ridge heads in closed form on GPU, delivering 16 to 71 times speedups over iterative Adam without optimizer state or hyperparameter sweeps. But while the linear solve was fast, hashmaps alone could not produce deep non-linear reasoning. Reaching that required doing first-principles mathematics rather than telling an empirical model to go faster.

Formalizing these structures in Lean 4 revealed that what I had previously treated as an isolated "null cell" was in fact the hyperbolic face of a classical quadratic trichotomy: ℝ[x]/(x² − σ), spanning elliptic (σ < 0), parabolic (σ = 0) and hyperbolic (σ > 0) geometries. That unified foundation prompted a clean split into two repositories: Apeiron, containing canonical Lean 4 definitions, verified Rust primitives extracted via Charon and Aeneas, and zero-allocation growable tables; and Song, an independent assembly-up operating system kernel eliminating LLVM dependencies, verified via Slang contracts.

Each of those systems (Penglai fluid simulation, Whispering Tides world generation, the Song capability kernel, Apeiron verified tables, and SPIR-V neural inference) gets its own dedicated engineering post. This article establishes the shared mathematical basis from first principles, assuming only arithmetic and English.

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

σ

face

elliptic

σ

−1.000

flow(σ, t)

0.622 + 0.783·x

N

1.000

§Challenging the floor of computer science

Computer science has spent decades abstracted away from physical reality, treating discrete mathematics and ZFC set theory as an unquestioned floor. In ZFC, everything is built upward from the empty set ∅. But in operational foundations, computation begins with active reduction rather than static elements: in combinatory logic, the primitive is Barker's single combinator ι, which applied to itself evaluates directly to the identity rule (ι ι ↠ I). In Apeiron (DotToTorus.lean:the_razor), this maps directly to the geometry of the null cone: the two lightlike rays have zero norm and multiply to zero under the split product, yet their metric pairing preserves an ineliminable non-zero distinction (⟨e_+, e_-⟩ = 2), while their sum recomposes the unit identity (e_+ + e_- = 1).

A second unexamined assumption is the Universal Turing machine. Turing's 1936 mathematical model assumes an unbounded tape. But an unbounded tape cannot physically exist in our universe: the holographic bound limits the information of any spatial region by its surface area, and signal propagation is capped by the speed of light. Modern computer science canonized the earliest discrete abstractions of its founders. Yet Alan Turing and John von Neumann recognized the limits of discrete machines: Turing investigated continuous non-linear reaction-diffusion systems in biological morphogenesis (1952), and von Neumann developed continuous geometry and operator algebras with Murray (1936–1943) before analyzing dynamical cellular automata (1966). Physical computation is bounded, continuous and dynamical.

Building software on a bounded algebra treats computers as finite state systems operating within physical metric invariants, where bounds are derivations of the algebra rather than arbitrary limits.

§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. The emptiest picture of that is a blank plane, the bulk everything else will happen in. With nothing in it, every place is like every other and every direction is like every other.

Put down one point. Now there is exactly one difference, here and not here, and exactly one thing becomes measurable: how far any place is from the point. With a single point there is still no special direction, so that distance is the same all the way round. Everything that can be said is said in circles around the point.

That is the elliptic face (σ = −1) of the algebra built below, where the size of a point is its squared distance from the centre. It comes first because it is what one point in empty space defines. The only motion that keeps a distance is turning, which is the moving point in the figure: the elliptic flow(σ, t).

The point itself is 0, the one place at distance zero. Choose one ring as the unit of distance and it is 1. These first two numbers have a property no other scalar number has: multiplied by themselves, they do not change (x·x = x).

§How one rule emerges from the trichotomy

Boole's rule x·x = x has only two solutions in ordinary numbers: 0 and 1. On a single number line, logic can only distinguish yes from no.

In a two-slot algebra, this rule splits. On the elliptic face (σ < 0), 0 and 1 remain the only solutions. But on the hyperbolic face (σ > 0), two new non-trivial elements satisfy x·x = x: the diagonal projectors e_+ and e_-.

In 1870, Benjamin Peirce showed that these two elements decompose the algebra into independent, orthogonal channels, the Peirce decomposition:

Under hyperbolic geometry, these two projectors satisfy three properties (the_razor in Apeiron's DotToTorus.lean):

1. Multiplication annihilates to zero: e_+ · e_- = 0 (null_times_mirror, the_razor). Composed under the split product, the two channels extinguish each other.
2. Metric pairing preserves distinction: Under the hyperbolic metric pairing, ⟨e_+, e_-⟩ = 2 ≠ 0 (nNull_pairing, the_razor). The same two null arms retain a non-zero metric invariant that multiplication cannot erase.
3. Summation recomposes the identity: e_+ + e_- = 1 (arms_sum_to_unit, the_razor), reconstructing the unit.

That split turns every point into an independent pair of channels: (u, v) = u·e_+ + v·e_-. Multiplying a state vector by e_+ projects onto the first channel and annihilates the second: (u·e_+ + v·e_-)·e_+ = u·e_+. This is linear projection: keeping one channel and discarding the other (proj_keeps_first_channel). Multiplying by e_- keeps v.

It is essential to distinguish linear projection from universal combinatory logic. A linear projection discards an orthogonal coordinate in a state vector. But in any bilinear algebra over ℝ, the algebra product itself cannot act as a universal discarding combinator K: bilinearity forces (K·a)·0 = 0, so K·a·b = a would force a = 0 for all a. Indeed, Apeiron's Lean corpus formally proves that the algebraic meet cannot host K (idem_no_K and no_K_of_comm_assoc in Implicative.lean): no commutative, associative operation can admit a discarding combinator across arbitrary terms.

Universal computation therefore lives in an autonomous term-rewriting calculus (Substrate/Ski/TermCore.lean), where combinator application is syntactic tree application rather than linear multiplication. There, two operational primitives suffice: keeping the first argument (K a b → a) and distributing an argument across two branches (S f g x → f x (g x)). Chris Barker (2001) showed that packing these two actions into a single two-slot pair ι = (S, K) generates every computable function (iota = pack S K). Handing ι an operand x evaluates to x S K, routing the operand to choose or distribute between retaining constants (K) and branching (S). The algebra provides the two-channel routing geometry and state-vector projection; the combinator calculus provides the discrete 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. Press Step to watch each → fire with an animated transition. In Apeiron's Lean corpus 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 has given a difference, a pair, a choice and counting. Combinators, Church's λ-calculus and Turing's machines compute exactly the same things (Turing, 1937).

§From counting to the plane

§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). That is the same two-slot shape as the pair above, now holding numbers. On this site it is written

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 and the centre stays put: the square becomes a slanted box. That is all multiplication by z does, 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 and do not mirror, and together they form a group. Everything below is about that group.

§Faces

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

Pause

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

Pause

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

Pause

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). One construction, three geometries.

§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: the point never leaves the curve, and swept areas add. So moving along the flow is a one-parameter group: every step is the same multiplication, and at the very 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.

§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

The algebra is not an abstract exercise; it directly addresses core engineering limits in security, OS verification, physical simulation and machine learning.

§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

Verifiedstays on cone (SAT) Refutedleaves cone (UNSAT)

fuel step

4

interval [lo, hi]

[1.000, 1.200]

norm N = lo·hi

1.200

prover status

INSIDE CONE: SAT (feasible invariant)

step detail

fixed point on cone: SAT model witness found

A program is a trajectory through a state space. In Song's decider (ncone0.slang), each variable's feasible interval [lo, hi] is mapped to the split-complex plane in null coordinates: (lower, upper) = (lo, hi).

Under these coordinates, the split norm is N(z) = lo · hi, with null axes along lo = 0 and hi = 0. Feasible intervals lie in the positive cone of the interval lattice: lo ≤ hi. As linear inequalities tighten, interval bounds propagate toward a fixed point inside this feasible cone.

If a specification or state transition violates an invariant, the bounds cross: lo > hi. The interval enters Kaucher's improper interval space (Kaucher, 1973; IEEE 1788-2015). In Song, this crossing marks an immediate refutation: bound propagation coupled with Fourier-Motzkin elimination produces an exact Farkas certificate (certcheck.slang) proving no valid state exists.

Rather than inheriting the undecidable halting problem of an imaginary infinite tape, a bounded systems architecture circumvents it: execution fuel is the finite metric diameter of the state space dictated by physical memory. A program designed within its algebraic invariant stays on the cone; bounding fuel verifies whether the trajectory remains confined within that physical envelope.

§Unbounded memory in practice

Song3-buffer ringRustruntime abortCstack smash

bytes

11

result

isolated to staging ring: bytes 8–10 captured in buffers 1–2; capability fault stamped, control untouched, cleanly reversible

C inherits the unbounded model: memory is one long line of bytes and a pointer can move anywhere along it. Writing past a buffer overwrites what comes next, on the stack 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 eliminates aliasing mistakes at compile time, but an unhandled out-of-bounds index triggers a process-aborting panic! by default unless guarded by .get() or unwound.

Song confines buffer access by construction using Software Fault Isolation (SFI; Wahbe et al., 1993): an address is masked as b + (index & (2ᴷ − 1)), structurally preventing a pointer from addressing memory outside its power-of-two sandbox. Wrapped access is routed through a 3-buffer staging ring (Buffer 0 payload, Buffer 1 staging, Buffer 2 sink). Drawing on the capability traditions of seL4 (Klein et al., 2009) and CHERI (Watson et al., 2015; 2020), Song records the fault into a capability register while keeping control flow intact, making boundary violations inspectable and recoverable without process aborts or memory corruption.

Apeiron and Song carry σ as an explicit parameter in every operation, so whether a quantity rotates (bounded and periodic), shears, or grows and decays is an invariant of the system rather than an accident of the code. That is the sense in which the substrate respects the same limits as the machine it runs on.

§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), the algebraic norm N(z) = a² + b² is the squared Euclidean norm, so multiplication by an element with N < 1 is a strict contraction. (On indefinite faces σ ≥ 0, contraction requires the Euclidean operator norm to be strictly bounded below 1). See the last figure.
• The quadratic window. Apeiron's Lean formalization engaged with Lohmiller and Slotine (2024), who argued the Schrödinger equation can be solved from classical action, and the subsequent dialogue with [Vattay (2026)](https://arxiv.org/abs/2605.02621; reply). While the physical interpretations remain active in the literature, the mathematical foundation turns on 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 coincide.
• 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. Falsifiable cosmological predictions derived from the discrete bulk algebra are pre-registered with explicit kill conditions (Zenodo, 2026), including normal neutrino mass hierarchy constraints evaluated against current dynamical dark-energy parameters (w_0, w_a).

§AI

tokens

0

Pause

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 concrete: a zero-allocation growable hash table to replace std::collections::HashMap and hashbrown, and a Rust training and inference stack on SPIR-V and Vulkan rather than CUDA and PyTorch.

Every piece runs as Rust (Apeiron) or Slang (Song) and is checked against one canonical Lean definition by a refinement proof. Charon and Aeneas carry the Rust into Lean, Song's prover discharges Slang contracts, and the Lean corpus holds the theorems. A kernel that is fast but unproven, or proven but slow, does not pass. Each of these gets its own post.