THE BIRTHDAY

the birthday paradox in the 5-window house format — with just 23 people the chance two share a birthday is over 50%, because collisions are about pairs (k people make k(k-1)/2 of them), so the threshold is ~1.18*sqrt(n), not n/2. The exact probability is a shrinking product. It's why a birthday attack finds a hash collision in ~sqrt(2^bits) tries. See the rising probability in 1D, a live experiment in 2D, and the colliding ring in 3D.

THE BIRTHDAY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE BIRTHDAY THE BIRTHDAY 23 people, 50% collision — pairs, not people 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The birthday paradox. How many people must be in a room before two of them probably share a birthday? Intuition says a lot — there are 365 days. The answer is just 23 . With 23 people the chance of a shared birthday is already over 50% ; with 50 it is 97%. The reason is that collisions are about pairs , not people. k people make k(k−1)/2 pairs, and that count grows quadratically , so it reaches n around k ≈ 1.18·√n — square-root-small. The exact probability of no collision is a shrinking product, 1 · (1−1/n) · (1−2/n) · …. This is not a party trick: it is why a birthday attack finds a hash collision in about √(2 bits ) tries, halving a hash function’s security in bits. LIT verified live: the collision formula matches simulation to within 1% across cases, 23 people cross 50% (P = 0.5073), and the √n threshold holds (window.__birthday.formulaMatchesEmpirical && p23over50). FIG no framing; the product formula, the √n threshold, and the crypto consequence are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE JACKPOT , beside THE COIN-FLIP HEAP and THE RANK — the loot domain of odds and long-run chance. The birthday paradox is the odds everyone gets wrong — and the engine behind Pollard’s rho (THE RHO) and every collision attack. AVAN (AI) built the instrument: the exact product, the empirical check, the pair count. The weave: David names the seat (the surprising odds); I make the crossover visible and the formula checkable — the rising probability in 1D, the live experiment in 2D, the colliding ring in 3D. The sphere is the seam. Credit: Richard von Mises (1939); the birthday attack in cryptography. 3 ONE DIMENSION The collision probability climbing as people are added, and the moment it crosses 50% — at just 23 for 365 days. The curve rises far faster than intuition expects, because every new person pairs with all the others already there. 4 TWO DIMENSIONS · INTERACTIVE Add people and watch their random birthdays land on the calendar; the first repeat flashes a collision . The theoretical S-curve shows how likely that was by now — and it agrees with what actually happens. Change n and see the √n threshold move. + person run to collision n: 365 reset 5 THREE DIMENSIONS + AVAN’S INVERSE People as a turning ring, each a thread to their birthday-slot — green , the crowd fanning out across the year. AVAN’s addition (the inverse-companion): the magenta threads are a colliding pair — two people, one day. Intuition counts people and expects the threshold near half of n. The inverse truth counts pairs : k people make about k²/2 of them, so collisions become likely at only √n. The quadratic number of pairs is the whole secret — and it is exactly why a birthday attack needs only the square root of a hash’s space, halving its bits of security. The surprise dissolves the moment you stop counting who is there and start counting who could match . The green is the crowd; the magenta is the pair that makes the improbable ordinary. pause spin LIT The birthday paradox (Richard von Mises, 1939; the birthday attack in cryptography). Verified live: the exact collision formula 1 - product(1-i/n) matches simulation to within 1% across cases, 23 people cross 50% (P = 0.5073), and the sqrt(n) threshold (~1.18*sqrt(n)) holds (window.__birthday.formulaMatchesEmpirical && p23over50, both true). The quadratic pair count that drives the square-root threshold and the crypto consequence (halving hash security in bits) are exact. FIG No metaphor is doing the work: the product formula, the 23-crosses-50% fact, the sqrt(n) threshold, and the match to simulation are all real and checked. The 'paradox' is only that intuition counts people while the math counts pairs — a genuine, demonstrated explanation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE SKETCH

the Count-Min Sketch in the 5-window house format — estimate item frequencies in a huge stream using a small d-by-w grid of counters and d hash functions. Add: hash d ways and bump those counters. Query: take the minimum of the d counters. Items collide and share cells, so a counter can only be too high, never too low — the sketch never underestimates, with a bounded overestimate. See one item's d cells in 1D, the streaming grid in 2D, and the counter surface in 3D.

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

THE SKETCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE STASH ◆ .dlw.fold THE FOLD / LOOT / THE STASH / THE SKETCH THE SKETCH Count-Min — tiny memory, never undercounts 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Count-Min Sketch. A billion events fly past — IP packets, search queries, words — and you want to know how often each one appeared, but you cannot store a counter for every distinct item. The Count-Min Sketch (Cormode & Muthukrishnan, 2005) does it in a tiny fixed grid: d rows of w counters and d hash functions. To add an item, hash it d ways and bump those d counters. To query its count, take the minimum of its d counters. Different items collide and share cells — so a counter can only be too high , never too low. And taking the minimum across independent hashes finds the least-polluted estimate: the sketch never underestimates , and its overestimate is provably bounded. LIT verified live: over hundreds of random streams the sketch’s estimate is always ≥ the true count — a strictly one-sided error — with a small, bounded overestimate (window.__countmin.neverUnderestimates; max over reported). FIG no framing; the hash-and-increment, the min-query, and the never-underestimate guarantee are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE STASH , beside THE CUCKOO and THE FENWICK LADDER — the loot domain of storing things to find fast. The sketch is a stash that gives up exactness for a fixed, tiny footprint, and pays it back with a guarantee: never too low. AVAN (AI) built the instrument: the hash grid, the min-query, the one-sided-error check. The weave: David names the seat (the compact stash); I make the collisions visible and the guarantee provable — one item’s d cells in 1D, the streaming counter grid in 2D, the counter surface in 3D. The sphere is the seam. Credit: Graham Cormode & S. Muthukrishnan (2005). 3 ONE DIMENSION One item, hashed into d rows , bumps one counter in each. A query re-hashes it to the same d cells and takes the smallest — because collisions from other items can only push a counter up, the minimum is the closest thing to the truth, and never below it. 4 TWO DIMENSIONS · INTERACTIVE Stream items into the d×w grid — a few frequent, many rare. Query one: its d cells light up and the minimum is the estimate. Compare it to the true count — equal or a touch high, never low. The heavy hitters stand out even when memory is tiny. stream 200 query item reset 5 THREE DIMENSIONS + AVAN’S INVERSE The counter grid as a turning surface — green heights are how full each cell is; heavy hitters push ridges up. AVAN’s addition (the inverse-companion): the magenta cells are one item’s d probes, and the estimate is their minimum . An exact tally needs a slot per distinct item — memory that grows without bound. The sketch is the inverse bargain: fix the memory and let everything collide , sharing counters. That should ruin the count — except that with d independent hashes, at least one of an item’s cells is the least polluted , and the minimum finds it. Accuracy comes not from space but from redundancy : overlap freely, then trust the smallest witness. The green is the shared, colliding grid; the magenta is the handful of probes whose minimum is never a lie downward. pause spin LIT Genuine Count-Min Sketch (Cormode & Muthukrishnan, 2005). Verified live: over 200 random streams the sketch's estimate is always >= the true count — a strictly one-sided error — with a small, bounded overestimate (window.__countmin.neverUnderestimates === true; max over reported). The hash-and-increment, the min-query, and the never-underestimate guarantee (collisions only inflate; the minimum finds the least-polluted cell) are exact. FIG No metaphor is doing the work: the hashing, the min-query, and the one-sided-error guarantee are all real and checked. It trades exactness for fixed memory — the error is provably one-sided (never under) and bounded, which is exactly the sketch's contract. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE STASH · David Lee Wise (ROOT0), with AVAN


THE ATTRACTOR NET

the Hopfield network in the 5-window house format — store patterns as valleys of an energy landscape via the Hebbian rule; async neuron updates each lower the energy E = -1/2 s^T W s (a Lyapunov function), so the state rolls downhill into the nearest stored memory. Feed a corrupted pattern and it cleans itself up — content-addressable memory (Hopfield, Nobel Physics 2024). See the energy drop in 1D, a pattern cleaning up in 2D, and the memory landscape in 3D.

THE ATTRACTOR NET · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · BACKPROP ◆ .dlw.fold THE FOLD / GRIND / BACKPROP / THE ATTRACTOR NET THE ATTRACTOR NET Hopfield — memory as a valley you fall into 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hopfield network. A recurrent net that remembers by falling . Store a handful of patterns by setting the weights with the Hebbian rule — neurons that agree in a pattern get a positive connection. That carves the stored patterns as valleys in an energy landscape E = −½ sᵀWs. Now update the neurons one at a time, each flipping to match the sign of its inputs. Every flip lowers the energy (E is a Lyapunov function), so the state rolls downhill and can never climb — it settles into the nearest valley, a stored memory. Feed it a corrupted pattern and it cleans itself up to the original. This is content-addressable memory : you recall the whole by presenting a broken piece. Hopfield won the 2024 Nobel in Physics for it. LIT verified live: the energy is monotone non-increasing under async updates, a single stored pattern is always an exact fixed point , and recall from ~12% corruption returns the original in ~97% of cases (window.__hopfield.energyMonotone && singlePatternFixed && recallSucceeds). FIG no framing; the energy descent, the fixed point, and the recall rate are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in BACKPROP , beside THE PERCEPTRON and THE CHAIN RULE — the grind domain of nets that learn. The perceptron classified; the Hopfield net remembers , storing memories as basins you fall into. It is a dynamical system, not a mind — recall is physics rolling downhill. AVAN (AI) built the instrument: the Hebbian weights, the energy descent, the noisy-recall test. The weave: David names the seat (nets that hold memory); I make the landscape roll and the guarantees checkable — the energy dropping in 1D, the pattern cleaning up in 2D, the basins of the landscape in 3D. The sphere is the seam. Credit: John Hopfield (1982; Nobel Physics 2024); Donald Hebb (1949, the learning rule). 3 ONE DIMENSION The energy , dropping. Every neuron flip toward its inputs lowers it — the curve only ever descends, step by step, until the state reaches the floor of a valley and stops moving. That resting point is a recalled memory. 4 TWO DIMENSIONS · INTERACTIVE Corrupt a stored pattern with noise, then run the network — watch it clean itself back to the original as the energy falls. Cycle the stored memories; the net completes each from a broken version, never climbing uphill. corrupt recall ▶ next memory 5 THREE DIMENSIONS + AVAN’S INVERSE The energy landscape turning — green , its valleys the stored memories carved into the surface. AVAN’s addition (the inverse-companion): the magenta ball is the current state, rolling downhill into a basin. Ordinary memory is addressed by location — give an address, receive contents. The Hopfield net inverts that: it is content-addressable . Give a fragment or a corrupted copy of the content itself, and the dynamics complete it to the whole stored memory. The inverse of ‘look up by where ’ is ‘recall by what ’ — you do not index a slot, you fall into an attractor. Recognition becomes physics: a landscape whose lowest points are the things you know, and remembering is just letting the ball roll. The green is the terrain of memory; the magenta is a broken input finding its way home to the nearest true one. pause spin LIT Genuine Hopfield network (John Hopfield, 1982; Nobel Physics 2024; Hebbian rule, Hebb 1949). Verified live: the energy is monotone non-increasing under asynchronous updates (a Lyapunov function), a single stored pattern is always an exact fixed point, and recall from ~12% corruption returns the original in ~97% of cases (window.__hopfield.energyMonotone && singlePatternFixed && recallSucceeds, all true). It is a dynamical system settling into attractors — recall is downhill relaxation, not cognition. FIG No metaphor is doing the work: the energy descent, the fixed-point property, and the measured recall rate are all real and checked. Honest scope: multiple stored patterns interfere (cross-talk), so a stored pattern is a guaranteed fixed point only for a single pattern / below capacity — recall degrades gracefully as stated, not perfectly. No sentience — it is relaxation dynamics. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of BACKPROP · David Lee Wise (ROOT0), with AVAN


