--- title: One multiplication, three geometries searchTitle: Complex, dual and split-complex numbers description: Complex, dual and split-complex numbers through one multiplication rule. Interactive figures show rotations, shears and squeezes, with links to Lean proofs. date: 2026-09-28 updated: 2026-10-04 tags: [algebra, design, verification, ai] --- 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](#song-gen3-and-iota) 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 :::line 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|real numbers]]: one number for every point of a line. ### A point is a pair of numbers :::point 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 ```math a + b·x say: a plus b x means: a in the first slot, b in the second; x only marks which slot b is in apeiron: Cell word representation in src/cell.rs and RingCell in AnyRing.lean physics: state pair coordinates in phase space or 1+1 spacetime ``` Adding two points adds slot to slot, which is walking one arrow and then the other: ```math (a + b·x) + (c + d·x) = (a + c) + (b + d)·x say: a plus b x, plus c plus d x, equals a plus c, plus b plus d times x means: add the firsts together and the seconds together apeiron: Cell::add in src/cell.rs, verified by AnyRing.ringAdd physics: superposition of linear states or vector translation ``` ### 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 [[times|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 [[sigma]] and declare $x·x = σ$ ($x$ [[square|squared]] is σ). Worked with σ = −1: ```math (2 + 3x)(1 + 4x) = 2 + 8x + 3x + 12·x·x = 2 + 11x − 12 = −10 + 11x say: two plus three x, times one plus four x, equals minus ten plus eleven x means: multiply every part by every part, then replace x times x by σ, here minus one apeiron: concrete evaluation of Cell multiplication on the elliptic face physics: complex multiplication in the Argand plane ``` and in general ```math (a + b·x)(c + d·x) = (ac + σbd) + (ad + bc)·x say: a plus b x, times c plus d x, equals a c plus sigma b d, plus (a d plus b c) x means: the first slot of the answer collects the plain products; the second collects the ones with one x apeiron: word_mul_denote extracted from src/cell.rs, proved as AnyRing.ringMul physics: the quadratic extension classifying elliptic, parabolic, and hyperbolic metric algebras ``` Order and grouping do not matter, and $1 + 0·x$ changes nothing. This is the algebra [[cell]]; the formula is forced by $x·x = σ$ rather than chosen (`mul_eq_quotient_mul`). ## Multiplication as a map :::area -1 Fix one point $z$ and multiply every point of [[plane|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: ```math N(z) = a² − σb² say: N of z equals a squared minus sigma b squared means: how many times bigger or smaller multiplying by z makes every area apeiron: ringNormForm in AnyRing.lean; certifies Table coordinate admission and zero-divisor avoidance physics: invariant Minkowski interval s² = c²t² − x² and quantum probability norm conservation ``` That is the [[norm|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 ```math N(zw) = N(z)·N(w) say: N of z w equals N of z times N of w means: scaling area twice is scaling by the product of the two scales apeiron: ringNormForm_mul in AnyRing.lean, proved in Lean 4 physics: composition of Lorentz boosts and area preservation in symplectic phase space ``` The elements with $N = 1$ keep every area without mirroring, and they form a [[group]]. ## Faces :::dial -1 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-set|level sets]] of $N$; every point stays on its own. ### σ = −1: rotation :::act -1 $x² = −1$: the [[complex-numbers|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 :::act 0 $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: ```math f(a + x) = f(a) + f′(a)·x say: f of a plus x equals f of a, plus f prime of a, times x means: the first slot is the formula's value at a; the second is its slope there apeiron: exact dual-number autodiff in fluid boundary solvers without numerical truncation physics: Galilean boost and classical Hamilton-Jacobi phase flow ``` 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 [[autodiff]]. ### σ = +1: squeeze :::act 1 $x² = +1$: the [[split-complex]]. Norm-1 elements are $cosh t + x·sinh t$ ([[cosh-sinh]]); points slide along hyperbolas and the diagonals stretch by $eᵗ$ and $e⁻ᵗ$ ([[exponential]]): a [[squeeze]], the [[lorentz-boost|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]]: :::collapse ```math (1 + x)(1 − x) = 1 − x·x = 1 − 1 = 0 say: one plus x, times one minus x, equals one minus x times x, which is one minus one, which is zero means: two things that are not zero multiply to zero; this can only happen when σ is zero or above apeiron: two-channel orthogonal expert routing in sparse attention (Nous/Seq/TwoChannelRouter.lean) physics: lightcone boundary of Minkowski spacetime; null trajectories at the speed of light ``` Each factor flattens the plane onto a line, and the second sends the first one's line to the origin. | σ | algebra | N = 1 | N = 0, z ≠ 0 | norm-1 action | |---|---|---|---|---| | −1 | [[complex-numbers]] | circle | none | rotation | | 0 | [[dual-numbers]] | lines $a = ±1$ | the $b$-axis | [[shear]] | | +1 | [[split-complex]] | hyperbola | lines $b = ±a$ | [[squeeze]] | Found separately: [[complex-numbers]] by Bombelli (1572) and Gauss (1831), [[split-complex]] by Cockle (1849), [[dual-numbers]] by Clifford (1873). ### Only three :::roots 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: ```math w·w = p + q·w, x = w − q/2, x·x = p + q²/4 = σ say: w times w is p plus q w; let x be w minus q over two; then x times x is p plus q squared over four, and that number is sigma means: any two-slot number system can be shifted so that its extra symbol squares to a plain number apeiron: rootsParts classification in Trichotomy.Roots physics: discriminant classification of quadratic dispersion relations ``` This is completing the square, the same step as in the school formula for quadratics. The sign of σ fixes how many [[root|real roots]] $λ·λ − q·λ − p$ has (two, one or none), and that is the number of null lines. ## The flow :::compose -1 The point [[flow]] 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)$: ```math d(area)/dt = ½·(C·S′ − S·C′) = ½·(C·C − σ·S·S) = ½·N = ½ say: the rate the area grows equals one half of (C times S prime, minus S times C prime), which is one half of N, which is one half means: in each small moment the line sweeps a thin triangle; its area always grows at half a unit per unit of t apeiron: area rate invariance across all three faces physics: conservation of symplectic 2-form area in Hamiltonian phase flows ``` 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 ```math N(flow(σ, t)) = 1 flow(σ, s) · flow(σ, t) = flow(σ, s + t) say: N of flow sigma t is one; flow sigma s times flow sigma t is flow sigma s plus t means: the point never leaves the size-one curve, and sweeping s then t sweeps s + t apeiron: normForm_flow and flow_add in Trichotomy.Flow physics: one-parameter group property of dynamical evolutions ``` 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 ([[derivative|derivatives]]): ```math C′ = σ·S, S′ = C, (C, S)(0) = (1, 0) say: C prime is sigma S, S prime is C, starting from one, zero means: the first slot changes at σ times the second, the second changes at the first, starting at 1 apeiron: infinitesimal generator derivation of cell flows physics: Hamilton's canonical equations for quadratic Hamiltonians ``` | σ | flow(σ, t) | returns to 1 | |---|---|---| | −1 | $(cos t, sin t)$ | at t = 2π | | 0 | $(1, t)$ | never | | +1 | $(cosh t, sinh t)$ | never | One formula covers all three rows. Each of $C$ and $S$ is an endless sum of simple pieces, a [[power-series]]: ```math C = 1 + σ·t²/2 + σ²·t⁴/24 + σ³·t⁶/720 + … S = t + σ·t³/6 + σ²·t⁵/120 + σ³·t⁷/5040 + … say: C equals one, plus sigma t squared over two, plus sigma squared t to the fourth over twenty-four, and so on; S equals t, plus sigma t cubed over six, plus sigma squared t to the fifth over one hundred and twenty, and so on means: every piece is a power of σ times a power of t divided by a fixed number, and the pieces shrink fast apeiron: power series expansion in AnyRing.Flow physics: analytic continuation of evolution operators between Euclidean and Lorentzian time ``` 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: ```math C = Σ σᵏ·t²ᵏ / (2k)!, S = Σ σᵏ·t²ᵏ⁺¹ / (2k+1)! say: C is the sum, for k equals zero, one, two and on, of sigma to the k times t to the two k, over two k factorial; S is the same with two k plus one means: the two lines above, in short form apeiron: compact series notation for generalized trigonometric functions physics: analytic propagator kernel across all metric signatures ``` 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 :::torus 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 :::genesis 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]]. 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 ([[idempotent]]). ```math x·x = x say: x times x equals x means: true only for x = 0 and x = 1; George Boole (1847) took it as the law of yes and no apeiron: idempotent_iff_trivial_of_disc_nonpos in Apeiron.Trichotomy.Idempotents physics: single-channel projection and truth classification ``` ## 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_-$. ```math e_+ = (1 + x/√σ)/2 e_- = (1 - x/√σ)/2 say: e plus is 1 plus x over root sigma, all over 2; e minus is 1 minus x over root sigma, all over 2 means: two new idempotent elements (x·x = x) that exist only when σ > 0 apeiron: exists_nontrivial_idempotent_iff_disc_pos in Idempotents physics: projection operators along the two lightlike rays of the cone ``` Benjamin Peirce (1870) showed they split the algebra into two independent channels, the [[peirce-decomposition|Peirce decomposition]]: ```math e_+ · e_- = 0 e_+ + e_- = 1 say: e plus times e minus equals 0; e plus plus e minus equals 1 means: Benjamin Peirce (1870); multiplied they annihilate to zero, added they recompose the unit apeiron: complementary_idemPlus in Idempotents; the_razor in DotToTorus physics: resolution of identity into two uncoupled, mutually annihilating channels ``` `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 :::comb ski 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$" ([[application]]), and each fork in the tree means the same thing. Two rules are enough for any computation ([Schönfinkel, 1924](https://doi.org/10.1007/BF01448013)): ```math K a b → a say: K, given a and then b, becomes a means: keep the first thing, drop the second apeiron: capp_kCombinator on weighted routes; proj_keeps_first_channel in Projection.lean physics: projection onto an orthogonal idempotent subspace, discarding complementary states ``` ```math S f g x → f x (g x) say: S, given f, g and x, becomes f given x, given (g given x) means: hand x to both f and g, then hand g's answer to f's apeiron: routing bifurcation in BulkAlgebra and BulkTower; S_bulk in BulkInevitability.lean physics: branched distribution of conserved flux across two channels ``` :::comb iota [[k-comb|K]] keeps; [[s-comb|S]] shares. Chris Barker found in 2001 that a single rule produces both, [[iota|ι]]: ```math ι x → x S K say: iota, given x, becomes x given S and then K means: whatever ι is given, ι hands it S and K apeiron: iota_app in Combinator.Basic; iota_eq_pack in Combinator.Pair physics: self-routing bifurcation dispatching between constant retention and dual branching ``` Given to itself, ι behaves as the do-nothing rule [[i-comb|I]]; three deep it behaves as K, and four deep as S. Step runs one [[rewrite]] at a time. In Apeiron these are `iota_is_I`, `iota_is_K` and `iota_is_S`. ### Pairs and choices :::comb pair The smallest structure is a [[pack|pair]]: it holds two things and hands both, in order, to whatever it meets. ```math pair(a, b) m → m a b say: the pair of a and b, given m, becomes m given a and then b means: a pair is anything that passes its two contents on, first then second apeiron: pack constructor in Combinator.Pair; two-channel decomposition of hyperbolic cells physics: two-slot state vector decomposing into independent normal coordinates ``` 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 :::comb count Counting is doing something again. The [[church-numeral|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)$. ```math 2 f x → f (f x) say: two, given f and x, becomes f given (f given x) means: the number two is do it twice apeiron: Church numeral representation in Combinator.Basic physics: discrete iteration of a transfer map or dynamical step ``` One rule gives a pair, a choice and counting. Combinators, Church's λ-calculus and Turing's machines compute the same functions ([Turing, 1937](https://doi.org/10.2307/2268280)). ## 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 :::slab A CSS [[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`: ```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 :::tape A universal [[turing-machine]] has an unbounded tape ([Turing, 1936](https://doi.org/10.1112/plms/s2-42.1.230)). Physical memory does not. The information a region can hold is bounded by its surface area, the [[holographic-bound]] ([Bekenstein, 1981](https://doi.org/10.1103/PhysRevD.23.287); ['t Hooft, 1993](https://arxiv.org/abs/gr-qc/9310026); [Susskind, 1995](https://arxiv.org/abs/hep-th/9409089)), and reaching a cell at distance $R$ takes at least $R/c$. [Lloyd (2000)](https://arxiv.org/abs/quant-ph/9908043) works out the resulting limits on speed and memory for a 1 kg computer. ### The valid program cone :::cone 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 :::overflow An unchecked C write can go past its buffer and corrupt neighbouring data, which can include the [[return-address]] ([Aleph One, 1996](https://phrack.org/issues/49/14)). About 70% of the vulnerabilities Microsoft fixes and assigns a CVE are memory-safety bugs ([MSRC, 2019](https://www.microsoft.com/en-us/msrc/blog/2019/07/we-need-a-safer-systems-programming-language)). 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](https://doi.org/10.1145/168619.168635)): 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](https://doi.org/10.1145/1629575.1629596)) and CHERI ([Watson et al., 2015](https://doi.org/10.1109/SP.2015.9); [2020](https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-987.html)). 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)](https://doi.org/10.1016/S0005-1098(98)00019-3): 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)](https://arxiv.org/abs/2405.06328), who argued the Schrödinger equation can be solved from classical action, and the exchange with [Vattay (2026)](https://arxiv.org/abs/2605.02621) ([reply](https://arxiv.org/abs/2606.05197)). 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](https://arxiv.org/abs/math/0512416)). In the Poincaré half-plane the [[ryu-takayanagi]] formula ([2006](https://arxiv.org/abs/hep-th/0603001)) reads a boundary region's entanglement from a bulk geodesic, and that bulk can be made discrete ([Gubser et al., 2016](https://arxiv.org/abs/1605.01061); [Heydeman, Marcolli and Saberi, 2016](https://arxiv.org/abs/1605.07639)). 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](https://doi.org/10.5281/zenodo.20652109)), including constraints on a normal neutrino mass hierarchy checked against the current dynamical dark-energy parameters ($w_0, w_a$). ### AI :::memory [[attention]] ([Vaswani et al., 2017](https://arxiv.org/abs/1706.03762)) 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](https://arxiv.org/abs/2006.16236)) rewrote it as a recurrence with a fixed-size state. [[ssm|Structured state space models]] ([Gu, Goel and Ré, 2021](https://arxiv.org/abs/2111.00396); [Gu and Dao, 2023](https://arxiv.org/abs/2312.00752)) and Mamba-2's state space duality ([Dao and Gu, 2024](https://arxiv.org/abs/2405.21060)) made that competitive, and DeltaNet ([Yang et al., 2024](https://arxiv.org/abs/2406.06484); [2024b](https://arxiv.org/abs/2412.06464)) made the update a step of online regression, the fast-weight view of [Schlag, Irie and Schmidhuber (2021)](https://arxiv.org/abs/2102.11174). :::spiral Mamba-3 ([Lahoti et al., 2026](https://arxiv.org/abs/2603.15569)) makes the state complex-valued and proves the update equivalent to a data-dependent [[rope|rotary embedding]] ([Su et al., 2021](https://arxiv.org/abs/2104.09864)). In this algebra each state pair is updated by ```math h ← λ·flow(−1, θ)·h + input say: h becomes lambda times flow of minus one and theta, times h, plus the input means: each step, turn the state by angle θ, shrink it by the factor λ, then add the new token apeiron: Mamba-3 and DeltaNet rotary state updates; norm below 1 guarantees contractive forgetting physics: non-linear contraction analysis; convergence of open dissipative dynamical systems ``` 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|Lean]] definition says. [[aeneas|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](https://shader-slang.org/). 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](https://sel4.systems/Verification/proofs.html) 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](/work/song#the-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](/results).