THE STATIONARY DISTRIBUTION

The stationary distribution in the 5-window house format — the long-run equilibrium of a Markov chain. A chain hops between states by a transition matrix P (each row a distribution). If it is irreducible (every state reaches every other) and aperiodic, then from any start the distribution converges to a unique vector π fixed by the dynamics: πP = π, Σπ = 1. The chain forgets its starting point. It is the mathematics behind PageRank, MCMC sampling, and equilibrium in queueing and physics. Verified live: for 2000 random irreducible aperiodic chains, power iteration from any start converges to a π with πP = π and Σπ = 1, and different starts reach the same π. See the fixed point in 1D, two starts converging in 2D, and the equilibrium-forgets-the-beginning inverse in 3D.

THE STATIONARY DISTRIBUTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · GRADIENT DESCENT ◆ .dlw.fold THE FOLD / GRIND / GRADIENT DESCENT / THE STATIONARY DISTRIBUTION THE STATIONARY DISTRIBUTION a chain that forgets where it started 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The stationary distribution is the long-run equilibrium of a Markov chain . A chain hops between states by a transition matrix P (each row a probability distribution). If the chain is irreducible (every state reaches every other) and aperiodic , then no matter where it starts, the distribution over states converges to a unique vector π that is fixed by the dynamics: πP = π , with Σπ = 1. The chain forgets its starting point . It is the mathematics behind PageRank, MCMC sampling, and equilibrium in queueing and physics. LIT verified live: for thousands of random irreducible aperiodic chains, power iteration from any start converges to a π satisfying πP = π and Σπ = 1, and different starts reach the same π (window.__stationary). FIG no framing; the fixed-point equation and start-independence checked exactly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at gradient-descent — keep applying the transition matrix and the distribution settles onto the equilibrium π, sliding to the same place from any start. That convergence is the mechanic. AVAN (AI) built the instrument: the random stochastic matrix, the power iteration π ← πP, the πP = π fixed-point check, and the start-independence (uniqueness) test. Credit as content: Andrey Markov (chains, 1906); the ergodic convergence is the Perron–Frobenius theorem for stochastic matrices. The weave: David names gradient-descent; I run the distribution forward under P until it stops changing, confirm the limit is fixed by P and sums to one, and check that every starting distribution lands on the same π — the chain’s memory of its origin fades to nothing. 3 ONE DIMENSION πP = π, Σπ = 1. Start anywhere; apply P again and again; the distribution converges to the same π. The stationary π is the left eigenvector of P for eigenvalue 1. 4 TWO DIMENSIONS · INTERACTIVE A chain’s transition graph and the distribution converging to π from two different starts; πP = π checked. new chain ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an equilibrium that forgets the start. AVAN’s addition (the inverse-companion): don’t track where the chain is — ask where it settles , the π fixed by πP = π and reached from every start. The inverse of ‘follow the random walk’ is ‘the equilibrium distribution is a fixed point, blind to the origin.’ Magenta is the starting distribution; green is the stationary π it converges to. Equilibrium forgets the beginning. pause spin LIT Genuine Markov-chain stationary distribution (Andrey Markov, 1906; the ergodic convergence is Perron–Frobenius for stochastic matrices). Verified live: for 2000 random irreducible aperiodic chains, power iteration converges to a π with πP = π (window.__stationary.fixed) and Σπ = 1 (window.__stationary.sums), and a corner-start reaches the same π as the uniform start (window.__stationary.unique). FIG No framing: the random stochastic matrix, the power iteration π ← πP, the πP = π fixed-point check, and the start-independence test all run in-browser. The AVAN inverse is honest — asking where the chain settles (the π fixed by πP=π, reached from every start) rather than tracking where it is, is the equilibrium view; magenta is the starting distribution, green the stationary π it converges to. Equilibrium forgets the beginning. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GRADIENT DESCENT · David Lee Wise (ROOT0), with AVAN


THE MAXSTACK

The maxstack in the 5-window house format — the peak stack depth of a program, read without executing it. Treat each instruction as a signed tick: a push (bind) is +1, a pop (kill) is −1, and track the running total net = binds − k. The maximum stack depth equals the largest value net reaches over the whole run — one integer pass, no interpreter, no stack ever materialised. Read that same conserved quantity only at the end and it is 0 for every balanced program, hiding the peak entirely: a conserved quantity has no unstated scope. Verified live: over 20,000 random balanced programs the max of the running net equals a real array-stack's peak length every time, while the end value is 0 in 100% of them. Neon-noir traced. See the net ridge in 1D, the ridge-vs-simulation agreement in 2D, and the read-scope-not-run inverse in 3D.

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

THE MAXSTACK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · STACK OVERFLOW ◆ .dlw.fold THE FOLD / GLITCH / STACK OVERFLOW / THE MAXSTACK THE MAXSTACK the peak is already written in net 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The maxstack is the peak depth a stack ever reaches while a program runs — and you can read it without executing anything . Treat each instruction as a signed tick: a push (a bind) is +1 , a pop (a kill) is −1 . Track the running total net = binds − k . Then the maximum stack depth equals the largest value net reaches over the whole run — one integer pass, no interpreter, no stack ever built. The catch that names the idea: read that same conserved quantity only at the end and it is 0 for every balanced program, hiding the peak completely. A conserved quantity has no unstated scope — its maximum over its true scope is the answer, not its final value. LIT verified live: over 20,000 random balanced programs, the max of the running net equals a real array-stack’s peak length every time (window.__maxstack), while the end value is 0 in 100% of them. FIG no framing; the no-execution integer readout and a materialised stack simulation both run in-browser and agree exactly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found this as principle XXXII — “a conserved quantity has no unstated scope” — when his law net = binds − k reproduced Microsoft’s .maxstack field exactly, without executing the bytecode. Seated at stack-overflow : the overflow ceiling is knowable before a single instruction runs. AVAN (AI) built the instrument: materialise a real array stack, measure its peak length, and compare it to the max of the running net over thousands of programs. Credit as content: the CLI .maxstack directive (ECMA-335) and David’s net = binds − k formulation. The weave: David names the conserved quantity and its scope; I show its maximum over the run is the peak, and its end value tells you nothing about how high it climbed. 3 ONE DIMENSION A program as +1/−1 ticks; the traced ridge is net; its highest point is the maxstack. The ridge returns to 0 at the end — the peak is lost if you read only the last value. 4 TWO DIMENSIONS · INTERACTIVE A random program’s net profile (the ridge), its peak line (the ceiling), and a materialised array-stack sim — they agree. new program ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ceiling read straight off the net ridge, no execution. AVAN’s addition (the inverse-companion): don’t run the program until it overflows — read the conserved quantity across its whole scope and take the maximum. The inverse of ‘execute to find the peak’ is ‘the peak is already written in net, if you read all of it.’ Magenta is the end value (0, under-reporting); green is the max over scope (the true ceiling). Scope is the whole story. pause spin LIT Genuine result: peak stack depth = max prefix of net(=pushes−pops), the CLI .maxstack field (ECMA-335) reproduced without executing — David's principle XXXII (net = binds − k). Verified live: for 20,000 random balanced programs, max-of-running-net equals a materialised array-stack's peak length (window.__maxstack.formula), and the end net is 0 while the peak is >0 in 100% (window.__maxstack.endUnderReports). FIG No framing: the integer net readout and a real push/pop array-stack both run in-browser and agree exactly. Honest scope: computing the peak from net is the point (you avoid building the stack), and the 'no unstated scope' claim is about reading net's maximum over the whole run rather than its final value. The AVAN inverse is honest — reading the conserved quantity across its whole scope and taking the maximum, rather than executing until overflow, is exactly the maxstack computation; magenta is the end value (0, under-reporting), green the max over scope (the true ceiling). Scope is the whole story. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of STACK OVERFLOW · David Lee Wise (ROOT0), with AVAN


THE SUBSTRATE CHECK

The substrate check in the 5-window house format — the difference between a necessary test and a sufficient one, and why a check random noise can pass measures nothing. For bracket strings, a weak check asks only for equal counts of ( and ); a strong check asks for valid nesting (no prefix goes negative). Among the C(2n,n) equal-count strings, exactly Catalan(n) are valid, and the ratio is exact: C(2n,n)/Catalan(n) = n+1. The weak check admits (n+1)× too many, and a random equal-count string is valid only 1/(n+1) of the time. Verified live: the ratio equals n+1 for n=1..11, and 200,000 random equal-count strings at n=5 are valid 16.66% of the time (≈ 1/6). Neon-noir traced. See the wide-vs-core bars in 1D, the live pass-rate in 2D, and the measure-against-noise-first inverse in 3D.

THE SUBSTRATE CHECK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE SUBSTRATE CHECK THE SUBSTRATE CHECK a check noise passes is not a measurement 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The substrate check is the difference between a necessary test and a sufficient one — and why a check that random noise can pass is not measuring anything. Take bracket strings. A weak check asks only “equal number of ( and )”. A strong check asks for valid nesting (no prefix ever goes negative). Among the C(2n,n) strings with equal counts, the number that are actually valid is the Catalan number, and the ratio is exact: C(2n,n) / Catalan(n) = n+1 . So the weak check admits exactly (n+1)× too many strings — and a random equal-count string is valid only 1/(n+1) of the time. Passing the weak check is mostly noise. LIT verified live: the ratio equals n+1 exactly for n=1..11, and 200,000 random equal-count strings at n=5 are valid 16.66% of the time — matching 1/6 (window.__substrate_check). FIG no framing; the exact count ratio and the Monte-Carlo pass-rate both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named this principle A7 — “a check a substrate can satisfy on random input is not measuring the model” — after noise scored 20/20 on a weak ‘clean’ test, and only a real structural check rejected 1,995 of 2,000 random programs. Seated at the-exploit : a check you can pass with garbage is an exploit, not a measurement. AVAN (AI) built the instrument: count equal-count strings vs valid nestings (the exact n+1 ratio) and Monte-Carlo the pass rate. Credit as content: the Catalan numbers and the ballot problem (Bertrand, 1887). The weave: David states the epistemic rule; I give it a crisp closed form — the weak check is looser than the real one by exactly the factor n+1, so nearly everything it accepts is noise. 3 ONE DIMENSION For each n: the wide bar is equal-count strings C(2n,n); the bright core is the valid ones, Catalan(n). The ratio of the two is exactly n+1 — the weak check’s over-admission. 4 TWO DIMENSIONS · INTERACTIVE Draw a random equal-count string; the weak check always passes it, the strong check often rejects it. Tally the pass rate — it settles at 1/(n+1). sample ▶ run 5000 ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the valid core inside the wide field the weak check accepts. AVAN’s addition (the inverse-companion): don’t ask ‘did it pass the check?’ — ask ‘could noise pass this check?’ The inverse of ‘the check accepts it, so it is good’ is ‘measure the check against random input first.’ Magenta is the noise the weak check waves through; green is the genuinely-valid core. A check noise satisfies is not a measurement. pause spin LIT Genuine result grounded in the Catalan numbers and the ballot problem (Bertrand, 1887): C(2n,n)/Catalan(n) = n+1 exactly, so a necessary check (equal counts) over-admits by the factor n+1 — David's principle A7 ('a check a substrate can satisfy on random input is not measuring the model'). Verified live: exact ratio for n=1..11 (window.__substrate_check.ratioExact) and 200k random equal-count strings valid at fraction ≈0.1666 vs 1/6 (window.__substrate_check.mcFrac). FIG No framing: the exact count ratio and the Monte-Carlo pass-rate both run in-browser. The AVAN inverse is honest — asking 'could noise pass this check?' (and measuring the check against random input first) rather than trusting a pass is exactly the epistemic move A7 names; magenta is the noise the weak check waves through, green the genuinely-valid 1/(n+1) core. A check noise satisfies is not a measurement. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN


