This page sets the ring in motion: a cellular automaton whose cells hold values of a tower ring and update by a local rule, neighbor by neighbor. Two proved facts govern everything that can happen, and they cut opposite ways. A rule built from ring arithmetic can never make the channels interact — bad news for anything shaped like Conway's Game of Life, whose birth-and-death threshold is exactly an interaction. And the same isolation quarantines damage: draw the cell values from an error-correcting dictionary and the dynamics corrects itself — a corrupted cell snaps back, and correction can even wait, open loop, until readout — a mode the per-step checksum tax cannot match. Both demos below run on those two facts.
Build an update rule from the ring's own operations — add, multiply, constants; every power map included — and the rule is a polynomial. Polynomials act channel by channel, so the automaton is not one machine but k independent machines running side by side: the mod-p plane of the entire future depends on the mod-p plane of the initial state alone (proved). Nothing that happens mod 3 can ever reach the mod-5 plane.
And the converse holds: those products are all there is, and every one of them is reachable. Pick per-channel rules independently — one automaton on the mod-2 plane, an unrelated one mod 3, a third mod 5 — and the tuple is a single polynomial rule (build each channel's rule by interpolation inside its prime field, then glue the coefficients degree by degree through the Chinese Remainder Theorem; exact). Ring-built automata are exactly the products of arbitrary per-channel automata: proved, checked exhaustively over rule batteries on the two-channel ring Z/6 with three-cell neighborhoods, trajectory invariance verified at Z/30. One piece of fine print: the “every rule is a polynomial” leg needs a squarefree modulus — it fails already at Z/4.
Conway's Life is a threshold on a count of alive neighbors — and “alive” is a whole-cell question. A ring cell has a natural graded reading, how many of its channels it carries, but compressing that into a one-bit answer inside the ring is precisely the cross-channel question no polynomial computes (witness on Z/30: 25 and 15 agree in the mod-2 channel, yet 25 carries two channels and is alive while 15 carries one and is dead — no per-channel function can output both). Life on the ring is bought, not built.
The purchase is small, and the price is exact. The design menu: any number of free per-channel pre-reads (a support bit per channel, or any order gate), one bit-operation across the channel boundary, and a free in-ring mask afterwards (multiplying by an idempotent is ring arithmetic). What a crossing costs is measured in bits per cell-read: plain aliveness — does any channel carry? do all? — is 1 bit; the support grade, how many of k channels, is log₂(k+1); full size comparison is log₂ N. The content never crosses. Only quantifier bits do.
The demo rule pays exactly one grade-read per cell per step and lets everything else stay free. On Z/30 — channels mod 2, 3, 5 — call a cell ALIVE when it carries at least two of its three channels. A live cell with 2 or 3 live neighbors survives unchanged; a dead cell with exactly 3 live neighbors is born as the ring sum of its three parents; every other cell fades channel by channel, keeping channel p exactly when enough neighbors carry p. The fade is channel-local, hence free — the one purchased bit is the aliveness threshold. (All numbers below: measured on a 48×48 torus with Moore-8 neighborhoods.)
Death here is not a flip but a decay down the support lattice: a cell abandoned by its neighborhood loses its channels one at a time, light to shadow — and the graded region is the bulk, 73% of nonzero cells at partial support in the measured run. Birth is inheritance with interference: the newborn takes the sum of its parents, so channel 2's newborn bit is the parity of its parents' (exact on all 17,528 births of the run), and a cell can arrive partly or wholly dead when parent residues cancel. Measured stillbirth rates sit above every independent model: the automaton makes neighboring cells residue-correlated, then interferes with itself.
The fade window is a density dial, and Conway had a point. The permissive window — keep a channel at 2 or more carriers — never lets overcrowding kill: a fully supported dense region is a fixed point, and the automaton freezes dense (static from step 36 in the measured run, 70% of cells nonzero). The Conway-flavored window — keep at exactly 2 or 3 — runs sparse ash, 13% nonzero, freezing late when it freezes at all; the split is seed-robust (three fresh soups). And the coupling is real, created rather than inherited: from a channel-independent soup the coupled rule builds mutual information between the channels' support planes within 20 steps — over five times the sampling floor by step 50 — while its decoupled twin never leaves the floor.
The same isolation that blocks Life is a gift to error correction, and cashing it takes one idea: stop asking numbers to survive the dynamics, and make the invariant a dictionary — a set of valid words separated in the window metric, the number of channels where two values differ. The ECC page's code is the static case, and its basins are exact: any one corrupted window snaps back to the unique nearest word, guaranteed (exhaustive at k = 7: all 210 data values × all 51 single-window corruptions); two corrupted windows are always detected and never mis-snapped; three can produce an illusion — a snap to a different valid word, never to garbage — but rarely (0.58% of 5,000 random three-window corruptions; the rest are refused). Read words as scenes — agent in the mod-2 and mod-3 windows, patient mod 5, action mod 7 — and every snap carries the whole scene: all 210 scenes read out exactly after every single-window corruption.
But that guarantee is a height cut — data below 210 — and running arithmetic destroys it. Add two codewords and the sums outgrow the bound: the minimum distance of the summed code degrades with running height, 4 → 3 (values reaching 210) → 2 (2,310) → 1 (30,030) → 0 (510,510), and one addition step already leaves about half the cells at distance 3 from the nearest codeword (computed; expected fraction 0.498). The only repair is re-deriving the parity channels from the data after every step — a checksum tax paid forever. The escape is to choose a dictionary closed under the dynamics itself.
A dictionary of units closed under multiplication is exactly a subgroup of the ring's unit group (proved: a finite multiplicatively closed set of units contains every element's inverse; non-units can never join). Each channel's units form a cycle, so a subgroup is a linear code over the exponents — the space Π Z/(p−1) — and window distance is exponent Hamming distance: classical coding theory imports wholesale. Order-2 exponents give ±1 per channel, so binary linear codes bind-closed — the Hamming [7,4,3] code on seven odd prime channels gives 16 words correcting any one window (verified).
The demo's dictionary is a designed tower — seven places chosen with p ≡ 1 (mod 8): 17, 41, 73, 89, 97, 113, 137 — holding an element g of multiplicative order 8 in every channel: the eight words g⁰…g⁷ sit pairwise distance 7 apart and correct any 3 corrupted windows of 7. The honest negative rides with it: the primorial rung's own units make a bad dictionary — the one generated by its maximal-order unit has minimum distance 1, the mod-2 channel never separating units at all (verified over all 239 differences). Designed towers earn this; the home rung does not carry it free.
The update is binding: each cell becomes the product of its two neighbors, xᵢ ← xᵢ₋₁ · xᵢ₊₁ — on exponents, the linear automaton eᵢ ← eᵢ₋₁ + eᵢ₊₁ (mod 8), Sierpinski's rule. Multiplication never spreads an error across windows — the wrong windows of a product sit inside the union of the factors' wrong windows — and under pure binding a fault in window p stays in window p forever: the decoupling law re-read as fault quarantine. Snap-then-bind then gives the eager guarantee: if every cell suffers at most 3 corrupted windows per step, the trajectory is exact forever — a word 3 away from its truth still agrees with it on 4 windows and with any rival on at most 3 (verified: 500 steps × 64 cells at the full 3-window budget, 96,000 corrupted windows absorbed, zero divergence from the noiseless twin). Failure is a single-step burst of 4 or more windows, never an accumulation (measured: binomial).
Quarantine buys a second mode the checksum tax cannot: correction can wait. Run open loop — no snapping, no maintenance — with up to three entire channels stuck at garbage, every cell, every step; at readout, one snap per cell recovers the exact symbols (verified: 64 cells × 200 steps × 3 stuck lanes, 64 of 64 exact readouts, zero refusals). A failed hardware lane costs nothing until read time.
The shape has classical owners and a quantum shadow, both worth naming. Computing on a dictionary closed under a group action, with coset correction, is charted territory (algebraic fault tolerance; readout-time lane repair is the residue number system's core move), and any nonlinear rule must decode its symbols first — the coupling toll again, paid at the snap: once a cell is snapped, its symbol is a decoded integer and any rule on it is free. Fault-tolerant quantum computation runs the same playbook one level up: transversal gates are the channel-local, code-preserving operations, and the Eastin–Knill theorem denies them universality. Binding is the classical transversal set, and the decoupling law is the matching wall. What the tower construction adds is the package deal: the code, its symmetry group, its quarantine, and its price list arrive together, by construction.