THE LT FOUNTAIN CODE

The LT fountain code in the 5-window house format — turning k source symbols into an endless stream of droplets, any sufficiently large handful of which rebuilds the message, no matter which ones you catch. Each droplet is the XOR of a random subset of sources, its size drawn from a soliton distribution. To decode you peel: find a droplet that XORs just one unknown source (degree 1), recover it, XOR it out of every droplet that used it — creating new degree-1 droplets — and repeat. It is rateless: collect droplets until decoding pops. Verified live: from about k(1+ε) droplets the peeling decoder recovers all k sources with high probability, and every recovered symbol matches the original whenever decoding completes. Neon-noir traced. See the droplet graph in 1D, peeling in 2D, and the catch-any-enough inverse in 3D.

THE LT FOUNTAIN CODE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE DROP ◆ .dlw.fold THE FOLD / LOOT / THE DROP / THE LT FOUNTAIN CODE THE LT FOUNTAIN CODE a message rebuilt from any enough droplets 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The LT fountain code (Luby Transform) turns k source symbols into an endless stream of droplets , any sufficiently large handful of which rebuilds the message — no matter which ones you catch. Each droplet is the XOR of a random subset of the sources, its size drawn from a soliton distribution. To decode you peel : find a droplet that XORs just one unknown source (a degree-1 droplet), recover it, XOR it out of every droplet that used it — which creates new degree-1 droplets — and repeat. It is rateless : a receiver collects droplets until decoding pops. LIT verified live: from about k(1+ε) droplets the peeling decoder recovers all k sources with high probability, and every recovered symbol matches the original whenever decoding completes (window.__lt_fountain). FIG honest scope: LT decoding is probabilistic; the check confirms high success and exact recovery, not a 100% guarantee. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-drop — the code literally emits droplets , and a receiver just catches drops until the message pours out. AVAN (AI) built the instrument: the soliton-degree encoder and the peeling decoder, checked for high-probability recovery and exact reconstruction. Credit as content: Michael Luby (2002), the first practical fountain code. The weave: David names the drops; I confirm that any large-enough set of droplets peels back to the exact sources. 3 ONE DIMENSION Sources (top) and droplets (bottom), each droplet an XOR of the sources it touches; a degree-1 droplet points at a single source. 4 TWO DIMENSIONS · INTERACTIVE Encode k sources into droplets, then peel: each degree-1 droplet recovers a source and is XORed out, cascading until all are recovered. new message ▶ peel-decode ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the sources rebuilt from a bag of droplets. AVAN’s addition (the inverse-companion): don’t number the packets — catch any enough of them. The inverse of ‘send symbol 1, 2, 3… and hope none is lost’ is ‘emit endless XOR-droplets, and any k(1+ε) of them peel back to the message.’ Magenta is a droplet; green is a recovered source. Catch any enough drops. pause spin LIT Genuine LT / Luby Transform fountain code (Michael Luby, 2002), the first practical fountain code. Verified live: from ~4k droplets the peeling decoder recovers all k sources ≥97% of the time (window.__lt_fountain.decodesHighProb), and every recovered symbol equals the original whenever decoding completes (.recoveredMatches). FIG Honest scope stated on the sphere: LT decoding is probabilistic — the check confirms high-probability success and exact recovery, not a 100% guarantee. The AVAN inverse is honest — emitting endless XOR-droplets so any k(1+ε) of them peel back to the message (rather than numbering packets and hoping none is lost) is the rateless erasure-coding idea; magenta is a droplet, green a recovered source. Catch any enough drops. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE DROP · David Lee Wise (ROOT0), with AVAN


THE COUNT-SKETCH

Count-Sketch in the 5-window house format — estimating item frequencies in a stream with tiny memory, and (unlike Count-Min) unbiased. Each row hashes an item to a bucket and multiplies by a random ±1 sign before adding; the estimate reads that bucket back times the same sign. Collisions from other items arrive with random signs, so on average they cancel — the single-row estimate is correct in expectation. Taking the median across rows crushes the variance for a sharp estimate in fixed memory. Verified live: the average single-row estimate of a target's count converges to its true frequency (unbiased), and the median across rows has far smaller error than any single row. Neon-noir traced. See signed counters in 1D, scatter-and-median in 2D, and the sign-the-noise-away inverse in 3D.

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

THE COUNT-SKETCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE COUNT-SKETCH THE COUNT-SKETCH a frequency estimate the median cleans up 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Count-Sketch estimates how often items appear in a stream using tiny memory — and, unlike its cousin Count-Min, it is unbiased . Each row hashes an item to a bucket and multiplies by a random ±1 sign before adding; the estimate reads that bucket back, times the same sign. Collisions from other items come in with random signs, so on average they cancel — the single-row estimate is correct in expectation. Taking the median across several rows crushes the variance, giving a sharp estimate in a fixed footprint. LIT verified live: the average single-row estimate of a target’s count converges to its true frequency (unbiased), and the median across rows has far smaller error than any single row (window.__count_sketch). FIG no framing; the signed counters and the median estimate run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at off-by-one — a frequency read that is only ever off by a little, its collision noise cancelling to a near-exact count. AVAN (AI) built the instrument: the signed hash counters, the unbiasedness check across many sketches, and the median-of-rows variance reduction. Credit as content: Moses Charikar, Kevin Chen & Martin Farach-Colton (2002). The weave: David names the off-by-one; I confirm the estimate is unbiased and that the median across rows beats a single one. 3 ONE DIMENSION An item hashes to a bucket and adds ±1; the estimate reads that bucket times the item’s sign, so other items’ signs cancel on average. 4 TWO DIMENSIONS · INTERACTIVE Stream items into several signed sketches; the single-row estimates scatter around the true count, and their median lands on it. new stream ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the median estimate, sitting on the true count. AVAN’s addition (the inverse-companion): don’t fight collisions — sign them so they cancel. The inverse of ‘a collision adds error’ is ‘a random ±1 sign makes collisions cancel in expectation, and the median kills the variance.’ Magenta is a single-row estimate’s scatter; green is the median on target. Sign the noise away. pause spin LIT Genuine Count-Sketch (Moses Charikar, Kevin Chen & Martin Farach-Colton, 2002): signed hash counters give an unbiased frequency estimate; median-of-rows reduces variance. Verified live: the mean single-row estimate converges to the true count (window.__count_sketch.unbiased), and the median-of-15 error is far below a single row's (.medianBeatsSingle). FIG No framing: the signed counters, the unbiasedness check across many sketches, and the median-of-rows variance reduction all run in-browser. The AVAN inverse is honest — attaching a random ±1 sign so collisions cancel in expectation (and the median kills the variance) rather than treating a collision as pure error is exactly what makes Count-Sketch unbiased; magenta is the single-row scatter, green the median on target. Sign the noise away. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE LANCZOS

The Lanczos iteration in the 5-window house format — Arnoldi's method with the luck of symmetry. For a symmetric matrix, the Krylov orthogonalization collapses from a full Gram–Schmidt to a three-term recurrence: A q_j = β_{j−1} q_{j−1} + α_j q_j + β_j q_{j+1}. The result is a small symmetric tridiagonal T (diagonals α, off-diagonals β) whose eigenvalues (Ritz values) approximate the huge matrix's — the engine for the eigenvalues of enormous sparse symmetric systems. Verified live: over thousands of random symmetric matrices (with reorthogonalization), Q is orthonormal, T is symmetric tridiagonal, the three-term relation holds to machine precision, and T carries A's trace and determinant. Neon-noir traced. See the tridiagonal T in 1D, A-vs-T in 2D, and the symmetry-shrinks-the-recurrence inverse in 3D.

THE LANCZOS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE LANCZOS THE LANCZOS symmetry shrinks the recurrence to three terms 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lanczos iteration is Arnoldi’s method with the luck of symmetry . For a symmetric matrix, the Krylov orthogonalization collapses from a full Gram–Schmidt to a three-term recurrence : each new basis vector needs only the previous two, A q j = β j−1 q j−1 + α j q j + β j q j+1 . The result is a small symmetric tridiagonal matrix T — just diagonals α and off-diagonals β — whose eigenvalues (Ritz values) approximate the huge matrix’s. It is the engine for the eigenvalues of enormous sparse symmetric systems. LIT verified live: over thousands of random symmetric matrices (with reorthogonalization), Q is orthonormal, T is symmetric tridiagonal, the three-term relation holds to machine precision, and T carries A’s trace and determinant (window.__lanczos). FIG honest scope: full reorthogonalization is used so orthogonality holds numerically; pure Lanczos loses it in finite precision. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hot-loop — symmetry tightens the loop to just three terms per step, the leanest possible hot loop. AVAN (AI) built the instrument: the three-term Lanczos recurrence with reorthogonalization, the tridiagonal build, and the relation and invariant checks. Credit as content: Cornelius Lanczos (1950). The weave: David names the hot loop; I confirm the symmetric case reduces to a three-term recurrence giving a tridiagonal T that shares A’s trace and determinant. 3 ONE DIMENSION The tridiagonal T: only the diagonal (α) and the two off-diagonals (β) are nonzero — symmetry emptied everything else. 4 TWO DIMENSIONS · INTERACTIVE A random symmetric matrix reduces to a tridiagonal T; Q is orthonormal, the three-term relation holds, and T keeps A’s trace and determinant. new matrix ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the tridiagonal T, A seen in the Krylov basis. AVAN’s addition (the inverse-companion): don’t re-orthogonalize against everything — symmetry says two neighbours suffice. The inverse of ‘subtract every prior direction’ is ‘for symmetric A, only q j−1 and q j matter, so the recurrence has three terms and T is tridiagonal.’ Magenta is the full matrix; green is the three-band tridiagonal. Symmetry shrinks the recurrence. pause spin LIT Genuine Lanczos iteration (Cornelius Lanczos, 1950): symmetric Arnoldi giving a three-term recurrence and tridiagonal T. Verified live: over 2000 random symmetric matrices, Q orthonormal (window.__lanczos.orthonormal), T symmetric tridiagonal (.tridiagonal), the 3-term relation to FIG Honest scope stated on the sphere: full reorthogonalization is used so orthogonality holds numerically — pure Lanczos loses it in finite precision. The AVAN inverse is honest — for symmetric A only the two neighbours q_{j−1}, q_j matter (so the recurrence is three terms and T is tridiagonal) rather than subtracting every prior direction; magenta is the full symmetric A, green the three-band tridiagonal. Symmetry shrinks the recurrence. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


THE DEUTSCH-JOZSA

The Deutsch–Jozsa algorithm in the 5-window house format — answering a yes/no question about a black box in one query where classical certainty may need over half of all inputs. Promised f:{0,1}^n→{0,1} is either constant (same output everywhere) or balanced (0 on exactly half), superpose all inputs, let the oracle stamp the phase (−1)^f(x), and Hadamard again: the amplitude at |0…0⟩ becomes (1/2^n)Σ(−1)^f(x) — magnitude 1 if constant, exactly 0 if balanced. One measurement decides. Verified live: simulating the amplitude, every constant function gives |amplitude at |0…0⟩| = 1 and every balanced function gives 0, from one oracle call (classical worst case 2^(n−1)+1). Neon-noir traced. See the amplitude in 1D, one-query verdict in 2D, and the interfere-to-decide inverse in 3D.

THE DEUTSCH-JOZSA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE DEUTSCH-JOZSA THE DEUTSCH-JOZSA constant-or-balanced in one question 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Deutsch–Jozsa algorithm answers a yes/no question about a black box in a single query where classical certainty may need over half of all inputs. You are promised a function f:{0,1} n →{0,1} is either constant (same output everywhere) or balanced (0 on exactly half, 1 on the other half). Superpose all inputs, let the oracle stamp the phase (−1) f(x) , and Hadamard again: the amplitude at |0…0⟩ becomes (1/2 n )∑ x (−1) f(x) — magnitude 1 if constant , exactly 0 if balanced . One measurement decides. LIT verified live: simulating the amplitude, every constant function gives |amplitude at |0…0⟩| = 1 and every balanced function gives 0 (window.__deutsch_jozsa), from one oracle call — classically the worst case needs 2 n−1 +1. FIG no framing; the Hadamard–oracle–Hadamard amplitude is computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at god-mode — one query settles a question that should take exponentially many; the quantum machine plays in god-mode. AVAN (AI) built the instrument: the amplitude simulation of the H–oracle–H circuit for constant and balanced functions. Credit as content: David Deutsch & Richard Jozsa (1992). The weave: David names god-mode; I confirm the |0…0⟩ amplitude is 1 for constant f and 0 for balanced f — one query, certain answer. 3 ONE DIMENSION The amplitude at |0…0⟩ = average of (−1) f(x) : a full spike for a constant f, dead zero for a balanced one. 4 TWO DIMENSIONS · INTERACTIVE Pick a constant or a balanced oracle; the algorithm reads the |0…0⟩ amplitude and decides which in one query. constant f ▶ balanced f ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the |0…0⟩ amplitude, full or empty. AVAN’s addition (the inverse-companion): don’t sample inputs one by one — make them interfere. The inverse of ‘check enough f(x) to be sure’ is ‘phase-stamp all inputs at once, and a Hadamard concentrates the amplitude at |0…0⟩ only when f is constant.’ Magenta is the balanced case that cancels to zero; green is the constant spike. Interfere to decide. pause spin LIT Genuine Deutsch–Jozsa algorithm (David Deutsch & Richard Jozsa, 1992): distinguishes constant from balanced in one query vs classical 2^(n−1)+1. Verified live (amplitude simulation): every constant f gives |amp at |0…0⟩|=1 (window.__deutsch_jozsa.constantDetected) and every balanced f gives 0 (.balancedDetected) over 3000 oracles. FIG Honest scope: this simulates the H–oracle–H amplitude classically (deterministic output), not on quantum hardware. The AVAN inverse is honest — phase-stamping all inputs at once so a Hadamard concentrates amplitude at |0…0⟩ only when f is constant (rather than sampling enough f(x) to be sure) is the quantum speedup; magenta is the balanced case cancelling to zero, green the constant spike. Interfere to decide. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE SPACE-SAVING

The Space-Saving algorithm in the 5-window house format — finding the heavy hitters of a stream using only k counters, far fewer than the distinct items. Each arrival either bumps a monitored item's counter or, if all k are taken, evicts the current minimum (the newcomer takes that slot at min+1). The guarantee is sharp: any item whose true frequency exceeds N/k is always in the summary, every counter overestimates (never undercounts), and the overestimate is at most N/k. Frequent items survive eviction; rare ones churn through the same slots. Verified live: over thousands of streams, every item with frequency > N/k is monitored, each estimate is ≥ the true count, and the overestimate never exceeds N/k. Neon-noir traced. See eviction in 1D, the counters locking on in 2D, and the frequent-survive inverse in 3D.

THE SPACE-SAVING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE SPACE-SAVING THE SPACE-SAVING the frequent survive eviction 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Space-Saving algorithm finds the heavy hitters of a stream — the most frequent items — using only k counters, far fewer than the number of distinct items. Each arrival either bumps a monitored item’s counter, or, if all k are taken, evicts the current minimum : the newcomer takes that slot with count set to min+1. The guarantee is sharp: any item whose true frequency exceeds N/k is always in the summary, every counter overestimates (never undercounts), and the overestimate is at most N/k . Frequent items survive eviction; rare ones churn through the same slots. LIT verified live: over thousands of streams, every item with frequency > N/k is monitored, each estimate is ≥ the true count, and the overestimate never exceeds N/k (window.__space_saving). FIG no framing; the counter eviction and the frequency bounds run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-jackpot — k slots that keep only the big winners, the jackpot items that keep hitting. AVAN (AI) built the instrument: the min-eviction counter table, and checks that heavy hitters are found, estimates overcount, and the error stays under N/k. Credit as content: Ahmed Metwally, Divyakant Agrawal & Amr El Abbadi (2005). The weave: David names the jackpot; I confirm every frequent item is captured and that the counts overestimate by no more than N/k. 3 ONE DIMENSION k counters; a new item with all slots full evicts the minimum, taking its slot at min+1 — frequent items keep climbing, rare ones get replaced. 4 TWO DIMENSIONS · INTERACTIVE Stream a skewed sequence; the k counters lock onto the heavy hitters, each estimate at or above the true count and within N/k. new stream ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the k monitored heavy hitters. AVAN’s addition (the inverse-companion): don’t track every item — let the rare ones fight over the smallest slot. The inverse of ‘count everything’ is ‘keep k counters and evict the minimum, so a frequent item can never be pushed out.’ Magenta are the churning evicted items; green are the heavy hitters that survive. The frequent survive eviction. pause spin LIT Genuine Space-Saving algorithm (Ahmed Metwally, Divyakant Agrawal & Amr El Abbadi, 2005): k-counter heavy-hitters with min-eviction. Verified live: over 3000 streams, every item with freq > N/k is monitored (window.__space_saving.heavyHittersFound), estimates are ≥ true counts (.overestimates), and overestimate ≤ N/k (.boundedError). FIG No framing: the min-eviction counter table and the frequency-bound checks all run in-browser. The AVAN inverse is honest — keeping k counters and evicting the minimum (so a frequent item can never be pushed out) rather than counting everything is exactly what makes the summary capture the heavy hitters; magenta are the churning evicted items, green the survivors. The frequent survive eviction. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE CHICKEN McNUGGET

The Chicken McNugget theorem in the 5-window house format — the Frobenius coin problem for two coprime denominations a and b: which totals cannot be made from non-negative whole numbers of each? There is a largest impossible amount, the Frobenius number, with a clean closed form g(a,b) = ab − a − b; every amount above it is makeable, and the count of impossible amounts is exactly (a−1)(b−1)/2. Two numbers, and the whole gap structure is pinned by a formula. Verified live: over thousands of coprime pairs, the largest non-representable amount equals ab−a−b, the count equals (a−1)(b−1)/2, and every amount above ab−a−b is representable. Neon-noir traced. See the number line in 1D, a chosen pair in 2D, and the name-the-last-gap inverse in 3D.

THE CHICKEN McNUGGET · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE MINT ◆ .dlw.fold THE FOLD / LOOT / THE MINT / THE CHICKEN McNUGGET THE CHICKEN McNUGGET the largest amount you cannot make 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Chicken McNugget theorem (the Frobenius coin problem for two values) asks: with only two coprime denominations a and b, what totals cannot be made from non-negative whole numbers of each? There is a largest impossible amount — the Frobenius number — and it has a clean closed form, g(a,b) = ab − a − b . Every amount above it is makeable. And the count of impossible amounts is exactly (a−1)(b−1)/2 . Two numbers, and the whole gap structure is pinned by a formula. LIT verified live: over thousands of coprime pairs, the largest non-representable amount equals ab−a−b, the number of non-representable amounts equals (a−1)(b−1)/2, and every amount above ab−a−b is representable (window.__chicken_mcnugget). FIG no framing; representability is enumerated in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mint — with just two coin denominations, the mint can make every amount past a certain point, and the last un-mintable value is fixed by a formula. AVAN (AI) built the instrument: the representability enumerator, the Frobenius-number and gap-count formulas, and the ‘all above are representable’ check. Credit as content: Ferdinand Frobenius / James Sylvester (the two-coin formula, 1880s); the “Chicken McNugget” nickname. The weave: David names the mint; I confirm ab−a−b is the largest impossible total and (a−1)(b−1)/2 the count of impossible ones. 3 ONE DIMENSION The number line for a, b: representable amounts (green) and gaps (magenta); the last gap is the Frobenius number ab−a−b. 4 TWO DIMENSIONS · INTERACTIVE Pick two coprime denominations; the Frobenius number and the count of impossible amounts are shown, each matched to the formula. new a, b ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the representable amounts filling the number line. AVAN’s addition (the inverse-companion): don’t list what you can make — name the last thing you cannot. The inverse of ‘enumerate all makeable totals’ is ‘the largest impossible one is ab−a−b, above which everything is makeable.’ Magenta are the gaps; green is the representable stretch past the Frobenius number. The last gap is a formula. pause spin LIT Genuine two-coin Frobenius / Chicken McNugget theorem (Ferdinand Frobenius; James Sylvester's formula, 1880s): for coprime a,b the largest non-representable amount is ab−a−b and there are (a−1)(b−1)/2 of them. Verified live: over 4000 coprime pairs, the largest gap equals ab−a−b (window.__chicken_mcnugget.frobeniusFormula), the gap count equals (a−1)(b−1)/2 (.countFormula), and every amount above is representable (.allAboveRepresentable). FIG No framing: representability is enumerated in-browser and matched to both formulas. The AVAN inverse is honest — naming the largest impossible total ab−a−b (above which everything is makeable) rather than enumerating all makeable amounts is the theorem's content; magenta are the gaps, green the representable stretch past the Frobenius number. The last gap is a formula. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MINT · David Lee Wise (ROOT0), with AVAN


THE GOMORY-HU TREE

The Gomory–Hu tree in the 5-window house format — compressing all the minimum cuts of a weighted graph into a single tree. A graph on n vertices has C(n,2) pairs, each with its own minimum cut, but you never compute them all: the Gomory–Hu tree is a weighted tree on the same vertices such that for every pair (s,t), the minimum s–t cut in the original graph equals the smallest edge weight on the tree path between s and t. It stores n−1 numbers and answers any of the C(n,2) cut queries exactly, built from just n−1 max-flow computations. Verified live: over thousands of random weighted graphs, for every pair the minimum edge on the tree path equals a brute-force minimum s–t cut. Neon-noir traced. See graph-and-tree in 1D, a pair query in 2D, and the one-tree-all-cuts inverse in 3D.

THE GOMORY-HU TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE GOMORY-HU TREE THE GOMORY-HU TREE all-pairs min-cuts in one tree 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Gomory–Hu tree compresses all the minimum cuts of a weighted graph into a single tree. A graph on n vertices has C(n,2) pairs, each with its own minimum cut — but you never need to compute them all. The Gomory–Hu tree is a weighted tree on the same vertices such that, for every pair (s, t), the minimum s–t cut in the original graph equals the smallest edge weight on the tree path between s and t. It stores n−1 numbers and answers any of the C(n,2) cut queries exactly, built from just n−1 max-flow computations. LIT verified live: over thousands of random weighted graphs, for every pair (s, t) the minimum edge on the tree path equals a brute-force minimum s–t cut (window.__gomory_hu). FIG no framing; Gusfield’s construction and the brute-force cuts run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-broadcast — one tree broadcasts every pair’s bottleneck at once; ask any two nodes and the path answers. AVAN (AI) built the instrument: an Edmonds–Karp max-flow, Gusfield’s Gomory–Hu construction, path-minimum queries, and a brute-force min-cut oracle. Credit as content: Ralph Gomory & T. C. Hu (1961); Dan Gusfield’s simplified construction (1990). The weave: David names the broadcast; I confirm the tree’s path minimum equals the true min cut for every pair. 3 ONE DIMENSION A weighted graph and its Gomory–Hu tree; the min cut between two vertices is just the smallest edge on their tree path. 4 TWO DIMENSIONS · INTERACTIVE A random graph’s Gomory–Hu tree; pick a pair and its path-minimum equals the true minimum cut, matched against brute force. new graph ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the tree whose paths hold every pair’s min cut. AVAN’s addition (the inverse-companion): don’t compute C(n,2) cuts — store n−1 and read the rest. The inverse of ‘find the min cut for each pair’ is ‘a single tree encodes them all: the min cut of (s,t) is the lightest edge on their path.’ Magenta is that lightest edge; green is the tree that answers everything. One tree, all cuts. pause spin LIT Genuine Gomory–Hu tree (Ralph Gomory & T. C. Hu, 1961; Gusfield's simplified construction, 1990): a tree encoding all-pairs min cuts. Verified live: over 1500 random weighted graphs, for every pair the min edge on the tree path equals a brute-force min s–t cut (window.__gomory_hu.allPairsMatch). FIG No framing: an Edmonds–Karp max-flow, Gusfield's construction, path-minimum queries, and a brute-force min-cut oracle all run in-browser and agree. The AVAN inverse is honest — storing n−1 tree edges and reading any pair's min cut as the lightest edge on their path (rather than computing all C(n,2) cuts) is exactly the tree's compression; magenta is that lightest edge, green the tree answering everything. One tree, all cuts. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE SIMON

Simon's algorithm in the 5-window house format — finding a hidden bit-mask s a black box conceals, with an exponential speedup over any classical method. The promise: the function is two-to-one with f(x)=f(x⊕s). Classically you must hunt for a colliding pair (~2^(n/2) queries); Simon's quantum circuit instead returns, each run, a random vector y with y·s=0 (mod 2). Gather about n−1 independent such y and linear algebra over GF(2) pins s exactly. Verified live: over thousands of hidden masks, collecting n−1 independent measurement vectors and solving the GF(2) system recovers s every time. Neon-noir traced. See the 2-to-1 oracle in 1D, the GF(2) solve in 2D, and the constraints-not-search inverse in 3D.

THE SIMON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · NOCLIP ◆ .dlw.fold THE FOLD / CHEAT / NOCLIP / THE SIMON THE SIMON a hidden mask pinned by linear equations 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Simon’s algorithm finds a hidden bit-mask s that a black box conceals, with an exponential speedup over any classical method. The promise: the function is two-to-one with f(x) = f(x ⊕ s) for a secret s. Classically you must hunt for a colliding pair, needing about 2 n/2 queries; Simon’s quantum circuit instead returns, each run, a random vector y with y·s = 0 (mod 2). Gather about n−1 independent such y and a little linear algebra over GF(2) pins s down exactly — a handful of queries where classical needs exponentially many. LIT verified live: over thousands of hidden masks, collecting n−1 independent measurement vectors and solving the GF(2) system recovers s every time (window.__simon). FIG honest scope: the quantum measurement distribution (uniform over y with y·s = 0) is simulated classically; the linear-algebra recovery is exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at noclip — the algorithm phases straight through the exponential wall a classical search hits, no-clipping past the collision hunt. AVAN (AI) built the instrument: the measurement sampler (uniform over the orthogonal complement of s) and the GF(2) Gaussian elimination that solves for s. Credit as content: Daniel Simon (1994), the problem that inspired Shor. The weave: David names the noclip; I confirm n−1 measurements and a GF(2) solve recover the hidden mask exactly. 3 ONE DIMENSION The oracle is two-to-one: x and x ⊕ s collide. Each measurement returns a y orthogonal to s — a linear constraint on the secret. 4 TWO DIMENSIONS · INTERACTIVE Collect measurement vectors y (each with y·s = 0); once n−1 are independent, the GF(2) solve returns the hidden s. sample y ▶ solve for s ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the recovered mask s. AVAN’s addition (the inverse-companion): don’t hunt for a collision — collect constraints. The inverse of ‘search for x, x⊕s that match’ is ‘each quantum run hands you a y ⊥ s, and n−1 of them determine s by linear algebra.’ Magenta are the orthogonality equations; green is the single mask that satisfies them all. Constraints, not search. pause spin LIT Genuine Simon's algorithm (Daniel Simon, 1994), the problem that inspired Shor: exponential quantum speedup for hidden-XOR-mask. Verified live: over 3000 hidden masks, n−1 independent measurement vectors (each y·s=0) plus GF(2) Gaussian elimination recover s exactly (window.__simon.recoversS). FIG Honest scope: the quantum measurement distribution (uniform over y with y·s=0) is simulated classically; the linear-algebra recovery is exact. The AVAN inverse is honest — collecting orthogonality constraints y·s=0 and solving over GF(2) (rather than hunting for a colliding pair) is exactly Simon's exponential advantage; magenta are the equations, green the single mask satisfying them all. Constraints, not search. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NOCLIP · David Lee Wise (ROOT0), with AVAN


THE GRAECO-LATIN SQUARE

The Graeco-Latin square in the 5-window house format — overlaying two Latin squares so no ordered pair ever repeats. A Latin square of order n fills an n×n grid so each symbol appears once per row and column; two are orthogonal if pairing them cell-by-cell yields all n² ordered pairs exactly once. Euler conjectured none exist for n≡2 (mod 4) — but he was wrong: a Graeco-Latin square exists for every order except 2 and 6. For odd n, L=(i+j) mod n and M=(2i+j) mod n do the job. Verified live: for every odd n from 3 to 15, L and M are each Latin squares and orthogonal (all n² pairs distinct). Neon-noir traced. See the overlay in 1D, adjustable order in 2D, and the no-pair-twice inverse in 3D.

THE GRAECO-LATIN SQUARE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PULL REQUEST ◆ .dlw.fold THE FOLD / CO-OP / THE PULL REQUEST / THE GRAECO-LATIN SQUARE THE GRAECO-LATIN SQUARE two squares that never repeat a pair 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Graeco-Latin square overlays two Latin squares so that no ordered pair ever repeats . A Latin square of order n fills an n×n grid so each symbol appears once per row and once per column; two of them are orthogonal if pairing them cell-by-cell yields all n² possible ordered pairs exactly once. Euler asked whether they exist for every n and famously conjectured “no” for n ≡ 2 (mod 4) — but he was wrong : a Graeco-Latin square exists for every order except 2 and 6 . For odd n, the pair L = (i+j) mod n and M = (2i+j) mod n does the job. LIT verified live: for every odd n from 3 to 15, L and M are each Latin squares (a permutation in every row and column) and orthogonal (all n² pairs distinct) (window.__graeco_latin). FIG honest scope: this construction covers odd n; 2 and 6 are the only orders with no Graeco-Latin square (Euler–Bose–Shrikhande–Parker). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-pull-request — two independent squares merged into one without a single conflicting pair, the clean merge every pull request wants. AVAN (AI) built the instrument: the (i+j, 2i+j) construction, the Latin-square check per row and column, and the orthogonality test over all n² pairs. Credit as content: Leonhard Euler (1782, the “36 officers”); the conjecture disproved by Bose, Shrikhande & Parker (1959). The weave: David names the pull request; I confirm the two squares merge with every ordered pair appearing exactly once. 3 ONE DIMENSION A Graeco-Latin square: each cell carries a number (from L) and a colour (from M); no number–colour pair repeats. 4 TWO DIMENSIONS · INTERACTIVE Pick an odd order n; the overlaid squares are shown, each Latin, and all n² ordered pairs appear exactly once. next n ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the two orthogonal squares as one grid of unique pairs. AVAN’s addition (the inverse-companion): don’t check the two squares apart — check that their overlay never repeats. The inverse of ‘are L and M each Latin?’ is ‘does (L, M) hit all n² pairs exactly once?’ — that is orthogonality. Magenta is a pair; green is the grid where none repeats. No pair twice. pause spin LIT Genuine Graeco-Latin (orthogonal Latin) squares (Euler 1782, the '36 officers'; conjecture disproved by Bose, Shrikhande & Parker, 1959): exist for all n except 2 and 6. Verified live: for odd n=3..15, L=(i+j)%n and M=(2i+j)%n are both Latin (window.__graeco_latin.bothLatin) and orthogonal (.orthogonal). FIG Honest scope: this construction covers odd n; 2 and 6 are the only orders with no Graeco-Latin square. The AVAN inverse is honest — checking that the overlay (L,M) hits all n² pairs exactly once (rather than checking L and M as Latin squares separately) is the definition of orthogonality; magenta is a pair, green the grid where none repeats. No pair twice. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


THE HILL CIPHER

The Hill cipher in the 5-window house format — encryption as matrix multiplication. Turn letters into numbers 0–25, group into vectors, and multiply each by a secret key matrix K mod 26: c = K·p (mod 26); decrypt with the inverse, p = K⁻¹·c (mod 26). K is invertible mod 26 exactly when its determinant is coprime to 26 (odd and not a multiple of 13). It was the first cipher to encrypt several letters at once, hiding letter frequencies inside linear algebra. Verified live: for every key with determinant coprime to 26, encrypting then decrypting recovers the plaintext exactly, and the modular inverse exists precisely when the determinant is coprime to 26. Neon-noir traced. See the vector encrypt in 1D, a word round-trip in 2D, and the invert-the-matrix inverse in 3D.

THE HILL CIPHER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT KIT / THE HILL CIPHER THE HILL CIPHER a cipher that is a matrix 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hill cipher is encryption as matrix multiplication . Turn letters into numbers 0–25, group them into vectors, and multiply each by a secret key matrix K modulo 26 : c = K·p (mod 26). To decrypt, multiply by the inverse matrix, p = K −1 ·c (mod 26). The catch is arithmetic: K is invertible mod 26 exactly when its determinant is coprime to 26 (odd and not a multiple of 13). It was the first cipher to encrypt several letters at once, hiding letter frequencies inside linear algebra. LIT verified live: for every key with determinant coprime to 26, encrypting then decrypting recovers the plaintext exactly, and the modular inverse exists precisely when the determinant is coprime to 26 (window.__hill_cipher). FIG no framing; the modular matrix multiply and inverse run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-root-kit — a key matrix is the root kit that locks and unlocks the message, the same tool both ways. AVAN (AI) built the instrument: modular matrix multiplication, the determinant-coprimality test, the modular inverse, and the encrypt–decrypt round-trip. Credit as content: Lester S. Hill (1929). The weave: David names the root kit; I confirm the round-trip recovers the plaintext and that the key is invertible exactly when its determinant is coprime to 26. 3 ONE DIMENSION A plaintext pair as a vector, multiplied by the key matrix mod 26 to a ciphertext pair; the inverse matrix carries it back. 4 TWO DIMENSIONS · INTERACTIVE Pick an invertible key matrix; encrypt a short word into ciphertext and decrypt it back — the round-trip returns the original. new key ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ciphertext, the plaintext vector rotated by K. AVAN’s addition (the inverse-companion): don’t invent a separate decoder — invert the matrix. The inverse of ‘c = K p (mod 26)’ is ‘p = K −1 c (mod 26)’, the same key run backwards, valid exactly when det(K) is coprime to 26. Magenta is the ciphertext; green is the plaintext the inverse restores. The key unlocks itself. pause spin LIT Genuine Hill cipher (Lester S. Hill, 1929), the first polygraphic cipher via matrix multiplication mod 26. Verified live: over 4000 keys, encrypt c=Kp then decrypt p=K⁻¹c recovers plaintext (window.__hill_cipher.roundTrip), and K is invertible mod 26 iff det(K) is coprime to 26 (.requiresInvertible). FIG No framing: the modular matrix multiply, the determinant-coprimality test, the modular inverse, and the round-trip all run in-browser. The AVAN inverse is honest — inverting the key matrix mod 26 (rather than inventing a separate decoder) is what decrypts, valid exactly when det(K) is coprime to 26; magenta is the ciphertext, green the plaintext the inverse restores. The key unlocks itself. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT KIT · David Lee Wise (ROOT0), with AVAN


THE PROUHET-TARRY-ESCOTT

The Prouhet–Tarry–Escott problem in the 5-window house format — splitting numbers into two sets with equal power sums (equal totals, sums of squares, of cubes, as high as possible). Prouhet's answer: take 0..2^k−1 and split by the Thue–Morse parity of each number (even or odd count of 1-bits). Then the two halves have Σaᵖ = Σbᵖ for every power p from 0 up to k−1 — matched sums, square-sums, all the way to the (k−1)-th — and they finally differ at power k. The same sequence that avoids repetition balances the powers. Verified live: for k=2..8, the Thue–Morse split has equal sums of p-th powers for all p<k, and unequal sums at p=k. Neon-noir traced. See the split in 1D, power sums in 2D, and the parity-balances-the-powers inverse in 3D.

THE PROUHET-TARRY-ESCOTT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE PROUHET-TARRY-ESCOTT THE PROUHET-TARRY-ESCOTT a set split into equal power sums 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Prouhet–Tarry–Escott problem asks to split numbers into two sets with equal power sums — equal totals, equal sums of squares, of cubes, and so on, as high as possible. Prouhet’s beautiful answer: take 0, 1, …, 2 k −1 and split them by the Thue–Morse parity of each number (even or odd count of 1-bits). Then the two halves have ∑a p = ∑b p for every power p from 0 up to k−1 — matched sums, matched square-sums, all the way to the (k−1)-th — and they finally differ at power k. The same sequence that avoids repetition balances the powers. LIT verified live: for k = 2..8, the Thue–Morse split has equal sums of p-th powers for all p < k, and unequal sums at p = k (window.__prouhet). FIG no framing; the power sums of both halves are computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-inventory — two inventories that balance not just in count but in every weighted total, matched power by power. AVAN (AI) built the instrument: the Thue–Morse parity split and the power-sum comparison across p. Credit as content: Eugène Prouhet (1851); Tarry & Escott (later). The weave: David names the inventory; I confirm the Thue–Morse halves match in every power sum up to k−1 and part ways at k. 3 ONE DIMENSION 0..2 k −1 split by Thue–Morse parity into set A and set B; the two sets have equal sums, equal square-sums, and so on. 4 TWO DIMENSIONS · INTERACTIVE Pick k; the two Thue–Morse halves are shown with their power sums ∑a p and ∑b p equal for every p below k. next k ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the two halves, matched in every power sum. AVAN’s addition (the inverse-companion): don’t search for a balanced split — read it off the parity. The inverse of ‘find two sets with equal power sums’ is ‘split 0..2 k −1 by Thue–Morse parity, and the powers balance up to k−1 for free.’ Magenta is set B; green is set A — equal in every low power. Parity balances the powers. pause spin LIT Genuine Prouhet–Tarry–Escott / Prouhet's theorem (Eugène Prouhet, 1851): the Thue–Morse split of 0..2^k−1 gives two sets with equal p-th power sums for all p FIG No framing: the power sums of both Thue–Morse halves are computed in-browser and compared. The AVAN inverse is honest — reading a balanced split off the Thue–Morse parity (which balances all powers up to k−1 for free) rather than searching for equal-power-sum sets is Prouhet's insight; magenta is set B, green set A, equal in every low power. Parity balances the powers. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE PALEY

The Paley construction in the 5-window house format — turning the quadratic residues of a prime into a perfectly balanced combinatorial design. Take a prime p≡3 (mod 4) and collect the nonzero squares mod p (the quadratic residues). This set of size (p−1)/2 is a cyclic difference set: every nonzero residue arises as a difference of two residues exactly (p−3)/4 times. Because p≡3 (mod 4), −1 is a non-residue, which makes the set 'skew' and gives the Paley graph and Paley's Hadamard matrices. Structure from squaring. Verified live: for every prime p≡3 (mod 4) up to 59, each nonzero residue is a difference of two quadratic residues exactly (p−3)/4 times, and −1 is always a non-residue. Neon-noir traced. See residues on a circle in 1D, difference counts in 2D, and the count-the-differences inverse in 3D.

THE PALEY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE PALEY THE PALEY residues that are a perfect difference set 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Paley construction turns the quadratic residues of a prime into a perfectly balanced combinatorial design. Take a prime p ≡ 3 (mod 4) and collect the nonzero squares mod p — the quadratic residues. This set of size (p−1)/2 is a cyclic difference set : every nonzero residue arises as a difference of two residues the same number of times , exactly (p−3)/4. Because p ≡ 3 (mod 4), −1 is a non-residue , which makes the set “skew” and gives the Paley graph and Paley’s Hadamard matrices. Structure from squaring. LIT verified live: for every prime p ≡ 3 (mod 4) up to 59, each nonzero residue is a difference of two quadratic residues exactly (p−3)/4 times, and −1 is always a non-residue (window.__paley). FIG no framing; the residues and their differences are enumerated in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-blue-screen — residues that look like noise but hide a perfectly regular difference pattern, order behind the static. AVAN (AI) built the instrument: the quadratic-residue set, the difference-count over all pairs, and the −1-non-residue check. Credit as content: Raymond Paley (1933). The weave: David names the blue screen; I confirm the residues form a difference set with every difference appearing (p−3)/4 times, and that −1 is a non-residue. 3 ONE DIMENSION The residues 0..p−1 around a circle; quadratic residues highlighted — a set whose pairwise differences hit every value equally often. 4 TWO DIMENSIONS · INTERACTIVE Pick a prime p ≡ 3 (mod 4); the quadratic residues and the count of each nonzero difference are shown — all equal to (p−3)/4. next prime ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the quadratic-residue set on the cycle. AVAN’s addition (the inverse-companion): don’t list the squares — count their differences. The inverse of ‘which numbers are squares mod p?’ is ‘every nonzero value is a difference of two of them the same number of times’ — a difference set. Magenta is a difference; green is the residue set that spreads them evenly. Structure from squaring. pause spin LIT Genuine Paley construction (Raymond Paley, 1933): for prime p≡3 mod 4, the quadratic residues form a (p,(p−1)/2,(p−3)/4) cyclic difference set, with −1 a non-residue (giving Paley graphs / Hadamard matrices). Verified live: for primes p≡3 mod4 to 59, every nonzero difference of two QRs occurs exactly (p−3)/4 times (window.__paley.differenceSet) and −1 is a non-residue (.minusOneNonResidue). FIG No framing: the quadratic-residue set, the difference-count over all pairs, and the −1-non-residue check all run in-browser. The AVAN inverse is honest — counting how often each value is a difference of two residues (revealing every value appears equally, a difference set) rather than merely listing the squares is what exposes the design; magenta is a difference, green the residue set spreading them evenly. Structure from squaring. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE WEYL

Weyl's equidistribution theorem in the 5-window house format — step around a circle by an irrational stride and you visit every region equally often. Take an irrational α and the fractional parts {α},{2α},{3α},…: the proportion landing in any subinterval [a,b] converges to exactly its length b−a. The points never repeat and never cluster; they fill the interval uniformly. A rational stride, by contrast, cycles through finitely many spots and fails to equidistribute. Verified live: for five irrationals across several intervals the empirical fraction matches b−a to within 0.01 over 200,000 terms, while a rational stride 1/5 visibly fails. Neon-noir traced. See the sequence filling [0,1) in 1D, the flattening histogram in 2D, and the intervals-get-their-share inverse in 3D.

THE WEYL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT-ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT-ZERO / THE WEYL THE WEYL an irrational stride fills the interval evenly 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Weyl’s equidistribution theorem says that stepping around a circle by an irrational stride visits every region equally often. Take an irrational α and the sequence of fractional parts {α}, {2α}, {3α}, …: as you take more terms, the proportion landing in any subinterval [a, b] converges to exactly its length b − a. The points never repeat and never settle into a pattern — they spread out perfectly uniformly. For a rational stride the sequence cycles through finitely many spots and fails utterly to equidistribute. LIT verified live: for five irrationals and several intervals, the fraction of {nα} in [a, b] matches b − a to within 0.01 over 200,000 terms, while a rational stride 1/5 does not equidistribute (window.__weyl). FIG no framing; the fractional parts and interval counts run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — start at zero and take irrational steps, and you touch every checkpoint on the circle in fair proportion. AVAN (AI) built the instrument: the fractional-part sequence, interval counting, and the rational counterexample. Credit as content: Hermann Weyl (1916). The weave: David names checkpoint-zero; I confirm the irrational orbit fills every interval in proportion to its length, and that a rational stride does not. 3 ONE DIMENSION The first terms of {nα} for an irrational α, dropped onto [0,1): they land everywhere, filling gaps as they go — never clustered. 4 TWO DIMENSIONS · INTERACTIVE Pick a stride; the histogram of {nα} flattens to uniform for irrationals, and the fraction in any interval approaches its length. next α ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the irrational orbit filling the circle evenly. AVAN’s addition (the inverse-companion): don’t track where each step lands — count how the intervals fill. The inverse of ‘iterate nα and watch’ is ‘every interval [a,b] receives a share b−a, because α is irrational.’ Magenta is a rational stride that clusters; green is the irrational orbit that spreads. Irrational fills evenly. pause spin LIT Genuine Weyl equidistribution theorem (Hermann Weyl, 1916). Verified live: for irrationals √2, φ, π, e−2, √3 over four intervals each, the fraction of {nα} in [a,b] matches b−a to within 0.01 across 200,000 terms; a rational stride 1/5 does not equidistribute (window.__weyl.equidistributes, .rationalFails). FIG No framing: the fractional-part sequence and interval counting run in-browser. The AVAN inverse is honest — instead of tracking where each step lands, one asks how the intervals fill; because α is irrational, every [a,b] receives a share exactly b−a. Magenta is a rational stride that clusters; green is the irrational orbit that spreads evenly. Irrational fills evenly. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT-ZERO · David Lee Wise (ROOT0), with AVAN


THE CONFERENCE MATRIX

The conference matrix in the 5-window house format — an n×n matrix with a zero diagonal, ±1 off it, whose rows are all mutually orthogonal: C·Cᵀ=(n−1)·I. Every pair of distinct rows has dot product exactly zero; each row's self-dot is n−1. Paley showed how to build a symmetric one whenever n=q+1 with q≡1 (mod 4) a prime power: fill the core with the Legendre symbol χ(i−j) and border it with ones. These matrices feed the construction of Hadamard matrices and strongly regular graphs. Verified live: for primes q=5,13,17,29,37, the Paley conference matrix satisfies C·Cᵀ=(n−1)·I exactly and is symmetric. Neon-noir traced. See the ±1 grid in 1D, the orthogonality product in 2D, and the multiply-the-rows inverse in 3D.

THE CONFERENCE MATRIX · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SHARED-MEMORY ◆ .dlw.fold THE FOLD / CO-OP / SHARED-MEMORY / THE CONFERENCE MATRIX THE CONFERENCE MATRIX a matrix whose rows are all orthogonal 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A conference matrix is an n×n matrix with a zero diagonal and ±1 off it , whose rows are all mutually orthogonal : C C T = (n−1) I. Every pair of distinct rows has dot product exactly zero, and each row’s self-dot is n−1. Paley showed how to build a symmetric one whenever n = q + 1 with q ≡ 1 (mod 4) a prime power: fill the core with the Legendre symbol χ(i−j) and add a border of ones. They named the family (from telephone conference networks) and feed the construction of Hadamard matrices and strongly regular graphs. LIT verified live: for primes q = 5, 13, 17, 29, 37, the Paley conference matrix satisfies C C T = (n−1) I exactly and is symmetric (window.__conference). FIG no framing; the Legendre-symbol core and the orthogonality product run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at shared-memory — every row shares perfect orthogonality with every other, a memory of ±1s where no two lines interfere. AVAN (AI) built the instrument: the Legendre-symbol core, the border of ones, and the C C T = (n−1) I check. Credit as content: Raymond Paley (the construction, 1933); conference matrices named by Belevitch. The weave: David names shared memory; I confirm the rows are mutually orthogonal and the matrix is symmetric for q ≡ 1 (mod 4). 3 ONE DIMENSION A conference matrix: zero on the diagonal, ±1 elsewhere — and any two different rows are orthogonal (dot product 0). 4 TWO DIMENSIONS · INTERACTIVE Pick a prime q ≡ 1 (mod 4); the Paley matrix is shown, and C C T comes out as (n−1) times the identity. next q ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the matrix of ±1s with all rows orthogonal. AVAN’s addition (the inverse-companion): don’t read the entries — multiply the rows. The inverse of ‘here are the ±1s’ is ‘C C T = (n−1) I, so every distinct row-pair is orthogonal.’ Magenta is an off-diagonal (a zero dot); green is the (n−1) diagonal. Orthogonality is the point. pause spin LIT Genuine Paley construction of symmetric conference matrices (Raymond Paley, 1933; family named by Belevitch after telephone conference networks). Verified live: for q=5,13,17,29,37 the Legendre-symbol core with a border of ones gives C·Cᵀ=(n−1)·I exactly and C=Cᵀ (window.__conference.orthogonality, .symmetric). FIG No framing: the Legendre-symbol core and the C·Cᵀ product run in-browser. The AVAN inverse is honest — rather than reading the ±1 entries, one multiplies the rows: C·Cᵀ=(n−1)·I says every distinct row-pair is orthogonal. Magenta is an off-diagonal (a zero dot); green is the (n−1) diagonal. Orthogonality is the point. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SHARED-MEMORY · David Lee Wise (ROOT0), with AVAN


THE WOODBURY

The Woodbury matrix identity in the 5-window house format — updating a big matrix inverse after a low-rank change, the rank-k generalization of Sherman–Morrison. If you know A⁻¹ and then modify A by a low-rank term UCV, the new inverse is (A+UCV)⁻¹ = A⁻¹ − A⁻¹U(C⁻¹+VA⁻¹U)⁻¹VA⁻¹. The only fresh inversion is of a tiny k×k matrix instead of the full n×n — a huge saving when k is small. It is the backbone of Kalman filtering, Gaussian-process updates, and recursive least squares. Verified live: over thousands of random A,U,C,V the formula matches a direct inversion of A+UCV to machine precision (max error ~1e-11). Neon-noir traced. See the rank-k correction in 1D, the side-by-side match in 2D, and the invert-small-not-big inverse in 3D.

THE WOODBURY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · DIVIDE-BY-ZERO ◆ .dlw.fold THE FOLD / GLITCH / DIVIDE-BY-ZERO / THE WOODBURY THE WOODBURY a low-rank patch to a big inverse 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Woodbury matrix identity updates a big matrix inverse after a low-rank change — the rank-k generalization of Sherman–Morrison. If you know A −1 and then modify A by a low-rank term U C V, the new inverse is (A + UCV) −1 = A −1 − A −1 U (C −1 + V A −1 U) −1 V A −1 . The only fresh inversion is of a tiny k×k matrix instead of the full n×n — a huge saving when k is small. It is the backbone of Kalman filtering, Gaussian-process updates, and recursive least squares. LIT verified live: over thousands of random A, U, C, V, the Woodbury formula matches a direct inversion of A + UCV to machine precision (window.__woodbury). FIG no framing; the identity and a Gauss–Jordan inverse both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at divide-by-zero — the identity trades one big division (the n×n inverse) for a small one (a k×k inverse), living exactly where those inversions are legal. AVAN (AI) built the instrument: the Woodbury formula, a Gauss–Jordan matrix inverter, and the error against a direct inverse. Credit as content: Max A. Woodbury (1950). The weave: David names the divide; I confirm the low-rank update reproduces the full inverse, needing only a k×k inversion. 3 ONE DIMENSION A rank-k change UCV to A becomes a rank-k correction of A −1 , gated by the inverse of a small k×k matrix. 4 TWO DIMENSIONS · INTERACTIVE Random A, U, C, V; the Woodbury update and a direct inverse of A + UCV are shown side by side — identical. new A,U,C,V ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the updated inverse, corrected not rebuilt. AVAN’s addition (the inverse-companion): don’t re-invert the n×n — invert the k×k. The inverse of ‘recompute (A+UCV) −1 ’ is ‘subtract a rank-k term gated by a small (C −1 +VA −1 U) −1 .’ Magenta is the full recompute; green is the low-rank patch. Invert small, not big. pause spin LIT Genuine Woodbury matrix identity (Max A. Woodbury, 1950), generalizing Sherman–Morrison to rank-k. Verified live: over 2000 random A,U,C,V the Woodbury formula matches a Gauss–Jordan inverse of A+UCV to under 1e-6 (max err ~7e-12) (window.__woodbury.matchesDirect). FIG No framing: the identity and a Gauss–Jordan inverter both run in-browser. The AVAN inverse is honest — instead of re-inverting the n×n, one inverts the k×k: the update subtracts a rank-k term gated by the small (C⁻¹+VA⁻¹U)⁻¹. Magenta is the full recompute; green is the low-rank patch. Invert small, not big. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of DIVIDE-BY-ZERO · David Lee Wise (ROOT0), with AVAN


THE TWO-SUM

Two-Sum in the 5-window house format — a tiny miracle of floating-point arithmetic that adds two numbers and hands you the rounding error, exactly. Ordinary a+b rounds to the nearest representable value s, silently discarding a little bit e. Two-Sum computes both, so a+b=s+e is an exact equation over the reals — using only a handful of ordinary additions and subtractions, no wider precision. This 'error-free transformation' is the seed of compensated summation, double-double arithmetic, and reproducible numerics. Verified live: over 20,000 random pairs, s is exactly the rounded sum and the pair (s,e) reconstructs a+b exactly — checked by comparing the exact dyadic (BigInt) fractions of the doubles. Neon-noir traced. See the split into (s,e) in 1D, the exact reconstruction in 2D, and the capture-the-error inverse in 3D.

THE TWO-SUM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE-GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE-GRINDSTONE / THE TWO-SUM THE TWO-SUM the rounding error captured exactly 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two-Sum is a tiny miracle of floating-point arithmetic: it adds two numbers and hands you the rounding error, exactly . Ordinary a + b rounds to the nearest representable value s, silently discarding a little bit e. Two-Sum computes both, so that a + b = s + e is an exact equation over the reals — using only a handful of ordinary additions and subtractions, no wider precision. This “error-free transformation” is the seed of compensated summation, double-double arithmetic, and reproducible numerics. LIT verified live: over 20,000 random pairs, s is exactly the rounded sum and the pair (s, e) reconstructs a + b exactly — checked by comparing exact dyadic fractions of the doubles (window.__two_sum). FIG no framing; Two-Sum and an exact BigInt comparison run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — grind a long sum and the errors accumulate; Two-Sum catches each grain of error as it falls. AVAN (AI) built the instrument: Knuth’s Two-Sum, and an exact rational (dyadic BigInt) comparison to prove a + b = s + e. Credit as content: Donald Knuth (Two-Sum); Dekker (the related fast version). The weave: David names the grindstone; I confirm the error term e makes a + b = s + e an exact identity, verified in exact arithmetic. 3 ONE DIMENSION a + b rounds to s and loses e; Two-Sum returns both, so s (the high part) plus e (the lost error) equals a + b exactly. 4 TWO DIMENSIONS · INTERACTIVE Pick two numbers of very different scale; the naive sum drops bits, but Two-Sum’s (s, e) reconstructs a + b exactly. new a, b ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the exact pair (s, e) representing a + b. AVAN’s addition (the inverse-companion): don’t discard the rounding error — compute it. The inverse of ‘s = fl(a+b), lose the rest’ is ‘e = the exact error, so a + b = s + e with no wider precision.’ Magenta is the rounding error e a naive add throws away; green is the exact pair that keeps it. Capture the error. pause spin LIT Genuine Two-Sum error-free transformation (Donald Knuth; Dekker's related fast version). Verified live: over 20,000 random pairs, s equals the rounded sum a+b and the pair (s,e) satisfies a+b=s+e exactly — confirmed by exact dyadic-fraction (BigInt) comparison of the IEEE-754 doubles (window.__two_sum.exact, .sIsRound). FIG No framing: Two-Sum and the exact BigInt comparison run in-browser. The AVAN inverse is honest — instead of discarding the rounding error, one computes it: e is the exact error, so a+b=s+e holds with no wider precision. Magenta is the rounding error e a naive add throws away; green is the exact pair (s,e) that keeps it. Capture the error. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE DOOMSDAY

The Doomsday rule in the 5-window house format — John Conway's method for finding the day of the week of any date in your head. Every year has an anchor weekday, its 'doomsday', and a set of easy-to-remember dates that always fall on it (4/4, 6/6, 8/8, 10/10, 12/12, and a few more). Compute the year's doomsday from its century anchor plus a small correction, then count from the nearest doomsday date to your target. A few additions mod 7 and you have the weekday — no calendar, no lookup. Verified live: over 20,000 random Gregorian dates (1700–2300), Conway's Doomsday computation gives the same weekday as a reference calendar. Neon-noir traced. See the anchor dates in 1D, the step-by-step weekday in 2D, and the one-anchor-per-year inverse in 3D.

THE DOOMSDAY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE-RESURRECT ◆ .dlw.fold THE FOLD / RESPAWN / THE-RESURRECT / THE DOOMSDAY THE DOOMSDAY the weekday of any date by hand 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Doomsday rule is John Conway’s method for finding the day of the week of any date in your head. Every year has an anchor weekday — its doomsday — and a set of easy-to-remember dates that always fall on it (4/4, 6/6, 8/8, 10/10, 12/12, and a few more). Compute the year’s doomsday from its century anchor plus a small correction, then count from the nearest doomsday date to your target. A few additions mod 7 and you have the weekday — no calendar, no lookup. LIT verified live: over 20,000 random Gregorian dates (1700–2300), Conway’s Doomsday computation gives the same weekday as a reference calendar (window.__doomsday). FIG no framing; the doomsday arithmetic and the reference weekday run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-resurrect — the rule resurrects the weekday of any date, pulling a buried day back from centuries of calendar. AVAN (AI) built the instrument: the century anchors, the year correction, the per-month doomsday dates, and the comparison to a reference calendar. Credit as content: John Horton Conway (1970s). The weave: David names the resurrection; I confirm the mental-arithmetic weekday matches the reference for tens of thousands of dates. 3 ONE DIMENSION The century anchors (Tue, Sun, Fri, Wed) and the doomsday dates per month — all landing on the same weekday within a year. 4 TWO DIMENSIONS · INTERACTIVE Pick a date; the Doomsday rule computes its weekday step by step and matches it against a reference calendar. random date ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the weekday, computed from anchors by hand. AVAN’s addition (the inverse-companion): don’t look the date up — anchor it. The inverse of ‘consult a calendar’ is ‘each year has one doomsday weekday, and every date is a short count from a known doomsday date.’ Magenta is the target date; green is the weekday the anchors give. One anchor per year. pause spin LIT Genuine Doomsday rule (John Horton Conway, 1970s). Verified live: over 20,000 random Gregorian dates 1700–2300, the century-anchor + year-correction + per-month doomsday-date arithmetic reproduces the reference weekday exactly (window.__doomsday.matchesReference). FIG No framing: the doomsday arithmetic and the reference weekday run in-browser. The AVAN inverse is honest — instead of consulting a calendar, one anchors the date: each year has a single doomsday weekday, and every date is a short count from a known doomsday date. Magenta is the target date; green is the weekday the anchors give. One anchor per year. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-RESURRECT · David Lee Wise (ROOT0), with AVAN


THE LEVINSON-DURBIN

The Levinson–Durbin recursion in the 5-window house format — solving a symmetric Toeplitz system (constant diagonals) in O(n²) instead of the O(n³) of general Gaussian elimination. It walks up in order, and at each step a single reflection coefficient extends the solution one more dimension, reusing the structure the constant diagonals give. Applied to a signal's autocorrelation (the Yule–Walker equations) it produces the best linear-predictor coefficients — the heart of LPC speech coding, spectral estimation, and autoregressive modelling. Verified live: over 2000 random positive-definite Toeplitz systems the recursion's solution satisfies T·a=−r to ~1e-15 and matches a direct Gaussian solve, with the prediction error staying positive. Neon-noir traced. See the constant diagonals in 1D, the coefficients vs direct in 2D, and the order-by-order inverse in 3D.

THE LEVINSON-DURBIN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE-HOT-LOOP ◆ .dlw.fold THE FOLD / GRIND / THE-HOT-LOOP / THE LEVINSON-DURBIN THE LEVINSON-DURBIN a Toeplitz system solved by recursion 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Levinson–Durbin recursion solves a symmetric Toeplitz system — one whose diagonals are all constant — in O(n²) time instead of the O(n³) of general Gaussian elimination. It walks up in order, and at each step a single reflection coefficient extends the solution to one more dimension, reusing the structure the constant diagonals give. Applied to the autocorrelation of a signal (the Yule–Walker equations), it produces the coefficients of the best linear predictor — the heart of LPC speech coding, spectral estimation, and autoregressive modelling. LIT verified live: over thousands of random positive-definite Toeplitz systems, the recursion’s solution satisfies T·a = −r to ~1e-15 and matches a direct Gaussian solve, with prediction error staying positive (window.__levinson). FIG no framing; the recursion and a direct solver both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hot-loop — a tight order-by-order recurrence that never rebuilds the whole system, just adds one reflection at a time. AVAN (AI) built the instrument: the Levinson–Durbin recursion, a valid autocorrelation source, and a direct-solve cross-check. Credit as content: Norman Levinson (1947), James Durbin (1960). The weave: David names the hot loop; I confirm the recursion solves the Toeplitz system exactly and matches the direct solve. 3 ONE DIMENSION A Toeplitz matrix: every diagonal is constant. The recursion climbs order by order, each step adding one reflection coefficient. 4 TWO DIMENSIONS · INTERACTIVE A random autocorrelation defines a Toeplitz system; Levinson–Durbin’s coefficients match a direct solve, with residual near zero. new system ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the predictor coefficients, built order by order. AVAN’s addition (the inverse-companion): don’t invert the whole matrix — exploit the constant diagonals. The inverse of ‘solve T·a=−r by elimination’ is ‘each order adds one reflection coefficient, O(n²) total.’ Magenta is the O(n³) full solve; green is the recursion. Structure beats brute force. pause spin LIT Genuine Levinson–Durbin recursion (Norman Levinson 1947, James Durbin 1960) for symmetric Toeplitz / Yule-Walker systems. Verified live: over 2000 random PD Toeplitz systems the O(n²) recursion gives T·a=−r residual under 1e-6 (max ~1.8e-15) and matches a direct Gaussian solve to ~3e-16, with prediction error E>0 (window.__levinson.residualOk, .matchesDirect). FIG No framing: the recursion and a direct solver both run in-browser. The AVAN inverse is honest — rather than inverting the whole matrix, one exploits the constant diagonals: each order adds one reflection coefficient, O(n²) total. Magenta is the O(n³) full solve; green is the recursion. Structure beats brute force. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-HOT-LOOP · David Lee Wise (ROOT0), with AVAN


THE DTW

Dynamic Time Warping in the 5-window house format — measuring the distance between two sequences that run at different speeds by stretching and compressing the time axis to line them up. Instead of comparing sample i to sample i, it finds a monotone alignment path through a cost grid that pairs each point of one sequence with one or more of the other, minimizing total mismatch. A word said fast and slow, two heartbeats, two gestures — DTW judges them similar even when their timing differs, via the DP recurrence D[i,j]=|aᵢ−bⱼ|+min(D[i−1,j],D[i,j−1],D[i−1,j−1]). Verified live: over 3000 random pairs, DTW(A,A)=0, the recovered path is monotone with cost equal to D[n,m], DTW is symmetric, and for equal lengths DTW ≤ the rigid aligned distance. Neon-noir traced. See the alignment links in 1D, the DP grid + path in 2D, and the cheapest-monotone-path inverse in 3D.

THE DTW · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE-SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE-SYNC / THE DTW THE DTW two signals warped into alignment 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Dynamic Time Warping (DTW) measures the distance between two sequences that may run at different speeds — stretching and compressing the time axis to line them up. Instead of comparing sample i to sample i, it finds a monotone alignment path through a cost grid that pairs each point of one sequence with one or more of the other, minimizing total mismatch. A spoken word said fast and slow, two heartbeats, two gestures — DTW judges them similar even when their timing differs. The dynamic-programming recurrence D[i,j] = |a i −b j | + min(D[i−1,j], D[i,j−1], D[i−1,j−1]) fills the grid in O(nm). LIT verified live: over thousands of random pairs, DTW(A,A)=0, the recovered path is monotone and its cost equals D[n,m], DTW is symmetric, and for equal lengths DTW ≤ the rigid aligned distance (window.__dtw). FIG no framing; the DP grid and path backtrack run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-sync — two signals brought into sync by warping time, not by forcing them to march in lockstep. AVAN (AI) built the instrument: the DP cost grid, the min-cost path backtrack, and the property checks. Credit as content: DTW arose in speech recognition (Sakoe & Chiba, 1978). The weave: David names the sync; I confirm the warping path is monotone, its cost matches the grid, and DTW never exceeds the rigid alignment. 3 ONE DIMENSION Two sequences at different speeds; DTW draws the alignment links that pair their points to minimize total mismatch. 4 TWO DIMENSIONS · INTERACTIVE The cost grid with the min-cost warping path highlighted; its accumulated cost is the DTW distance. new signals ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the warping path through the grid. AVAN’s addition (the inverse-companion): don’t compare sample-to-sample — find the cheapest monotone alignment. The inverse of ‘pair i with i’ is ‘a monotone path pairing each point so total mismatch is least.’ Magenta is the rigid diagonal alignment; green is the warped path that dips below it. Warp time to match. pause spin LIT Genuine Dynamic Time Warping (Sakoe & Chiba, 1978, speech recognition). Verified live: over 3000 random sequence pairs, DTW(A,A)=0, the backtracked path is monotone and its accumulated cost equals D[n,m], DTW(A,B)=DTW(B,A), and for equal lengths DTW ≤ the rigid sample-to-sample distance (window.__dtw). FIG No framing: the DP cost grid and path backtrack run in-browser. The AVAN inverse is honest — instead of comparing sample-to-sample, one finds the cheapest monotone alignment. Magenta is the rigid diagonal alignment; green is the warped path that dips below it. Warp time to match. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-SYNC · David Lee Wise (ROOT0), with AVAN


THE BENTLEY-OTTMANN

The Bentley–Ottmann algorithm in the 5-window house format — finding every intersection among a set of line segments without checking all pairs. A vertical sweep line moves left to right; the segments it currently crosses are kept in top-to-bottom order, and only neighbours in that order are ever tested for crossing. Two segments can only intersect after becoming adjacent on the sweep line, so tracking neighbourhood changes at endpoints and crossings catches all K intersections in O((n+K)log n) — far better than the O(n²) of brute force when crossings are few. Verified live: over 300 random segment sets, the sweep's intersection set exactly equals the brute-force all-pairs set. Neon-noir traced. See the sweep line in 1D, the found-vs-brute count in 2D, and the test-only-neighbours inverse in 3D.

THE BENTLEY-OTTMANN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · RACE-CONDITION ◆ .dlw.fold THE FOLD / GLITCH / RACE-CONDITION / THE BENTLEY-OTTMANN THE BENTLEY-OTTMANN a sweep line catching every crossing 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Bentley–Ottmann algorithm finds every intersection among a set of line segments without checking all pairs . A vertical sweep line moves left to right; the segments it currently crosses are kept in top-to-bottom order, and only neighbours in that order are ever tested for crossing. Two segments can only intersect after becoming adjacent on the sweep line, so tracking neighbourhood changes at endpoints and crossings catches all K intersections in O((n+K) log n) — far better than the O(n²) of brute force when crossings are few. LIT verified live: over hundreds of random segment sets, the sweep’s intersection set exactly equals the brute-force all-pairs set (window.__bentley_ottmann). FIG no framing; the event-driven sweep and an O(n²) check both run in-browser (general position; the classic degenerate-handling caveats apply). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at race-condition — segments race along the sweep line, and a crossing is exactly the moment two of them swap order. AVAN (AI) built the instrument: the event queue, the sweep-status order, neighbour tests, and the brute-force cross-check. Credit as content: Jon Bentley & Thomas Ottmann (1979). The weave: David names the race; I confirm the sweep recovers exactly the same intersection set as testing all pairs. 3 ONE DIMENSION Segments and their crossings; the sweep line moves right, and only segments adjacent on it are tested for intersection. 4 TWO DIMENSIONS · INTERACTIVE A random segment set; the sweep marks every intersection, and the count matches the brute-force all-pairs test. new segments ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the intersection points the sweep discovers. AVAN’s addition (the inverse-companion): don’t test all pairs — test only neighbours on the sweep. The inverse of ‘check every pair’ is ‘two segments can cross only where they are adjacent on the sweep line.’ Magenta is the O(n²) all-pairs cloud; green is the crossings the sweep actually finds — the same set. Sweep, don’t enumerate. pause spin LIT Genuine Bentley–Ottmann sweep-line algorithm (Jon Bentley & Thomas Ottmann, 1979). Verified live: over 300 random segment sets the event-driven sweep (endpoint + intersection events, neighbour tests on the sweep status) recovers exactly the brute-force all-pairs intersection set, 0 mismatches (window.__bentley_ottmann.matchesBrute). FIG No framing: the event-driven sweep and an O(n²) brute-force check both run in-browser. Honest scope — segments are generated in general position; the classic degenerate cases (vertical segments, triple points, overlapping collinear segments) need the standard extra handling. The AVAN inverse is honest — two segments can cross only where they are adjacent on the sweep line, so only neighbours are tested. Magenta is the O(n²) all-pairs cloud; green is the same crossings the sweep finds. Sweep, don't enumerate. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of RACE-CONDITION · David Lee Wise (ROOT0), with AVAN


THE RANSAC

RANSAC (RANdom SAmple Consensus) in the 5-window house format — fitting a model to data riddled with outliers, the workhorse of computer vision for finding lines, planes, and geometric relations in noisy point sets. Instead of least-squares (which one bad point can wreck), it repeatedly draws the minimal sample needed to define a model (two points for a line), counts how many other points agree within a tolerance, and keeps the model with the largest consensus set. With enough random trials it almost surely hits a sample of pure inliers and locks onto the true model — even when nearly half the data is garbage. Verified live: over 800 trials with 60 inliers and 40 outliers, RANSAC recovers the planted line's slope (to within 0.1) and its inlier set in 100% of runs. Neon-noir traced. See the consensus fit in 1D, the inlier marking in 2D, and the most-votes-wins inverse in 3D.

THE RANSAC · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE-RAID ◆ .dlw.fold THE FOLD / BOSS / THE-RAID / THE RANSAC THE RANSAC a model found through a storm of outliers 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION RANSAC (RANdom SAmple Consensus) fits a model to data riddled with outliers — the workhorse of computer vision for finding lines, planes, and geometric relations in noisy point sets. Instead of least-squares (which one bad point can wreck), it repeatedly draws the minimal sample needed to define a model (two points for a line), counts how many other points agree within a tolerance, and keeps the model with the largest consensus set . With enough random trials, it almost surely hits a sample of pure inliers and locks onto the true model — even when nearly half the data is garbage. LIT verified live: over 800 trials with 60 inliers and 40 outliers, RANSAC recovers the planted line’s slope (to within 0.1) and its inlier set in 100% of runs (window.__ransac). FIG honest scope: RANSAC is randomized — this is a high-probability guarantee, and the success rate is reported, not assumed. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-raid — the true model survives a raid of outliers by gathering the largest party of points that agree. AVAN (AI) built the instrument: the minimal-sample loop, the consensus count, and the planted-line recovery test. Credit as content: Fischler & Bolles (1981). The weave: David names the raid; I confirm RANSAC recovers the planted line through heavy outlier contamination, and report the measured success rate rather than overclaiming certainty. 3 ONE DIMENSION Points from a line plus scattered outliers; RANSAC’s best model is the line with the most points in agreement. 4 TWO DIMENSIONS · INTERACTIVE Generate inliers and outliers; RANSAC finds the consensus line and marks its inliers — least-squares would bend toward the noise. new data ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the recovered line and its consensus set. AVAN’s addition (the inverse-companion): don’t fit all the points — find the model most points vote for. The inverse of ‘minimize error over everything’ is ‘the line with the largest inlier consensus, outliers ignored.’ Magenta is the outlier storm; green is the line the inliers agree on. Consensus beats least-squares. pause spin LIT Genuine RANSAC (Fischler & Bolles, 1981). Verified live: over 800 trials with 60 inliers (near a planted line) and 40 uniform outliers, the minimal-sample consensus loop recovers the planted slope to within 0.1 and captures ≥90% of inliers in 100% of runs (window.__ransac.successRate). FIG Honest scope: RANSAC is randomized, so this is a high-probability guarantee — the measured success rate is reported, not assumed certain. The AVAN inverse is honest — instead of minimizing error over all points, one finds the model the most points vote for, ignoring outliers. Magenta is the outlier storm; green is the line the inliers agree on. Consensus beats least-squares. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-RAID · David Lee Wise (ROOT0), with AVAN


THE XORSHIFT

Xorshift in the 5-window house format — George Marsaglia's family of fast pseudo-random generators, where the whole state is one machine word and each step is three xor-with-shift operations: x ^= x<<a; x ^= x>>b; x ^= x<<c. No multiply, no memory — just shifts and xors. With a primitive shift triple the generator is a bijection on the nonzero states that runs through every one exactly once before repeating, a full period of 2^w−1; zero is an isolated fixed point the cycle never touches. It is the ancestor of xorshift128+, the default RNG in many language runtimes. Verified live: for a 16-bit generator with triple (1,1,14), iterating from any nonzero seed visits all 65,535 nonzero states exactly once and returns to the seed — a proven full period — and the 32-bit (13,17,5) generator passes a χ² equidistribution test. Neon-noir traced. See the shift-xor scramble in 1D, the state-coverage fill in 2D, and the single-cycle inverse in 3D.

THE XORSHIFT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE-JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE-JACKPOT / THE XORSHIFT THE XORSHIFT three shifts spin through every state once 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Xorshift is George Marsaglia’s family of fast pseudo-random generators: the whole state is one machine word, and each step is three xor-with-shift operations — x ^= x<<a; x ^= x>>b; x ^= x<<c. No multiply, no memory, just shifts and xors. With a primitive shift triple the generator is a bijection on the nonzero states that runs through every one of them exactly once before repeating — a full period of 2 w −1. Zero is an isolated fixed point the cycle never touches. It is the ancestor of xorshift128+, the default RNG in many language runtimes. LIT verified live: for a 16-bit generator with triple (1,1,14), iterating from any nonzero seed visits all 65,535 nonzero states exactly once and returns to the seed — a proven full period — and the 32-bit (13,17,5) generator passes a χ² equidistribution test (window.__xorshift). FIG no framing; the full-period walk and the χ² count run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-jackpot — three shifts and an xor spin the reels through every state once before the sequence comes up the same again. AVAN (AI) built the instrument: the xorshift step, the full-period walk over all 65,535 states, and the χ² check. Credit as content: George Marsaglia (Xorshift RNGs, 2003). The weave: David names the jackpot; I confirm the primitive triple gives a single full-length cycle over every nonzero state, and the output is equidistributed. 3 ONE DIMENSION One step: x ^= x<<1, then x ^= x>>1, then x ^= x<<14 — three shift-xors scramble the 16 bits of state. 4 TWO DIMENSIONS · INTERACTIVE Run the 16-bit generator; every state it visits lights a cell. It fills all 65,535 nonzero states exactly once — a complete period. step ×2000 ▶ run to full ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the single cycle threading every nonzero state. AVAN’s addition (the inverse-companion): don’t just draw the next number — see the whole orbit. The inverse of ‘step the state’ is ‘the map is a bijection on nonzero states forming one 2 w −1 cycle.’ Magenta is the isolated fixed point 0 the cycle never enters; green is the single full-length loop through everything else. One cycle, every state. pause spin LIT Genuine Xorshift RNG (George Marsaglia, 2003). Verified live: the 16-bit generator with triple (1,1,14) walks all 65,535 nonzero states exactly once and returns to its seed (a proven full period 2^16−1), never hitting the 0 fixed point; the 32-bit (13,17,5) generator's low nibble is equidistributed over 1.6M draws (χ²≈21.6 FIG No framing: the full-period walk over all 65,535 states and the χ² count run in-browser. Honest scope — full period is demonstrated exactly on the 16-bit word (the 32-bit/64-bit versions inherit the same primitive-triple theory but are too large to enumerate); equidistribution is a statistical test, not a proof of cryptographic quality (xorshift is a fast non-cryptographic RNG). The AVAN inverse is honest — the step map is a bijection on nonzero states forming one 2^w−1 cycle. Magenta is the isolated fixed point 0; green is the single full-length loop through everything else. One cycle, every state. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-JACKPOT · David Lee Wise (ROOT0), with AVAN


THE GAUSS SUM

The quadratic Gauss sum in the 5-window house format — add up the p complex numbers e^{2πi·k²/p} for k=0..p−1, and although the phases scatter chaotically around the circle, their sum has magnitude exactly √p. Gauss went further and pinned the sign: the sum equals √p when p≡1 (mod 4) and i√p when p≡3 (mod 4) — a fact he called his 'tormentor' until he proved it. These sums underlie quadratic reciprocity, the functional equation of L-functions, and the construction of certain codes. Verified live: for every prime up to 200 the squared magnitude of the sum equals p to ~1e-13, and the real/imaginary split matches Gauss's sign rule. Neon-noir traced. See the unit vectors on the circle in 1D, the head-to-tail resultant in 2D, and the magnitude-locked inverse in 3D.

THE GAUSS SUM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST-LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST-LIGHT / THE GAUSS SUM THE GAUSS SUM p unit vectors sum to exactly √p 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The quadratic Gauss sum is one of the small miracles of number theory: add up the p complex numbers e 2πi·k²/p for k = 0…p−1, and although the phases scatter chaotically around the circle, their sum has magnitude exactly √p . Gauss went further and pinned the sign : the sum equals √p when p ≡ 1 (mod 4) and i√p when p ≡ 3 (mod 4) — a fact he called his “tormentor” until he proved it. These sums underlie quadratic reciprocity, the functional equation of L-functions, and the fast construction of certain codes. LIT verified live: for every prime up to 200, the squared magnitude of the sum equals p to ~1e-13, and the real/imaginary split matches Gauss’s sign rule (window.__gauss_sum). FIG no framing; the p complex exponentials and their sum run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at first-light — p points of light placed around the circle by k², and no matter how they scatter their sum is a beam of length exactly √p. AVAN (AI) built the instrument: the k² phases, the head-to-tail sum, and the magnitude/sign checks. Credit as content: Carl Friedrich Gauss (1801–1805). The weave: David names first light; I confirm the chaotic-looking phases sum to a resultant of length exactly √p, with the sign Gauss determined. 3 ONE DIMENSION The p unit vectors e^{2πik²/p} on the circle; scattered in phase, yet their sum is a resultant of length exactly √p. 4 TWO DIMENSIONS · INTERACTIVE Pick a prime; the k² phasors add head-to-tail into a resultant whose length is √p, its direction set by p mod 4. next prime ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the resultant of length √p. AVAN’s addition (the inverse-companion): don’t read the phases — measure the sum. The inverse of ‘scatter p unit vectors by k²’ is ‘their magnitude is locked to exactly √p, sign by p mod 4.’ Magenta are the individual unit vectors; green is the resultant of length √p. Chaos in phase, order in magnitude. pause spin LIT Genuine quadratic Gauss sum (Carl Friedrich Gauss, 1801–1805). Verified live: for every prime p ≤ 200, |Σ_{k=0}^{p−1} e^{2πik²/p}|² = p to ~1e-13, and the sum is √p (real) when p≡1 mod4 and i√p (imaginary) when p≡3 mod4 — Gauss's sign determination (window.__gauss_sum.magEqualsP, .signCorrect). FIG No framing: the p complex exponentials and their vector sum run in-browser. The AVAN inverse is honest — instead of reading the scattered phases, one measures their sum: the magnitude is locked to exactly √p, sign fixed by p mod 4. Magenta are the p individual unit vectors; green is the resultant of length √p. Chaos in phase, order in magnitude. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST-LIGHT · David Lee Wise (ROOT0), with AVAN


THE FLAJOLET-MARTIN

The Flajolet–Martin algorithm in the 5-window house format — estimating how many distinct items a stream contains using a few hundred bits, no matter how many billions flow past. A random hash lands on a value ending in exactly r zero-bits with probability 2^{−r−1}, so among n distinct items the longest trailing-zero run is about log₂ n. Track, per bucket, the lowest bit position never hit; average across buckets and correct by φ≈0.77351, and you recover the cardinality. Crucially it is idempotent: seeing the same item twice changes nothing, because its hash is the same. Verified live: with 256 buckets the estimate lands within ~3–5% of the true distinct count on average (matching the theoretical 0.78/√m), and re-adding duplicates leaves it unchanged. Neon-noir traced. See the bitmap read-out in 1D, the estimate-vs-true in 2D, and the count-without-counting inverse in 3D.

THE FLAJOLET-MARTIN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE-HOARD ◆ .dlw.fold THE FOLD / LOOT / THE-HOARD / THE FLAJOLET-MARTIN THE FLAJOLET-MARTIN a vast count from a tiny bitmap 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Flajolet–Martin algorithm estimates how many distinct items a stream contains — using a few hundred bits, no matter how many billions flow past. The trick is in the hashes: a random hash lands on a value ending in exactly r zero-bits with probability 2 −r−1 , so among n distinct items the longest run of trailing zeros seen is about log 2 n. Track, per bucket, the lowest bit position never hit; average across buckets and correct by a constant φ ≈ 0.77351, and you recover the cardinality. Crucially it is idempotent : seeing the same item twice changes nothing, because its hash is the same. LIT verified live: with 256 buckets, the estimate lands within ~3–5% of the true distinct count on average (matching the theoretical 0.78/√m), and re-adding duplicates leaves it unchanged (window.__flajolet_martin). FIG honest scope: this is a probabilistic estimate; the measured average error is reported, not a per-run guarantee. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hoard — count a vast hoard from a thumbprint, a few hundred bits standing in for billions of items. AVAN (AI) built the instrument: the hash, the per-bucket bitmaps, the φ-corrected estimate, and the idempotence check. Credit as content: Philippe Flajolet & G. Nigel Martin (1985), ancestor of LogLog and HyperLogLog. The weave: David names the hoard; I confirm a tiny sketch estimates the cardinality within a few percent and ignores repeats. 3 ONE DIMENSION Each item's hash sets a bit at its trailing-zero count; the lowest bit never set sits near log₂(count) — the sketch's read-out. 4 TWO DIMENSIONS · INTERACTIVE Stream distinct items and duplicates; the sketch's estimate tracks the true distinct count and ignores the repeats. new stream ▶ add duplicates ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the cardinality read from the sketch. AVAN’s addition (the inverse-companion): don’t store the set — store the extremes of its hashes. The inverse of ‘count by remembering everything’ is ‘the longest trailing-zero run ≈ log₂ of the count, read from a few hundred bits.’ Magenta is the true set you never keep; green is the estimate the bitmap yields. Count without counting. pause spin LIT Genuine Flajolet–Martin probabilistic counting (Philippe Flajolet & G. Nigel Martin, 1985), ancestor of LogLog/HyperLogLog. Verified live: with m=256 bucket bitmaps (bit set at each hash's trailing-zero count, R = lowest unset bit, estimate (m/φ)·2^{avg R}), the average relative error over 200 streams is ~3–5% (theory 0.78/√m ≈ 4.9%) and the estimate is idempotent to duplicate insertions (window.__flajolet_martin.within, .idempotent). FIG Honest scope: this is a probabilistic estimate — the measured average error is reported, not a per-run guarantee. The AVAN inverse is honest — instead of storing the set, one stores the extremes of its hashes: the longest trailing-zero run ≈ log₂ of the count. Magenta is the true set you never keep; green is the estimate the bitmap yields. Count without counting. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-HOARD · David Lee Wise (ROOT0), with AVAN


THE STEINHAUS-JOHNSON-TROTTER

The Steinhaus–Johnson–Trotter algorithm in the 5-window house format — listing every permutation of n items so each differs from the last by a single swap of two adjacent positions. It is a Gray code for permutations: a Hamiltonian path through the permutohedron touching all n! arrangements, changing as little as possible each step. Each element carries a direction; the largest 'mobile' element moves, and when it can move no further, directions flip and the next-largest takes over — no permutation repeated or skipped. Verified live: for n=2..7 it emits exactly n! permutations, all distinct, and every consecutive pair differs by exactly one adjacent transposition. Neon-noir traced. See the highlighted swaps in 1D, the step-through in 2D, and the Hamiltonian-path inverse in 3D.

THE STEINHAUS-JOHNSON-TROTTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE-HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE-HANDOFF / THE STEINHAUS-JOHNSON-TROTTER THE STEINHAUS-JOHNSON-TROTTER every permutation one swap apart 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Steinhaus–Johnson–Trotter algorithm lists every permutation of n items so that each one differs from the last by a single swap of two adjacent positions . It is a Gray code for permutations: a Hamiltonian path through the permutohedron that touches all n! arrangements, changing as little as possible at each step. The mechanism gives each element a direction and moves the largest “mobile” element; when an element moves past all it can, directions flip and the next-largest takes over. No permutation is ever repeated or skipped. LIT verified live: for n = 2…7 the algorithm emits exactly n! permutations, all distinct, and every consecutive pair differs by exactly one adjacent transposition (window.__sjt). FIG no framing; the mobile-element generation and the difference checks run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-handoff — each arrangement hands off to the next by a single adjacent swap, a relay through all n! of them. AVAN (AI) built the instrument: the directed mobile-element method, and the count / distinctness / adjacent-swap checks. Credit as content: Steinhaus, Selmer Johnson & Hale Trotter (1962–63). The weave: David names the handoff; I confirm the sequence visits every permutation exactly once, each one adjacent-swap away from the last. 3 ONE DIMENSION Consecutive permutations of 4 items; the two positions that swap are highlighted — always adjacent, always a single exchange. 4 TWO DIMENSIONS · INTERACTIVE Step through the full list; the highlighted adjacent pair is the only change from the previous permutation. ◀ prev next ▶ run ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the minimal-change path through all permutations. AVAN’s addition (the inverse-companion): don’t just list them — walk between them. The inverse of ‘enumerate all n! permutations’ is ‘a Hamiltonian path where each edge is one adjacent transposition.’ Magenta is a permutation node; green is the single path threading all of them. Every arrangement, one swap apart. pause spin LIT Genuine Steinhaus–Johnson–Trotter permutation generation (Steinhaus; Selmer Johnson & Hale Trotter, 1962–63). Verified live: for n=2..7 the directed mobile-element method emits exactly n! permutations, all distinct, with every consecutive pair differing by exactly one adjacent transposition (window.__sjt.countOk, .distinctOk, .adjacentOk). FIG No framing: the mobile-element generation and the difference checks run in-browser. The AVAN inverse is honest — instead of merely listing permutations, one walks between them: a Hamiltonian path whose every edge is a single adjacent transposition. Magenta is a permutation node; green is the path threading all of them. Every arrangement, one swap apart. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE-HANDOFF · David Lee Wise (ROOT0), with AVAN