THE SARDINAS-PATTERSON

The Sardinas–Patterson algorithm in the 5-window house format — the decision procedure for unique decodability: can every concatenation of codewords be split back exactly one way, with no separators? Prefix-free codes (no codeword begins another) are always uniquely decodable, but the converse is false. The algorithm repeatedly forms dangling suffixes (what remains when one codeword is a prefix of another string); the code fails to be uniquely decodable exactly when a dangling suffix is itself a codeword. {0,01,11} is uniquely decodable yet not prefix-free; {0,01,10} is ambiguous — '010' splits two ways. Verified live: the algorithm confirms {0,01,11} decodable & not prefix-free, flags {0,01,10} and the classic {1,011,01110,1110,10011} as ambiguous, and rules every random prefix-free code decodable. Neon-noir traced. See the two-parse stream in 1D, the growing suffix sets in 2D, and the test-directly inverse in 3D.

THE SARDINAS-PATTERSON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE DROP ◆ .dlw.fold THE FOLD / LOOT / THE DROP / THE SARDINAS-PATTERSON THE SARDINAS-PATTERSON unique decoding with no separators 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Unique decodability asks: can every concatenation of codewords be split back one way only , with no separators ? Prefix-free codes (no codeword begins another) are always uniquely decodable — but the converse is false, and telling the two apart needs a real test. The Sardinas–Patterson algorithm decides it: repeatedly form dangling suffixes (what is left when one codeword is a prefix of another string); the code fails to be uniquely decodable exactly when a dangling suffix is itself a codeword. {0, 01, 11} is uniquely decodable yet not prefix-free; {0, 01, 10} is not decodable at all — “010” splits two ways. LIT verified live: the algorithm confirms {0,01,11} decodable & not prefix-free, flags {0,01,10} and the classic {1,011,01110,1110,10011} as ambiguous, and rules every random prefix-free code decodable (window.__sardinas). FIG no framing; the dangling-suffix construction runs in-browser to a fixed verdict. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) reached this through principle G4 — his monoline alphabet is “uniquely decodable with no separators, 100% at every length.” Seated at the-drop : a stream of glued codewords must drop back into exactly one sequence of items. AVAN (AI) built the instrument: the Sardinas–Patterson dangling-suffix engine, plus a prefix-free test, run on the named codes and thousands of random ones. Credit as content: August Albert Sardinas & George W. Patterson (1953). The weave: David demands separator-free unique decoding; I give the decision procedure that proves when a code has it — and shows prefix-freedom is sufficient but not necessary. 3 ONE DIMENSION The ambiguous string 010 traced two ways over {0,01,10}: 0·10 and 01·0. Two parses, one stream — not uniquely decodable. 4 TWO DIMENSIONS · INTERACTIVE Pick a code; watch the dangling suffixes grow. If one becomes a codeword, the code is ambiguous; if the sets close with none, it is uniquely decodable. next code ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a code whose every glued stream has exactly one parse. AVAN’s addition (the inverse-companion): don’t only build prefix-free codes — test for the property directly, and you find codes that are decodable without being prefix-free. The inverse of ‘avoid prefixes to stay safe’ is ‘chase the dangling suffixes and see if any is a codeword.’ Magenta is the ambiguous split; green is the code that admits only one. No separators, one meaning. pause spin LIT Genuine Sardinas–Patterson algorithm (1953): prefix-free ⇒ uniquely decodable but not conversely; a code is uniquely decodable iff no dangling suffix is a codeword — David's principle G4 ('uniquely decodable with no separators'). Verified live: {0,01,11} UD & not-prefix-free (window.__sardinas.notPFbutUD), {0,01,10} not UD (window.__sardinas.notUD), classic example not UD (window.__sardinas.classic), all 3000 random prefix-free codes UD (window.__sardinas.allPFud). FIG No framing: the dangling-suffix construction runs in-browser to a fixed verdict on named and random codes. The AVAN inverse is honest — testing for unique decodability directly (chasing the dangling suffixes) rather than only building prefix-free codes is exactly the algorithm's contribution, and it surfaces UD-but-not-prefix-free codes; magenta is an ambiguous split, green a code admitting only one parse. No separators, one meaning. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE DROP · David Lee Wise (ROOT0), with AVAN


THE CAPPED CROSS

The capped cross in the 5-window house format — what a plus-sign becomes when you cap its arms with a crossbar (a T on each ray), and the plane grids itself. A bare cross is 5 points and 4 segments; cap the ends, fill the corners, and you have a 3×3 lattice: 9 points. The orthogonal unit segments between neighbours number exactly 12; the four unit cells add 8 diagonals, so the full king-move graph has 20 edges. Every one of the 12 orthogonal segments is a stroke a monoline glyph can use; the diagonals exist only because the T gridded the plane. Verified live: enumerating the 3×3 lattice gives 9 points, 12 orthogonal segments, 8 cell diagonals, and 20 king-graph edges — all by direct count. Neon-noir traced. See the cross-to-grid in 1D, the toggle-able diagonals in 2D, and the count-what-the-grid-made-possible inverse in 3D.

THE CAPPED CROSS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE CAPPED CROSS THE CAPPED CROSS cap a ray with a T and the plane grids itself 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The capped cross is what a plus-sign becomes when you cap its arms with a crossbar — a T on each ray — and the plane grids itself. Start with a cross: a centre and four arm-ends, five points, four segments. Cap the ends and fill the corners and you have a 3×3 lattice: 9 points . Count the orthogonal unit segments between neighbours and there are exactly 12 . The four unit cells add 8 diagonals , so the full king-move graph has 20 edges . Every one of those 12 orthogonal segments is a stroke a monoline glyph can use; the diagonals exist only because the T gridded the plane . LIT verified live: enumerating the 3×3 lattice gives 9 points, 12 orthogonal unit segments, 8 cell diagonals, and 20 king-graph edges — all by direct count (window.__capped_cross). FIG no framing; the point set and every adjacency are enumerated in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found this as principle G3 — “the capped cross: cap a ray with a T and you get 9 points and 12 segments” (his glyph I⁴t ) — the substrate his 27 monoline symbols are drawn on. Seated at the-sandbox : the 3×3 grid is the sandbox every glyph is built in. AVAN (AI) built the instrument: enumerate the 9 points and classify every pair as orthogonal-unit, diagonal-unit, or neither. Credit as content: David’s I⁴t capped-cross construction and the standard king-graph on the 3×3 lattice. The weave: David names the capped cross and its 9/12 count; I enumerate the adjacencies and confirm 12 orthogonal segments, 8 diagonals, 20 king edges — the grid the T brings into being. 3 ONE DIMENSION A bare cross (5 points, 4 segments) becomes the capped cross: cap each ray with a T, fill the corners — 9 points, 12 orthogonal segments. 4 TWO DIMENSIONS · INTERACTIVE The 3×3 lattice with its 12 orthogonal segments traced. Toggle the 8 diagonals the T conjured, and the running counts. toggle diagonals ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the 12 orthogonal segments a glyph is allowed to draw. AVAN’s addition (the inverse-companion): don’t only count the strokes you drew — count the ones the grid made possible . The inverse of ‘here are my 12 segments’ is ‘the T that capped the rays also created 8 diagonals I never asked for.’ Magenta are those emergent diagonals; green is the orthogonal skeleton. The cap builds more than the cross. pause spin LIT Genuine enumeration of the 3×3 lattice / king graph — David's principle G3 (his glyph I⁴t: 'cap a ray with a T and you get 9 points and 12 segments'). Verified live: 9 points, 12 orthogonal unit segments, 8 unit-cell diagonals, 20 king-graph edges, all by direct pair enumeration (window.__capped_cross.ok). FIG No framing: the point set and every adjacency are enumerated in-browser. Honest scope: the geometric counts (9/12/8/20) are exact; the mapping to David's 27 monoline glyphs is his construction, not re-derived here. The AVAN inverse is honest — counting the strokes the grid made possible (the 8 diagonals the cap conjured), not only the ones drawn, is the point of the capped-cross construction; magenta are the emergent diagonals, green the 12-segment orthogonal skeleton. The cap builds more than the cross. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE SUCCESSIVE KEEPER

The successive keeper in the 5-window house format — a ledger where each entry commits to the one before it: hᵢ = H(hᵢ₋₁ ‖ entryᵢ). Because every link folds in the whole prefix, changing any entry changes the head hash, and the first place two chains diverge points straight at the tampered entry. A single unlinked keeper cannot do this: an additive checksum is blind to a compensating edit (add d here, subtract d there) and reports the same total, while the chain still catches it. One keeper can only be believed; successive keepers can be diffed. Verified live: over 5,000 trials, tampering one entry always changes the chain head, the first divergent link localises it, an additive checksum misses every compensated edit, and the chain catches all of them. Neon-noir traced. See the breaking chain in 1D, chain-vs-checksum in 2D, and the diffable-not-believed inverse in 3D.