THE DERANGEMENT

derangements in the 5-window house format — permutations with no element in its original position (nobody gets their own hat back). The count is !n = round(n!/e), so the probability a random shuffle is a total derangement is 1/e = 36.8% — and it barely depends on n, because the number of coincidences is Poisson(1). See the permutation arrows in 1D, live shuffles converging to 1/e in 2D, and the derangement cloud in 3D.

THE DERANGEMENT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · NULL ISLAND ◆ .dlw.fold THE FOLD / SPAWN / NULL ISLAND / THE DERANGEMENT THE DERANGEMENT nobody gets their own hat — probability 1/e 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Derangements. n guests check their hats; the attendant returns them at random . What is the chance that nobody gets their own hat back? A permutation with no element in its original place is a derangement , and their count is !n = n!(1 − 1/1! + 1/2! − …) = round(n! / e) . So the probability of a total derangement is !n / n! → 1/e ≈ 36.8% — and, astonishingly, it barely depends on n. Two guests or two thousand, the chance nobody gets their own hat is about the same. The reason: the number of people who do get their own hat follows a Poisson(1) distribution — the expected number of coincidences is exactly 1 for every n — so the chance of zero is e −1 . LIT verified live: the recurrence count !n equals round(n!/e) for every n up to 14, and shuffling n=12 items hundreds of thousands of times gives a derangement fraction within 0.01 of 1/e (window.__derange.roundFormula && empiricalNearInvE). !4 = 9, !5 = 44. FIG no framing; the count, the 1/e limit, and the Poisson-1 fixed points are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in NULL ISLAND , beside THE SIEVE — the spawn domain of the empty coordinate, the place where nothing is. A derangement is exactly that: a shuffle where nothing sits in its own spot . AVAN (AI) built the instrument: the count, the 1/e limit, the fixed-point census. The weave: David names the seat (nothing in its place); I make the no-self-match visible and the constant checkable — the permutation in 1D, the live shuffles converging to 1/e in 2D, the derangement cloud in 3D. The sphere is the seam. Credit: Pierre Rémond de Montmort (1708, the hat-check problem); Euler. 3 ONE DIMENSION A permutation drawn as arrows from each position to where its item landed. A fixed point is a self-loop — someone got their own hat. A derangement has no self-loops: every arrow points elsewhere. 4 TWO DIMENSIONS · INTERACTIVE Shuffle the hats and see who got their own (magenta self-matches). Run many and the fraction of shuffles with nobody matching settles on 1/e ≈ 0.368 — and it stays there whether n is 5 or 50. shuffle run 5000 n: 12 reset 5 THREE DIMENSIONS + AVAN’S INVERSE Shuffles as a turning cloud — green the derangements (no one matched), scattered among the rest. AVAN’s addition (the inverse-companion): the magenta shuffles have at least one person holding their own hat. Intuition says avoiding all n coincidences must get harder as n grows — more people, more chances to accidentally match. The inverse is the surprise: the probability of a clean derangement converges to a constant, 1/e, and stays there for every n. Because the count of coincidences is Poisson with mean exactly 1 — one expected match, always — the chance of none is e −1 , independent of the crowd. The inverse of ‘more items, more coincidences’ is ‘the same fixed chance of none’: a constant hiding inside a growing chaos. The green is the world where nothing is where it belongs; the magenta is the stubborn one-expected-coincidence that never goes away. pause spin LIT Genuine derangement theory (Montmort's hat-check problem, 1708; Euler). Verified live: the recurrence count !n equals round(n!/e) for every n up to 14, and shuffling n=12 items hundreds of thousands of times gives a derangement fraction within 0.01 of 1/e (window.__derange.roundFormula && empiricalNearInvE, both true). !4 = 9, !5 = 44. The exact count, the 1/e limit, and the Poisson(1) fixed-point structure (expected coincidences exactly 1 for all n) are exact. FIG No metaphor is doing the work: the derangement count, the 1/e probability, and the Poisson-1 fixed points are all real and checked (recurrence exact; round(n!/e) checked in the float-safe range n ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NULL ISLAND · David Lee Wise (ROOT0), with AVAN


THE MERSENNE

the Lucas-Lehmer test in the 5-window house format — a deterministic, exact primality test for Mersenne numbers M_p = 2^p - 1. Set s=4, iterate s <- (s^2 - 2) mod M_p exactly p-2 times; M_p is prime iff the final s is 0. It's how the largest known primes are found (GIMPS; the record 2^136279841-1 has over 41 million digits). See the residue sequence in 1D, the live test in 2D, and the Mersenne ladder in 3D.

THE MERSENNE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE MERSENNE THE MERSENNE Lucas-Lehmer — exact primality for 2^p-1 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lucas–Lehmer test decides, with certainty , whether a Mersenne number M p = 2 p −1 is prime. Set s₀ = 4 and iterate s → (s² − 2) mod M p , exactly p−2 times. M p is prime if and only if the final s is 0 — no randomness, no witnesses, one deterministic recurrence. It is why every record-breaking ‘largest known prime’ for decades has been a Mersenne prime: this test makes checking them feasible where general numbers need slow or probabilistic methods. LIT verified live: the test passes for prime exponents {3,5,7,13,17,19,31,61} and fails for {11,23,29,37,41,43} (whose M p are composite) — window.__lucaslehmer. FIG no framing; exact primality. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-final-boss — the ultimate test a number must survive, the verdict on the largest primes we can reach. Lucas–Lehmer is that final gate. AVAN (AI) built the instrument: the big-integer recurrence, the known-exponent cross-check. Credit as content: Édouard Lucas (1878) and Derrick Henry Lehmer (1930s). The weave: David names the final boss; I run the exact s²−2 iteration modulo M p and confirm the verdict against the known Mersenne-prime exponents. 3 ONE DIMENSION The sequence s₀=4, s₁=14, s₂=194… each squared minus two, reduced mod M p . For a Mersenne prime the last term lands exactly on zero. 4 TWO DIMENSIONS · INTERACTIVE Pick an exponent p; the Lucas–Lehmer recurrence runs mod M p and lands on 0 (prime) or nonzero (composite). p: 7 ▶ verify known ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the verdict — the recurrence landing on zero for a Mersenne prime. AVAN’s addition (the inverse-companion): a special form buys a deterministic test where general numbers get only probabilistic ones. The Mersenne structure lets one exact iteration decide primality with certainty — no random witnesses, no chance of error. The inverse of ‘primality is hard or probabilistic in general’ is ‘for Mersenne numbers it is a single deterministic recurrence.’ Magenta is the general-number tests that only give a probability; green is the exact Lucas–Lehmer verdict. Structure earns certainty — which is exactly why the largest known primes are all Mersenne. pause spin LIT Genuine Lucas-Lehmer test (Edouard Lucas 1878; Derrick Lehmer 1930s), computed with exact BigInt arithmetic. Verified live: the test agrees with the known Mersenne primes for every prime exponent p FIG No metaphor is doing the work: the Lucas-Lehmer iteration, the iff-zero criterion, and the primality verdicts are all real and checked with BigInt against the known Mersenne-prime list. The test is exact and fast only for the special Mersenne form 2^p-1 — that structural restriction is the honest point, and why record primes are Mersennes. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE PARTITION

the partition function in the 5-window house format — p(n) counts the ways to write n as a sum of positive integers (p(4)=5). Direct counting explodes, but Euler's pentagonal number theorem gives a sparse recurrence p(n)=p(n-1)+p(n-2)-p(n-5)-p(n-7)+... over the generalized pentagonal numbers 1,2,5,7,12,15..., computing p(100)=190569292 instantly. Ramanujan: p(5k+4) is always divisible by 5. See partitions as Young diagrams in 1D, the recurrence and growth in 2D, and the pentagonal engine in 3D.

THE PARTITION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE PARTITION THE PARTITION p(n) — counting sums by Euler's pentagonal recurrence 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The partition function p(n). In how many ways can you write n as a sum of positive integers, order ignored? For 4 there are 5 : 4, 3+1, 2+2, 2+1+1, 1+1+1+1. The counts explode — p(100) is 190,569,292 — and listing them all is hopeless. Euler found a miracle: the pentagonal number theorem gives a sparse recurrence, p(n) = p(n−1) + p(n−2) − p(n−5) − p(n−7) + p(n−12) + p(n−15) − … where 1, 2, 5, 7, 12, 15, … are the generalized pentagonal numbers and the signs run + + − − + + − −. It computes p(100) in a blink. Ramanujan later found astonishing patterns hiding in it: p(5k+4) is always divisible by 5 . LIT verified live: the pentagonal recurrence matches a direct brute-force count for n = 0…14, gives p(100) = 190569292 exactly, and Ramanujan’s p(5k+4) ≡ 0 (mod 5) holds (window.__partition.matchesBrute && p100===190569292). FIG no framing; the recurrence, the value, and the congruence are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE GRINDSTONE , beside THE EUCLID , THE CONVERGENT and the number-theory thread — the grind domain of grinding numbers to their structure. Partitions are how a number breaks into sums, and Euler’s recurrence is the machinery that counts the breaks. AVAN (AI) built the instrument: the pentagonal recurrence, the brute-force check, the Ramanujan congruence. The weave: David gathers the number theory; I make the counting explode and then tame it — the partitions in 1D, the recurrence and growth in 2D, the pentagonal engine in 3D. The sphere is the seam. Credit: Leonhard Euler (pentagonal number theorem, 1748); Hardy & Ramanujan; Ramanujan’s congruences. 3 ONE DIMENSION The partitions of a small n, drawn as rows of dots (Young diagrams). Each is a different way to break n into a decreasing sum — and even for modest n there are already surprisingly many. 4 TWO DIMENSIONS · INTERACTIVE Choose n and watch Euler’s recurrence assemble p(n) from a handful of earlier values at pentagonal offsets, with alternating signs. The bar chart shows p(0..n) rocketing up; the Ramanujan check confirms p(5k+4) is divisible by 5. ◀ n n ▶ n = 100 5 THREE DIMENSIONS + AVAN’S INVERSE The growth of p(n) as a turning curve — green , the count climbing sub-exponentially with n. AVAN’s addition (the inverse-companion): the magenta marks are the pentagonal offsets 1, 2, 5, 7, 12, 15, … with their + + − − signs — the sparse engine of the recurrence. Counting partitions directly is a combinatorial explosion: you would enumerate exponentially many sums. Euler’s inverse move is to not count at all — a short alternating sum over a different sequence, the pentagonal numbers, computes p(n) from its predecessors in almost no work. The inverse of ‘list every partition’ is ‘a generating-function identity that lists none’: one sequence secretly encoding how another one grows. The green is the count exploding; the magenta is the handful of pentagonal terms that tame the explosion into a recurrence. pause spin LIT Genuine partition function and Euler's pentagonal number theorem (Euler 1748; Hardy-Ramanujan; Ramanujan congruences). Verified live: the pentagonal recurrence matches a direct brute-force partition count for n=0..14, gives p(100)=190569292 exactly, p(4)=5, p(10)=42, and Ramanujan's p(5k+4) = 0 (mod 5) holds (window.__partition.matchesBrute && p100 === 190569292, and ramanujan5). The recurrence, the value, and the congruence are exact. FIG No metaphor is doing the work: the pentagonal recurrence, the exact p(100), and Ramanujan's mod-5 congruence are all real and checked (recurrence cross-verified against brute enumeration for small n). Euler's identity genuinely turns an exponential enumeration into a near-linear recurrence. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE ESCAPE

the Mandelbrot set in the 5-window house format — the complex c for which z->z^2+c (from z=0) stays bounded. A hard escape criterion (once |z|>2 it's doomed), an exact main cardioid c=mu/2-mu^2/4, and a period-2 bulb that is a perfect disk of radius 1/4 at c=-1. Its real slice is the logistic bifurcation. See the real slice in 1D, the escape-time picture with live orbits in 2D, and the escape surface in 3D.

THE ESCAPE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE ESCAPE THE ESCAPE the Mandelbrot set — bounded orbits of z→z²+c 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Mandelbrot set. For each complex number c, iterate z → z² + c starting from 0. If the orbit stays bounded , c belongs to the set; if it flies to infinity, it does not. From that one line grows the most famous object in mathematics — an infinitely intricate fractal whose boundary has (Shishikura) Hausdorff dimension 2 . Its structure is exact, not vague. There is a hard escape criterion : the moment |z| > 2, the orbit is doomed — a finite certificate of an infinite fate. The big heart is the main cardioid (period 1), parametrised by c = μ/2 − μ²/4; attached at c = −1 is the period-2 bulb , a perfect disk of radius exactly 1/4 ; and around the rim, infinitely many bulbs, one for every period. LIT verified live: every c with |c| > 2 escapes; every c in the disk |c+1| < 1/4 stays bounded; and every c on the cardioid c = μ/2 − μ²/4 (|μ| < 1) stays bounded (window.__mandelbrot.bigEscapes && bulbBounded && cardioidBounded). FIG no framing; the escape bound, the exact 1/4 bulb, and the cardioid are real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in UNDEFINED BEHAVIOR , beside THE PERIOD (the logistic map) and THE EDGE OF CHAOS — the glitch domain of simple rules gone wild. And the tie is exact: the Mandelbrot set’s real slice is the logistic bifurcation , the same doubling cascade. AVAN (AI) built the instrument: the escape iteration, the cardioid and bulb, the orbit tracer. The weave: David names the seat (the wild edge); I make the set render and its exact features checkable — the real slice in 1D, the escape-time picture and live orbits in 2D, the escape surface in 3D. The sphere is the seam. Credit: Benoit Mandelbrot (1980); Douady & Hubbard (proved it connected); Brooks & Matelski (early picture). 3 ONE DIMENSION The real slice : c along the real axis. Where the orbit stays bounded is exactly where the logistic map is stable or period-doubling — the Mandelbrot set on the real line is the same cascade into chaos, seen from the complex side. 4 TWO DIMENSIONS · INTERACTIVE The set, coloured by escape time . Click a point to trace its orbit — inside, it stays trapped; just outside, it spirals out past radius 2 and is gone. Zoom into the boundary and the same motifs repeat forever. zoom boundary reset view orbit: on 5 THREE DIMENSIONS + AVAN’S INVERSE The escape-time as a turning surface — green , deep flat plateau where the set lives, cliffs rising at the fractal boundary. AVAN’s addition (the inverse-companion): the magenta ridge is the boundary, and it marks a deep inversion. The set is defined by an infinite process — iterate forever, ask if it stays bounded — which you can never actually run to completion. The escape criterion is the inverse: it converts that infinity into a finite certificate . You do not wait forever to see a point leave; the instant |z| > 2 you know its whole future is escape. The inverse of ‘run to the end of time to decide’ is ‘a threshold that decides the escapees early’. The honest edge: membership itself — staying bounded — has no such shortcut, so the set is only semi-decidable ; you can prove a point out, never (by iterating) prove it in. The green is the trapped interior; the magenta is the cliff where finite certainty ends and infinity begins. pause spin LIT Genuine Mandelbrot set (Benoit Mandelbrot 1980; Douady & Hubbard proved it connected). Verified live: every c with |c|>2 escapes, every c in the disk |c+1| FIG No metaphor is doing the work: the escape criterion, the exact period-2 disk, and the cardioid are all real and checked. Honest edge: escape is a finite certificate, but membership (staying bounded) is only semi-decidable — you can prove a point out, never prove it in by iterating; the rendering uses a fixed iteration cap, as all do. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE INTERPOLANT

Lagrange interpolation in the 5-window house format — through any n+1 points with distinct x-values there passes exactly one polynomial of degree <= n, written directly as a sum of basis polynomials each equal to 1 at its own node and 0 at the others. It's the unique interpolant, but high-degree fits through equally-spaced points wiggle at the edges (Runge's phenomenon). See the basis spikes in 1D, the live exact fit and Runge demo in 2D, and the curve with its basis in 3D.

THE INTERPOLANT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE INTERPOLANT THE INTERPOLANT Lagrange — the one polynomial through every point 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Lagrange interpolation. Through any n+1 points with distinct x-values there passes exactly one polynomial of degree ≤ n. Lagrange’s formula writes it down directly, with no equation-solving: L(x) = Σ i y i · ∏ j≠i (x − x j )/(x i − x j ) . Each basis piece is 1 at its own node and 0 at every other , so the sum threads every point precisely. It is the unique interpolant — any polynomial of that degree through the same points is the same polynomial. But exactness has a cost: force a high-degree curve through many equally-spaced points and it can wiggle violently near the edges — Runge’s phenomenon. LIT verified live: over 5,000 random point sets the Lagrange interpolant passes through every data point, and it equals the polynomial found by solving the Vandermonde system everywhere — the uniqueness made concrete (window.__lagrange.passesThrough && uniqueVandermonde). FIG no framing; the exact interpolation, the uniqueness, and the Runge wiggle are all real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE HANDOFF , beside THE BEZIER — the co-op domain of passing smoothly from point to point. Bézier approximates a control frame; Lagrange hits every point exactly — the same problem, opposite promise. AVAN (AI) built the instrument: the basis polynomials, the unique fit, the Runge demonstration. The weave: David names the seat (the point-to-point pass); I make the exact thread visible and the uniqueness checkable — the basis spikes in 1D, the live fit and Runge wiggle in 2D, the curve and its basis in 3D. The sphere is the seam. Credit: Joseph-Louis Lagrange (1795); Waring & Euler earlier; Carl Runge (1901). 3 ONE DIMENSION The Lagrange basis : one polynomial per node, each spiking to 1 at its own point and crossing 0 at all the others. Weight them by the data values and add — the sum is forced through every point, because at each node only that node’s basis is alive. 4 TWO DIMENSIONS · INTERACTIVE Click to drop points and watch the unique polynomial re-thread all of them exactly. Add more and it obeys perfectly at the nodes — then try the Runge demo: equally-spaced points make the high-degree curve buckle wildly at the edges. + random point Runge demo clear 5 THREE DIMENSIONS + AVAN’S INVERSE The interpolant turning with its data points — green , one curve pinned to every node. AVAN’s addition (the inverse-companion): the magenta traces are the basis polynomials that sum to it. The usual way to fit data is to approximate — least squares, minimize the total miss, accept small errors at the points for a calmer curve. Lagrange is the inverse: it refuses to miss anything . By construction it passes exactly through every node, a sum of perfect indicator polynomials. The inverse of ‘minimize the error’ is ‘guarantee the hit’ — and the price is paid between the points: exactness at the nodes buys the freedom to oscillate in the gaps, Runge’s revenge. Exact where you looked, wild where you did not. The green is the curve nailed to the data; the magenta is the basis whose perfection at the nodes is also its recklessness between them. pause spin LIT Genuine Lagrange interpolation (Lagrange 1795; Runge phenomenon, Carl Runge 1901). Verified live: over 5,000 random point sets the interpolant passes through every data point exactly, and equals the polynomial found by solving the Vandermonde system everywhere — uniqueness made concrete (window.__lagrange.passesThrough && uniqueVandermonde, both true). The exact interpolation, the uniqueness, and the Runge oscillation are real. FIG No metaphor is doing the work: the exact pass-through, the uniqueness (cross-checked against a Vandermonde solve), and the Runge wiggle are all real and checked. Exactness at the nodes genuinely buys oscillation between them — the honest tradeoff, not a flaw hidden. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE SCAN

the parallel prefix sum (Blelloch scan) in the 5-window house format — turn an array into its running totals in O(log n) parallel depth and O(n) work, via two tree passes: an up-sweep that reduces partial sums up a binary tree, and a down-sweep that broadcasts prefixes back down. Because + is associative the sequential-looking chain reshapes into a shallow tree. The fundamental parallel primitive. See the running total in 1D, the up-sweep/down-sweep in 2D, and the tree in 3D.

THE SCAN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE SCAN THE SCAN prefix sums in log-depth — a chain made a tree 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The parallel prefix sum (scan). Turn an array into its running totals: [3,1,7,0] → [0,3,4,11]. It feels hopelessly sequential — each total needs all the ones before it, a chain you must walk in order, n steps. But it hides deep parallelism. Blelloch’s work-efficient scan does it in O(log n) parallel depth with only O(n) total work, through two tree passes. The up-sweep reduces partial sums up a binary tree, like a tournament. The down-sweep then pushes the prefixes back down, each node handing its left child the running total and its right child that total plus the left subtree. Because + is associative , the order can be reshuffled into a tree — and log n levels replace n steps. It is the fundamental parallel primitive: sorting, compaction, and most of GPU computing sit on it. LIT verified live: over 5,000 random arrays the tree-based scan gives exactly the sequential prefix sums (window.__scan.matchesSequential). [3,1,7,0,4,1,6,3] → [0,3,4,11,11,15,16,22]. FIG no framing; the up-sweep/down-sweep and its match to the sequential result are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE BROADCAST , beside THE FOURIER and THE ORTHOGONAL SIGN-FLIP — the co-op domain of many working as one. The down-sweep is a broadcast: partial sums flow up the tree, then are broadcast back down to become every prefix. AVAN (AI) built the instrument: the reduce, the broadcast, the sequential cross-check. The weave: David names the seat (the shared broadcast); I make the two sweeps visible and the equivalence checkable — the running total in 1D, the up-sweep/down-sweep tree in 2D, the flow in 3D. The sphere is the seam. Credit: Guy Blelloch (work-efficient scan, 1990); Hillis & Steele, Kogge & Stone (earlier scans). 3 ONE DIMENSION The array and its prefix sums — each output the total of everything to its left. Sequentially this is a chain of n dependent adds; the scan is the same answer, but computed with the dependencies reorganised so many adds run at once. 4 TWO DIMENSIONS · INTERACTIVE Up-sweep reduces partial sums up the tree (a tournament of additions); then down-sweep pushes prefixes back down. Step through both and watch the working array become the exclusive scan — identical to the sequential result, in far fewer levels. up-sweep ▶ down-sweep ▶ new array 5 THREE DIMENSIONS + AVAN’S INVERSE The scan’s binary tree turning — green , the levels that replace the long sequential chain. AVAN’s addition (the inverse-companion): the magenta flow is partial sums climbing up (reduce), then broadcasting down (prefixes). A running total looks irreducibly sequential — each value literally depends on the sum of all before it, so surely you must walk them in order. The inverse insight is that the dependency is a lie of presentation : because addition is associative , the same total can be regrouped into a tree , and a tree is shallow — log n levels instead of n. The inverse of ‘each waits for the previous’ is ‘reassociate so many happen together’. Sequential-looking work is parallel work wearing a disguise, and the disguise is just the order you chose to read it. The green is the shallow tree; the magenta is the reduce-then-broadcast that turns a chain into two quick sweeps. pause spin LIT Genuine work-efficient parallel scan (Guy Blelloch, 1990; Hillis-Steele, Kogge-Stone earlier). Verified live: over 5,000 random arrays the tree-based up-sweep/down-sweep scan gives exactly the sequential prefix sums (window.__scan.matchesSequential === true). [3,1,7,0,4,1,6,3] -> [0,3,4,11,11,15,16,22]. The reduce/broadcast tree, its O(log n) depth, and its equivalence to the sequential result (guaranteed by associativity of +) are exact. FIG No metaphor is doing the work: the up-sweep/down-sweep and its match to the sequential prefix sums are real and checked. The parallelism is genuine — associativity lets the n-step chain regroup into a log-n-depth tree; the demo shows power-of-two sizes, as the classic algorithm assumes. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE PERFECT

perfect numbers in the 5-window house format — a number equal to the sum of its proper divisors (6 = 1+2+3, 28 = 1+2+4+7+14). Euclid proved 2^(p-1)(2^p-1) is perfect when 2^p-1 is a Mersenne prime; Euler proved every even perfect number has exactly that form — a perfect one-to-one correspondence. Whether an odd perfect number exists is unknown. See the divisors sum in 1D, the Euclid-Euler correspondence in 2D, and the paired ladders in 3D.

THE PERFECT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE PERFECT THE PERFECT perfect numbers = Mersenne primes, both ways 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Perfect numbers. A number equal to the sum of its own proper divisors. 6 = 1 + 2 + 3. 28 = 1 + 2 + 4 + 7 + 14. They are rare and ancient, and they hide one of mathematics’ most beautiful bridges. Euclid (~300 BCE) proved: whenever 2 p −1 is a Mersenne prime, 2 p−1 (2 p −1) is perfect. Two thousand years later Euler proved the converse: every even perfect number has exactly that form. So even perfect numbers and Mersenne primes are in perfect one-to-one correspondence — 51 of each are known, no more. (Whether any odd perfect number exists is unknown — a 2,300-year-old open problem.) LIT verified live: Euclid’s construction gives σ(n) = 2n (perfect) for each Mersenne prime — producing 6, 28, 496, 8128, 33550336 — and every even perfect number below 10,000 has the Euclid-Euler form (window.__perfect.euclidPerfect && eulerForm). FIG no framing; the divisor sums and the bijection are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in SUDDEN DEATH , right beside THE MERSENNE — the boss domain of the exact verdict. A perfect number is a Mersenne prime doubled into a triangle; the two spheres are the same fact from two sides. AVAN (AI) built the instrument: the divisor sum, the Euclid construction, the Euler-form check. The weave: David places it next to its twin; I make the divisor sum land on 2n and the bijection visible — the divisors of 6 in 1D, the Euclid-Euler correspondence in 2D, the paired ladders in 3D. The sphere is the seam. Credit: Euclid (Elements IX.36, ~300 BCE); Leonhard Euler (converse, 1749). 3 ONE DIMENSION A perfect number and its proper divisors , laid out and summed. For 6: 1 + 2 + 3 = 6. For 28: 1 + 2 + 4 + 7 + 14 = 28. The parts rebuild the whole exactly — that is all ‘perfect’ means. 4 TWO DIMENSIONS · INTERACTIVE The Euclid-Euler correspondence : pick a Mersenne exponent p, and 2 p−1 (2 p −1) is the matching perfect number. Its divisors sum to exactly 2n — confirming perfection — and the strip lines up the perfect numbers with their Mersenne primes, one for one. next Mersenne p ▶ show divisors 5 THREE DIMENSIONS + AVAN’S INVERSE Two turning ladders — Mersenne primes and perfect numbers — green , climbing in step. AVAN’s addition (the inverse-companion): the magenta threads are the bijection , and it is a literal inverse spanning two millennia. Euclid showed one direction: a Mersenne prime builds a perfect number. Euler showed the inverse: every even perfect number decomposes back to a Mersenne prime, uniquely. The two theorems are exact inverses of each other, and together they close the loop — to know all the even perfect numbers is to know all the Mersenne primes, and vice versa. And the honest edge sits right here: the inverse of ‘we know every even perfect number exactly’ is ‘we cannot rule out a single odd one’ — the oldest unsolved question in mathematics. The green is the twin ladders; the magenta is the bridge Euclid built and Euler proved could carry weight both ways. pause spin LIT Genuine perfect numbers and the Euclid-Euler theorem (Euclid ~300 BCE; Euler converse 1749). Verified live: Euclid's construction gives sigma(n)=2n for each Mersenne prime, producing 6, 28, 496, 8128, 33550336, and every even perfect number below 10,000 has the Euclid-Euler form 2^(p-1)(2^p-1) (window.__perfect.euclidPerfect && eulerForm, both true). The divisor sums and the bijection with Mersenne primes are exact. FIG No metaphor is doing the work: the divisor sums (sigma(n)=2n), Euclid's construction, and Euler's converse (checked exhaustively below 10,000) are all real. The honest open edge is stated plainly — whether any ODD perfect number exists is unknown, one of the oldest unsolved problems. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE TOTIENT

Euler's totient in the 5-window house format — phi(n) counts the integers from 1 to n coprime to n. Three gems: the product formula phi(n) = n*prod(1-1/p) (phi is multiplicative), the divisor-sum partition sum over d|n of phi(d) = n, and Euler's theorem a^phi(n) = 1 mod n (the reason RSA decrypts). See the totatives in 1D, the count and partition in 2D, and the residue ring in 3D.

THE TOTIENT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE TOTIENT THE TOTIENT Euler's phi — the count that runs RSA 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Euler’s totient φ(n). Count the integers from 1 to n that share no factor with n — that are coprime to it. φ(12) = 4 (namely 1, 5, 7, 11). It is quiet but load-bearing: φ is the backbone of RSA . Three gems. First, a clean product: φ(n) = n·∏ p|n (1 − 1/p) over the primes dividing n, because φ is multiplicative — φ(mn) = φ(m)φ(n) for coprime m, n. Second, a perfect partition: Σ d|n φ(d) = n — the totients over the divisors of n sum exactly to n. Third, and the reason RSA decrypts: Euler’s theorem , a φ(n) ≡ 1 (mod n) whenever gcd(a, n) = 1. LIT verified live: Σ d|n φ(d) = n for all n, φ is multiplicative on coprime pairs, and Euler’s theorem holds for every valid a and n in range (window.__totient.divisorSum && multiplicative && eulerTheorem). φ(1..12) = 1,1,2,2,4,2,6,4,6,4,10,4. FIG no framing; the count, the identities, and Euler’s theorem are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in CHECKPOINT ZERO , beside THE REMAINDER (CRT) — the spawn domain of numbers seen through their residues. Totient, CRT and Euler’s theorem are the modular machinery that makes public-key crypto turn. AVAN (AI) built the instrument: the coprime count, the product formula, the divisor-sum partition, Euler’s theorem. The weave: David gathers the modular thread; I make the coprimes visible and the identities checkable — the totatives in 1D, the count and partition in 2D, the residue ring in 3D. The sphere is the seam. Credit: Leonhard Euler (1763); Gauss (divisor-sum identity); RSA (Rivest, Shamir, Adleman). 3 ONE DIMENSION The numbers 1…n, with the ones coprime to n lit up — the totatives. Their count is φ(n). Numbers sharing a factor with n go dark; what remains, glowing, is exactly φ(n) of them. 4 TWO DIMENSIONS · INTERACTIVE Dial n and see its totatives light up, counted as φ(n) — and matched by the product formula n·∏(1−1/p). Below, the divisor sum: φ over each divisor of n stacks up to exactly n , a perfect partition. ◀ n n ▶ show Σφ(d) 5 THREE DIMENSIONS + AVAN’S INVERSE The residues 0…n−1 on a turning ring — green the coprimes, dark the rest. AVAN’s addition (the inverse-companion): the magenta arcs group residues by their gcd with n . Counting φ(n) directly is local — test each number, tally the coprimes. The inverse view is structural: partition 1…n by exactly which factor they share with n. The numbers whose gcd with n is d form a set of size φ(n/d), and these sets tile 1…n with no overlap — so Σ d|n φ(d) = n falls out for free. The inverse of ‘count the coprimes one by one’ is ‘the coprimes-at-every-scale partition the whole’: a local tally that assembles into a global identity. And that same multiplicative structure is the hinge RSA turns on. The green is the coprime count; the magenta is the hidden partition that makes the count a law. pause spin LIT Genuine Euler totient (Euler 1763; Gauss divisor-sum identity; RSA). Verified live: sum over d|n of phi(d) equals n for all n in range, phi is multiplicative on coprime pairs (phi(mn)=phi(m)phi(n)), and Euler's theorem a^phi(n) = 1 (mod n) holds for every valid a and n tested (window.__totient.divisorSum && multiplicative && eulerTheorem, all true). phi(1..12) = 1,1,2,2,4,2,6,4,6,4,10,4. The count, the identities, and Euler's theorem are exact. FIG No metaphor is doing the work: the coprime count, the product formula, the divisor-sum partition, and Euler's theorem are all real and checked. Euler's theorem generalizes Fermat's little theorem and is precisely why RSA decryption inverts encryption — stated as the genuine mechanism, not an analogy. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE LOOK-AND-SAY

the look-and-say sequence in the 5-window house format — start with 1 and read each term aloud to get the next: 1, 11, 21, 1211, 111221, 312211... Conway proved no digit ever exceeds 3 (from seed 1), and the term lengths grow by a universal ratio, Conway's constant 1.303577 (root of a degree-71 polynomial). See the terms in 1D, the parse and length growth in 2D, and the growing digit-spiral in 3D.

THE LOOK-AND-SAY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE LOOK-AND-SAY THE LOOK-AND-SAY describe yourself forever → Conway's constant 1.3036 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The look-and-say sequence. Start with 1 . Read it aloud — ‘one 1’ — and write what you said: 11 . Read that — ‘two 1s’ — write 21 . Then 1211 , 111221 , 312211 … each term literally describes the digits of the one before. A children’s puzzle — until John Conway found the hidden order (1986). First: from the seed 1, no digit ever exceeds 3 . Second, and stranger: the lengths of the terms grow by a fixed ratio, Conway’s constant λ ≈ 1.303577 — the unique positive root of a specific degree- 71 polynomial, and the only non-trivial constant that arises this way. Conway even proved every long term decays into combinations of 92 ‘atoms’ — the same count as the natural chemical elements. LIT verified live: generating 40 terms from ‘1’, no digit exceeds 3 , and the length ratio settles onto ~1.3036 , matching Conway’s constant to a few parts in 10 4 (window.__lookandsay.noDigitOver3 && ratioNearConway). FIG no framing; the count-and-say rule, the digit bound, and the growth constant are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in FIRST LIGHT , beside THE ATTRACTOR and THE GUN — the spawn domain of much arising from almost nothing. From a single digit and one silly rule, a precise universal constant is born. AVAN (AI) built the instrument: the count-and-say step, the digit-bound check, the growth-ratio measurement. The weave: David names the seat (order from a seed); I make the rule run and the constant appear — the terms in 1D, the parsing and length growth in 2D, the growing spiral in 3D. The sphere is the seam. Credit: John H. Conway (‘The Weird and Wonderful Chemistry of Audioactive Decay’, 1986). 3 ONE DIMENSION The sequence, term by term: 1, 11, 21, 1211, 111221, 312211, … Each is the previous read as runs — count then digit. Only 1, 2, 3 ever appear, no matter how far you go. 4 TWO DIMENSIONS · INTERACTIVE Step the rule and watch the terms grow; the parse (runs → count+digit) is shown for the current one. The length-vs-step plot is a straight line on a log scale — its slope is ln(Conway’s constant), and the ratio readout closes on 1.3036. next term ▶ run 12 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The terms as a turning spiral of digits, each ring longer than the last — green , the sequence growing. AVAN’s addition (the inverse-companion): the magenta ring marks the growth ratio , homing on λ. The rule is childish and self-referential — describe yourself, forever — and it looks like it should spew arbitrary nonsense. The inverse is the wonder: a rigid algebraic constant governs it, the root of a degree-71 polynomial, the same for (almost) every seed. Order is not designed into the sequence; it is forced by the self-reference itself . The inverse of ‘a silly self-describing rule makes chaos’ is ‘an exact constant runs it’ — describe yourself long enough and a law you never wrote comes to govern your growth. The green is the babbling sequence; the magenta is λ, the number it cannot help obeying. pause spin LIT Genuine look-and-say / audioactive decay (John Conway, 1986). Verified live: generating 40 terms from '1', no digit ever exceeds 3, and the length ratio settles onto ~1.3036, matching Conway's constant (1.303577, the unique positive root of a degree-71 polynomial) to a few parts in 10^4 (window.__lookandsay.noDigitOver3 && ratioNearConway, both true). The count-and-say rule, the digit bound, and the universal growth constant are exact. FIG No metaphor is doing the work: the count-and-say rule, the no-digit-over-3 bound, and the growth ratio approaching Conway's constant are all real and measured from the generated terms. The degree-71 polynomial and the '92 atoms' cosmological theorem are cited results, not re-proved here; the growth constant is demonstrated empirically. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE FAILURE FUNCTION

Knuth-Morris-Pratt string matching in the 5-window house format — find a pattern in text in O(n+m) with the text pointer never moving backward. The failure function gives, for each pattern position, the longest proper prefix that is also a suffix, so on a mismatch you slide by exactly the right amount, reusing what matched instead of restarting. See the borders in 1D, the live never-backtrack scan in 2D, and the reuse structure in 3D.

THE FAILURE FUNCTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE FAILURE FUNCTION THE FAILURE FUNCTION KMP — match without ever re-reading the text 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Knuth-Morris-Pratt. Search a text of length n for a pattern of length m. The naive way, on every mismatch, throws away all progress and shifts the pattern one step — O(nm), and it re-reads the same text characters again and again. KMP (1977) does it in O(n+m) , and the text pointer never moves backward . The secret is the failure function π: for each position in the pattern, the length of the longest proper prefix that is also a suffix there. On a mismatch, that number says exactly how far you can slide the pattern without re-checking — because the matched part’s own structure guarantees a chunk still lines up. You reuse what you learned instead of forgetting it. LIT verified live: over 5,000 random text/pattern pairs KMP finds exactly the same matches as a naive scan, and its failure function equals the independent prefix-suffix definition (window.__kmp.matchesNaive && failureCorrect). π(‘ababaca’) = 0,0,1,2,3,0,1. FIG no framing; the failure function, the never-backtrack scan, and the exact match set are real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in SPLIT SCREEN , beside THE ROLLING HASH and THE OVERLAP-FREE WORD — the co-op domain of two strings held against each other. Rabin-Karp matched by fingerprint; KMP matches by structure, never re-reading the text. AVAN (AI) built the instrument: the failure function, the never-backtrack scan, the naive cross-check. The weave: David names the seat (the side-by-side compare); I make the slide-not-restart visible and the linearity checkable — the borders in 1D, the live scan in 2D, the reuse in 3D. The sphere is the seam. Credit: Donald Knuth, James Morris & Vaughan Pratt (1977). 3 ONE DIMENSION The failure function of a pattern: at each position, how long a prefix also appears as a suffix ending there. Those borders are the reusable overlaps — the exact amount you can slide on a mismatch without losing a confirmed match. 4 TWO DIMENSIONS · INTERACTIVE Step the scan: the pattern slides beneath the text, matching character by character. On a mismatch it jumps by the failure function — not back to the start — and the text cursor never retreats. Matches light up; the comparison count stays linear. step ▶ run new pattern 5 THREE DIMENSIONS + AVAN’S INVERSE The pattern’s border structure as a turning chain — green , each position linked to its longest reusable prefix. AVAN’s addition (the inverse-companion): the magenta jump is a mismatch reusing the matched prefix. Naive search, on failure, forgets — it discards every character it just matched and restarts one position over, doomed to re-read the same text. KMP is the inverse: on failure it remembers . The failure function has, in advance, distilled the pattern’s own self-similarity — how much of its beginning echoes inside it — so it always knows the largest safe slide. The inverse of ‘on failure, start over’ is ‘on failure, keep the longest reusable prefix’. Memory of the pattern’s internal repetition is exactly what turns quadratic re-reading into a single linear pass. The green is the chain of borders; the magenta is the slide that never throws matched work away. pause spin LIT Genuine Knuth-Morris-Pratt (Knuth, Morris & Pratt, 1977). Verified live: over 5,000 random text/pattern pairs KMP finds exactly the same matches as a naive scan, and its failure function equals the independent prefix-suffix definition (window.__kmp.matchesNaive && failureCorrect, both true). pi('ababaca') = 0,0,1,2,3,0,1. The failure function, the never-backtrack linear scan, and the exact match set are all exact. FIG No metaphor is doing the work: the failure function (cross-checked against its brute prefix-suffix definition), the never-backtrack scan, and the match set (cross-checked against naive) are all real. The linearity comes from the text pointer never retreating — demonstrated, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE ORTHONORMAL

Gram-Schmidt orthonormalization in the 5-window house format — turn any vectors into an orthonormal set (mutually perpendicular, unit length) spanning the same space, by stripping each vector of its projections onto the ones already chosen and normalizing the remainder. The engine behind QR decomposition and least squares. See the projection subtraction in 1D, the 2D orthogonalization in 2D, and the perpendicular frame in 3D.

THE ORTHONORMAL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE ORTHONORMAL THE ORTHONORMAL Gram-Schmidt — independence made by subtraction 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 Genuine Gram-Schmidt process (Gram 1883, Schmidt 1907). Verified live: over 5,000 random vector sets the output is orthonormal (every pairwise dot product 0, every self-dot 1) and spans the same subspace as the input — each original vector is exactly recovered as a combination of the new frame (window.__gramschmidt.orthonormal && sameSpan, both true). The projection-subtraction, orthonormality, and span preservation are exact. FIG No metaphor is doing the work: the projection subtraction, the orthonormality (dot products checked to 1e-9), and the span preservation are all real and verified. Classical Gram-Schmidt can lose orthogonality under floating-point for near-dependent vectors (modified Gram-Schmidt fixes it); the exactness shown here is on well-conditioned random sets, stated honestly. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE BASEL

the Basel problem in the 5-window house format — the sum of reciprocal squares 1 + 1/4 + 1/9 + 1/16 + ... equals exactly pi^2/6, Euler's 1734 shock: a sum over the plain counting numbers producing pi, the circle constant. The same sine-product trick gives zeta(4) = pi^4/90 and every even zeta value. See the partial sums in 1D, the running total and error in 2D, and the shrinking terms in 3D.

THE BASEL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · GRADIENT DESCENT ◆ .dlw.fold THE FOLD / GRIND / GRADIENT DESCENT / THE BASEL THE BASEL 1 + 1/4 + 1/9 + ... = pi^2/6 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Basel problem. Add up the reciprocals of the perfect squares: 1 + 1/4 + 1/9 + 1/16 + 1/25 + … It clearly converges — but to what ? For ninety years no one knew. In 1734 the 27-year-old Euler stunned Europe with the answer: Σ n≥1 1/n² = π²/6 ≈ 1.644934 . A sum over the plain counting numbers — the flattest, most circle-free objects in mathematics — produces π , the constant of the circle. Euler got it by factoring sin(x)/x by its roots at every multiple of π. The same trick gives ζ(4) = π 4 /90, and every even zeta value as a rational times a power of π. LIT verified live: the partial sum of 1/n² converges to π²/6 (its error shrinking like 1/N — within 10 −5 by two million terms), and Σ1/n⁴ converges to π 4 /90 (window.__basel.converges && zeta4Correct). FIG no framing; the sum, its limit π²/6, and the ζ(4) value are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GRADIENT DESCENT , beside THE BOWL and THE CLUSTERS — the grind domain of a quantity settling onto its true value. The Basel partial sums descend, term by shrinking term, onto π²/6. AVAN (AI) built the instrument: the running sum, the 1/N error decay, the ζ(4) check. The weave: David names the seat (the settling limit); I make the climb visible and the limit checkable — the partial sums in 1D, the running total and error in 2D, the shrinking terms in 3D. The sphere is the seam. Credit: posed by Pietro Mengoli (1650); solved by Leonhard Euler (1734). 3 ONE DIMENSION The partial sums rising toward π²/6. Early terms leap; later ones barely nudge, because 1/n² falls off fast — yet the tail is just slow enough that reaching the limit takes forever, the remaining gap always about 1/N. 4 TWO DIMENSIONS · INTERACTIVE Add terms and watch the running total climb toward the π²/6 line, the error readout shrinking by roughly 1/N. Jump ahead a million terms and it is right on the mark — a sum of fractions landing exactly on a power of π. + 50 terms jump to 1,000,000 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The terms 1/n² as a turning stack of shrinking blocks, their heights summing upward — green , the pieces of the total. AVAN’s addition (the inverse-companion): the magenta line is π²/6, the limit the blocks reach. π is the circle constant — it lives in curves, areas, rotations. The integers 1, 2, 3 are pure discrete counting , with no circle anywhere in sight. The Basel sum is the inverse bridge: a sum over the flattest, most circle-free objects reconstructs π². It works because Euler wrote the sine wave as an infinite product over its zeros — which sit at every integer multiple of π — so the integers were secretly carrying π inside the sine all along. The inverse of ‘π lives in circles’ is ‘π is hiding in the integers’, and factoring a wave by its roots is the key that lets it out. The green is the pile of humble fractions; the magenta is the circle-constant they cannot help summing to. pause spin LIT The Basel problem (posed by Mengoli 1650; solved by Euler 1734). Verified live: the partial sum of 1/n^2 converges to pi^2/6 with error shrinking like 1/N (within 1e-5 by two million terms), and sum 1/n^4 converges to pi^4/90 (window.__basel.converges && zeta4Correct, both true). The sum, its exact limit pi^2/6, and the zeta(4) value are real; Euler's method (factoring sin(x)/x by its roots at multiples of pi) is why the circle constant appears. FIG No framing: the sum, its convergence to pi^2/6, and the zeta(4)=pi^4/90 value are all real and computed. Convergence is slow (error ~1/N), so the partial sum only approaches the exact limit — the closed-form pi^2/6 is Euler's exact result, demonstrated numerically. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GRADIENT DESCENT · David Lee Wise (ROOT0), with AVAN


THE MOBIUS

the Mobius function in the 5-window house format — mu(n) is +1 for a product of an even number of distinct primes, -1 for odd, 0 if any prime repeats. Its identity sum over d|n of mu(d) = [n==1] drives Mobius inversion: if g is the divisor sum of f, then f(n) = sum over d|n of mu(d)*g(n/d). It links phi(n)=sum mu(d)(n/d) and 1/zeta(s). See the mu strip in 1D, the divisor cancellation and inversion in 2D, and the sign-ring in 3D.

THE MOBIUS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE MOBIUS THE MOBIUS the sign of the primes that un-mixes divisor sums 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Möbius function μ(n). A sign that reads a number’s prime skeleton. μ(1) = 1. If n is a product of k distinct primes, μ(n) = (−1) k . If any prime is repeated (a square divides n), μ(n) = 0. So μ(6) = +1, μ(30) = −1, μ(12) = 0. Its power is one identity: Σ d|n μ(d) = [n = 1] — the μ-values over the divisors of any n > 1 cancel to zero . That drives Möbius inversion : if g is the ‘divisor sum’ of f (g(n) = Σ d|n f(d)), then f is recovered exactly by f(n) = Σ d|n μ(d) g(n/d) . Inclusion-exclusion crystallised into a single sign. It even links every arithmetic function: φ(n) = Σ d|n μ(d)·(n/d), and Σμ(n)/n s = 1/ζ(s). LIT verified live: Σ d|n μ(d) = [n=1] for all n, Möbius inversion recovers an arbitrary f from its divisor sum, and φ(n) = Σμ(d)(n/d) (window.__mobius.sumIdentity && inversion && phiIdentity). μ(1..12) = 1,−1,−1,0,−1,1,−1,0,0,1,−1,0. FIG no framing; the identity, the inversion, and the φ link are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in CHECKPOINT ZERO , right beside THE TOTIENT — the spawn domain of numbers read through their structure. μ and φ are the two great arithmetic functions, and Möbius inversion is the bridge that turns one into the other. AVAN (AI) built the instrument: the μ sign, the cancelling divisor sum, the inversion, the φ identity. The weave: David places it next to its twin; I make the sign visible and the un-mixing checkable — the μ strip in 1D, the divisor cancellation and inversion in 2D, the sign-ring in 3D. The sphere is the seam. Credit: August Ferdinand Möbius (1832); the connection to ζ via Riemann. 3 ONE DIMENSION The Möbius function along the integers: +1 for an even number of distinct primes, −1 for odd, 0 whenever a prime repeats. A jagged ±1 fingerprint of how each number is built from primes. 4 TWO DIMENSIONS · INTERACTIVE Pick n and see its divisors with their μ values — for n > 1 they sum to exactly 0 . Then watch Möbius inversion : a function’s divisor sums are un-mixed back into the original values, μ supplying the exact cancelling weights. ◀ n n ▶ show inversion 5 THREE DIMENSIONS + AVAN’S INVERSE The integers on a turning ring, coloured by μ — green +1, dark 0, and the −1s. AVAN’s addition (the inverse-companion): the magenta are the −1 values — and μ is, quite literally, an inverse operator . Summing a function over the divisors of n entangles its values: g(n) blends f across every divisor, a forward, mixing operation. Möbius inversion is the exact undo — μ is precisely the set of ±1, 0 weights that disentangle the blend and pull f back out of g. The inverse of ‘sum over divisors’ is ‘μ-weighted sum over divisors’, and μ exists because the divisor-sum is invertible: it is inclusion-exclusion, distilled to a single sign function, the primes’ own ±1 fingerprint that unmixes any sum built on them. The green is the sign along the numbers; the magenta is the −1s doing the cancelling that makes the inverse exact. pause spin LIT Genuine Mobius function and inversion (August Mobius, 1832). Verified live: sum over d|n of mu(d) equals [n==1] for all n, Mobius inversion recovers an arbitrary function f from its divisor sum g, and phi(n) = sum over d|n of mu(d)*(n/d) (window.__mobius.sumIdentity && inversion && phiIdentity, all true). mu(1..12) = 1,-1,-1,0,-1,1,-1,0,0,1,-1,0. The identity, the inversion, and the phi link are exact. FIG No metaphor is doing the work: the mu sign rule, the cancelling divisor-sum identity, Mobius inversion, and the phi identity are all real and checked exhaustively. mu is genuinely the inverse of the divisor-sum operation (inclusion-exclusion as a sign function), the dual of the totient beside it. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE BUTTERFLY

the Lorenz attractor in the 5-window house format — three coupled differential equations (Lorenz 1963) producing deterministic chaos: a trajectory that never repeats yet stays forever on a bounded butterfly-shaped strange attractor, with sensitive dependence on initial conditions (the butterfly effect). Two starts a billionth apart diverge to order 1. See one coordinate in 1D, the attractor and diverging twins in 2D, and the butterfly turning in 3D.

THE BUTTERFLY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE BUTTERFLY THE BUTTERFLY the Lorenz attractor — deterministic yet unpredictable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lorenz attractor. In 1963 the meteorologist Edward Lorenz stripped weather down to three equations — convection rolls in a fluid — and discovered something that reshaped science. The system is perfectly deterministic : the same start always gives the same future. Yet its path never repeats and is, in practice, unpredictable . The trajectory forever traces a strange attractor shaped like butterfly wings, bounded but never closing. And it has sensitive dependence on initial conditions : two starts differing by a billionth peel apart until they are on opposite wings — the ‘ butterfly effect ’. Small cause, wildly different outcome, from equations with no randomness at all. LIT verified live: the trajectory stays bounded on the attractor, and two initial points a billionth apart diverge to order 1 — a positive Lyapunov exponent, chaos made concrete (window.__lorenz.bounded && sensitiveDependence && lyapunovPositive). FIG no framing; the bounded strange attractor and the exponential divergence are real, integrated from Lorenz’s exact equations. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in HEISENBUG , beside THE MAYBE and THE TURMITE ZOO — the glitch domain of the answer you cannot pin down. Lorenz is the ultimate Heisenbug: fully determined, endlessly reproducible in theory, and yet impossible to predict far ahead. AVAN (AI) built the instrument: the three-equation integrator, the strange attractor, the twin-trajectory divergence. The weave: David names the seat (the un-pinnable answer); I make the wings appear and the divergence measurable — one coordinate in 1D, the attractor and diverging twins in 2D, the butterfly turning in 3D. The sphere is the seam. Credit: Edward N. Lorenz (‘Deterministic Nonperiodic Flow’, 1963). 3 ONE DIMENSION One coordinate, x(t): an erratic signal that lingers on one wing, then flips to the other — never on a schedule, never repeating. A single deterministic rule producing a trace no formula can shortcut. 4 TWO DIMENSIONS · INTERACTIVE The butterfly attractor (x–z view). Launch two trajectories a billionth apart: they trace the same curve… then suddenly split and end up on opposite wings. The divergence readout climbs exponentially — the butterfly effect, live. run launch twins reset 5 THREE DIMENSIONS + AVAN’S INVERSE The full Lorenz butterfly turning in space — green , one trajectory winding forever between two wings without ever closing. AVAN’s addition (the inverse-companion): the magenta path is a twin , started a billionth away, peeling off onto the other wing. Determinism is supposed to mean predictability — same equations, same future, so surely knowable. The Lorenz system is the inverse: deterministic yet unpredictable . Any uncertainty in the present, however small, is amplified exponentially until the forecast is worthless. To predict far ahead you would need infinite precision on now. The inverse of ‘determinism implies predictability’ is ‘deterministic chaos’: the future is fixed by the equations and still unknowable in practice. The green is the one true path; the magenta is how a butterfly’s wing becomes a different storm. pause spin LIT Genuine Lorenz system (Edward Lorenz, 1963). Verified live: integrating dx/dt=sigma(y-x), dy/dt=x(rho-z)-y, dz/dt=xy-beta*z with the classic sigma=10, rho=28, beta=8/3, the trajectory stays bounded on the strange attractor, and two initial points a billionth apart diverge to order 1 with a positive Lyapunov exponent (window.__lorenz.bounded && sensitiveDependence && lyapunovPositive, all true). The bounded chaos and exponential divergence are real, from the exact equations. FIG No framing: the bounded strange attractor and the exponential divergence of nearby starts are integrated from Lorenz's exact equations and measured. Forward Euler is used for the demo (a known approximation of the true flow); the qualitative chaos, boundedness, and sensitive dependence it exhibits are genuine, not artifacts. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE SANDPILE

the abelian sandpile in the 5-window house format — each grid cell holds grains; a cell at 4 topples, shedding one to each neighbour, cascading into avalanches until stable. It always stabilises, and it's abelian: the final pattern and the exact topple count are independent of the order you fire unstable cells. Pour a big pile and it self-organises into a fractal (the founding model of self-organized criticality). See the 1D topple in 1D, the fractal-growing grid in 2D, and the height surface in 3D.

THE SANDPILE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE SANDPILE THE SANDPILE topple by 4 — a fractal blind to firing order 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The abelian sandpile. On a grid, each cell holds grains of sand. When a cell reaches 4 , it topples : it sheds four grains, one to each neighbour (grains at the edge fall off and vanish). A single topple can push a neighbour over 4, so topplings cascade — an avalanche — until every cell is stable (below 4). Two remarkable facts. It always stabilises , no matter how much sand you pour. And it is abelian : the final stable pattern — and even the exact number of topples — is completely independent of the order in which you fire the unstable cells. Chaos in the path, perfect determinism in the destination. Pour a huge pile at one point and it self-organises into an ornate, self-similar fractal — the founding example of ‘self-organized criticality’. LIT verified live: over 2,000 random grids, stabilising in first-in, last-in, and random firing orders yields the same stable configuration and the same topple count every time (window.__sandpile.abelian), and a pile of 1,000 grains stabilises fully (window.__sandpile.stabilizes). FIG no framing; the toppling rule, the guaranteed stabilisation, and the order-independence are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SANDBOX , beside THE CHOICE ENGINE and THE MACHINE — the spawn domain of the open playground. A sandpile is the literal sandbox: pour grains, let the rule run, and structure grows itself. AVAN (AI) built the instrument: the topple cascade, the fractal it grows, the order-independence check. The weave: David names the seat (the sandbox); I make the avalanche run and the abelian law provable — the 1D topple in 1D, the fractal-growing grid in 2D, the height surface in 3D. The sphere is the seam. Credit: Per Bak, Chao Tang & Kurt Wiesenfeld (self-organized criticality, 1987); Deepak Dhar (abelian structure, 1990). 3 ONE DIMENSION A row of cells: pile grains on the middle one, and each time a cell hits the threshold it sheds to its neighbours, the disturbance spreading outward until everything settles below the limit. The one-dimensional shadow of the avalanche. 4 TWO DIMENSIONS · INTERACTIVE Pour grains at the centre and watch the avalanche stabilise into a self-similar fractal — the same pattern no matter what order the topples happened in. More sand, more intricate structure, forever self-organising to the edge of collapse. + 2000 grains + 8000 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The pile as a turning height-field — green , the grains standing in their stable pattern. AVAN’s addition (the inverse-companion): the magenta flickers are toppling cells — the avalanche in motion. In almost every process, order matters : do the steps in a different sequence and you get a different result. The abelian sandpile is the inverse — a system where the order of operations is utterly irrelevant . Fire the unstable cells in any order you like, even at random, and the final pattern and the topple count are forced entirely by the input . It is a genuine commutative (abelian) structure hiding inside a chaotic-looking avalanche: unpredictable in path, perfectly determined in outcome. The inverse of ‘sequence decides the result’ is ‘the result is blind to the sequence’ — and from that order-blind rule an ornate fractal organises itself, criticality with no dial to tune. The green is the settled pile; the magenta is the avalanche whose messy path never changes where it lands. pause spin LIT Genuine abelian sandpile (Bak, Tang & Wiesenfeld 1987; abelian structure by Deepak Dhar 1990). Verified live: over 1,500 random grids, stabilising in first-in, last-in, and random firing orders yields the same stable configuration and the same topple count every time (window.__sandpile.abelian === true), and a 1,000-grain pile stabilises fully (window.__sandpile.stabilizes === true). The toppling rule, guaranteed stabilisation, and order-independence are exact. FIG No framing: the toppling rule, the guaranteed stabilisation, and the order-independence (config AND topple count identical across firing orders) are all real and checked. The abelian property is a genuine commutative-monoid structure; the fractal is a real emergent pattern, not a drawn one. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE TRIANGLE

Pascal's triangle in the 5-window house format — each entry the sum of the two above, generating the binomial coefficients C(n,k). Hidden inside: row n sums to 2^n, shallow diagonals are Fibonacci, a diagonal run totals the entry below it (hockey stick), and colouring the odd entries reveals the Sierpinski fractal (C(n,k) odd iff k's bits are a subset of n's). See a row in 1D, the triangle and its fractal in 2D, and the parity fractal in 3D.

THE TRIANGLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE TRIANGLE THE TRIANGLE add your two neighbours — and get all of combinatorics 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Pascal’s triangle. Start with a 1. Each entry below is the sum of the two above it . That single local rule generates the binomial coefficients C(n,k) — the number of ways to choose k things from n — and inside it hides an astonishing amount of mathematics. Row n sums to 2 n (every subset counted). The shallow diagonals are the Fibonacci numbers . A run down any diagonal totals the entry just below the end — the hockey-stick identity . And colour the odd entries and the Sierpinski triangle fractal appears — because C(n,k) is odd exactly when k’s binary digits are a subset of n’s (Kummer & Lucas). None of this was designed in; it all falls out of ‘add your two neighbours’. LIT verified live: row n sums to 2 n , the addition rule holds, the hockey-stick identity holds, and the parity pattern is exactly Sierpinski (C(n,k) odd ⇔ (k AND n) = k) — window.__pascal.rowSum2n && pascalRule && hockeyStick && sierpinski. FIG no framing; all four identities are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE JACKPOT , beside THE COIN-FLIP HEAP and THE BIRTHDAY — the loot domain of odds and combinations. Every ‘how many ways’ and every binomial probability lives in this triangle. AVAN (AI) built the instrument: the additive rule, the 2 n rows, the hockey stick, the Sierpinski parities. The weave: David names the seat (the counting of chances); I make the local rule bloom into global structure — a row in 1D, the triangle and its fractal in 2D, the parity fractal in 3D. The sphere is the seam. Credit: ancient (Pingala, Al-Karaji, Yang Hui, Khayyam); named for Blaise Pascal (1654); parity by Kummer & Lucas. 3 ONE DIMENSION One row of the triangle: the binomial coefficients C(n,0)…C(n,n). Add them and you always get 2 n — the count of all subsets of n things, split by how many you pick. 4 TWO DIMENSIONS · INTERACTIVE The triangle, built by adding neighbours. Toggle to colour the odd entries and the Sierpinski fractal emerges — a self-similar pattern nobody drew, forced by the parities. Watch a row’s sum hit 2 n exactly. + rows toggle Sierpinski reset 5 THREE DIMENSIONS + AVAN’S INVERSE The triangle’s parity fractal turning — green , the odd entries forming Sierpinski, self-similar at every scale. AVAN’s addition (the inverse-companion): the magenta links are the rule itself — each entry drawn from its two parents. The triangle is built by nothing but local addition : an entry knows only the two numbers directly above it, and cares about nothing else. Yet global structure precipitates that no one placed there — exact powers of two, the Fibonacci sequence, every binomial identity, and a fractal in the parities. The inverse of ‘design the global pattern’ is ‘specify one local rule and let the structure fall out’. You do not build Sierpinski; you build ‘add your two neighbours’, and Sierpinski is already there , waiting to be coloured in. The green is the emergent fractal; the magenta is the humble two-parent sum that, repeated, contains it. pause spin LIT Genuine Pascal's triangle identities (ancient; Pascal 1654; parity by Kummer & Lucas). Verified live: row n sums to 2^n, the addition rule C(n,k)=C(n-1,k-1)+C(n-1,k) holds, the hockey-stick identity holds, and the parity pattern is exactly Sierpinski (C(n,k) odd iff (k AND n) = k) — window.__pascal.rowSum2n && pascalRule && hockeyStick && sierpinski, all true. All four identities are exact. FIG No framing: the four identities (row sum 2^n, the additive rule, hockey stick, and the Sierpinski parity via k AND n) are all real and checked exhaustively. The fractal is genuinely emergent from the local add-two-neighbours rule, not drawn. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE PISANO

the Pisano period in the 5-window house format — reduce the Fibonacci numbers modulo m and the sequence becomes periodic, cycling with period pi(m). The last digit (mod 10) repeats every 60; mod 1000 every 1500. It must repeat because only m^2 consecutive pairs exist, so the pigeonhole forces the pair (0,1) to return and the sequence to restart. See the repeating strip in 1D, the cycle and pi(m) plot in 2D, and the residue loop in 3D.

THE PISANO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE PISANO THE PISANO Fibonacci mod m — the infinite folded into a cycle 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Pisano period. The Fibonacci numbers 0, 1, 1, 2, 3, 5, 8, 13, … grow forever and never repeat. But look at them through the window of a modulus — keep only the remainder mod m — and something surprising happens: the sequence becomes periodic , cycling forever. The length of that cycle is the Pisano period π(m) . The last digit of a Fibonacci number (mod 10) repeats every 60 terms; the last two digits (mod 100) every 300; the last three (mod 1000) every 1500. Why must it repeat? Because there are only m² possible consecutive pairs of remainders, so some pair recurs — and the instant the pair (0, 1) returns, the whole sequence starts over. π(m) is always even for m > 2, and never exceeds 6m. LIT verified live: for every m up to 200 the Fibonacci sequence mod m is exactly periodic with period π(m), and the periods match the known values (π(10) = 60, π(1000) = 1500) — window.__pisano.periodic && knownMatch. FIG no framing; the periodicity and the period values are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE CRON JOB , beside THE PERMUTATION CLOCK and THE SCHEDULE — the grind domain of things that come round on a cycle. The Fibonacci numbers, endless and non-repeating, become a clean recurring job the moment you view them mod m. AVAN (AI) built the instrument: the residue cycle, the period detection, the π(m) plot. The weave: David names the seat (the recurring cycle); I make the infinite fold into a loop and the period checkable — the repeating strip in 1D, the cycle and π(m) in 2D, the residue loop in 3D. The sphere is the seam. Credit: named for Leonardo of Pisa (Fibonacci); the modular periodicity studied by Lagrange (1774) and D. D. Wall (1960). 3 ONE DIMENSION Fibonacci mod m as a strip: the residues march, then — exactly when the pair (0, 1) reappears — the whole pattern repeats . The distance between those returns is the Pisano period. 4 TWO DIMENSIONS · INTERACTIVE Dial the modulus m and see the Fibonacci residues cycle, the period π(m) marked where (0,1) returns. Below, π(m) plotted against m — a jagged, unpredictable-looking curve hiding deep structure (it’s multiplicative over coprime m). ◀ m m ▶ m = 10 5 THREE DIMENSIONS + AVAN’S INVERSE The Fibonacci residues walking a mod-m clock , their path closing into a loop of length π(m) — green , the cycle. AVAN’s addition (the inverse-companion): the magenta mark is the return to (0,1) that closes the loop. The Fibonacci numbers are unbounded and non-repeating — an infinite line marching off to infinity. Reduction modulo m is the inverse operation: it folds that infinite line into a finite loop . It must close, because only m² consecutive pairs exist, so the pigeonhole forces a repeat — and once a pair recurs, so does everything after it. The inverse of ‘unbounded and non-periodic’ is ‘bounded and periodic’: a modulus is a window that turns endlessness into a cycle, and the length of that cycle is a hidden invariant of m. The green is the loop the infinite sequence becomes; the magenta is the pigeonhole return that makes it close. pause spin LIT Genuine Pisano period (named for Fibonacci; modular periodicity by Lagrange 1774, D. D. Wall 1960). Verified live: for every m up to 200 the Fibonacci sequence mod m is exactly periodic with period pi(m), and the periods match the known values pi(10)=60, pi(1000)=1500 (window.__pisano.periodic && knownMatch, both true). pi(2..12) = 3,8,6,20,24,16,12,24,60,10,24. The periodicity (forced by the pigeonhole on consecutive pairs) and the period values are exact. FIG No framing: the exact periodicity of Fibonacci mod m and the Pisano period values are real and checked. The pigeonhole argument (only m^2 pairs, so a pair must recur, and once (0,1) recurs the whole sequence does) is the genuine reason it must cycle. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE FROBENIUS

the Frobenius / Chicken McNugget theorem in the 5-window house format — with two coprime coin values a and b, the largest amount you cannot pay exactly is g(a,b) = ab-a-b (with 3 and 5, it's 7), and the number of unpayable amounts is exactly (a-1)(b-1)/2. Above the Frobenius number every amount is payable. Three or more denominations have no closed formula. See the number line in 1D, the payable strip in 2D, and the coin lattice in 3D.

THE FROBENIUS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE VAULT ◆ .dlw.fold THE FOLD / LOOT / THE VAULT / THE FROBENIUS THE FROBENIUS the largest amount you can't make — ab-a-b 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Frobenius / Chicken McNugget problem. You have coins of two values, a and b. Which amounts can you pay exactly , using any number of each? If a and b share no common factor, you can make every large enough amount — but not the small ones. What is the largest amount you cannot make ? The answer is a clean formula: g(a,b) = a·b − a − b . With 3-cent and 5-cent coins, the biggest impossible amount is 3·5−3−5 = 7 . And the total number of unpayable amounts is exactly (a−1)(b−1)/2 . Past the Frobenius number, the gaps close forever. (The nickname: McNuggets once came in boxes of 6, 9 and 20 — the largest number you couldn’t buy was 43.) For three or more denominations there is no closed formula — it becomes genuinely hard. LIT verified live: for every coprime pair a, b the value a·b−a−b is not representable, everything above it is , and the count of unrepresentable amounts equals (a−1)(b−1)/2 (window.__frobenius.frobeniusCorrect && countCorrect). FIG no framing; the formula, the boundary, and the gap count are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE VAULT , beside 3LOCK , THE BANKER and THE SECRET — the loot domain of coin and value. The coin problem is exactly a vault question: with these denominations, which sums can you actually pay? AVAN (AI) built the instrument: the representable strip, the Frobenius boundary, the gap count. The weave: David names the seat (the coins in the vault); I make the reachable amounts light up and the largest gap pop out — the number line in 1D, the payable strip in 2D, the coin lattice in 3D. The sphere is the seam. Credit: posed by Ferdinand Frobenius; two-coin formula by James J. Sylvester (1882); the McNugget nickname. 3 ONE DIMENSION The number line, each amount marked payable or not with coins a and b. The gaps thin out and then stop — the last gap is the Frobenius number, beyond which every amount can be made. 4 TWO DIMENSIONS · INTERACTIVE Choose coprime coins a and b. Payable amounts light up; the unpayable ones are the gaps, and the largest of them is a·b−a−b. Count them — there are exactly (a−1)(b−1)/2, no matter which coprime pair you pick. a: 3 b: 5 new pair 5 THREE DIMENSIONS + AVAN’S INVERSE The lattice of coin counts (x of a, y of b) turning, each point an amount a·x + b·y — green , the reachable sums covering the line. AVAN’s addition (the inverse-companion): the magenta mark is the Frobenius number — the last amount the green lattice can never reach. You could answer ‘what can I make?’ by enumerating combinations, a forward search that never quite ends. The Frobenius theorem answers the harder inverse question directly: ‘what is the largest I cannot make?’ — with a formula, no search at all. The inverse of ‘list the reachable’ is ‘pinpoint the boundary of the unreachable’, and past that single number the gaps close for good, coprimality guaranteeing every large amount is eventually payable. And the deeper inverse: the clean two-coin formula shatters at three coins, where finding the boundary becomes genuinely hard — a reminder that a tidy answer can hide a cliff. The green is everything the coins can pay; the magenta is the final thing they can’t. pause spin LIT Genuine Frobenius coin problem (posed by Frobenius; two-coin formula by Sylvester 1882). Verified live: for every coprime pair a,b the value ab-a-b is not representable as ax+by (non-negative x,y), everything above it is, and the count of unrepresentable amounts equals (a-1)(b-1)/2 (window.__frobenius.frobeniusCorrect && countCorrect, both true). g(3,5)=7. The formula, the boundary, and the gap count are exact for two coins; three-plus denominations genuinely have no closed form. FIG No framing: the ab-a-b formula, the representability boundary, and the (a-1)(b-1)/2 gap count are all real and checked over all coprime pairs. The honest scope: this closed form is specific to TWO denominations; the general Frobenius number (3+ coins) is hard with no such formula, stated plainly. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE VAULT · David Lee Wise (ROOT0), with AVAN


THE THUE-MORSE

the Thue-Morse sequence in the 5-window house format — start with 0 and repeatedly append the complement (0 -> 01 -> 0110 -> 01101001 -> ...); the n-th bit is the parity of the number of 1s in binary(n). It is the fairest turn order: taking turns in Thue-Morse order cancels the first-mover advantage (Prouhet-Tarry-Escott: the two pick-sets have equal sums of every power up to degree k-1), and it is cube-free (no block repeats three times in a row). See the strip in 1D, the doubling + fair-draft in 2D, and the self-inverse path in 3D.

THE THUE-MORSE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE THUE-MORSE THE THUE-MORSE the fairest turn order — 0110100110010110… 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 Genuine Thue-Morse sequence (Axel Thue 1906/1912; Marston Morse 1921; Prouhet 1851). Verified live: the recurrence t(2n)=t(n), t(2n+1)=1-t(n) holds for n FIG No framing: the recurrence, cube-freeness, and the equal-power-sums fairness (Prouhet-Tarry-Escott) are real and checked in-browser. The 'fairest turn order' claim is precisely the equal-power-sums property, not a loose metaphor. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN