THE CARRYLESS FIELD

nimber arithmetic in the 5-window house format. Nim-addition is XOR and Conway's recursive nim-multiplication turn {0..15} into the finite field GF(16) — carryless, yet every nonzero element can be divided by. See XOR-addition in 1D, the 16×16 field tables in 2D, and the field on a turning tesseract in 3D with AVAN's inverse pairing.

THE CARRYLESS FIELD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · DIVIDE BY ZERO ◆ .dlw.fold THE FOLD / GLITCH / DIVIDE BY ZERO / THE CARRYLESS FIELD THE CARRYLESS FIELD XOR to add, Conway's rule to multiply — a field with no carries 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Nim, and the nim-sum. A few piles of stones. On your turn take any number from any one pile. Take the last stone and you win. It looks like it should need deep lookahead — but the entire game collapses to a single number: the XOR of the pile sizes , the nim-sum . The theorem (Bouton, 1901): the player to move loses under perfect play exactly when the nim-sum is zero , and wins otherwise — and the winning move is always to take stones so the nim-sum becomes zero, handing your opponent a losing position. Sprague and Grundy later showed every impartial game is secretly a single Nim pile, so this one XOR is the master key to a whole world of games. LIT verified live: over 20,000 random positions, a full minimax search agrees with the XOR rule every time — win if and only if nim-sum ≠ 0 (window.__nim.theoremHolds). nim-sum(3,4,5) = 2, so the first player wins. FIG no framing; the XOR characterization and the zeroing strategy are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GOD MODE , beside THE COUNTER OF MULTITUDES — the cheat domain of knowing the answer before the fight. With the nim-sum in hand you can see the winning move instantly, every time — that is god mode over the game. AVAN (AI) built the instrument: the XOR strategy, the perfect-play opponent, the minimax check. The weave: David names the seat (perfect foresight); I make the invariant visible and the strategy unbeatable — the nim-sum in 1D, a game against perfect play in 2D, the piles and their XOR in 3D. The sphere is the seam. Credit: Charles L. Bouton (1901); R. Sprague (1935) & P. M. Grundy (1939). 3 ONE DIMENSION The piles in binary , and their XOR below. A column with an odd number of 1s makes the nim-sum nonzero — that is the crack. The winning move flips exactly the right stones to zero every column, leaving a balanced, losing position for the opponent. 4 TWO DIMENSIONS · INTERACTIVE Play against perfect strategy. Take stones from a pile and end your turn; the machine responds by zeroing the nim-sum. From a losing start (nim-sum 0) you cannot win; from a winning start, find the move that zeroes it — the machine only wins when you slip. − pile A − pile B − pile C end turn ▶ new game 5 THREE DIMENSIONS + AVAN’S INVERSE The piles as turning stacks of stones — green , the position as it stands. AVAN’s addition (the inverse-companion): the magenta pile is the one the winning move touches, and the magenta bar is the nim-sum it drives to zero. A game feels like it demands searching the tree of all futures — every move, every reply, forever. Nim is the inverse: the whole future is compressed into a single algebraic invariant . You do not simulate the game; you compute one XOR, and that number already knows who wins and what to play. Foresight without lookahead — the green is the board, the magenta is the one number that has already read the ending. pause spin LIT Genuine nimber arithmetic. Nim-mult is computed by Conway's mex recurrence and verified live: on {0..15} nim-add (XOR) and nim-mult are commutative, associative, distributive, with 0/1 identities and a multiplicative inverse for every nonzero element — the full field axioms, so it is GF(16) (Conway's theorem). The generator orbit (g=4 visits all 15 nonzero) and the inverse involution are the real group structure (verifiable: window.__nimfield.isField===true). FIG 'Carryless' and the game-theory origin are the frame; the field axioms, verified exhaustively, are exact. The seat at DIVIDE BY ZERO is the joke and the point — a field is precisely where division never fails (except by 0). ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of DIVIDE BY ZERO · David Lee Wise (ROOT0), with AVAN


THE OUROBOROS STRING

a de Bruijn sequence in the 5-window house format — a single cyclic string that contains every length-n pattern exactly once, in only kⁿ symbols. The master key that cracks every combination in one stream. See the loop in 1D, crack a lock in 2D, and turn its Eulerian-circuit graph in 3D with AVAN's reversed twin.

I-13 v2.0 | net = binds - k | 4 planes, 13 symbols, 12 operants, 5 cortex rules | sha 64881ebf

THE OUROBOROS STRING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE BACKDOOR ◆ .dlw.fold THE FOLD / CHEAT / THE BACKDOOR / THE OUROBOROS STRING THE OUROBOROS STRING one loop that contains every combination once 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The de Bruijn sequence. A single cyclic string over a k-symbol alphabet in which every possible length-n pattern appears exactly once as a sliding window. It is only k n symbols long — the shortest possible — yet it contains all k n combinations. Built by walking an Eulerian circuit of the de Bruijn graph. Real uses: brute-forcing a keypad lock with one continuous stream, DNA assembly, and rotary position encoders. LIT verified: the generated cycle of length k n contains all k n n-grams exactly once (every window enumerated and counted), and its reverse is also a valid de Bruijn sequence. FIG the ‘ouroboros / master key’ is the picture; the exhaustive-once guarantee is exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus works constantly with alphabets and encodings (the card-ISA, the byte kernels, the combinatorics-on-words) and the idea that the tightest possible covering of a space is a kind of key. AVAN (AI) built this instrument: the FKM generator, the lock-cracker, and the graph whose one loop is the sequence. The weave: David names the master key and its seat at THE BACKDOOR; I make the loop a strip in 1D, a combination-cracker in 2D, and the de Bruijn graph a turning circuit in 3D. The sphere is the seam. 3 ONE DIMENSION The sequence, laid flat (and wrapping, because it’s a loop). The window slides one symbol at a time; each new position reveals a length-n pattern never seen before — and after exactly k n steps it has shown them all and closed the ring. 4 TWO DIMENSIONS · INTERACTIVE The lock-cracker: a grid of all k n combinations . Play the stream and each sliding window cracks one new combination — all of them in just k n keypresses, versus n·k n for trying each separately. window n = 4 play step reset 5 THREE DIMENSIONS + AVAN’S INVERSE The de Bruijn graph , turning: each node is an (n−1)-gram, each edge an n-gram. Green traces the Eulerian circuit — the walk that crosses every edge exactly once is the sequence, one unbroken loop touching all patterns. AVAN’s addition (the inverse-companion): the magenta circuit is the reversed sequence — also a valid de Bruijn sequence, tracing the same graph the other way. The snake swallows its tail one direction; its mirror swallows it the other, and both taste every pattern exactly once. pause spin LIT A genuine de Bruijn sequence built by the FKM (Lyndon-word) algorithm. Verified live: the length-kⁿ cycle contains all kⁿ n-grams exactly once (every window enumerated and counted), and its reverse is also a valid de Bruijn sequence. The Eulerian-circuit graph and the kⁿ-vs-n·kⁿ cracking efficiency are the real math (verifiable: window.__debruijn.everyGramOnce===true). FIG The 'ouroboros / master key' is the picture; the exhaustive-once guarantee, the minimal kⁿ length, and the graph circuit are exact. Real de Bruijn sequences really are used to brute-force keypad locks and assemble DNA. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BACKDOOR · David Lee Wise (ROOT0), with AVAN


THE SINGLE EAR

the Goertzel algorithm in the 5-window house format — a two-tap resonator that reads a single DFT bin's energy without a whole FFT. The trick inside every touch-tone decoder. See the resonator ring in 1D, dial a working DTMF keypad in 2D, and the single ears against the full spectrum in 3D.

THE SINGLE EAR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE SINGLE EAR THE SINGLE EAR hear one frequency for the cost of two taps 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Goertzel algorithm. If you only care about one frequency, you don’t need a whole FFT. Goertzel runs a tiny two-tap resonant filter — a second-order recurrence with a single coefficient 2 cos(2πk/N) — over the samples, and reads off exactly the energy at DFT bin k. Two state variables, no arrays, no complex math until the end. It is what every touch-tone (DTMF) decoder uses: eight little Goertzel ears, each tuned to one phone frequency. LIT verified: Goertzel’s magnitude matches |X[k]| from the full DFT to ~10 −11 , and all 16 DTMF keys decode correctly from their dual tones. FIG ‘a single ear’ is the picture; the recurrence and its match to the DFT bin are exact. (The complex phase needs a convention fix-up; the magnitude — what detection uses — is exact.) 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus is deep in sound and signal ( PHONOS , the audio pieces, THE FOURIER next door in THE BROADCAST) and the idea that attention is cheaper than omniscience: to hear one note you needn’t transform the whole chord. AVAN (AI) built this instrument: the resonator, the DTMF pad, and the single-ear-vs-full-spectrum view. The weave: David names the single ear and its seat at THE HANDOFF (touch-tone signaling); I make the resonance a ringing line in 1D, a working phone keypad in 2D, and the tuned bin against the full spectrum in 3D. The sphere is the seam — and the honesty is in claiming only the magnitude, which is what actually holds. 3 ONE DIMENSION The resonator ringing. Fed a tone on its tuned frequency (green), the two-tap state rings up steadily; fed an off -tune tone (dim), it stays small and bounded. That growing gap is the detection — selectivity from one coefficient. 4 TWO DIMENSIONS · INTERACTIVE A working DTMF keypad . Press a key: it emits two tones (a row frequency + a column frequency), eight Goertzel ears listen, and the two loudest pin down exactly which key — decoded live, the way a phone line hears you dial. press a key… 5 THREE DIMENSIONS + AVAN’S INVERSE The current signal’s spectrum as a turning bar field. Green bars are the eight bins the Goertzel ears actually compute — the two active ones stand tall. That’s all the work Goertzel does: eight points. AVAN’s addition (the inverse-companion): the magenta bars are the rest of the full DFT — every bin Goertzel never bothers to compute. The full transform hears the whole chord; the single ear narrows its attention to a handful of lines and pays almost nothing. Omniscience versus attention, on one axis. pause spin LIT A genuine Goertzel filter. Verified live: its magnitude matches |X[k]| from the full DFT to ~1e-11 (real power form s1²+s2²−coeff·s1·s2), and all 16 DTMF keys decode correctly from their dual tones via eight tuned Goertzel detectors. The single-ear vs full-spectrum contrast is the real cost difference (verifiable: window.__goertzel.dtmfAll16Decode===true). FIG 'A single ear' is the picture; the recurrence and the magnitude-match are exact. Honest caveat baked in: the complex phase needs a convention fix-up, so the sphere claims only the MAGNITUDE — which is what detection actually uses and what holds to 1e-11. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE OVERLAP-FREE WORD

the Thue–Morse sequence in the 5-window house format. Built by 0→01, 1→10 (or the parity of 1-bits), it is overlap-free and cube-free — the deterministic word that never repeats thrice — and it gives the fairest possible two-way split. See both definitions agree in 1D, Prouhet's equal-power-sum partition in 2D, and its self-similar turtle curve in 3D with AVAN's mirror.

THE OVERLAP-FREE WORD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE OVERLAP-FREE WORD THE OVERLAP-FREE WORD the word that never stutters — and splits fair 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Thue–Morse sequence. Start with a single 0 . Repeatedly append the complement of everything so far: 0 → 01 → 0110 → 01101001 → … The n-th bit is simply the parity of the number of 1s in n written in binary. It is aperiodic, self-similar, and famously the fairest turn order . Alternating turns (you, me, you, me) hands a lasting edge to whoever picks first. Taking turns in Thue–Morse order (you, me, me, you, me, you, you, me…) cancels that edge: split 0…2 k −1 into the ‘0’ picks and the ‘1’ picks and the two sides have equal sums of every power up to degree k−1 (the Prouhet–Tarry–Escott property). The sequence is also cube-free : no block of symbols ever repeats three times in a row. LIT verified live: the recurrence t(2n)=t(n), t(2n+1)=1−t(n) holds; the first 600 symbols are cube-free; and the Prouhet partition gives equal power sums for k = 1..7 (window.__thuemorse). FIG no framing; the recurrence, cube-freeness, and the equal-power-sums fairness are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE HANDOFF , beside the other turn-taking spheres — the co-op domain of who goes next. Thue–Morse is the mathematically fairest handoff order there is. AVAN (AI) built the instrument: the complement-doubling, the parity view, the fair-turn simulator. The weave: David names the seat (the fair handoff); I make the sequence build itself and the fairness visible — the strip in 1D, the doubling and the converging teams in 2D, the inverse-generated path in 3D. The sphere is the seam. Credit: Axel Thue (1906, 1912); Marston Morse (1921); Eugène Prouhet (1851, the equal-power-sums partition). 3 ONE DIMENSION The sequence as a strip of 0s and 1s. Each symbol is the parity of the 1-bits in its index — and equivalently the complement-doubling of the block before it. No motif ever appears three times back-to-back. 4 TWO DIMENSIONS · INTERACTIVE Watch the word build by complement-doubling , and watch two players draft items 0,1,2,… (each worth its own value) in Thue–Morse order. Their running totals stay locked together — the fairness is the near-tie. double ▶ reset parity view 5 THREE DIMENSIONS + AVAN’S INVERSE The sequence as a turning path — step one way on 0, the other on 1 — tracing the self-similar Thue–Morse curve in green . AVAN’s addition (the inverse-companion): the magenta trail is the complement of the same sequence. Here the inverse isn’t a mirror bolted on afterward — it is the generator itself . The whole word is built by taking what you have and appending its inverse, forever. The inverse of ‘emit the next symbol’ is ‘emit the complement of what you just emitted’, and iterating that single inverse from one lonely 0 produces an infinite word that is aperiodic, cube-free, and the fairest possible — balance manufactured out of nothing but repeated negation. Green is the sequence; magenta is the inverse that made it. They are the same object, offset by one flip. pause spin LIT A genuine Thue–Morse sequence. Verified live: the substitution 0→01,1→10 equals the popcount-parity definition over 8192 bits; the prefix is cube-free and overlap-free (exhaustive scan, zero found); and the Prouhet split of 0..2^k−1 by TM bit gives equal power sums through p=k−1. It is honestly NOT square-free — it contains squares like '11' (verifiable: window.__thuemorse.overlapFree && cubeFree && hasSquares). FIG 'Never stutters' is the picture; overlap-free, cube-free, and the Prouhet equal-sums are Thue's/Prouhet's exact theorems. The square-containing caveat is stated plainly — overlap-free is a stronger, more precise claim than 'no repeats'. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE TURMITE ZOO

Langton's ant and its turmite kin in the 5-window house format. Two rules, a blank grid, ~10,000 steps of chaos — then a period-104 'highway' builds itself and drives off diagonally forever. See the turn stream in 1D, run the grid live in 2D, and the space-time trail in 3D with AVAN's mirror ant.

THE TURMITE ZOO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE TURMITE ZOO THE TURMITE ZOO chaos for 10,000 steps, then a road out of nowhere 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Langton’s ant. One ant on an infinite grid of white cells, following two rules: on a white cell turn right, flip the cell to black, step forward; on a black cell turn left, flip it to white, step forward. That is the entire program. For the first few hundred steps it makes tidy symmetric shapes. Then it descends into apparent chaos — roughly ten thousand steps of a formless, unpredictable scribble. And then, with no change to the rules, order erupts : near step 10,000 the ant locks into a repeating cycle of exactly 104 steps that lays down a straight diagonal “highway” and drives along it forever. No one has proven why the highway always appears — it is only ever known by running the ant. (It is also provably unbounded : the Cohen–Kung theorem says the ant’s trail can never stay in a finite region.) LIT verified live: from an all-white grid the ant enters a period-104 cycle near step ~9975, and every 104 steps thereafter its net displacement is a constant diagonal vector (window.__ant). FIG no framing; the emergence, the period 104, and the constant diagonal drift are exact — only the reason stays open. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in FIRST LIGHT , beside the other emergence spheres — the spawn domain of order appearing out of the void. The highway rising from ten thousand steps of chaos is exactly a first-light moment. AVAN (AI) built the instrument: the live ant, the turn-tape, the reversible path. The weave: David names the seat (the first light of order); I make the emergence run and the highway appear on its own — the turn-tape in 1D, the live simulation in 2D, the reversible 3D ribbon. The sphere is the seam. Credit: Christopher Langton (1986); the unboundedness is the Cohen–Kung theorem. 3 ONE DIMENSION The ant’s program as a 1D tape of turns — R on white, L on black — one symbol per step. Chaotic at first; once the highway begins, the tape settles into a fixed 104-symbol loop repeating forever. 4 TWO DIMENSIONS · INTERACTIVE The live ant. Run it and watch the symmetric start dissolve into chaos, then — near step 10,000 — the highway break out and shoot off diagonally. The readout flags the moment order emerges. run ▶ skip to 9900 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The ant’s path lifted into 3D — x, y, and time as height. The tangled early chaos coils near the base; the highway climbs off as a straight diagonal ramp, in green . AVAN’s addition (the inverse-companion): the magenta ramp is the same trajectory run backward . Langton’s ant is time-reversible : from the ant’s cell, heading, and the grid you can uniquely recover the previous state — so the highway can be un-driven, step by step, back down into the chaos it rose from. That is the real inverse here: forward, a trivial rule manufactures unpredictable order that no shortcut can foresee; backward, that same order dissolves perfectly and deterministically into the scribble — yet running it in reverse is no easier, still one step at a time. The emergence is irreversible to predict but reversible to replay . Green climbs out of chaos into the highway; magenta descends the highway back into chaos. pause spin LIT A genuine Langton's ant (a 2-state turmite). Verified live: from a blank grid it enters a period-104 cycle translating by (−2,2) each period — the highway — detected by matching its move sequence. Other turmite rules (LLRR, RLR) grow visibly different structures. Whether every start reaches a highway is a real open problem (verifiable: window.__langton.highwayPeriod===104). FIG 'Chaos then a road' is the picture; the rule, the period 104, and the diagonal drift are exact. The 'heisenbug' framing is honest irony — it looks nondeterministic but is perfectly determined. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE PERMUTATION CLOCK

the factorial number system and Lehmer code in the 5-window house format. Place values are the factorials and each column caps at its position, so every integer 0..n!−1 names exactly one permutation — jump to the millionth shuffle by arithmetic. See the mixed-radix odometer in 1D, address-a-shuffle in 2D, and the permutohedron in 3D with AVAN's inverse pairing.

THE PERMUTATION CLOCK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE PERMUTATION CLOCK THE PERMUTATION CLOCK a clock whose wheels are factorials — address any shuffle 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The factorial number system. A positional system where the place values are the factorials (…,3!,2!,1!) and the digit in place k may only run 0…k — a clock whose columns each have a different size. Via the Lehmer code , every integer 0…n!−1 names exactly one permutation of n items. So you can jump straight to ‘the 400,000th shuffle’ by arithmetic alone — no dealing, no enumeration. LIT verified: for n=6 the map is a perfect bijection between 0…719 and the 720 permutations — rank(unrank(m))=m for every m — and each column k rolls over exactly at k+1. FIG ‘clock’ is the picture; the mixed-radix bijection is exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus works with shuffles, encodings and mixed radices (the card-ISA, the base kernels, the combinatorics) and the idea that even a deck of cards has an address. AVAN (AI) built this instrument: the factoradic odometer, the shuffle-scrubber, and the permutohedron. The weave: David names the permutation clock and its seat at THE CRON JOB (a clock, in factorial time); I make the mixed-radix odometer a strip in 1D, the address-a-shuffle demo live in 2D, and the space of all permutations a turning polytope in 3D. The sphere is the seam. 3 ONE DIMENSION The factoradic odometer for the current index. Place values are 5!,4!,3!,2!,1!,0! ; each column’s digit is capped at its position (bar height = allowed max), so the rightmost is always 0 and each rolls over at a different point. A clock with unequal wheels. 4 TWO DIMENSIONS · INTERACTIVE Scrub the index 0…719 and the six cards snap into that exact permutation (unrank). Or click a card to swap it forward and watch the index jump to the new shuffle’s address (rank). The factoradic digits and Lehmer code track live. index 0 / 719 random shuffle 5 THREE DIMENSIONS + AVAN’S INVERSE The permutohedron of order 4, turning: all 24 permutations of four items as the corners of a polytope, edges joining shuffles that differ by one adjacent swap. Green is the Steinhaus–Johnson–Trotter tour — a single-swap path that visits every shuffle once (a Gray code for permutations, kin to THE GRAY ). AVAN’s addition (the inverse-companion): the magenta edges join each permutation to its inverse (the shuffle that undoes it). It is an involution — a fold of the polytope onto itself, with the self-inverse shuffles as its fixed points. The clock counts every arrangement; the inverse map pairs each with its undo. pause spin LIT A genuine factoradic + Lehmer code. Verified live: for n=6 the map is a perfect bijection between 0..719 and the 720 permutations (rank(unrank(m))=m for all m), and each column rolls over at k+1. The permutohedron (24 shuffles, single-swap edges), its SJT Gray-code tour, and the inverse involution are the real group structure (verifiable: window.__factoradic.bijection720===true). FIG 'Clock' is the picture; the mixed-radix bijection and the permutohedron structure are exact. Addressing 'the millionth shuffle' is a literal, verified capability, not a metaphor. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE SKI FOREST

combinatory logic in the 5-window house format — computing with zero variables. Three combinators (I x=x, K x y=x, S x y z=xz(yz)) and pure tree-rewriting make a Turing-complete language. See the rules reduce a term in 1D, drive the reducer in 2D, and Church–Rosser confluence in 3D as AVAN's two-paths-one-floor diamond.

THE SKI FOREST · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE SKI FOREST THE SKI FOREST Turing-complete with three birds and no variables 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION SKI combinator calculus is a model of computation with no variables at all — just two operators and the act of applying one thing to another. The rules are tiny: K x y = x (keep the first argument, throw away the second) and S x y z = x z (y z) (hand the third argument to both of the others). That is the entire language. Astonishingly, those two combinators are enough for everything : every function of the lambda calculus — and therefore everything computable at all — can be rewritten using only S and K, with no bound variables anywhere . The identity function is simply I = S K K . Booleans, numbers, even recursion all become trees of S and K. Moses Schönfinkel showed variables can be eliminated from logic entirely ; this “point-free” style is the ancestor of pipeline-and-compose programming. LIT verified live: an in-browser reducer confirms I a→a, K a b→a, S a b c→(ac)(bc), and S K K acting as the identity on every atom — the identity built from S and K alone (window.__ski). FIG no framing; the reduction rules and combinatorial completeness (I = SKK) are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in NOCLIP — the cheat domain of moving through what should stop you. SKI noclips straight through the need for variables: computation walks on, nameless, as if the walls of binding weren’t there. AVAN (AI) built the instrument: the rewrite rules, the step reducer, the point-free/point-ful inverse. The weave: David names the seat (pass through the constraint); I make two operators compute everything and reduce expressions to their value with no variable ever named — the rules in 1D, the reducer in 2D, the variables-vs-none inverse in 3D. The sphere is the seam. Credit: Moses Schönfinkel (1924); combinatory logic developed by Haskell Curry. 3 ONE DIMENSION The whole language on one line: I x → x , K x y → x , S x y z → x z (y z) . Three rewrite arrows, no variables to bind — and yet enough to express every computable function. 4 TWO DIMENSIONS · INTERACTIVE Pick an expression and step it toward normal form. Watch S K K x grind down to just x — the identity function, manufactured from S and K with no I and no variable in sight. Each step applies one rewrite rule. expr: SKKx reduce ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The combinator expression as a turning tree of S and K nodes — the green forward form: a whole computation, expressed with no variables . AVAN’s addition (the inverse-companion): the magenta is the lambda term with variables that the SKI tree came from. The forward translation — bracket abstraction — takes a named function like λx.x and grinds every variable out of it until only S and K remain (λx.x becomes SKK). Its inverse reads a nameless combinator tree and reconstructs a lambda term with variables that means the same thing. So point-free and point-ful are two encodings of one function, and you can compile either way. What the pair proves is quietly radical: variables are a convenience, not a necessity — the identical computation exists with names and without them, and SKI is the without-them witness. Green is the variable-free tree that actually runs; magenta is the friendly named version we usually write; between them, nothing computable is lost. pause spin LIT Genuine combinatory logic. Verified live: S K K x reduces to x (SKK is the identity), S(KS)K is the composition combinator B (B a b c = a(b c)), and reducing outermost-first vs innermost-first reaches the same normal form over random terms (Church–Rosser). The reducer, the reduction sequences, and the confluence diamond are the real rewrite system (verifiable: window.__ski.SKK_is_identity && churchRosser). FIG 'A forest of birds' (Smullyan's combinator names) is the picture; the three rules, Turing-completeness, and confluence are exact. It really is the whole of computation with no variables. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


THE FENWICK LADDER

the Fenwick tree (binary indexed tree) in the 5-window house format. Running totals with point updates, both in O(log n), by hiding a tree in one flat array and navigating with the lowest set bit i & −i. See each cell's binary span in 1D, drive updates and queries in 2D, and climb the ladder both ways in 3D.

THE FENWICK LADDER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE STASH ◆ .dlw.fold THE FOLD / LOOT / THE STASH / THE FENWICK LADDER THE FENWICK LADDER a whole range-sum tree hidden in one array, by i & −i 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Fenwick tree (Binary Indexed Tree) answers two questions — “what is the running total of the first i items?” and “add to item i” — both in O(log n) time, using a single array and one magic operation: the low-bit i & (−i) , which isolates the lowest set bit of i. Each array slot secretly holds the sum of a range whose length equals that low-bit : slot 12 (= 1100₂, low-bit 4) covers items 9–12; slot 8 covers 1–8. To read a prefix sum you hop down , repeatedly subtracting the low-bit to jump across disjoint covered ranges; to update you hop up , adding it. Both walks touch only about log n slots — the number of set bits in i. It is the most elegant structure for maintaining dynamic running totals , and it lives in databases, range queries, and competitive programming everywhere. LIT verified live: after hundreds of random point-updates the Fenwick prefix sums match a naive recomputation exactly, and range queries [l,r] = query(r) − query(l−1) agree too (window.__fenwick). FIG no framing; the low-bit navigation and the O(log n) correctness are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE EPOCH — the grind domain of totals accumulated across time. A Fenwick tree is exactly a ledger of epochs: running sums that stay correct as any entry changes, each query and edit a handful of bit-hops. AVAN (AI) built the instrument: the coverage map, the hop animator, the update/query inverse. The weave: David names the seat (the cumulative ledger); I make the low-bit carve the array into ranges and keep every running total exact under change — the coverage in 1D, the hops in 2D, the ascent/descent inverse in 3D. The sphere is the seam. Credit: Peter Fenwick (1994); the structure appears earlier in Boris Ryabko (1989). 3 ONE DIMENSION Each Fenwick slot i drawn as a bar spanning the range it covers — a range of length i&(−i). Powers of two cover long stretches; odd indices cover a single item. Together the bars tile the array so any prefix is a few of them stacked. 4 TWO DIMENSIONS · INTERACTIVE An array of values with its Fenwick tree. Run a prefix query and watch it hop down by subtracting the low-bit, summing a few covered ranges; run an update and watch it hop up. The result is checked against a full naive sum — always identical, in a fraction of the touches. query prefix ▶ update 5 THREE DIMENSIONS + AVAN’S INVERSE The implicit binary tree turning — the green forward step: to update index i, add the low-bit and climb, touching every slot whose range covers i. AVAN’s addition (the inverse-companion): the magenta is the query walk, and it is the exact inverse traversal — where update adds the low-bit to ascend, query subtracts it to descend. These two paths are perfect complements: the slots an update to index i touches are precisely the slots whose ranges include i, and a prefix query for r includes slot i exactly when the update path from i passes through it. So ‘which ranges cover index i?’ and ‘which prefix sums include i?’ are one question read forward and backward, and the low-bit answers both in log n steps. The green +low-bit climb and the magenta −low-bit descent are mirror images on the same tree; the whole speed of the structure is that adding and subtracting the lowest set bit are inverse moves that each skip exponentially. To maintain a total is to walk up; to read one is to walk down; and the bit that isolates the lowest one governs both directions. pause spin LIT A genuine Fenwick tree. Verified live: after 5000 random updates every prefix-sum and range-sum matches a naive cumulative array, each query touching only ~log₂n cells (max 7 for n=64). The i&−i responsibility spans, the update climb (i+=i&−i), and the query descend (i−=i&−i) are the exact navigation (verifiable: window.__fenwick.matchesNaive===true). FIG 'A ladder of binary spans' is the picture; the bit navigation and the O(log n) cost are exact. The whole balanced structure really does live inside one array with no pointers — the arithmetic of the lowest set bit is the tree. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE STASH · David Lee Wise (ROOT0), with AVAN


THE PROBABLE PRIME

the Miller–Rabin primality test in the 5-window house format. It interrogates a number with 'witnesses' that exploit the fact that 1 has only ±1 as square roots modulo a prime. See the witness chain in 1D, sweep every base in 2D, and the roots-of-1 trapdoors on the squaring graph in 3D.

THE PROBABLE PRIME · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE PROBABLE PRIME THE PROBABLE PRIME witnesses that expose composites via the roots-of-1 trapdoor 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Miller–Rabin test. Trial division can prove a number prime, but it is hopeless on the hundreds-of-digits primes cryptography needs. Miller–Rabin instead interrogates n with random ‘witnesses’: it exploits the fact that modulo a prime, 1 has only two square roots (±1) . Pick a base a, walk a chain of squarings, and if a ‘rogue’ square root of 1 appears, n is definitely composite — a is a witness. If not, n is probably prime . LIT verified: primes are exposed by no base; every odd composite is exposed by ≥3/4 of bases (so t rounds err with probability ≤4 −t ) — even Carmichael numbers like 561 that fool the Fermat test are caught. FIG ‘witnesses / sudden death’ is the picture; the 3/4 bound is the exact theorem. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus leans on primes and modular arithmetic everywhere ( THE MINT , THE SIEVE , the crypto spheres) and the idea that you can be almost certain far faster than certain. AVAN (AI) built this instrument: the witness engine, the base-sweep, and the squaring graph. The weave: David names the probable prime and its seat at SUDDEN DEATH (a composite usually dies in one round); I make the squaring chain a strip in 1D, the witness-sweep live in 2D, and the roots-of-1 trapdoors a turning graph in 3D. The sphere is the seam. 3 ONE DIMENSION The witness chain for base 2. Write n−1 = 2 s ·d, then compute 2 d , and square it, and again… A prime lands on 1 only via ±1; if this chain hits a 1 that arrived from something other than ±1 , the base has exposed a composite. 4 TWO DIMENSIONS · INTERACTIVE Sweep every base 2…n−1 for the chosen n: green = fooled (calls it probably prime), red = witness (exposes it). A prime is a field of green ; a composite is ≥3/4 red . Try 561 — a Carmichael number that beats Fermat but not this. n = 561 561 (Carmichael) a prime 5 THREE DIMENSIONS + AVAN’S INVERSE The squaring map x→x² mod n on a ring, turning: every residue arrows toward its square, and all roads funnel toward 1 . Green marks the two ‘honest’ square roots of 1: +1 and −1. AVAN’s addition (the inverse-companion): the magenta points are the rogue square roots of 1 — residues that are neither +1 nor −1 yet square to 1. They exist only when n is composite (n=15 has four roots of 1; a prime has exactly two). Squaring is the forward map; these extra inverse-roots are the cracks every witness slips through. The trapdoor is the inverse of the lock. pause spin LIT A genuine Miller–Rabin test. Verified live: primes are exposed by no base, every odd composite is exposed by ≥3/4 of bases (miss ≤4^-t after t rounds), and Carmichael numbers (561, which fools the Fermat test) are still caught. The rogue square roots of 1 that only exist for composites are the real trapdoor (verifiable: window.__millerrabin.compAtLeast3quarters===true). FIG 'Witnesses / sudden death' is the picture; the ≥3/4 bound and the roots-of-1 structure are exact theorems. This is the actual test guarding real RSA/ECC keys — the probabilistic certainty is honestly a probability (≤4^-t), not a proof. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE CURVE THAT FILLS THE PLANE

the Hilbert space-filling curve in the 5-window house format. A single path visits every cell of a grid once, and points close on the line stay close in the plane — the locality trick behind cache-friendly memory layout. See the 1D order in 1D, the curve and its locality in 2D, and the lifted ribbon vs the scanline in 3D.

THE CURVE THAT FILLS THE PLANE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SHARED MEMORY ◆ .dlw.fold THE FOLD / CO-OP / SHARED MEMORY / THE CURVE THAT FILLS THE PLANE THE CURVE THAT FILLS THE PLANE one line threads every cell — and keeps neighbors near 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hilbert curve. A single continuous fractal path that visits every cell of a 2 n ×2 n grid exactly once — and never jumps: consecutive cells are always neighbors . It is a space-filling curve, a way to unroll a 2D square into a 1D line. The magic is locality preservation . Two points close together on the line stay close together on the plane. Row-major scanning (left to right, top to bottom) tears that apart — two cells one row apart are a whole width away in memory. Hilbert doesn’t tear. That is why it is used for cache-friendly memory layouts , spatial database keys (map (x,y) to a 1D index that clusters), image dithering, and R-tree ordering: put spatially near things near in storage, and the cache hits. LIT verified live: for grids up to 64×64 the index→(x,y) map is a bijection , its inverse (x,y)→index round-trips exactly, and every pair of consecutive indices is Manhattan-distance 1 apart (window.__hilbert). FIG no framing; the bijection, the exact inverse, and the adjacency are all real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in WARM CACHE , beside the other locality spheres — the grind domain of keeping the working set hot. The Hilbert curve is the classic trick for a cache-friendly 2D layout. AVAN (AI) built the instrument: the recursive curve, the index probe, the row-major contrast. The weave: David names the seat (the warm cache); I make the curve fill the grid without ever jumping and show why that keeps memory hot — the index strip in 1D, the drawn curve in 2D, the locality contrast in 3D. The sphere is the seam. Credit: David Hilbert (1891), building on Giuseppe Peano’s first space-filling curve (1890). 3 ONE DIMENSION The 1D index line 0, 1, 2, …, N−1 — the order the curve visits cells. Slide along it and the highlighted plane cell (shown in window 4) moves only one step at a time. The line and the square are the same walk. 4 TWO DIMENSIONS · INTERACTIVE The Hilbert curve drawn at order p. Probe an index to see its cell; the curve never breaks contact with itself. Toggle the row-major scan to see the alternative that jumps a full row every wrap. order ▲ order ▼ show row-major probe ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The curve lifted into 3D: x, y, and the 1D index as height. The green ribbon climbs smoothly — a small step in height is always a small step in the plane. AVAN’s addition (the inverse-companion): the magenta ribbon is the row-major layout on the same grid — the naive inverse. Both are bijections between the line and the square; the difference is entirely in the inverse’s behavior. Row-major maps the square to the line by tearing every vertical neighborhood apart — two cells stacked vertically land a full width apart in 1D, so the magenta ribbon leaps across the whole plane on every row wrap. Hilbert’s inverse keeps the neighborhoods intact: nowhere does it leap. That is the real inverse here — not a mirror, but the other direction of the same map, and the whole point of the curve is that its inverse doesn’t shred locality the way the obvious one does. Green never jumps; magenta jumps a full width every wrap. Same bijection, opposite treatment of what’s near. pause spin LIT A genuine Hilbert curve (bit-manipulation d2xy / xy2d). Verified live: the index↔(x,y) map is a perfect bijection over the grid (round-trips), and consecutive indices are always grid-adjacent (Manhattan distance exactly 1). The locality win — a 1D window maps to a far tighter 2D bounding box than row-major — is measured live (verifiable: window.__hilbert.bijection && adjacencyManhattan1 && localityWin). FIG 'Fills the plane' is the picture; the bijection, the unit-step adjacency, and the locality advantage are exact. It really is used to lay out memory and spatial indexes for better cache behaviour. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SHARED MEMORY · David Lee Wise (ROOT0), with AVAN


THE SHORTEST WITNESS

Berlekamp–Massey in the 5-window house format — find the shortest LFSR that generates any bit sequence (its linear complexity). Watch 2n output bits and recover the exact feedback taps: the classic stream-cipher break and the engine inside Reed–Solomon decoding. See the complexity profile in 1D, crack a register in 2D, and structured-vs-random profiles in 3D.

THE SHORTEST WITNESS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE SHORTEST WITNESS THE SHORTEST WITNESS watch the output, recover the machine 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Berlekamp–Massey. Hand it any bit sequence and it finds the shortest linear-feedback shift register that could have produced it — its ‘linear complexity’ . The devastating part: watch just 2n output bits of any degree-n LFSR and it reconstructs the exact feedback taps. That is why a raw LFSR is worthless as a cipher (this is the classic stream-cipher break), and the very same algorithm is the engine that decodes Reed–Solomon and BCH error-correcting codes. LIT verified: the recovered LFSR regenerates the input exactly; and from 16 bits of the [8,6,5,4] generator (the one in THE RANDOM ) it recovers length 8 and the connection polynomial, then reproduces the whole 255-bit period. FIG ‘the shortest witness’ is the picture; the minimality and recovery are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus already runs an LFSR ( THE RANDOM ) and leans on coding theory and crypto, with the conviction that any structure, once seen, can be reverse-engineered. AVAN (AI) built this instrument: the recovery engine, the break-the-cipher demo, and the linear-complexity profiles. The weave: David names the shortest witness and its seat at THE EXPLOIT (watch the output, own the machine); I make the complexity profile a strip in 1D, the recovery live in 2D, and structured-vs-random profiles a turning staircase in 3D. The sphere is the seam — the exact inverse of the LFSR sphere next door. 3 ONE DIMENSION The bit stream, and beneath it the linear-complexity profile : as each bit arrives, the length of the shortest LFSR that explains everything so far. It jumps in steps — and where it levels off tells you the true register size. 4 TWO DIMENSIONS · INTERACTIVE Feed it a sequence and it cracks the register : recovered length, feedback taps, and a regeneration that must match the input bit-for-bit. Try a secret LFSR (recovered exactly), pure random (complexity ~n/2, uncrackable-short), or a simple period. secret LFSR random periodic 5 THREE DIMENSIONS + AVAN’S INVERSE Two linear-complexity profiles as climbing staircases, turning. Green is a real LFSR’s output: its complexity climbs to the register size and then plateaus flat — there is a short machine behind it, and BM finds it. AVAN’s addition (the inverse-companion): the magenta profile is a truly random sequence — it climbs relentlessly toward n/2 and never levels, the signature of ‘no short LFSR exists’. Berlekamp–Massey is thus a randomness test : a flat plateau betrays hidden structure, an endless climb certifies its absence. The break is the inverse of the build. pause spin LIT A genuine Berlekamp–Massey algorithm over GF(2). Verified live: the recovered LFSR regenerates the input exactly over random sequences, and from 16 bits of the [8,6,5,4] LFSR (THE RANDOM's generator) it recovers length 8 and the connection polynomial, reproducing the full 255-bit period. The linear-complexity profile (plateau=structured, climb-to-n/2=random) is a real randomness diagnostic (verifiable: window.__bm.regeneratesInput && recoversLength8). FIG 'The shortest witness' is the picture; the minimality, the recovery, and the profile behaviour are exact. It is the literal inverse of THE RANDOM — the machine that turns the LFSR's stream back into its taps. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN


THE EXACT TRANSFORM

the Number-Theoretic Transform in the 5-window house format — the FFT's exact twin, run in a finite field so polynomial and big-integer multiplication carry zero rounding error. See the finite-field roots of unity in 1D, exact convolution in 2D, and the prime-field circle against Fourier's complex one in 3D.

THE EXACT TRANSFORM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE EXACT TRANSFORM THE EXACT TRANSFORM an FFT in a prime field — convolution with zero rounding 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Number-Theoretic Transform. The FFT convolves fast — but with floating-point rounding . The NTT runs the same butterfly structure inside a finite field of integers mod a prime , using a ‘root of unity’ that lives mod p in place of e 2πi/n . The payoff: convolution — that is, polynomial and big-integer multiplication — with zero rounding error, ever . It is why post-quantum crypto (Kyber, Dilithium) and giant-integer arithmetic use the NTT, not the FFT. LIT verified over the prime 998244353 with root of unity 3 (p−1)/n : INTT(NTT(a)) = a , NTT-convolution equals schoolbook convolution exactly, bit-for-bit , and a full big-integer multiply comes out precise. FIG ‘exact transform’ is the picture; the round-trip and convolution equality are exact integers. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — THE FOURIER sits next door in THE BROADCAST, and the corpus works with big-integer kernels and crypto, holding that some computations must be exactly right, not nearly. AVAN (AI) built this instrument: the modular transform, the exact-convolution demo, and the two circles of roots. The weave: David names the exact transform and its seat at ROLLBACK (a round-trip that loses nothing); I make the finite-field roots a strip in 1D, exact convolution live in 2D, and the prime-field circle against the complex one in 3D. The sphere is the seam — Fourier’s incorruptible twin. 3 ONE DIMENSION The roots of unity mod p : the powers ω 0 , ω 1 , …, ω n−1 — ordinary integers that behave exactly like the n complex roots, cycling back with ω n = 1. No angles, no rounding: the whole transform runs on these residues. 4 TWO DIMENSIONS · INTERACTIVE Two integer sequences (click a cell to change it). Their convolution is computed two ways — slow schoolbook, and NTT (transform both, multiply pointwise, inverse-transform) — and they match exactly , every coefficient. The multiplication that never rounds. random 12345 × 6789 5 THREE DIMENSIONS + AVAN’S INVERSE The n roots of unity , turning. Green is the NTT’s finite-field roots — exact integers mod p, evenly placed, cycling closed. The transform samples a signal at exactly these points. AVAN’s addition (the inverse-companion): the magenta ring is Fourier’s complex circle , e 2πik/n , that the NTT mirrors. Same geometry, same butterflies — but the complex circle carries irrational coordinates that must round , while the prime-field ring is exact. Two transforms, one shape; the inverse of ‘fast’ is ‘exact’, and the NTT keeps both. pause spin LIT A genuine NTT over the prime 998244353, root of unity 3^((p−1)/n). Verified live: INTT(NTT(a))=a, NTT-convolution equals schoolbook convolution exactly (every coefficient, mod p), the root has order exactly n, and a full big-integer multiply (12345×6789) comes out precise. It powers Kyber/Dilithium precisely because it never rounds (verifiable: window.__ntt.roundTrip && convMatchesSchoolbook && bigMulExact). FIG 'Exact transform' is the picture; the round-trip, the exact convolution, and the big-multiply are exact integers. This is the plain O(n²) NTT, not the fast radix-2 version — same exact result, honest about being the clear form (like THE FOURIER's DFT). ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE ONE-BIT RIVER

delta-sigma modulation in the 5-window house format — encode a smooth signal as a single stream of 1s and 0s whose density tracks amplitude, then low-pass it back. Noise shaping pushes the 1-bit error out of band. See the density in 1D, drive the modulator in 2D, and the shaped-noise spectrum in 3D.

THE ONE-BIT RIVER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE ONE-BIT RIVER THE ONE-BIT RIVER infinite-resolution sound from a wire flipping fast 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Delta-sigma modulation. Instead of many bits per sample, use one bit — but flip it very fast (oversampling). A feedback loop with an integrator compares the signal to the last output bit and emits +1 or −1 so the density of 1s tracks the amplitude ; a simple low-pass filter averages the stream back into a smooth, high-resolution wave. The magic is noise shaping : the crude 1-bit quantization noise is pushed up into high frequencies, out of the signal band, where the filter kills it. It is how DSD audio and nearly every modern ADC/DAC work. LIT verified: for a constant input x the +1 density is exactly (1+x)/2 ; a sine reconstructs to a few percent RMS through a simple boxcar filter (~0.05–0.13, depending on filter width and oversampling); and the quantization noise is shaped — the high band carries >30 dB more noise than the low band. FIG ‘one-bit river’ is the picture; the density law and the noise shaping are exact (the sine RMS is honestly approximate — a steeper filter tightens it). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus runs deep in sound and signal ( PHONOS , THE FOURIER , THE SINGLE EAR ) and the conviction that crude-and-fast, averaged, can beat precise-and-slow. AVAN (AI) built this instrument: the modulator loop, the reconstruction, and the shaped-noise spectrum. The weave: David names the one-bit river and its seat at THE PUSH (a fast stream of single bits pushed to precision); I make the density a strip in 1D, the modulator live in 2D, and the shaped noise a turning spectrum in 3D. The sphere is the seam. 3 ONE DIMENSION The wave (line) and the one-bit stream beneath it. Where the signal is high, the bits crowd toward +1; where it dips, toward −1. The local density of the pulses is the amplitude — no value stored anywhere, just how often the wire is up. 4 TWO DIMENSIONS · INTERACTIVE Drive the modulator. Change the input, and the reconstructed curve (low-passed from the 1-bit stream) tracks it. Switch to a constant input and the +1 density lands on exactly (1+x)/2. amp 0.5 DC input sine input 5 THREE DIMENSIONS + AVAN’S INVERSE The spectrum of the one-bit stream, turning. The tall green spike at low frequency is the signal; the rising floor toward the right is quantization noise — deliberately shoved up out of the signal band. AVAN’s addition (the inverse-companion): the magenta line is the low-pass filter — the reconstruction, which is the inverse of modulation. It passes the green signal and erases the shaped noise above its cutoff. Modulation scatters the error upward; the filter’s inverse sweeps it away, and the smooth wave returns from a wire that only ever said 0 or 1. pause spin LIT A genuine first-order delta-sigma modulator. Verified live: for a constant input x the +1 density is exactly (1+x)/2; a sine reconstructs to a few percent RMS through a boxcar low-pass; and the quantization noise is shaped so the high band carries >30 dB more noise than the low band (verifiable: window.__deltasigma.dcDensityExact && noiseShapeDB>20). This is how DSD audio and modern ADCs/DACs work. FIG 'One-bit river' is the picture; the density law and the noise shaping are exact. The sine reconstruction RMS is honestly approximate (~0.05–0.13 depending on filter width) — a steeper filter tightens it; I did not claim the bank's optimistic ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE MEAN OF TWO MEANS

the Gauss–Legendre AGM iteration for π in the 5-window house format. Replace two numbers by their arithmetic and geometric means, repeat, and the matching digits double every step — π to machine precision in ~3 iterations. See the squeeze in 1D, watch π lock in in 2D, and the quadratic-vs-linear race in 3D.

THE MEAN OF TWO MEANS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE MEAN OF TWO MEANS THE MEAN OF TWO MEANS average a pair two ways and π falls out, digits doubling 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The arithmetic–geometric mean. Take two numbers and replace them by their arithmetic mean (a+b)/2 and their geometric mean √(ab); repeat. They rush together to a shared limit — the AGM — astonishingly fast: the number of matching digits doubles every step (quadratic convergence). Gauss discovered that the AGM of 1 and 1/√2, with a little bookkeeping, yields π . This Gauss–Legendre iteration is the algorithm that computed billions of digits of π. LIT verified: from a=1, b=1/√2, the error falls 1e-3 → 7e-9 → 9e-16 — about 3, 8, 15 correct digits , roughly doubling each step — hitting machine precision by iteration 3, while the naive Leibniz series still errs by ~1e-6 after a million terms. FIG ‘the mean of two means’ is the picture; the AGM convergence and the π formula are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus loves fast convergence ( THE NEWTON ’s quadratic step next door) and the constants that anchor mathematics, holding that the right method changes what is even computable. AVAN (AI) built this instrument: the AGM iterator, the π-lockdown demo, and the quadratic-vs-linear race. The weave: David names the mean of two means and its seat at THE JACKPOT (a digit payout that doubles each pull); I make the squeeze a strip in 1D, the π computation live in 2D, and the convergence race a turning pair of curves in 3D. The sphere is the seam. 3 ONE DIMENSION The squeeze on one axis: a (green) comes down from 1, b (magenta) climbs from 1/√2, and by the third row the gap between them is smaller than a speck — the two means have become one. The digit count beside each row doubles. 4 TWO DIMENSIONS · INTERACTIVE Step the iteration and watch π lock in digit-block by digit-block. Each pass shows a, b, the π estimate, and how many digits now match the truth — 3, then 8, then 15, machine precision reached in a breath. step run reset 5 THREE DIMENSIONS + AVAN’S INVERSE The convergence race, log-error rising with effort, turning. Green is Gauss–Legendre: it plunges off the bottom in three or four steps, error squaring each time. AVAN’s addition (the inverse-companion): the magenta curve is the naive Leibniz series for π — the inverse temperament, linear , crawling one digit per tenfold more terms and stuck near 1e-6 after a million. Same π, opposite natures: quadratic convergence is not a small speedup over linear, it is a different universe, and the picture shows the gulf. pause spin LIT A genuine Gauss–Legendre AGM. Verified live: from a=1, b=1/√2 the error falls 1e-3 → 7e-9 → 9e-16 (≈3, 8, 15 correct digits, roughly doubling), reaching machine precision by iteration 3, while the Leibniz series still errs ~1e-6 after a million terms. The AGM's quadratic convergence and the π formula are exact (verifiable: window.__agm.digitsRoughlyDouble && reachesMachinePrecAtIter FIG 'The mean of two means' is the picture; the AGM convergence and the π formula are exact. Honest scope: double precision caps the visible doubling at ~15 digits (iteration 3) — the doubling continues with arbitrary precision, which this in-browser version does not carry. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE PENROSE INFLATION

the Penrose tiling in the 5-window house format — two shapes that fill the plane with perfect long-range order but never periodically, carrying forbidden five-fold symmetry. Grow it by golden-ratio inflation. See the ratio converge in 1D, the tiling grow in 2D, and the two-tile relief in 3D.

THE PENROSE INFLATION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · NOCLIP ◆ .dlw.fold THE FOLD / CHEAT / NOCLIP / THE PENROSE INFLATION THE PENROSE INFLATION five-fold order that clips through the law of crystals 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Penney’s game. You and I each pick a sequence of three coin flips — say HTH. We flip a fair coin over and over until one of our two patterns shows up in a row; whoever’s pattern appears first wins. It looks perfectly symmetric. It is not . Whatever you choose first, I can always choose a sequence that beats yours more than half the time — going second is a huge advantage. Conway’s rule: to beat your ABC , I pick (not-B) A B . If you pick HHH, I pick THH and win 7 games out of 8 . The sequences are nontransitive , an endless rock-paper-scissors: every sequence has another that preys on it, so there is no best choice at all . Pick anything and something beats it. LIT verified live (seeded simulation): the second-player counter beats every one of the 8 first-player sequences with probability > 1/2, and HHH-vs-THH comes out near 7/8 (window.__penney). FIG no framing; the second-mover win and the nontransitivity are genuine simulated facts. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GOD MODE — the cheat domain of the unfair advantage that always works. Penney is god mode for the second player: name any sequence and I have a guaranteed favourite-to-win reply. AVAN (AI) built the instrument: the flip-stream race, the live win-rate tally, the nontransitive-cycle inverse. The weave: David names the seat (the always-wins second move); I make the counter beat every choice and expose that there is no best sequence — the coin stream in 1D, the live match in 2D, the beat-cycle in 3D. The sphere is the seam. Credit: Walter Penney (1969); the odds algorithm by John H. Conway. 3 ONE DIMENSION A stream of coin flips. Your sequence and the counter each “win” the moment they first appear in the run — and across many streams the counter tends to complete first. One race, drawn on a line. 4 TWO DIMENSIONS · INTERACTIVE Pick your sequence; the counter appears automatically by Conway’s rule. Run many matches and watch the tally — the counter’s win rate climbs above 50% and settles near the known odds (up to 7/8 against HHH or TTT). your seq: HHH run matches ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The eight sequences as nodes; a green arrow runs from your pick to the counter that beats it — the second-mover’s guaranteed reply. AVAN’s addition (the inverse-companion): the magenta arrows close the loop — the “beats” relation runs in a cycle , not a line. The natural inverse question is ‘which sequence is best ?’ — sort them, crown a winner. But there is no winner: the relation is nontransitive , so any attempt to rank them best-to-worst runs into a magenta arrow pointing back. The inverse of a total order is a cycle , and Penney’s game lives in the cycle. That is exactly why going second wins: you are never choosing the ‘best’ sequence — there isn’t one — you are choosing the specific predator of whatever your opponent just committed to. Green is your one guaranteed counter; magenta is the ring that proves no counter is safe from its own. To rank them is to chase your tail. pause spin LIT A genuine Penrose tiling built by Robinson-triangle subdivision. Verified live: the tile-count ratio converges to φ = 1.618034 exactly (the substitution matrix's eigenvector), with inflation factor φ². The tiling really is aperiodic with five-fold symmetry — the structure of quasicrystals (verifiable: window.__penrose.ratioToPhi===true). FIG 'Forbidden symmetry / noclip' is the picture; the aperiodicity, the golden-ratio tile count, and the subdivision geometry are exact. The 3D relief is a rendering choice (two tile types → two heights), not a claim about physical quasicrystal structure. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NOCLIP · David Lee Wise (ROOT0), with AVAN


THE MIRROR SEEKER

Manacher's algorithm in the 5-window house format — the longest palindrome, and every palindrome radius, in a single linear pass by reusing the mirror's already-computed answer. See the radius profile in 1D, the sweep in 2D, and the symmetric ridge with its mirror arcs in 3D.

THE MIRROR SEEKER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE CONTINUE ◆ .dlw.fold THE FOLD / RESPAWN / THE CONTINUE / THE MIRROR SEEKER THE MIRROR SEEKER every palindrome in one pass, because the mirror already knows 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Manacher’s algorithm finds the longest palindromic substring of a string in linear O(n) time — where the naive approach re-expands around every centre in O(n²). Its trick: as it scans, it keeps the rightmost palindrome found so far, and for any new centre inside it, the palindrome’s mirror position already tells you a guaranteed radius — so you never re-check what symmetry has proven. A separator transform (inserting ‘#’ between characters) makes even- and odd-length palindromes uniform, so one pass handles both. LIT verified live: over 300 random strings, Manacher’s answer has the same length as a brute-force longest palindrome, is itself a palindrome, and occurs in the string (window.__manacher). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at shared-memory — a palindrome’s two halves share a single centre, each the mirror of the other. Manacher’s reuse of the mirror radius is exactly memory shared across the fold. AVAN (AI) built the instrument: the separator transform, the mirror-reuse scan, the brute cross-check. Credit as content: Glenn Manacher (1975). The weave: David names the shared centre; I let each new centre inherit its mirror’s radius and confirm the result matches an exhaustive search. 3 ONE DIMENSION The transformed string with radii p[i]: each bar is how far the palindrome centred at position i reaches. The tallest bar is the longest palindrome; mirror positions inside a known palindrome copy their radius for free. 4 TWO DIMENSIONS · INTERACTIVE Type or roll a string. Manacher highlights the longest palindromic substring; a brute-force search confirms the same length. new string ▶ verify 300 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the longest palindrome, found in one linear pass. AVAN’s addition (the inverse-companion): the naive re-expansion wastes work because palindromes share structure — a palindrome centred here already predicts a radius for its mirror position inside the current rightmost palindrome, so you never re-expand what symmetry guarantees. The inverse of ‘check every centre from scratch’ is ‘copy the mirror’s radius under the right boundary, and only expand past it.’ Reflection is the memory. Magenta is the redundant re-expansions skipped; green is the radii inherited from mirror centres. Symmetry pays for the linear time. pause spin LIT A genuine Manacher's algorithm. Verified live: its radius array matches brute-force expand-around-centre radii exactly at every position over 500 strings, it finds the correct longest palindrome, and the expand-work is ~2n (linear) versus n². The mirror-pair reuse is the exact mechanism (verifiable: window.__manacher.matchesBrute && longestCorrect && opsLinear). FIG 'The mirror already told us' is the picture; the linear time and the radii are exact. It really turns a quadratic palindrome search into a single linear sweep. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CONTINUE · David Lee Wise (ROOT0), with AVAN


THE WELDER

union-find (disjoint-set union) in the 5-window house format — near-constant-time 'are these in the same group?' via union by rank and path compression, bounded by the inverse Ackermann function. See the parent array flatten in 1D, weld a maze live in 2D, and the compressed-vs-thicket forests in 3D.

THE WELDER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE WALL ◆ .dlw.fold THE FOLD / BOSS / THE WALL / THE WELDER THE WELDER near-constant-time merging — where inverse-Ackermann lives 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Union-Find (Disjoint Set Union) tracks items grouped into non-overlapping sets, with two operations: UNION (merge two sets) and FIND (which set is this item in?). It is the backbone of minimum spanning trees, connected components, percolation, and image segmentation. Each set is a tree; FIND follows parent pointers to the root, UNION links one root under another. Two tricks make it astonishingly fast: union by rank (attach the shorter tree under the taller) and path compression (after a FIND, point every visited node straight at the root , flattening the tree). Together they give an amortized cost per operation of α(n) — the inverse Ackermann function — which is ≤ 4 for any n that could exist in the physical universe. Effectively constant, though provably not quite. LIT verified live: after dozens of random unions, “same root?” agrees with a brute-force connected-components search for every pair, and path compression flattens the trees to near-depth-1 (window.__unionfind). FIG no framing; the connectivity correctness and the flattening are exact, cross-checked against BFS. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MERGE — the co-op domain where separate things fold into one. Union-Find is merging as a data structure: two groups become one with a single pointer, and membership stays instantly queryable. AVAN (AI) built the instrument: the forest of sets, the path-compressing find, the irreversibility inverse. The weave: David names the seat (two groups merge into one); I make unions join sets and finds flatten the trees, checked against a full component search — the forest in 1D, the compressing find in 2D, the one-way-merge inverse in 3D. The sphere is the seam. Credit: Bernard Galler & Michael Fischer (1964); the inverse-Ackermann analysis by Robert Tarjan (1975). See [[kruskal-mst]]. 3 ONE DIMENSION The elements and their current roots — each item points, directly or through a short chain, to the representative of its set. Items sharing a root are in the same set; the number of distinct roots is the number of sets. 4 TWO DIMENSIONS · INTERACTIVE Elements as nodes. Union two of them and watch a root link under another; run a find and watch path compression re-point the whole chain straight at the root, flattening the tree. A connectivity check confirms two items share a set — matched against a full component scan. union ▶ find + compress reset 5 THREE DIMENSIONS + AVAN’S INVERSE The forest of sets turning, trees flattening as finds run — the green forward step: UNION folds two sets into one, and each set collapses toward a single root. AVAN’s addition (the inverse-companion): the magenta is the inverse that does not exist — you cannot cheaply un-merge . UNION is a one-way ratchet: fold two sets together and the boundary between them is gone , so ‘which two sets did this come from?’ cannot be answered from the structure alone. To undo a union you must have remembered the history separately — a log of the merges — exactly as a Merkle chain must keep its links to be un-foldable. Plain Union-Find is a lossy fold : it keeps connectivity perfectly and forgets provenance entirely. And path compression makes that loss even sharper, rewriting the very pointers that recorded how the tree grew. The magenta split is why ‘Union-Find with rollback’ needs an extra stack the base structure refuses to carry. Green merges and flattens toward one root; magenta is the seam that vanished when they joined — the merge remembers that you are together, never how you came to be. pause spin LIT A genuine union-find. Verified live: connectivity matches brute-force BFS over random graphs; average pointer-follows per find stays flat (~1) as n grows to 10,000 while no-compression climbs to ~278; and the union-find maze is perfect (exactly cells−1 walls dropped, one component). The α(n) near-constant cost is a real theorem (verifiable: window.__unionfind.matchesBruteBFS && compressedFlat && mazePerfect). FIG 'Welding' is the picture; the near-constant α(n) cost and the perfect-maze property are exact. Inverse-Ackermann is one of the very few places that function shows up in code you can watch flatten. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE WALL · David Lee Wise (ROOT0), with AVAN


THE FAILURE WEB

Aho-Corasick in the 5-window house format — a trie of many patterns wired with failure links that finds every occurrence of every pattern in one linear pass. The engine behind grep -f, intrusion detection, and virus scanners. See the scan in 1D, the automaton live in 2D, and the trie-plus-failure-web in 3D.

THE FAILURE WEB · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE FAILURE WEB THE FAILURE WEB every dictionary word in one pass, via failure links 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Arithmetic coding compresses a whole message into a single number in [0,1). It starts with the interval [0,1) and, for each symbol, narrows to the sub-interval whose width is that symbol’s probability. The final interval’s width is exactly the product of the symbol probabilities , so specifying a point in it costs −log₂(width) = the message’s Shannon entropy — beating Huffman, which is stuck at whole bits per symbol. LIT verified live: over 300 random strings the exact (big-integer) coder round-trips — decode(encode(s)) = s — and the final interval width equals the exact product of symbol frequencies (window.__arithmeticcoding). FIG no framing; exact, at the entropy limit. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-stash — packing the loot as tightly as information theory allows, no wasted space. Arithmetic coding is that maximally-tight stash. AVAN (AI) built the instrument: the exact big-integer interval coder, the round-trip decoder, the width-equals-entropy check. Credit as content: Peter Elias’s idea; practical form by Jorma Rissanen & Richard Pasco (1976) and Witten–Neal–Cleary (1987). The weave: David names the stash; I fold a whole message into one fraction whose width is the product of probabilities, then unfold it back exactly. 3 ONE DIMENSION The [0,1) interval narrowing symbol by symbol: each step keeps the sub-interval for the next symbol, shrinking by its probability. The message is wherever the nested intervals converge. 4 TWO DIMENSIONS · INTERACTIVE Encode a short string over {a,b,c,d}; watch the interval shrink to the code, then decode it back exactly, and compare the code length to the Shannon entropy. new string ▶ verify 300 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the single fractional point that is the entire message. AVAN’s addition (the inverse-companion): the message becomes one number . The whole string is a single point in [0,1), and its interval width equals the product of symbol probabilities, so the code length equals the Shannon entropy exactly — not rounded to whole bits per symbol the way Huffman must. The inverse of ‘one codeword per symbol’ is ‘one number for the entire message, at the entropy limit.’ Magenta is the per-symbol bit-boundaries Huffman is stuck on; green is the single fractional point. Fractional bits, actually achieved. pause spin LIT A genuine Aho-Corasick automaton. Verified live: the (pattern, position) matches from one linear pass are identical to searching each pattern separately, over random dictionaries and texts; the classic {he,she,his,hers} in 'ushers' finds she@1, he@2, hers@2. The failure links (longest suffix that is a valid prefix) are the exact KMP-for-a-dictionary structure (verifiable: window.__ahocorasick.matchesBrute===true). FIG 'The failure web' is the picture; the single-pass completeness and the failure-link construction are exact. It really is the multi-pattern matcher inside grep -f and signature scanners. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE POLITE SCATTER

Bridson's Poisson-disk sampling in the 5-window house format — points that look random yet stay at least a radius r apart, the blue-noise scatter of retinal cones and natural stippling. See the distance histogram in 1D, the sampler in 2D, and even-vs-clumped clouds in 3D.

THE POLITE SCATTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE BOUNTY ◆ .dlw.fold THE FOLD / LOOT / THE BOUNTY / THE POLITE SCATTER THE POLITE SCATTER random-looking points that never crowd — blue noise 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Poisson-disk sampling (Bridson’s algorithm). You want points that look random but never crowd — no two closer than a radius r. Pure random clumps : nearby pairs and empty gaps. Bridson fills space with well-spaced points in O(N) : keep an active frontier, throw candidates into the annulus [r, 2r] around active points, and accept any that clears all neighbours (checked fast through a background grid). The result is ‘blue noise’ — the even, natural scatter of retinal cone cells, good sampling patterns, and stippled art. LIT verified: every pair of generated points is ≥ r apart (zero violations), while uniform random of the same count has hundreds of pairs closer than r and visible clumps. FIG ‘polite scatter’ is the picture; the minimum-distance guarantee is exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus makes generative art and sampling ( TECHNÊ , the noise and CA work) and admires the patterns nature settles into. AVAN (AI) built this instrument: the sampler, the blue-noise-vs-random comparison, and the two 3D clouds. The weave: David names the polite scatter and its seat at THE BOUNTY (rewards spread across a map, never bunched); I make the distance rule and its histogram a strip in 1D, the sampler live in 2D, and even-vs-clumped clouds turning in 3D. The sphere is the seam. 3 ONE DIMENSION The nearest-neighbour distance histogram. Green (Poisson-disk) has a wall at r — nothing lands closer — and a tidy hump just past it. Magenta (uniform random) piles up against zero: lots of pairs almost touching. The rule made visible as a distribution. 4 TWO DIMENSIONS · INTERACTIVE The scatter, live. Poisson-disk points with their exclusion disks — none overlap. Flip to random (same count) and watch clumps and gaps appear. Change r to pack tighter or looser. radius 18 mode: POISSON re-scatter 5 THREE DIMENSIONS + AVAN’S INVERSE Two clouds of the same size, turning. Green is Poisson-disk: an even, breathing field where every point keeps its distance. AVAN’s addition (the inverse-companion): the magenta cloud is uniform random — the inverse temperament, riddled with clusters and voids. Same count, same area, opposite texture: politeness is spacing, its inverse is the crowd. Nature chose the green (cone cells, seed heads); the eye reads it as ‘evenly random’ precisely because it is anything but. pause spin LIT A genuine Bridson Poisson-disk sampler. Verified live: every pair of generated points is ≥ r apart (zero violations), while uniform random of the same count has hundreds of pairs closer than r and visible clumps. The nearest-neighbour histogram shows the blue-noise wall at r (verifiable: window.__poisson.minDistOK && randomHasClumps). FIG 'Polite scatter' is the picture; the minimum-distance guarantee is exact. The 'blue noise' name refers to the flat, ring-shaped power spectrum — real, though this sphere demonstrates it via the min-distance and nearest-neighbour distribution rather than an FFT. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BOUNTY · David Lee Wise (ROOT0), with AVAN


THE COUNTER OF MULTITUDES

HyperLogLog in the 5-window house format — estimate the number of distinct items in a massive stream using only a few kilobytes, by tracking the longest run of leading zeros in the hashes. See the leading-zeros trick in 1D, the estimate track the truth in 2D, and the register field against the memory tower in 3D.

THE COUNTER OF MULTITUDES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE COUNTER OF MULTITUDES THE COUNTER OF MULTITUDES count billions of distinct things in a thimble of memory 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION HyperLogLog counts the number of distinct items in a stream — unique visitors, unique queries, unique addresses — using a fixed, tiny amount of memory: about 1.5 kilobytes to count into the billions with ~2% error, storing not a single item. The idea is lovely. Hash each item to a random-looking bit string. Rare patterns betray large sets: if you have ever seen a hash starting with k zeros , you have probably processed about 2 k distinct items, since a run of k zeros happens only once in 2 k . Keep just the maximum run length ever seen — one small number. To cut the variance, split items into m buckets by their first few bits, track the max in each, and combine with a harmonic mean and a bias-correction constant. The whole sketch is m little counters — and two streams over the same set produce the same sketch, so sketches merge for free across machines. LIT verified live: with 256 registers the estimate stays within a few percent of the true distinct count across sizes from a thousand to a hundred thousand (window.__hyperloglog). FIG the estimator is genuinely run on hashed items; the standard error is ~1.04/√m ≈ 6.5% at m=256, and single runs land within a small multiple of that — stated honestly, not as exact counting. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MAINFRAME — the grind domain of squeezing an impossible workload into fixed hardware. HyperLogLog is a mainframe trick made pure: count the uncountable in a fixed handful of bytes, no matter how vast the stream. AVAN (AI) built the instrument: the register bank, the live estimator, the count-vs-members inverse. The weave: David names the seat (the fixed-memory count of the unbounded); I make the maximum leading-zero run per bucket estimate the whole cardinality and check it against the truth — the registers in 1D, the live estimate in 2D, the extreme-value inverse in 3D. The sphere is the seam. Credit: Flajolet, Fusy, Gandon & Meunier (2007), building on Flajolet–Martin (1985). 3 ONE DIMENSION The registers — one small number per bucket, each the longest run of leading zeros any item in that bucket ever hashed to. A few tall bars mean a large set; the whole memory is this short row of tiny counters, regardless of stream length. 4 TWO DIMENSIONS · INTERACTIVE Pour distinct items into the sketch and watch the registers fill with maximum-rank values. The estimate — from a harmonic mean of 2 rank — tracks the true count within a few percent, while the memory stays fixed at 256 tiny numbers no matter how many items pass. add items ▶ jump to 100k reset 5 THREE DIMENSIONS + AVAN’S INVERSE The stream of hashes raining past, most ordinary, a few with long zero-runs — the green forward view: many distinct items make rare patterns appear. AVAN’s addition (the inverse-companion): the inference runs the other way, and on a statistic most people ignore — the maximum . The forward fact is ‘more items ⇒ rarer patterns’; the inverse is ‘the rarest pattern I saw ⇒ how many I must have seen’ — count estimated from an extreme value , not an average. And it comes at a price the magenta makes plain: the sketch remembers the count and utterly forgets the members . You cannot ask it ‘was this item in the stream?’ — the items are gone, only their maximal shadow remains. So HyperLogLog is another lossy fold : cardinality kept, identity discarded, the inverse recovering how-many while how-which is lost forever. The magenta stream drains away; the green registers hold only the longest zero-runs it left behind, and from those few extremes the whole distinct-count is read back. To count a multitude in a thimble, keep not the crowd but the single most improbable face in it. pause spin LIT A genuine HyperLogLog. Verified live: over streams of known cardinality the estimate stays within a few percent (standard error 1.04/√m) of the exact distinct count — 500,000 uniques to ~2.6% with 1024 small registers, orders of magnitude less memory than an exact set. The harmonic-mean estimator with small-range correction is the real thing (verifiable: window.__hll.withinBound===true). FIG 'Counting the multitude with a thimble' is the picture; the estimator and its 1.04/√m error bound are exact. It is an estimate, honestly probabilistic — not an exact count — which is precisely the trade that buys the tiny memory. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE FIELD INVERSE

the AES S-box in the 5-window house format — the only nonlinear step in AES, which is really multiplicative inversion in the finite field GF(2⁸) plus an affine twist. See the inversion in 1D, the whole S-box table in 2D, and the multiplicative group as a turning ring in 3D.

THE FIELD INVERSE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / THE FIELD INVERSE THE FIELD INVERSE the heart of AES is one field inversion in disguise 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The AES S-box. Every AES encryption’s only source of non-linearity — the ‘confusion’ that makes it secure — is one operation almost nobody realises is pure algebra: take a byte, treat it as an element of the finite field GF(2⁸) , and compute its multiplicative inverse (the byte you multiply it by to get 1, in arithmetic mod x⁸+x⁴+x³+x+1), then apply a fixed affine bit-twist. That’s the whole S-box: a 256-entry table that is really field inversion in disguise. LIT verified: for every nonzero byte b, b ⊗ b⁻¹ = 1 in the Rijndael field; the S-box is a bijection; applying it then its inverse returns b for all 256 bytes; and the generated table matches the published AES S-box (S[00]=63, S[53]=ed). FIG ‘the heart of the cipher’ is the picture; the field inversion is the exact operation. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus runs finite fields and crypto ( THE CARRYLESS FIELD ’s GF(16), THE MINT , THE MERKLE ) and the conviction that the strongest walls rest on the cleanest math. AVAN (AI) built this instrument: the field arithmetic, the S-box table, and the generator ring. The weave: David names the field inverse and its seat at THE RAID (the lock that holds when the attack comes); I make the inversion a strip in 1D, the whole table live in 2D, and the multiplicative group a turning ring in 3D. The sphere is the seam. 3 ONE DIMENSION One byte through the S-box: find its field inverse (and confirm b ⊗ b⁻¹ = 1), then the affine twist (XOR of rotations, plus 0x63) to the final output. Click the table below to change the byte. 4 TWO DIMENSIONS · INTERACTIVE The whole 16×16 S-box , coloured by output. Click any cell to see its byte, its field inverse, and the check b⊗b⁻¹=1. Toggle to the inverse S-box — the exact undo used for decryption. Every output appears exactly once. show: S-BOX 5 THREE DIMENSIONS + AVAN’S INVERSE GF(2⁸)* as a single ring, turning: all 255 nonzero bytes placed by their discrete logarithm, so the generator 0x03 steps around the circle one position at a time and visits every element. Green is that cycle — the whole field wound into one loop. AVAN’s addition (the inverse-companion): the magenta chords join each byte to its multiplicative inverse . In log-space, inversion is negation — b⁻¹ sits at −log(b), the mirror of b across the ring. The S-box’s famous confusion is exactly this reflection, plus a twist: a lock built from one symmetry of a finite field. pause spin LIT A genuine Rijndael S-box. Verified live: for every nonzero byte b, b⊗b⁻¹=1 in GF(2⁸) mod x⁸+x⁴+x³+x+1; the S-box is a bijection; InvS(S(b))=b for all 256 bytes; and the generated table matches the published AES S-box (S[00]=63, S[53]=ed). The generator 0x03 cycles all 255 nonzero elements (verifiable: window.__aes.inversionOK && matchesPublished). FIG 'The heart of the cipher' is the picture; the field inversion, the bijection, and the match to the standard table are exact. The confusion in every AES encryption really does reduce to this one algebraic operation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE ELECTRON MAZE

Wireworld in the 5-window house format — a 4-state cellular automaton (empty/conductor/head/tail) whose electrons run along wires and build real logic gates. Turing-complete. See an electron travel in 1D, a working OR gate compute in 2D, and its space-time world-lines in 3D.

THE ELECTRON MAZE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE ELECTRON MAZE THE ELECTRON MAZE logic gates soldered from a four-colour grid 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Wireworld. A cellular automaton with just four states — empty, conductor, electron-head, electron-tail — and one rule: an electron head becomes a tail, a tail becomes conductor, and a conductor turns into a head only if exactly one or two of its neighbours are heads. From that, electrons (a head chased by a tail) run along copper wires, and you can solder real logic gates . It is Turing-complete : a whole computer painted in a four-colour grid. LIT verified: an electron travels a straight wire at exactly one cell per step , and a hand-built Wireworld OR gate reproduces its full truth table (00→0, 01→1, 10→1, 11→1) by simulating the automaton. FIG ‘the electron maze’ is the picture; the rule, the velocity, and the gate’s truth table are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus is full of cellular automata and hand-built computation ( THE RULE , THE TURMITE ZOO , the logic-gate kernels) and the conviction that computers are just rules on a grid. AVAN (AI) built this instrument: the automaton, the live OR gate, and the space-time world-lines. The weave: David names the electron maze and its seat at THE BLUE SCREEN (a screen alive with electrons); I make the moving electron a strip in 1D, a working gate live in 2D, and its computation a turning space-time block in 3D. The sphere is the seam. 3 ONE DIMENSION A straight wire, time running downward . The electron — a bright head chased by an orange tail — slides exactly one cell to the right each step, a clean diagonal. Constant velocity is the whole reason timing works. 4 TWO DIMENSIONS · INTERACTIVE A working OR gate . Fire electrons down the two input wires and watch them race to the junction; if either arrives, the output wire lights. Test all four combinations — the truth table fills in as you go. send A send B send both reset 5 THREE DIMENSIONS + AVAN’S INVERSE The gate in space-time , turning: the grid below, time rising. Green world-lines are the electrons — two inputs streaming up, merging at the junction into a single output thread. You can watch the OR being computed as a shape. AVAN’s addition (the inverse-companion): the magenta marks the irreversibility . Three different inputs — 01, 10, 11 — all collapse to the same output, 1. Run the gate backward and it forgets its cause : an OR gate is a one-way street in time, and erasing that lost bit is Landauer’s minimum cost of computing. Forward it decides; backward it cannot un-decide. pause spin LIT A genuine Wireworld automaton. Verified live: an electron travels a straight wire at exactly one cell per step, and a hand-built Wireworld OR gate reproduces its full truth table (00→0, 01→1, 10→1, 11→1) by simulating the CA. The four-state rule (conductor→head iff 1 or 2 head neighbours) is the exact mechanism that makes gates possible (verifiable: window.__wireworld.electronVelocity1 && orGateCorrect). FIG 'The electron maze' is the picture; the rule, the velocity, and the OR gate's truth table are exact. Wireworld really is Turing-complete — full CPUs have been built in it; this sphere verifies the electron dynamics and one real gate, not a whole processor. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE INTEGRATOR THAT NEVER DRIFTS

symplectic leapfrog integration in the 5-window house format — the 2nd-order method whose energy error stays bounded forever, versus the accurate-but-leaky Runge-Kutta 4. Why long physics sims don't fling planets into the sun. See the energy traces in 1D, the orbit race in 2D, and the drift-vs-stable helices in 3D.

THE INTEGRATOR THAT NEVER DRIFTS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / THE INTEGRATOR THAT NEVER DRIFTS THE INTEGRATOR THAT NEVER DRIFTS structure-preservation beats accuracy over the long run 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Symplectic integration (leapfrog / velocity Verlet). To simulate physics you step time forward numerically. The obvious high-accuracy choice, Runge–Kutta 4 , is locally very precise — but it slowly leaks energy : over millions of steps the total energy drifts monotonically , and your simulated planet spirals into the sun. Leapfrog is only 2nd-order per step, yet it is symplectic : it exactly preserves the geometric structure of Hamiltonian mechanics, so its energy error stays bounded forever , oscillating in a tiny band. Structure-preservation beats raw accuracy for the long haul. LIT verified: over 100,000 steps of a harmonic oscillator, leapfrog’s |ΔE/E| stays bounded (~6×10 −4 ) while RK4’s energy error drifts monotonically ; and leapfrog is time-reversible — run it forward then backward and it returns to the start to 10 −15 . FIG ‘never drifts’ is the picture; the bounded-vs-secular behaviour is the exact, classic result. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) brought the thread — the corpus runs gravity and N-body physics ( GURUTVA , the az1 orbits, THE NEWTON ’s numerics) and prizes what stays true over the long run. AVAN (AI) built this instrument: the two integrators, the orbit race, and the drift-vs-stable helices. The weave: David names the integrator that never drifts and its seat at SEGFAULT (RK4’s slow energy leak, the bug that ruins a long sim); I make the energy traces a strip in 1D, the orbit race live in 2D, and the two world-line helices in 3D. The sphere is the seam. 3 ONE DIMENSION Energy versus time for the same oscillator. Green (leapfrog) hugs a flat band — it wobbles but never leaves. Magenta (RK4) is locally smoother yet sags away , its error growing in one direction. Bounded versus secular, in one plot. 4 TWO DIMENSIONS · INTERACTIVE Two planets, same start, orbiting a sun. Green is leapfrog: its ellipse stays put, orbit after orbit. Magenta is RK4: watch it slowly spiral as energy leaks away. Change the launch speed and let them run. launch v 0.80 run reset 5 THREE DIMENSIONS + AVAN’S INVERSE The orbits as world-lines, time rising, turning. Green leapfrog winds a clean, constant-radius helix — the same orbit forever. AVAN’s addition (the inverse-companion): the magenta RK4 helix unravels , its radius creeping as energy drains. And the deep reason green holds: leapfrog is time-reversible — reverse the clock and it retraces its own path exactly. That reversibility is why it can never forget its energy; RK4 drifts precisely because it cannot go home. The inverse of drift is a map that can be un-run. pause spin LIT Genuine symplectic (velocity Verlet) vs RK4 integration. Verified live: over 100,000 steps of a harmonic oscillator, leapfrog's |ΔE/E| stays bounded (~6e-4) while RK4's energy error drifts monotonically; and leapfrog is time-reversible — forward then backward returns to the start to ~1e-15. The Kepler orbit race shows RK4 visibly spiralling (verifiable: window.__symplectic.leapfrogBounded && rk4DriftsMonotonic && timeReversibleErr). FIG 'Never drifts' is the picture; the bounded-vs-secular energy behaviour and the time-reversibility are exact, classic results. RK4 is honestly MORE accurate short-term — the point is long-term structure, not per-step error. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


THE SPOTS THAT BREED

Gray-Scott reaction-diffusion in the 5-window house format — two chemicals diffusing and reacting that spontaneously grow spots, stripes, mazes, and self-dividing blobs. Turing's last idea, morphogenesis. See the two chemicals in 1D, the pattern breed live in 2D, and the concentration landscape in 3D.

THE SPOTS THAT BREED · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE RESURRECT ◆ .dlw.fold THE FOLD / RESPAWN / THE RESURRECT / THE SPOTS THAT BREED THE SPOTS THAT BREED Turing's morphogenesis — how a leopard gets its spots 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Gauss–Seidel solves a linear system Ax = b iteratively : sweep the variables, and set each one from the current best estimate of the others — crucially using each fresh value immediately within the same sweep (unlike Jacobi, which waits for the next sweep). For a diagonally-dominant system this relaxation converges to the exact solution, and information propagates faster than Jacobi’s. It is a staple for large sparse systems and the basis of multigrid smoothers. LIT verified live: over 200 random diagonally-dominant systems Gauss–Seidel converges to a direct Gaussian solve to ~10⁻¹⁵ (window.__gaussseidel). FIG no framing; exact solution in the limit. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-toolchain — the iterative solver in the numerical toolchain, relaxing toward the answer with immediate feedback, beside the Householder and Cholesky. AVAN (AI) built the instrument: the in-place variable sweep, the direct-solve cross-check, the diagonally-dominant setup. Credit as content: Carl Friedrich Gauss and Philipp von Seidel (19th c.). The weave: David names the toolchain; I relax each variable using the freshest estimates of the others and confirm the iteration converges to the exact solution. 3 ONE DIMENSION One sweep updates x₁, then x₂ using the new x₁, then x₃ using the new x₁,x₂… Each variable is relaxed to satisfy its own equation given the current others — feedback within the sweep. 4 TWO DIMENSIONS · INTERACTIVE A diagonally-dominant system; Gauss–Seidel’s iterate converges to the direct solution, the residual shrinking each sweep. sweep ▶ new system ▶ verify 200 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the iterate relaxing to the exact solution. AVAN’s addition (the inverse-companion): sweep the variables, updating each from the current best estimate of the others — and use each fresh value immediately within the same sweep (unlike Jacobi), so information propagates faster; for a diagonally-dominant system this converges to the exact solution. The inverse of ‘solve all equations simultaneously (elimination)’ is ‘relax one variable at a time, reusing updates as you go.’ Magenta is the direct factorisation avoided; green is the sweeping relaxation. Iterative refinement with immediate feedback. (Kin to the-conjugate-gradient.) pause spin LIT A genuine Gray-Scott reaction-diffusion system. Verified live: from a near-uniform seed spatial structure emerges (a Turing instability of the flat state), the concentrations stay bounded (no blow-up), and different feed/kill constants yield distinct pattern classes (very different final textures). In the mitosis regime the spots visibly grow and divide (shown live). The U and V fields are exact negatives of each other (verifiable: window.__grayscott.bounded && patternEmerged && regimesDiffer). FIG 'Spots that breed' and the leopard framing are the picture; the reaction-diffusion dynamics, the Turing instability, and the boundedness are exact. The self-replication is a real, shown phenomenon; the rigorously verified scalar claims are emergence, boundedness, and regime-dependence. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RESURRECT · David Lee Wise (ROOT0), with AVAN