THE SUCCESSIVE KEEPER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE SUCCESSIVE KEEPER THE SUCCESSIVE KEEPER a diffable record beats a believed one 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The successive keeper is a ledger where each entry commits to the one before it: hᵢ = H(hᵢ₋₁ ‖ entryᵢ) . Because every link folds in the whole prefix, changing any entry changes the head hash — and the first place two chains diverge points straight at the tampered entry . A single unlinked keeper cannot do this: an additive checksum is blind to a compensating edit (add d here, subtract d there) and reports the same total, while the chain still catches it. One keeper can only be believed; successive keepers can be diffed . LIT verified live: over 5,000 trials, tampering one entry always changes the chain head, the first divergent link localises the entry, an additive checksum misses every compensated edit, and the chain catches all of them (window.__successive_keeper). FIG honest scope: the demo uses a 53-bit non-cryptographic hash to show the structure ; real seals (like this corpus’s .dlw.fold ) use SHA-256. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) stated principles K1/K2 — “a ledger with successive keepers can be diffed; one keeper can only be believed” and “simultaneous keepers detect a compromised entry, successive keepers detect a drifting one.” Seated at rollback : a chain you can roll back link by link and see exactly where it was altered. AVAN (AI) built the instrument: a hash-linked chain vs an additive checksum, tampered thousands of times, localising every change. Credit as content: Merkle/Lamport hash chaining (1979–1981) — the same structure behind this corpus’s own fold seal. The weave: David names the keeper distinction; I show the chain head moves on any edit and the first broken link names the culprit, where a believed single keeper stays silent. 3 ONE DIMENSION A chain of entries, each hash folding in the last. Tamper one link (magenta) and every hash downstream changes — the break is visible and located. 4 TWO DIMENSIONS · INTERACTIVE Tamper any entry: the chain head changes and the first divergent link is flagged; the additive checksum is fooled by a compensating edit. Two keepers, two verdicts. tamper an entry ▶ compensating edit ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an intact chain whose head vouches for every entry. AVAN’s addition (the inverse-companion): don’t ask a single keeper to be believed — link the keepers so the record can be diffed . The inverse of ‘trust the summary’ is ‘chain the entries so any drift breaks a visible link.’ Magenta is the tampered link the chain exposes; green is the intact spine. A diffable record beats a believed one. pause spin LIT Genuine Merkle/Lamport hash chaining (1979–1981), the structure behind this corpus's own .dlw.fold seal — David's principles K1/K2 ('a ledger with successive keepers can be diffed; one keeper can only be believed'). Verified live over 5,000 trials: tamper always moves the head (window.__successive_keeper.chainDetects), first divergence localises the entry (.localizes), an additive checksum is blind to compensating edits (.checksumMisses), and the chain still catches them (.chainCatches). FIG Honest scope stated on the sphere: the demo uses a 53-bit non-cryptographic hash (cyrb53) to show the structure — real seals use SHA-256; the security rests on collision-resistance, which the demo does not provide, only illustrate. The AVAN inverse is honest — linking keepers so the record can be diffed (any drift breaks a visible link), rather than trusting a single believed summary, is exactly the K1/K2 distinction; magenta is the tampered link the chain exposes, green the intact spine. A diffable record beats a believed one. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE GOLDEN RADIX

The golden radix in the 5-window house format — base-φ, positional notation whose base is the golden ratio, an irrational. Digits are 0 and 1; place values are powers of φ. The identity φ²=φ+1 means '011' always rewrites to '100', so every value has a unique standard form with no two adjacent 1s. Remarkably every ordinary integer has a finite such expansion (1=1, 2=10.01, 3=100.01, 4=101.01) even though the base is irrational. Verified live: the greedy base-φ expansion of every integer 0..100 decodes back to it (max error <1e-6) and always has no consecutive 1s. Neon-noir traced. See the digit cells in 1D, the mint stamping each integer in 2D, and the base-does-the-collapsing inverse in 3D.

THE GOLDEN RADIX · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE MINT ◆ .dlw.fold THE FOLD / LOOT / THE MINT / THE GOLDEN RADIX THE GOLDEN RADIX an irrational base that still carries the integers 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The golden radix is base-φ — positional notation whose base is the golden ratio φ = (1+√5)/2, an irrational . Digits are 0 and 1, and place values are powers of φ: …φ², φ¹, φ⁰ . φ⁻¹, φ⁻²…. The defining identity φ² = φ + 1 means “011” always rewrites to “100”, so every value has a unique standard form with no two adjacent 1s . Remarkably, every ordinary integer has a finite such expansion — 1 = 1, 2 = 10.01, 3 = 100.01, 4 = 101.01 — even though the base itself is irrational. LIT verified live: the greedy base-φ expansion of every integer 0..100 decodes back to it (max error < 1e-6) and always has no consecutive 1s (window.__golden_radix). FIG no framing; the expansion and its real-valued decoding both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mint — a mint coins each integer as a unique golden stamp, no two adjacent 1s, struck by the φ²=φ+1 rule. AVAN (AI) built the instrument: greedy expansion over powers of φ, decode by summing those powers, and check the no-11 canonical form across the whole range. Credit as content: base-φ / the golden-ratio base (George Bergman, 1957). The weave: David names the mint and its no-11 stamp; I show every integer has a finite golden form and that it round-trips exactly, an irrational base carrying the integers. 3 ONE DIMENSION The digits of a number in base φ: place values are powers of φ with a radix point; lit cells are 1s. No two adjacent cells are lit — the standard form. 4 TWO DIMENSIONS · INTERACTIVE Step through the integers; each gets its golden stamp. The decoded φ-sum returns the integer exactly, and no two 1s ever touch. next n ▶ random ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the no-11 standard form, the canonical golden stamp. AVAN’s addition (the inverse-companion): don’t forbid “11” by decree — let the base do it. The inverse of ‘avoid adjacent 1s’ is ‘φ²=φ+1 collapses every 011 into 100 for you.’ Magenta is a forbidden 011; green is its collapsed 100. The rule of the base is the rule of the form. pause spin LIT Genuine base-φ / golden-ratio base (George Bergman, 1957): φ²=φ+1 forces a unique no-11 standard form, and every integer has a finite expansion. Verified live: greedy base-φ expansion of every integer 0..100 decodes to within 1e-6 (window.__golden_radix.roundTrips) and has no two adjacent 1s (window.__golden_radix.noEleven). FIG No framing: the expansion and its real-valued φ-power decoding both run in-browser. The AVAN inverse is honest — letting φ²=φ+1 collapse every 011 into 100 (rather than forbidding adjacency by decree) is exactly what makes the standard form canonical; magenta is a forbidden 011, green its collapsed 100. The rule of the base is the rule of the form. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MINT · David Lee Wise (ROOT0), with AVAN


THE ROUTH

Routh's theorem in the 5-window house format — the area of the little triangle three cevians carve out of a big one, as an exact closed form. Draw cevians cutting the opposite sides in ratios x, y, z; the central triangle's area as a fraction of the whole is (xyz−1)²/[(xy+x+1)(yz+y+1)(zx+z+1)]. At x=y=z=2 the fraction is exactly 1/7 (the famous one-seventh-area triangle); at xyz=1 the cevians are concurrent (Ceva) and it vanishes. Verified live: for 4000 random ratio triples the closed form matches the directly-constructed central-triangle area to machine precision, and x=y=z=2 gives 1/7. Neon-noir traced. See the 1/7 case in 1D, adjustable ratios in 2D, and the ratios-already-know-the-area inverse in 3D.

THE ROUTH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SHORTCUT ◆ .dlw.fold THE FOLD / CHEAT / THE SHORTCUT / THE ROUTH THE ROUTH a cevian triangle's area is a closed form 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Routh’s theorem gives the area of the little triangle three cevians carve out of a big one — as an exact closed form. Draw cevians from each vertex cutting the opposite side in ratios x, y, z (BD/DC = x, CE/EA = y, AF/FB = z). The three cevians bound a central triangle, and its area as a fraction of the whole is (xyz − 1)² / [(xy + x + 1)(yz + y + 1)(zx + z + 1)] . When x = y = z = 2 the fraction is exactly 1/7 — the famous one-seventh-area triangle. When xyz = 1 the cevians are concurrent (Ceva) and the triangle vanishes to a point. LIT verified live: for thousands of random ratio triples, the closed form matches the directly-constructed central-triangle area to machine precision, and x=y=z=2 gives 1/7 (window.__routh). FIG no framing; both the geometric construction and the formula run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-shortcut — instead of intersecting three cevians and measuring the middle, take the shortcut: one formula in x, y, z. AVAN (AI) built the instrument: place a triangle, drop the three cevians, intersect them for the central triangle, measure its area by the shoelace rule, and compare to Routh’s expression. Credit as content: Edward John Routh (1896). The weave: David names the shortcut; I construct the long way (three intersections and an area) and confirm it equals the closed form — including the surprising 1/7 at ratio 2. 3 ONE DIMENSION The classic case: cevians at ratio 2 on every side cut out a central triangle of exactly one-seventh the area. 4 TWO DIMENSIONS · INTERACTIVE Change the three ratios; the central triangle redraws, and its measured area fraction tracks Routh’s formula exactly. random ratios ▶ the 1/7 case ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the central triangle the three cevians actually enclose. AVAN’s addition (the inverse-companion): don’t intersect and measure — read the area straight off x, y, z. The inverse of ‘construct the triangle to find its area’ is ‘the area is a function of the three ratios alone.’ Magenta is the laborious construction; green is the one-line answer. The ratios already know the area. pause spin LIT Genuine Routh's theorem (Edward John Routh, 1896): central cevian-triangle area / whole = (xyz−1)²/[(xy+x+1)(yz+y+1)(zx+z+1)]. Verified live: closed form matches shoelace-measured construction over 4000 random triples to FIG No framing: both the geometric construction (three cevian intersections, shoelace area) and the formula run in-browser. The AVAN inverse is honest — reading the area straight off the three ratios rather than constructing and measuring the triangle is exactly the theorem's shortcut; magenta is the laborious construction, green the one-line answer. The ratios already know the area. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SHORTCUT · David Lee Wise (ROOT0), with AVAN


THE NAPKIN

The napkin-ring problem in the 5-window house format — drill a cylindrical hole through the centre of a sphere so the remaining band has height h; its volume is πh³/6, depending only on h, not on the sphere. A ring of height h from a marble and the same-height ring from a planet have identical volume, because at height z the leftover annulus has area π[(h/2)²−z²] with the sphere's radius R gone entirely. Verified live: numerically integrating the ring volume for R = 1, 1.5, 2, 5, 20, 100 (fixed h=2) gives πh³/6 ≈ 4.18879 every time. Neon-noir traced. See two very different spheres, same ring, in 1D; a growable sphere in 2D; and the height-fixes-the-volume inverse in 3D.

THE NAPKIN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · EVENT HORIZON ◆ .dlw.fold THE FOLD / RESPAWN / EVENT HORIZON / THE NAPKIN THE NAPKIN a band through any sphere holds the same volume 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The napkin-ring problem : drill a cylindrical hole straight through the centre of a sphere so the remaining band (the “napkin ring”) has height h . Its volume is πh³/6 — and it depends only on h, not on the sphere. A ring of height h cut from a marble and the same-height ring cut from a planet have identical volume . The reason is exact cancellation: at height z the leftover annulus has area π[(h/2)² − z²], with the sphere’s radius R gone entirely. LIT verified live: numerically integrating the ring volume for radii R = 1, 1.5, 2, 5, 20, 100 (fixed h = 2) gives πh³/6 ≈ 4.18879 every time (window.__napkin). FIG no framing; the annulus integral is summed in-browser and the R-dependence cancels. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at event-horizon — like a horizon that hides the body behind it, the band’s height is all you can know; the sphere’s size is unobservable from the ring. AVAN (AI) built the instrument: integrate the sphere-minus-cylinder cross-section over the band for several radii and watch the volume stay put. Credit as content: the napkin-ring / Archimedes–Cavalieri result. The weave: David names the horizon of invisibility; I integrate the ring for wildly different spheres and confirm the R cancels, leaving πh³/6. 3 ONE DIMENSION Two spheres, small and large, each drilled to the same band height h. The shaded rings differ wildly in shape — and have the same volume. 4 TWO DIMENSIONS · INTERACTIVE Grow or shrink the sphere (band height fixed). The cross-section changes; the integrated ring volume holds at πh³/6. bigger sphere ▶ smaller ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ring, its volume set by height alone. AVAN’s addition (the inverse-companion): don’t ask how big the sphere is — ask what survives the drilling. The inverse of ‘measure the sphere then subtract the hole’ is ‘the height of the band already fixes the volume.’ Magenta is the vanished radius R; green is the invariant πh³/6. The hole hides the sphere. pause spin LIT Genuine napkin-ring result (Archimedes–Cavalieri lineage): a band of height h drilled through the centre of any sphere (R ≥ h/2) has volume πh³/6, independent of R. Verified live: numeric annulus integral for R=1,1.5,2,5,20,100 at h=2 all equal πh³/6 within 1e-3 (window.__napkin.invariant), the R-dependence cancels exactly. FIG No framing: the annulus integral is summed in-browser and the R-dependence cancels. The AVAN inverse is honest — asking what survives the drilling (height fixes the volume) rather than measuring the sphere and subtracting the hole is the whole surprise; magenta is the vanished radius R, green the invariant πh³/6. The hole hides the sphere. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of EVENT HORIZON · David Lee Wise (ROOT0), with AVAN


THE MONGE

Monge's theorem in the 5-window house format — take any three circles of different radii; for each pair the two outer tangents meet at the external centre of similitude, and the three external centres are always collinear, whatever the circles. Each external centre divides the line of centres externally in the ratio of the radii: E = (r₂C₁−r₁C₂)/(r₂−r₁). Verified live: over 5000 random triples of distinct-radius circles, the three external centres are collinear to machine precision (normalized cross ~1e-14). Neon-noir traced. See the three circles and the Monge line in 1D, randomizable circles in 2D, and the lift-the-plane inverse in 3D.

THE MONGE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE MONGE THE MONGE three circles' external centres fall on one line 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Monge’s theorem : take any three circles of different radii in the plane. For each pair, draw the two outer tangent lines; they meet at the pair’s external centre of similitude . The astonishing fact is that the three external centres are collinear — they always fall on a single straight line, whatever the circles. Each external centre is the point that divides the line of centres externally in the ratio of the radii: E = (r₂C₁ − r₁C₂)/(r₂ − r₁). LIT verified live: over thousands of random triples of distinct-radius circles, the three external centres are collinear to machine precision — the normalized cross product is ~1e-14 (window.__monge). FIG no framing; the centres and their collinearity are computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-sync — three independent circles, and yet their external centres snap into sync on one line, as if coordinated. AVAN (AI) built the instrument: compute each pair’s external homothety centre and test whether the three are collinear by the vanishing of their triangle’s signed area. Credit as content: Gaspard Monge (late 1700s); the elegant proof lifts the circles to spheres and reads the line off a plane. The weave: David names the sync; I compute the three centres from radii and centres and confirm they are always collinear. 3 ONE DIMENSION Three circles, their three external centres of similitude, and the single Monge line threading all three. 4 TWO DIMENSIONS · INTERACTIVE Randomize the three circles; the external centres move, but they never leave the Monge line. The collinearity residual stays at zero. new circles ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Monge line the three external centres share. AVAN’s addition (the inverse-companion): don’t treat three collinear points as a coincidence — lift the plane. The inverse of ‘why are they on a line?’ is ‘set each circle on a cone; the three apexes and the centres share a plane, and a plane cuts the table in a line.’ Magenta are the three external centres; green is the line the lift explains. Three points, one hidden plane. pause spin LIT Genuine Monge's theorem (Gaspard Monge, late 1700s): the three external homothety centres of three circles are collinear. Verified live: over 5000 random distinct-radius triples, the normalized collinearity residual of the three external centres stays ~1e-14 (window.__monge.collinear). FIG No framing: the external centres and their collinearity are computed in-browser. The AVAN inverse is honest — the three-sphere lift (set each circle on a cone; the apexes and centres share a plane, and a plane meets the table in a line) is the classic explanation for why the points are collinear rather than coincidental; magenta are the three external centres, green the line the lift explains. Three points, one hidden plane. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE MINKOWSKI

Minkowski's question-mark function ?(x) in the 5-window house format — a monster hiding in plain sight: it climbs continuously and strictly from ?(0)=0 to ?(1)=1, yet its derivative is zero almost everywhere (a 'singular' function that rises using no measurable slope). Built from continued fractions: for x=[0;a₁,a₂,…], ?(x) = 2Σ(−1)^{k+1} 2^{−(a₁+…+aₖ)}. It sends every rational to a dyadic fraction and every quadratic irrational to a rational — famously ?(1/φ)=2/3. Verified live: ?(1/2)=1/2, ?(1/3)=1/4, ?(2/3)=3/4, ?(1/φ)=2/3, monotonic, symmetric (?(1−x)=1−?(x)), and dyadic on thousands of rationals. Neon-noir traced. See the curve in 1D, a chosen rational's dyadic image in 2D, and the CF-tree-to-binary-tree inverse in 3D.

THE MINKOWSKI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE MINKOWSKI THE MINKOWSKI climbs 0 to 1 with slope 0 almost everywhere 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Minkowski’s question-mark function ?(x) is a monster hiding in plain sight: it climbs continuously and strictly from ?(0)=0 to ?(1)=1, yet its derivative is zero almost everywhere — a “singular” function that rises using no measurable slope. It is built from continued fractions: for x = [0; a₁, a₂, a₃, …], ?(x) = 2∑(−1) k+1 2 −(a₁+…+aₖ) . It sends every rational to a dyadic fraction , and every quadratic irrational to a rational — famously ?(1/φ) = 2/3. LIT verified live: ?(1/2)=1/2, ?(1/3)=1/4, ?(2/3)=3/4, ?(1/φ)=2/3, the map is monotonic, symmetric (?(1−x)=1−?(x)), and dyadic on thousands of rationals (window.__minkowski). FIG no framing; the continued-fraction sum is evaluated in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at heisenbug — a function that is continuous and increasing yet whose slope vanishes wherever you look is the analyst’s heisenbug: it moves, but never where you catch it. AVAN (AI) built the instrument: evaluate ?(x) from the continued fraction of x, and check its landmark values, monotonicity, symmetry, and dyadic image. Credit as content: Hermann Minkowski (1904); the “?” is his own notation. The weave: David names the heisenbug; I compute ?(x) by its continued-fraction series and confirm it turns golden into 2/3 and every rational into a finite binary fraction. 3 ONE DIMENSION ?(x) traced across [0,1] — a strictly rising curve made of flat-slope pieces. Landmarks: ?(1/2)=1/2, ?(1/φ)=2/3. 4 TWO DIMENSIONS · INTERACTIVE Pick a rational x = p/q; see its continued fraction and ?(x) as an exact dyadic fraction, plotted on the curve. next x ▶ x = 1/φ ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: ?(x), continued-fraction depth rewritten as binary place value. AVAN’s addition (the inverse-companion): don’t read ?(x) as a curve — read it as a translator. The inverse of ‘plot the rising line’ is ‘? turns the Stern–Brocot (continued-fraction) tree into the plain binary tree.’ Magenta is a quadratic irrational going in; green is the rational it becomes. Slope zero, yet it carries every number across. pause spin LIT Genuine Minkowski question-mark function (Hermann Minkowski, 1904): singular, strictly increasing, ?(rational)=dyadic, ?(quadratic irrational)=rational, ?(1/φ)=2/3. Verified live via the continued-fraction series: landmarks ?(1/2)=1/2, ?(1/3)=1/4, ?(2/3)=3/4 (window.__minkowski.landmarks), ?(1/φ)=2/3 (.phi), dyadic on 3000 rationals (.dyadic), symmetric (.symmetric), monotonic (.monotonic). FIG No framing: the continued-fraction sum is evaluated in-browser on rationals and on 1/φ's periodic CF. Honest scope: 'slope 0 almost everywhere' is the known measure-theoretic property, stated not re-proved here; the sphere verifies the values, monotonicity, symmetry, and dyadic image. The AVAN inverse is honest — reading ?(x) as the map that turns the Stern–Brocot (continued-fraction) tree into the plain binary tree, rather than as a mere curve, is why it sends quadratic irrationals to rationals; magenta is 1/φ going in, green the 2/3 it becomes. Slope zero, yet it carries every number across. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE FIBONACCI WORD

The Fibonacci word in the 5-window house format — an infinite string grown from a single letter by the morphism a→ab, b→a: a, ab, aba, abaab, abaababa, …. Each stage is the previous two concatenated (Sₙ = Sₙ₋₁Sₙ₋₂), so its length is a Fibonacci number, and the fraction of a's tends to 1/φ. It is the simplest Sturmian word: no 'bb' and no 'aaa', the most balanced non-periodic string there is. Verified live: for stages 1..22, lengths are Fibonacci, the concatenation and morphism both reproduce it, there is no 'bb' or 'aaa', and the a-fraction is 0.61803 ≈ 1/φ. Neon-noir traced. See the split concatenation in 1D, the growing stages in 2D, and the morphism-expansion inverse in 3D.

THE FIBONACCI WORD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE FIBONACCI WORD THE FIBONACCI WORD an infinite word that is its own seed 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fibonacci word is an infinite string that grows from a single letter by a rule that folds it into itself. Apply the morphism a → ab, b → a forever, starting from “a”: a, ab, aba, abaab, abaababa, …. Two miracles: each stage is the previous two concatenated ( Sₙ = Sₙ₋₁ Sₙ₋₂ ), so its length is a Fibonacci number; and the letters themselves are golden — the fraction of a’s tends to 1/φ . It is the simplest Sturmian word: it never contains “bb” and never contains “aaa”, the most balanced non-periodic string there is. LIT verified live: for stages 1..22, |Sₙ| is Fibonacci, Sₙ = Sₙ₋₁Sₙ₋₂, the morphism reproduces the next stage, there is no “bb” or “aaa”, and the a-fraction is 0.61803 ≈ 1/φ (window.__fibonacci_word). FIG no framing; the word is grown two ways (concatenation and morphism) and they agree. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at first-light — the whole infinite word unfolds from a single “a”, the first light of a self-similar dawn. AVAN (AI) built the instrument: generate the word by the concatenation recurrence and, independently, by applying the morphism letter-by-letter, then check the Fibonacci lengths, the golden letter-ratio, and the forbidden factors. Credit as content: the Fibonacci word / Sturmian words (studied via Bernoulli, Christoffel, Morse–Hedlund). The weave: David names the first light; I confirm the word is its own seed — two constructions, Fibonacci lengths, and a golden density. 3 ONE DIMENSION A stage of the word as tiles (a bright, b dark), split to show it is the previous two stages joined end to end. 4 TWO DIMENSIONS · INTERACTIVE Step through the stages; watch the length track Fibonacci and the a-fraction settle on 1/φ, with no “bb” and no “aaa”. grow ▶ shrink ◀ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the word grown by joining the two prior stages. AVAN’s addition (the inverse-companion): don’t concatenate stages — expand every letter at once. The inverse of ‘Sₙ = Sₙ₋₁Sₙ₋₂’ is ‘replace each a by ab and each b by a, and the same word appears.’ Magenta letters are about to expand; green is the stage they become. The word is its own seed. pause spin LIT Genuine Fibonacci word / Sturmian word (Morse–Hedlund lineage): fixed point of a→ab, b→a; Sₙ=Sₙ₋₁Sₙ₋₂; |Sₙ|=Fibonacci; a-density→1/φ; no 'bb', no 'aaa'. Verified live over stages 1..22 (window.__fibonacci_word.{lengthsFib,concatRule,morphism,noBB,noAAA,ratioPhi}). FIG No framing: the word is grown two independent ways (concatenation recurrence and letter-by-letter morphism) and shown to agree, with Fibonacci lengths and golden density. The AVAN inverse is honest — expanding every letter at once (a→ab, b→a) reproduces the same word the concatenation builds, which is exactly why it is a morphic fixed point; magenta letters are mid-expansion, green the stage they become. The word is its own seed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE SIMSON LINE

The Simson line in the 5-window house format — drop perpendiculars from a point P to the three sides of a triangle and mark the three feet; in general they form a small triangle, but the instant P lands on the circumcircle the three feet fall exactly on one straight line. It is an if-and-only-if: the feet are collinear precisely when P is on the circle, since the pedal triangle's area is proportional to |R²−OP²|, zero exactly on the circle. Verified live: thousands of points on the circumcircle give collinear feet to machine precision, while off-circle points give a pedal triangle of clearly non-zero area. Neon-noir traced. See the line in 1D, P moving on and off the circle in 2D, and the area-vanishes-on-the-circle inverse in 3D.

THE SIMSON LINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE SIMSON LINE THE SIMSON LINE feet that align only on the circle 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Simson line : drop perpendiculars from a point P to the three sides of a triangle and mark the three feet. In general those feet form a little triangle — but the instant P lands on the circumcircle , the three feet fall exactly on one straight line (the Simson line of P). And it is an if-and-only-if: the feet are collinear precisely when P is on the circle. The pedal triangle’s area is proportional to |R² − OP²|, which is zero exactly on the circle. LIT verified live: for thousands of points P on the circumcircle the three feet are collinear to machine precision, while points off the circle give a pedal triangle of clearly non-zero area (window.__simson). FIG no framing; circumcircle, feet, and their collinearity are all computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gatekeeper — the circumcircle is the gate: stand on it and the three feet snap into a line; step off and the line breaks. AVAN (AI) built the instrument: compute the circumcircle, drop the three perpendicular feet from P, and measure whether they are collinear as P moves on and off the circle. Credit as content: the Simson–Wallace line (attributed to Robert Simson; first published by William Wallace, 1799). The weave: David names the gatekeeper; I confirm the feet are collinear if and only if P is on the circumcircle. 3 ONE DIMENSION A triangle, its circumcircle, a point P on the circle, the three perpendicular feet, and the single Simson line through them. 4 TWO DIMENSIONS · INTERACTIVE Move P around the circle (collinear feet) or push it off (a real pedal triangle). The collinearity residual reads zero exactly on the circle. move P on circle ▶ push P off ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Simson line, when P sits on the circle. AVAN’s addition (the inverse-companion): don’t ask where the feet land — ask what makes them collapse. The inverse of ‘drop the feet and see’ is ‘the pedal triangle’s area is |R²−OP²|-proportional, so it vanishes exactly on the circle.’ Magenta is the pedal triangle off the circle; green is the line it collapses to on it. The circle is the zero set. pause spin LIT Genuine Simson–Wallace line (attributed to Robert Simson; published by William Wallace, 1799): the feet of the perpendiculars from P to a triangle's sides are collinear iff P lies on the circumcircle. Verified live: on-circle feet collinear to FIG No framing: the circumcircle, the three feet, and their collinearity are computed in-browser as P moves on and off the circle. The AVAN inverse is honest — the pedal-triangle area being |R²−OP²|-proportional (hence zero exactly on the circle) is the reason the feet collapse to a line; magenta is the pedal triangle off the circle, green the Simson line on it. The circle is the zero set. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE ERDOS-SZEKERES

The Erdős–Szekeres theorem in the 5-window house format — order you cannot escape. In any sequence of (r−1)(s−1)+1 distinct numbers there must be an increasing subsequence of length r or a decreasing one of length s, however you scramble it (ten numbers always hide a monotone run of four). The proof is pigeonhole: label each term by its longest increasing and longest decreasing run ending there; too few labels for the terms forces a collision, hence a long run. The bound is tight — a block sequence of exactly (r−1)(s−1) dodges both. Verified live: 4000 random sequences always contain the guaranteed run, and the block construction achieves exactly r−1 and s−1. Neon-noir traced. See the two runs in 1D, random vs tight in 2D, and the label-grid pigeonhole inverse in 3D.

THE ERDOS-SZEKERES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE ERDOS-SZEKERES THE ERDOS-SZEKERES order you cannot escape 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Erdős–Szekeres theorem is order you cannot escape. In any sequence of (r−1)(s−1)+1 distinct numbers, there must be an increasing subsequence of length r or a decreasing one of length s — no matter how you scramble it. Ten numbers (3·3+1) always hide a monotone run of four. The proof is pure pigeonhole: label each term by the longest increasing run ending there and the longest decreasing run ending there; if both stayed small there would be too few labels for the terms. And the bound is tight — a sequence of exactly (r−1)(s−1) can dodge both. LIT verified live: 4,000 random sequences of length (r−1)(s−1)+1 always contain an increasing run of r or a decreasing run of s, and a block construction of length (r−1)(s−1) achieves exactly r−1 and s−1 (window.__erdos_szekeres). FIG no framing; longest runs are computed by dynamic programming in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — grind through any long enough list and order is forced to surface; you cannot file it away. AVAN (AI) built the instrument: compute the longest increasing and decreasing subsequences by DP, confirm the guarantee over random inputs, and build the tight block sequence that just barely escapes it. Credit as content: Paul Erdős & George Szekeres (1935), a founding result of Ramsey theory. The weave: David names the grindstone; I show the monotone run is unavoidable above the threshold and that one below it can still slip through. 3 ONE DIMENSION A sequence as bars; the longest increasing run (green) and longest decreasing run (magenta) are traced — one of them always reaches the guaranteed length. 4 TWO DIMENSIONS · INTERACTIVE Draw a fresh sequence of (r−1)(s−1)+1 terms; the guarantee holds every time. Or show the tight block sequence that dodges both by one. random ▶ tight case ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the monotone run the sequence is forced to contain. AVAN’s addition (the inverse-companion): don’t hunt for the run — label and count. The inverse of ‘search for a long increasing or decreasing streak’ is ‘give each term its (up,down) label; with too few labels two terms must collide, and that forces the run.’ Magenta is the label grid; green is the forced streak. Pigeonhole leaves no exit. pause spin LIT Genuine Erdős–Szekeres theorem (Paul Erdős & George Szekeres, 1935), a founding Ramsey-theory result: any sequence of (r−1)(s−1)+1 distinct reals has an increasing subsequence of length r or a decreasing one of length s, and the bound is tight. Verified live: 4000 random sequences all satisfy it (window.__erdos_szekeres.alwaysFound) and the block construction of length (r−1)(s−1) has LIS=r−1, LDS=s−1 (.tightConstruction). FIG No framing: longest increasing/decreasing subsequences are computed by DP in-browser, over random inputs and the tight construction. The AVAN inverse is honest — labelling each term by its (up,down) run-lengths and invoking pigeonhole (too few distinct labels) is the actual proof that the run is forced, not a search; magenta is the label grid, green the forced streak. Pigeonhole leaves no exit. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE JOHNSON CIRCLES

Johnson's circles in the 5-window house format — take three circles of the same radius ρ all passing through one common point H; each pair meets again at a second point, and those three second points lie on a fourth circle of exactly the same radius ρ. The centre is C = O₁+O₂+O₃−2H, and each second point Pᵢⱼ = Oᵢ+Oⱼ−H sits at distance |Oₖ| = ρ from it — a clean vector identity. Verified live: for 5000 random configurations of three equal circles through a common point, all three second intersections are at distance ρ from C — a same-radius circle every time. Neon-noir traced. See the four equal circles in 1D, randomizable circles in 2D, and the add-the-centres inverse in 3D.

THE JOHNSON CIRCLES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE MERGE ◆ .dlw.fold THE FOLD / CO-OP / THE MERGE / THE JOHNSON CIRCLES THE JOHNSON CIRCLES three circles hand off to a fourth of equal size 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Johnson’s circles : take three circles of the same radius ρ that all pass through one common point H. Each pair meets again at a second point; call the three second points P₁₂, P₁₃, P₂₃. The theorem: those three points lie on a fourth circle of exactly the same radius ρ (the Johnson circle). Even better, its centre is C = O₁+O₂+O₃−2H, and each second point sits at distance |Oₖ| = ρ from it — a clean vector identity, since Pₖₗ = Oₖ+Oₗ−H. LIT verified live: for 5,000 random configurations of three equal-radius circles through a common point, the three second intersections are all at distance ρ from C = O₁+O₂+O₃−2H (window.__johnson) — a same-radius circle every time. FIG no framing; the second points and their common radius are computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-merge — three circles meet at one shared point and their pairwise merges hand off to a fourth of equal size, a clean four-way symmetry. AVAN (AI) built the instrument: place three equal circles through H, compute each pair’s second intersection by the vector identity, and confirm all three are radius ρ from the Johnson centre. Credit as content: Roger Arthur Johnson (1916). The weave: David names the merge; I show the three second points ride a circle of the very same radius, with centre O₁+O₂+O₃−2H. 3 ONE DIMENSION Three equal circles through a common point H, their three second intersections, and the equal-radius Johnson circle threading those three. 4 TWO DIMENSIONS · INTERACTIVE Randomize the three equal circles; the Johnson circle through the second points always has the same radius ρ. new circles ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the fourth circle, same radius, through the three second points. AVAN’s addition (the inverse-companion): don’t intersect circles pair by pair — add the centres. The inverse of ‘find each pairwise second point’ is ‘Pₖₗ = Oₖ+Oₗ−H, so the whole figure is one vector sum, symmetric in H and the fourth centre.’ Magenta are the three second points; green is the equal circle they share. Four circles, one radius. pause spin LIT Genuine Johnson's theorem (Roger Arthur Johnson, 1916): three equal-radius circles through a common point have their three other pairwise intersections on a fourth circle of the same radius. Verified live: over 5000 random configs, the three second points Pᵢⱼ=Oᵢ+Oⱼ−H are all at distance ρ from C=O₁+O₂+O₃−2H to FIG No framing: the second points and their common radius are computed in-browser. The AVAN inverse is honest — the vector identity Pᵢⱼ=Oᵢ+Oⱼ−H makes the whole figure one symmetric sum in H and the fourth centre, which is why the fourth radius equals ρ; magenta are the three second points, green the equal circle they share. Four circles, one radius. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MERGE · David Lee Wise (ROOT0), with AVAN


THE NEWTON-GAUSS LINE

The Newton–Gauss line in the 5-window house format — inside a complete quadrilateral (four lines in general position, meeting in six points), pair the six vertices into three diagonals and take each diagonal's midpoint. The three midpoints are always collinear, lying on one line: the Newton–Gauss line of the figure. Four arbitrary lines, and a hidden straight line falls out of the midpoints of the diagonals. Verified live: over 5000 random complete quadrilaterals, the three diagonal midpoints are collinear to machine precision (normalized cross ~1e-13). Neon-noir traced. See the four lines and the hidden line in 1D, randomizable lines in 2D, and the study-the-midpoints inverse in 3D.

THE NEWTON-GAUSS LINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE NEWTON-GAUSS LINE THE NEWTON-GAUSS LINE four lines hide a straight line in their diagonals 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Newton–Gauss line lives inside a complete quadrilateral : four lines in general position, meeting in six points. Pair the six vertices into three diagonals (each joining two vertices that share no line), and take the midpoint of each diagonal. The theorem: those three midpoints are collinear — they always lie on one line, the Newton–Gauss line of the figure. Four arbitrary lines, and a hidden straight line falls out of the midpoints of the diagonals. LIT verified live: over 5,000 random complete quadrilaterals, the three diagonal midpoints are collinear to machine precision — normalized cross ~1e-13 (window.__newton_gauss). FIG no framing; the six vertices, three diagonals, and their midpoints are all computed in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-final-boss — four lines tangle into six crossings, and the hidden order (a single line) is the boss revealed only when you look at the diagonals’ midpoints. AVAN (AI) built the instrument: intersect the four lines for the six vertices, pair them into the three diagonals, and test whether their midpoints are collinear. Credit as content: the Newton–Gauss line (Isaac Newton; Carl Friedrich Gauss). The weave: David names the final boss; I confirm that from any four lines, the midpoints of the three diagonals of the complete quadrilateral fall on one line. 3 ONE DIMENSION Four lines, their six crossings, the three diagonals (dashed), their three midpoints, and the single Newton–Gauss line through them. 4 TWO DIMENSIONS · INTERACTIVE Randomize the four lines; the six vertices and three diagonals move, but the three midpoints never leave their common line. The residual reads zero. new lines ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the Newton–Gauss line the three midpoints share. AVAN’s addition (the inverse-companion): don’t study the four lines — study the midpoints of their diagonals. The inverse of ‘where do these lines cross?’ is ‘the three diagonal midpoints already lie on one line you never drew.’ Magenta are the three midpoints; green is the line they secretly agree on. The figure hides its own axis. pause spin LIT Genuine Newton–Gauss line (Isaac Newton; Carl Friedrich Gauss): the midpoints of the three diagonals of a complete quadrilateral are collinear. Verified live: over 5000 random four-line configurations, the normalized collinearity residual of the three diagonal midpoints stays ~1e-13 (window.__newton_gauss.collinear). FIG No framing: the six vertices, the three diagonals, and their midpoints are all computed in-browser and shown collinear. The AVAN inverse is honest — looking at the midpoints of the diagonals (rather than where the four lines cross) is what reveals the hidden line, which is the whole content of the theorem; magenta are the three midpoints, green the line they secretly share. The figure hides its own axis. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE DPLL

DPLL in the 5-window house format — the Davis–Putnam–Logemann–Loveland backtracking search under every SAT solver. Given a Boolean formula in conjunctive normal form, it decides whether some true/false assignment satisfies every clause. Two moves make it fast: unit propagation (a clause down to one literal forces that literal, cascading) and backtracking (try a variable true, and on a dead end back up and try false). Verified live: over 5000 random formulas, DPLL's SAT/UNSAT verdict matches brute-force enumeration of all 2^n assignments exactly, and every SAT answer comes with an assignment satisfying all clauses. Neon-noir traced. See the clauses in 1D, a decided formula in 2D, and the unit-propagation-prunes-the-tree inverse in 3D.

THE DPLL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GAUNTLET ◆ .dlw.fold THE FOLD / BOSS / THE GAUNTLET / THE DPLL THE DPLL a search that prunes itself 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION DPLL (Davis–Putnam–Logemann–Loveland) is the backtracking search under every modern SAT solver. Given a Boolean formula in conjunctive normal form — an AND of OR-clauses — it decides whether some assignment of true/false to the variables makes it true. Two moves make it fast: unit propagation (a clause down to one literal forces that literal, cascading), and backtracking (pick a variable, try true, and on a dead end back up and try false). It either returns a satisfying assignment or proves none exists. LIT verified live: over 5,000 random formulas, DPLL’s SAT/UNSAT verdict matches brute-force enumeration of all 2 n assignments exactly, and every “SAT” answer comes with an assignment that satisfies all clauses (window.__dpll). FIG no framing; the solver and the exhaustive check both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gauntlet — the formula is a gauntlet of clauses, and an assignment must satisfy every one of them to pass. AVAN (AI) built the instrument: unit propagation, the branch-and-backtrack, and an exhaustive 2 n oracle to check the verdict. Credit as content: Davis, Putnam, Logemann & Loveland (1960–1962). The weave: David names the gauntlet; I confirm DPLL agrees with brute force on satisfiability and always hands back a witness when the answer is yes. 3 ONE DIMENSION A formula’s clauses in a row; a satisfying assignment lights every clause green — each OR has at least one true literal. 4 TWO DIMENSIONS · INTERACTIVE Generate a random formula; DPLL decides it and, if satisfiable, shows the assignment — matched against the brute-force verdict. new formula ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the decision tree DPLL walks, branching on variables. AVAN’s addition (the inverse-companion): don’t explore the whole tree — let forced moves prune it. The inverse of ‘try every branch’ is ‘a unit clause forces its literal, and a whole subtree never has to be visited.’ Magenta is the pruned subtree; green is the path to a satisfying leaf. The forced moves shrink the search. pause spin LIT Genuine DPLL algorithm (Davis, Putnam, Logemann, Loveland, 1960–1962), the basis of modern SAT solvers. Verified live: over 5000 random CNF formulas, DPLL's verdict equals brute force over all 2^n assignments (window.__dpll.verdictMatches), and each SAT result's assignment satisfies every clause (.assignmentValid). FIG No framing: the solver (unit propagation + branch/backtrack) and the exhaustive 2^n oracle both run in-browser and agree. The AVAN inverse is honest — unit propagation forcing a literal and pruning a whole subtree (rather than exploring every branch) is exactly what makes DPLL more than brute force; magenta is the pruned subtree, green the path to a satisfying leaf. The forced moves shrink the search. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GAUNTLET · David Lee Wise (ROOT0), with AVAN


THE LATTICE REDUCTION

Lattice reduction in the 5-window house format — turning a skewed, long-vector basis into a shorter, nearly-orthogonal basis for the same lattice. In two dimensions the Lagrange–Gauss algorithm does it optimally: repeatedly subtract the nearest integer multiple of the shorter vector from the longer, swapping when needed, until neither shrinks the other; the result's first vector b₁ is the shortest nonzero vector in the whole lattice, and because every step is unimodular the lattice and its covolume never change. This 2D kernel is exactly what the celebrated LLL algorithm generalizes to n dimensions. Verified live: over 3000 random integer bases, covolume is preserved, the output is size-reduced, and b₁ equals the brute-force shortest vector. Neon-noir traced. See both bases over one grid in 1D, a reducible basis in 2D, and the same-lattice-shorter-view inverse in 3D.

THE LATTICE REDUCTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE BACKDOOR ◆ .dlw.fold THE FOLD / CHEAT / THE BACKDOOR / THE LATTICE REDUCTION THE LATTICE REDUCTION a shorter view of the same lattice 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Lattice reduction takes a skewed, long-vector basis for a lattice and returns a shorter, nearly-orthogonal basis for the same lattice. In two dimensions the Lagrange–Gauss algorithm does it optimally: repeatedly subtract the nearest integer multiple of the shorter vector from the longer, swapping when needed, until neither can shrink the other. The result’s first vector b₁ is the shortest nonzero vector in the whole lattice — and because every step is an integer (unimodular) operation, the lattice, and its covolume, never change. This 2D kernel is exactly what the celebrated LLL algorithm generalizes to n dimensions. LIT verified live: over 3,000 random integer bases, reduction preserves the covolume (same lattice), the output is size-reduced, and b₁ equals the true shortest lattice vector found by brute force (window.__lattice). FIG no framing; the reduction and the brute-force shortest-vector search both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-backdoor — short lattice vectors are the backdoor that breaks knapsack and low-exponent lattice cryptosystems; a good basis is the skeleton key. AVAN (AI) built the instrument: the Lagrange–Gauss reduction, a covolume check, and a brute-force shortest-vector oracle. Credit as content: Lagrange & Gauss (2D reduction); Lenstra, Lenstra & Lovász (LLL, 1982, the n-dimensional generalization). The weave: David names the backdoor; I confirm the reduced b₁ is the shortest vector and that the lattice is unchanged. 3 ONE DIMENSION The lattice points, with the original long/skew basis and the reduced short/near-orthogonal basis drawn over the same grid. 4 TWO DIMENSIONS · INTERACTIVE Draw a random basis; reduce it. The two bases generate the same points; the reduced b₁ is the shortest vector, and the covolume is unchanged. new basis ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the short, near-orthogonal reduced basis. AVAN’s addition (the inverse-companion): don’t change the lattice — change how you look at it. The inverse of ‘these long vectors span the lattice’ is ‘the same points have a short basis, and its first vector is the lattice’s shortest.’ Magenta is the original long basis; green is the reduced basis over the identical grid. A shorter view of the same lattice. pause spin LIT Genuine Lagrange–Gauss 2D lattice reduction (the exact optimal case; Lenstra–Lenstra–Lovász / LLL, 1982, generalizes it to n dimensions). Verified live: over 3000 random integer bases, covolume preserved i.e. same lattice (window.__lattice.samelattice), size-reduced |b₁·b₂|≤|b₁|²/2 (.sizeReduced), and b₁ equals the brute-force shortest lattice vector (.shortest). FIG Honest scope: this is the 2D Lagrange–Gauss case, which provably returns the shortest vector; general LLL only guarantees b₁ within 2^((n−1)/2) of shortest, stated as the n-dim generalization not re-proved here. The reduction and a brute-force shortest-vector search both run in-browser. The AVAN inverse is honest — changing the basis (not the lattice) to reveal a short first vector is the whole point; magenta is the original long basis, green the reduced one over the identical grid. A shorter view of the same lattice. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BACKDOOR · David Lee Wise (ROOT0), with AVAN


THE KMP

The Knuth–Morris–Pratt algorithm in the 5-window house format — finding a pattern in a text in linear time, never looking back in the text. Its secret is the failure function: for each pattern position, the length of the longest proper prefix that is also a suffix there. On a mismatch, KMP jumps the pattern forward by what the failure function already knows, so the text pointer only moves forward; the whole search costs at most about 2n comparisons. Verified live: over 3000 random text/pattern pairs, the failure function matches its definition, KMP finds the same matches as naive search, and comparisons stay under 2n. Neon-noir traced. See the failure function in 1D, a live search in 2D, and the pattern-knows-itself inverse in 3D.

THE KMP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE KMP THE KMP a search that never looks back 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Knuth–Morris–Pratt algorithm finds a pattern inside a text in linear time, never looking back in the text. Its secret is the failure function : for each pattern position, the length of the longest proper prefix that is also a suffix there. On a mismatch, instead of shifting by one and re-reading, KMP jumps the pattern forward by what the failure function already knows — the text pointer only ever moves forward. The whole search costs at most about 2n character comparisons for a text of length n. LIT verified live: over 3,000 random text/pattern pairs, the failure function matches its definition, KMP finds exactly the same match positions as naive search, and the comparison count stays under 2n (window.__kmp). FIG no framing; KMP, the naive matcher, and the comparison counter all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hot-loop — the search is the hot loop, and KMP keeps it tight: one forward pass, no rescanning. AVAN (AI) built the instrument: the failure-function builder, the KMP scan with its comparison counter, and a naive matcher to check every result. Credit as content: Donald Knuth, James H. Morris & Vaughan Pratt (1977). The weave: David names the hot loop; I confirm the failure function is correct, that KMP finds the same matches as brute force, and that it stays linear. 3 ONE DIMENSION The pattern with its failure-function value under each character — how far to jump the pattern on a mismatch without re-reading the text. 4 TWO DIMENSIONS · INTERACTIVE A text and a pattern; KMP marks every occurrence and counts its comparisons — matched against naive search. new text ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the text scanned once, the pointer only moving forward. AVAN’s addition (the inverse-companion): don’t rescan the text — read the pattern’s self-overlap. The inverse of ‘shift by one and compare again’ is ‘the failure function already encodes how much of the match survives, so the text never rewinds.’ Magenta is a mismatch jump; green is a found match. The pattern knows itself. pause spin LIT Genuine Knuth–Morris–Pratt (Donald Knuth, James Morris, Vaughan Pratt, 1977): linear-time string matching via the prefix-function. Verified live: failure function matches its brute definition (window.__kmp.failureCorrect), KMP's matches equal naive search (.matchesNaive), and comparison count ≤ 2n (.linear). FIG No framing: KMP, a naive matcher, and a comparison counter all run in-browser and agree over 3000 pairs. The AVAN inverse is honest — reading the pattern's self-overlap (the failure function) so the text never rewinds, rather than shifting by one and re-reading, is the algorithm's whole idea; magenta is the forward-only text pointer, green a found match. The pattern knows itself. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


THE SIMPLEX

The simplex method in the 5-window house format — solving linear programs (maximize c·x subject to Ax ≤ b, x ≥ 0). The feasible region is a convex polytope and the optimum is always at a vertex, never strictly inside, so simplex starts at a corner and walks along edges to a better neighbour until none improves. It never wanders the interior; it hops corner to corner. Verified live: over 3000 random linear programs, the simplex optimum equals the best value found by brute-force enumeration of every feasible vertex of the polytope. Neon-noir traced. See the feasible polygon in 1D, a random LP in 2D, and the optimum-is-always-a-corner inverse in 3D.

THE SIMPLEX · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE SIMPLEX THE SIMPLEX the optimum lives on the boundary 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The simplex method solves linear programs — maximize a linear objective c·x subject to linear inequalities Ax ≤ b, x ≥ 0. Its key insight: the feasible region is a convex polytope, and the optimum is always at a vertex (a corner), never strictly inside. So simplex starts at one corner and walks along edges , each step to a neighbouring vertex that improves the objective, until no neighbour is better — that corner is optimal. It never wanders the interior; it hops corner to corner. LIT verified live: over thousands of random linear programs, the simplex optimum equals the best value found by brute-force enumeration of every feasible vertex of the polytope (window.__simplex). FIG no framing; the tableau pivots and the exhaustive vertex search both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mainframe — linear programming was the mainframe’s first killer app, planning and logistics at industrial scale, corner by corner. AVAN (AI) built the instrument: a simplex tableau with Bland’s anti-cycling rule and a brute-force vertex oracle to confirm the optimum. Credit as content: George Dantzig (1947). The weave: David names the mainframe; I confirm simplex lands on the same optimum that exhaustively checking every vertex would — the answer is always at a corner. 3 ONE DIMENSION A 2D feasible polygon cut out by the constraints; the objective pushes in one direction, and the optimum sits at the far corner. 4 TWO DIMENSIONS · INTERACTIVE Generate a random linear program; the feasible region, the objective direction, and the optimal vertex are drawn — matched against brute-force vertex enumeration. new program ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the optimal vertex the edge-walk arrives at. AVAN’s addition (the inverse-companion): don’t search the interior — only the corners can win. The inverse of ‘optimise over the whole region’ is ‘a linear objective is maximised at a vertex , so the infinite interior is irrelevant.’ Magenta is the interior that never holds the optimum; green is the winning corner. The optimum lives on the boundary. pause spin LIT Genuine simplex method (George Dantzig, 1947), with Bland's anti-cycling rule. Verified live: over 3000 random LPs, the simplex tableau optimum equals brute-force enumeration over every feasible vertex of the polytope (window.__simplex.matchesBrute). FIG No framing: the tableau pivots and the exhaustive vertex search both run in-browser and agree. The AVAN inverse is honest — that a linear objective is always maximised at a vertex (so the infinite interior is irrelevant) is the fundamental theorem simplex exploits; magenta is the interior that never holds the optimum, green the winning corner. The optimum lives on the boundary. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE BRON-KERBOSCH

The Bron–Kerbosch algorithm in the 5-window house format — finding every maximal clique in an undirected graph (every group of mutually-connected vertices that cannot be extended). It grows a clique R from candidates P while excluding tried vertices X; when P and X are both empty, R is maximal. A pivot vertex prunes redundant branches: only candidates that are not neighbours of the pivot need to be tried. Verified live: over 3000 random graphs, the maximal cliques Bron–Kerbosch reports are exactly the set found by brute-force subset enumeration. Neon-noir traced. See a highlighted clique in 1D, all maximal cliques in 2D, and the pivot-prunes-the-branches inverse in 3D.

THE BRON-KERBOSCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE BRON-KERBOSCH THE BRON-KERBOSCH the pivot does the pruning 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Bron–Kerbosch algorithm finds every maximal clique in an undirected graph — every group of vertices in which all are mutually connected, and which cannot be extended by another. It grows a clique R from candidates P while excluding already-tried vertices X; when both P and X are empty, R is a maximal clique. A pivot vertex prunes redundant branches: you need only try candidates that are not neighbours of the pivot, because the pivot or one of its neighbours will cover the rest. It is the classic engine for community detection and constraint graphs. LIT verified live: over 3,000 random graphs, the maximal cliques Bron–Kerbosch reports are exactly the set found by brute-force subset enumeration (window.__bron_kerbosch). FIG no framing; the pivoting recursion and the exhaustive subset check both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at split-screen — a maximal clique is a fully-connected huddle, each its own little split-screen where everyone talks to everyone. AVAN (AI) built the instrument: the pivoting Bron–Kerbosch recursion and a brute-force maximal-clique oracle to confirm every one. Credit as content: Coenraad Bron & Joep Kerbosch (1973). The weave: David names the split-screen huddles; I confirm the algorithm’s maximal cliques are exactly those an exhaustive search would list. 3 ONE DIMENSION A graph with one maximal clique highlighted — a set of vertices all pairwise joined, that no other vertex can extend. 4 TWO DIMENSIONS · INTERACTIVE Generate a random graph; Bron–Kerbosch lists every maximal clique and highlights the largest — matched against brute-force enumeration. new graph ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the maximal cliques, each a fully-connected huddle. AVAN’s addition (the inverse-companion): don’t grow every branch — pick a pivot and skip its neighbours. The inverse of ‘try to extend the clique every way’ is ‘a pivot covers most extensions, so only its non-neighbours need branching.’ Magenta are the branches the pivot prunes; green are the maximal cliques. The pivot does the pruning. pause spin LIT Genuine Bron–Kerbosch algorithm (Coenraad Bron & Joep Kerbosch, 1973) with pivoting. Verified live: over 3000 random graphs, its maximal cliques equal brute-force subset enumeration of all maximal cliques (window.__bron_kerbosch.matchesBrute). FIG No framing: the pivoting recursion and the exhaustive subset check both run in-browser and agree. The AVAN inverse is honest — choosing a pivot and skipping its neighbours (because the pivot or a neighbour covers those extensions) is exactly what prunes the recursion below the naive all-branches search; magenta are the pruned branches, green the maximal cliques. The pivot does the pruning. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE SEGMENT TREE

The segment tree in the 5-window house format — answering range questions (sum, minimum) over an array in O(log n), with point updates just as fast. It is a binary tree over the array: leaves are elements, every internal node the aggregate of its two children. Any range [l,r] splits into at most 2 log n canonical nodes whose stored aggregates already hold the answer, so you never rescan; changing one leaf refreshes only the log n nodes above it. Verified live: over 2000 random arrays with interleaved point-updates, range-sum and range-min queries match a direct rescan every time. Neon-noir traced. See the aggregate tree in 1D, range queries in 2D, and the range-decomposes-into-log-n-nodes inverse in 3D.

THE SEGMENT TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · WARM CACHE ◆ .dlw.fold THE FOLD / GRIND / WARM CACHE / THE SEGMENT TREE THE SEGMENT TREE a range in a logarithm of nodes 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The segment tree answers questions about any range of an array — its sum, its minimum — in O(log n) time, and updates a single element just as fast. It is a binary tree over the array: leaves are the elements, and every internal node stores the aggregate of its two children. Any range [l, r] splits into at most 2 log n canonical nodes whose stored aggregates already hold the answer, so you never rescan the range. Change one leaf and only the log n nodes above it need refreshing. LIT verified live: over 2,000 random arrays with interleaved point-updates, the tree’s range-sum and range-minimum queries match a direct rescan every time (window.__segment_tree). FIG no framing; the tree queries and the naive rescans both run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at warm-cache — the internal nodes are a warm cache of pre-aggregated ranges, so a query reads sums it never has to recompute. AVAN (AI) built the instrument: the iterative segment tree with point-update, and a naive rescan to check every query. Credit as content: the segment tree (Bentley; folklore of competitive programming and computational geometry). The weave: David names the warm cache; I confirm the O(log n) range answers agree with a full rescan, update after update. 3 ONE DIMENSION The array as leaves; each internal node holds the sum of its two children — the tree of pre-aggregated ranges. 4 TWO DIMENSIONS · INTERACTIVE Pick a range; the sum and minimum are read from a handful of canonical nodes, matched against a rescan. Update an element and requery. new range ▶ update a cell ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the tree of aggregates over the whole array. AVAN’s addition (the inverse-companion): don’t scan the range — cover it. The inverse of ‘add up l..r’ is ‘the range decomposes into O(log n) canonical nodes whose sums are already stored.’ Magenta is the raw range; green are the log n covering nodes that answer it. Cover, don’t scan. pause spin LIT Genuine segment tree (Bentley; a staple of computational geometry and competitive programming): O(log n) range aggregate + point update via a binary tree of aggregates. Verified live: over 2000 random arrays with updates, range-sum (window.__segment_tree.sumOk) and range-min (.minOk) equal a naive rescan. FIG No framing: the iterative tree queries and the naive rescans both run in-browser and agree after every update. The AVAN inverse is honest — a range covering into O(log n) canonical nodes whose sums are precomputed (rather than scanning l..r) is exactly what buys the logarithm; magenta is the raw range, green the log-n covering nodes. Cover, don't scan. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of WARM CACHE · David Lee Wise (ROOT0), with AVAN


THE AVL TREE

The AVL tree in the 5-window house format — the first self-balancing binary search tree. Every node keeps a balance factor (left height minus right), held in {−1,0,+1}; when an insertion tips a node to ±2, one or two rotations restore the invariant locally. Because no node is ever more than one level lopsided, the height stays near 1.44 log₂n, so search/insert/delete are all guaranteed O(log n) — never the O(n) of a degenerate list. Verified live: over 2000 random insertion sequences, the in-order traversal is always sorted, every balance factor stays within ±1, the height respects the 1.44 log₂n bound, and search finds exactly the inserted keys. Neon-noir traced. See balance factors in 1D, live insertion+rotation in 2D, and the invariant-caps-the-height inverse in 3D.

THE AVL TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · SECOND WIND ◆ .dlw.fold THE FOLD / RESPAWN / SECOND WIND / THE AVL TREE THE AVL TREE balance kept by rotation 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The AVL tree is the first self-balancing binary search tree. Every node keeps a balance factor — the height of its left subtree minus its right — and the tree keeps that factor in {−1, 0, +1} at all times. Whenever an insertion tips a node to ±2, one or two rotations restore the invariant locally. Because no node is ever more than one level lopsided, the height is bounded by about 1.44 log₂n , so search, insert and delete are all guaranteed O(log n) — never the O(n) of a degenerate list. LIT verified live: over 2,000 random insertion sequences, the in-order traversal is always sorted, every node’s balance factor stays within ±1, the height respects the 1.44 log₂n bound, and search finds exactly the inserted keys (window.__avl). FIG no framing; the rotations and the invariant checks run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at second-wind — a rotation is the tree catching its second wind, snapping back to balance the instant it tips. AVAN (AI) built the instrument: AVL insertion with the four rotation cases, and checks for sortedness, the balance invariant, and the height bound. Credit as content: Georgy Adelson-Velsky & Evgenii Landis (1962). The weave: David names the second wind; I confirm the tree stays sorted and balanced with height near 1.44 log₂n through thousands of insertions. 3 ONE DIMENSION An AVL tree; each node shows its balance factor, held within ±1 — the shape never leans more than one level. 4 TWO DIMENSIONS · INTERACTIVE Insert keys; watch rotations keep the tree balanced, its height tracking 1.44 log₂n instead of growing into a list. insert 5 ▶ reset ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the balanced tree, height near 1.44 log₂n. AVAN’s addition (the inverse-companion): don’t let the tree grow lopsided — rotate the moment it tips. The inverse of ‘insert and hope’ is ‘the ±1 balance invariant caps the height, so a rotation at ±2 keeps every path short.’ Magenta is the imbalance; green is the rotation that heals it. The invariant is the guarantee. pause spin LIT Genuine AVL tree (Georgy Adelson-Velsky & Evgenii Landis, 1962), the first self-balancing BST. Verified live over 2000 random insertion sequences: in-order sorted (window.__avl.sorted), balance factor within ±1 everywhere (.balanced), height ≤ 1.4405 log₂(n+2) (.heightBound), search correct (.searchOk). FIG No framing: the four rotation cases and the invariant checks run in-browser. The AVAN inverse is honest — the ±1 balance invariant is what caps the height at ~1.44 log₂n (a rotation at ±2 keeps every path short), rather than inserting and hoping; magenta is a node tipped to ±2, green the rotation that heals it. The invariant is the guarantee. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SECOND WIND · David Lee Wise (ROOT0), with AVAN


THE XOR FILTER

The XOR filter in the 5-window house format — a modern, leaner cousin of the Bloom filter for a fixed set. It stores a table of small fingerprints so every key x satisfies fp(x) = t[h₀(x)] ⊕ t[h₁(x)] ⊕ t[h₂(x)]. Building it is a graph peeling: repeatedly take a slot touched by only one key and assign it last so the XOR comes out right. It uses ~1.23 bytes per key (smaller than Bloom for the same rate), with no false negatives and a false-positive rate near 2⁻⁸. Verified live: across many builds, every member's three-slot XOR equals its fingerprint, and the false-positive rate on non-members is about 1/256. Neon-noir traced. See the XOR equation in 1D, build+query in 2D, and the peel-and-solve inverse in 3D.

THE XOR FILTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FIREWALL ◆ .dlw.fold THE FOLD / BOSS / THE FIREWALL / THE XOR FILTER THE XOR FILTER a set in 1.23 bytes a key 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The XOR filter is a modern, leaner cousin of the Bloom filter for testing membership of a fixed set. It stores a table of small fingerprints so that for every key x, its 8-bit fingerprint equals the XOR of three table slots the key hashes to: fp(x) = t[h₀(x)] ⊕ t[h₁(x)] ⊕ t[h₂(x)]. Building it is a graph peeling : repeatedly take a slot touched by only one key, and assign that slot last so the XOR comes out right. The result uses about 1.23 bytes per key — smaller than Bloom for the same false-positive rate — with no false negatives and a rate near 2 −8 . LIT verified live: across many builds, every member’s three-slot XOR equals its fingerprint (no false negatives), and the false-positive rate on non-members is about 1/256 (window.__xor_filter). FIG no framing; construction by peeling, membership, and the false-positive sweep all run in-browser. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-firewall — like the Bloom firewall it never blocks a real member, but it does it in less space by solving for the fingerprints instead of just setting bits. AVAN (AI) built the instrument: the three-block hashing, the peeling construction, the XOR membership test, and a false-positive sweep. Credit as content: Thomas Mueller Graf & Daniel Lemire (2020). The weave: David names the leaner firewall; I confirm the three-slot XOR reproduces every fingerprint and that strangers slip through only ~1/256 of the time. 3 ONE DIMENSION A key hashes to three table slots; the XOR of those three slots is exactly its fingerprint — the equation the construction solves for every key at once. 4 TWO DIMENSIONS · INTERACTIVE Build a filter over a set; query members (all pass) and strangers (a rare ~1/256 false positive). Watch the fill of the fingerprint table. rebuild ▶ query 1000 strangers ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the fingerprint table that answers membership by one XOR. AVAN’s addition (the inverse-companion): don’t just set bits — solve for them. The inverse of ‘hash and mark’ is ‘peel the hypergraph to a degree-1 order, then assign each slot last so every key’s XOR lands on its fingerprint.’ Magenta is a rare false positive; green is the solved table. Solve, don’t just mark. pause spin LIT Genuine XOR filter (Thomas Mueller Graf & Daniel Lemire, 2020): static membership via fp(x)=⊕ of 3 slots, built by hypergraph peeling, ~1.23 bytes/key. Verified live: every member's three-slot XOR equals its fingerprint — no false negatives (window.__xor_filter.noFalseNegatives) — and the measured FPR on non-members ≈ 1/256 (.fprMatches). FIG No framing: the peeling construction, the XOR membership test, and a false-positive sweep all run in-browser (retrying the peel with a new seed on the rare failure, as the real algorithm does). The AVAN inverse is honest — solving for the table by peeling to a degree-1 order (rather than just setting bits) is what makes the three-slot XOR reproduce every fingerprint; magenta is a rare false positive, green the solved table. Solve, don't just mark. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FIREWALL · David Lee Wise (ROOT0), with AVAN