THE KAHAN SUM

Kahan compensated summation in the 5-window house format — add a long list of floating-point numbers while recovering the rounding error a naive running total silently discards. It carries a tiny compensation variable: each step computes what was lost to rounding and feeds it back into the next addition, so the sum stays accurate to nearly the last bit even when the naive total has drifted. Verified live: summing 0.1 one million times, naive float64 drifts by ~1e-6, while Kahan matches the accurately-rounded sum to ~0. See the compensation step in 1D, naive-vs-Kahan drift in 2D, and the feed-back-the-error inverse in 3D.

THE KAHAN SUM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · WARM CACHE ◆ .dlw.fold THE FOLD / GRIND / WARM CACHE / THE KAHAN SUM THE KAHAN SUM sum a million floats without losing the crumbs 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Kahan summation (compensated summation) adds a long list of floating-point numbers while recovering the rounding error that a naive running total silently throws away. It carries a tiny compensation variable c: each step computes what was lost to rounding and feeds it back into the next addition. The result is a sum accurate to nearly the last bit, even when the naive total has drifted — at the cost of a few extra flops. LIT verified live: summing 0.1 one million times, naive float64 drifts by ~10 −6 , while Kahan matches the accurately-rounded sum to ~0 (window.__kahan). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at warm-cache — the long accumulation loop where small errors would otherwise pile up unnoticed. Kahan summation keeps that loop honest. AVAN (AI) built the instrument: the naive accumulator, the compensated accumulator, a pairwise-accurate reference, and the error comparison. Credit as content: William Kahan (1965). The weave: David names warm-cache; I run both sums over the same million values and confirm the compensated one stays near the true total while the naive one drifts. 3 ONE DIMENSION Each addition rounds off a few low bits. Kahan captures that lost piece as c = (t − s) − y and subtracts it from the next term — so the crumbs are put back instead of vanishing. 4 TWO DIMENSIONS · INTERACTIVE Naive vs Kahan running totals of 0.1, and their drift from the true value; the error gap is checked over one million terms. new count ▶ verify 1e6 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the accurate sum with rounding fed back. AVAN’s addition (the inverse-companion): sum many floats without losing the crumbs by carrying a compensation term that recovers each step’s rounding error and adds it back next time. The inverse of ‘accumulate and let each rounding vanish’ is ‘capture the lost low bits and return them to the running total.’ Magenta is the drift of the naive sum; green is the compensated total hugging the true value. Nothing lost to rounding. pause spin LIT Genuine Kahan compensated summation (Kahan 1965). Verified live: summing the float64 value 0.1 exactly one million times, the naive accumulator drifts from the true sum by ~1.3e-6 while the compensated Kahan accumulator's error is ~0 (matching a pairwise-accurate reference) — Kahan is strictly closer to the true sum than naive (window.__kahan.kahanBetter). FIG No framing: the naive accumulator, the compensated accumulator, a pairwise-accurate reference sum, and the error comparison run in-browser and show Kahan's error at ~0 vs naive's ~1.3e-6. The AVAN inverse is honest — carrying a compensation term that recovers each step's rounding error and adds it back keeps the running total accurate; magenta is the naive sum's drift, green the compensated total hugging the true value. Nothing lost to rounding. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of WARM CACHE · David Lee Wise (ROOT0), with AVAN


THE RESIDUE NUMBER SYSTEM

a residue number system (RNS) in the 5-window house format — represent an integer not by its digits but by its remainders modulo a set of coprime bases (n <-> (n mod 3, n mod 5, n mod 7)). By the Chinese Remainder Theorem every value from 0 to the product minus one has a unique such triple, and addition and multiplication work independently, in parallel, with no carries between channels. It is used for fast carry-free arithmetic in DSP and cryptographic hardware. Verified live: over 0..104 the triples are unique and CRT reconstructs n exactly; componentwise + and x match ordinary arithmetic mod 105. See the three lanes in 1D, a channel-wise add/multiply in 2D, and the many-moduli-at-once inverse in 3D.

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

THE RESIDUE NUMBER SYSTEM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE RESIDUE NUMBER SYSTEM THE RESIDUE NUMBER SYSTEM carry-free arithmetic in parallel modular lanes 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A residue number system (RNS) represents an integer not by its digits but by its remainders modulo a set of coprime bases — e.g. n ↔ (n mod 3, n mod 5, n mod 7). By the Chinese Remainder Theorem , every value from 0 to the product minus one has a unique such triple, and addition and multiplication work independently, in parallel, with no carries between channels. It is used for fast, carry-free arithmetic in DSP and cryptographic hardware. LIT verified live: over 0..104 the triples are unique and CRT reconstructs n exactly; componentwise + and × match ordinary arithmetic mod 105 (window.__rns). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-mainframe — the arithmetic unit that does big sums in parallel lanes with no carry chain. RNS is that carry-free arithmetic. AVAN (AI) built the instrument: the remainder encoding, the CRT reconstruction (via modular inverses), and the componentwise add/multiply checks. Credit as content: the Chinese Remainder Theorem (Sunzi, c. 3rd–5th century CE); RNS formalized by Svoboda & Valach and by Garner (1950s). The weave: David names the mainframe; I encode each integer as remainders, add and multiply channel-by-channel, and confirm CRT rebuilds the exact result mod 105. 3 ONE DIMENSION The integer 20 becomes (20 mod 3, 20 mod 5, 20 mod 7) = (2, 0, 6). Add or multiply two numbers by doing it separately in each channel — no carry ever crosses between the 3-, 5-, and 7-lanes. 4 TWO DIMENSIONS · INTERACTIVE Two integers in RNS {3,5,7}; add or multiply them channel-by-channel and watch CRT rebuild the exact answer mod 105. new a,b ▶ + / × ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: each integer as a point in the 3×5×7 residue grid. AVAN’s addition (the inverse-companion): carry one integer as many remainders at once (mod coprime bases), so + and × run in independent lanes with no carry — and CRT reassembles the single value. The inverse of ‘one big number with a carry chain across digits’ is ‘many small remainders computed in parallel, reassembled by CRT.’ Magenta is the carry chain a positional base needs; green is the carry-free residue tuple. One number, many moduli at once. pause spin LIT Genuine residue number system with CRT reconstruction, moduli {3,5,7} (Chinese Remainder Theorem, Sunzi c.3rd-5th c. CE; RNS via Garner, Svoboda & Valach 1950s). Verified live: over 0..104 the residue triples are unique and CRT rebuilds n exactly, and componentwise addition and multiplication of triples match ordinary (a+b) mod 105 and (a*b) mod 105 (window.__rns.reconstruct && .add && .mul). FIG No framing: the remainder encoding, the CRT reconstruction via modular inverses, and the componentwise add/multiply checks run in-browser exhaustively over 0..104 and hold. The AVAN inverse is honest — carrying one integer as many remainders lets + and x run in independent carry-free lanes, reassembled by CRT; magenta is the carry chain a positional base needs, green the carry-free residue tuple. One number, many moduli at once. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE NON-ADJACENT FORM

the non-adjacent form (NAF) in the 5-window house format — a signed-binary representation with digits {-1,0,+1} in which no two adjacent digits are both nonzero. Every integer has a unique NAF, and it has the fewest nonzero digits of any signed-binary representation (on average only a third nonzero, versus half for ordinary binary). That sparsity speeds up the double-and-add used in elliptic-curve and modular exponentiation: fewer nonzero digits means fewer additions. Verified live: every integer from -128 to 127 has a unique NAF over {-1,0,1} with no two adjacent nonzeros, it evaluates back exactly, and its weight never exceeds the ordinary binary weight. See a run collapse in 1D, NAF vs binary in 2D, and the sparse-signed inverse in 3D.

THE NON-ADJACENT FORM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · NULL ISLAND ◆ .dlw.fold THE FOLD / SPAWN / NULL ISLAND / THE NON-ADJACENT FORM THE NON-ADJACENT FORM the sparsest signed-binary representation 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The non-adjacent form (NAF) is a signed-binary representation with digits {−1, 0, +1} in which no two adjacent digits are both nonzero . Every integer has a unique NAF, and it has the fewest nonzero digits of any signed-binary representation — on average only a third are nonzero, versus half for ordinary binary. That sparsity is why NAF speeds up the “double-and-add” used in elliptic-curve and modular exponentiation: fewer nonzero digits means fewer additions. LIT verified live: every integer from −128 to 127 has a unique NAF over {−1,0,1} with no two adjacent nonzeros, it evaluates back exactly, and its weight never exceeds the ordinary binary weight (window.__naf). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at null-island — the sparsest possible signature, as many zeros as the number will allow. The non-adjacent form is that minimal-weight encoding. AVAN (AI) built the instrument: the “n mod 4” digit rule, the exact reconstruction, the no-adjacent and uniqueness checks, and the weight comparison against binary. Credit as content: the non-adjacent form (Reitwiesner 1960). The weave: David names null-island; I emit ±1 whenever the low two bits force it and confirm the result is the unique, adjacency-free, minimum-weight signed-binary encoding. 3 ONE DIMENSION When the number is odd, look at its low two bits: emit +1 if they are 01, −1 if 11 — then subtract that and halve. This guarantees the next digit is 0, so no two nonzeros ever touch. 4 TWO DIMENSIONS · INTERACTIVE Any integer’s NAF beside its ordinary binary; the reconstruction, the no-adjacent rule, and the lower nonzero-count are checked. new n ▶ verify −128..127 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the minimum-weight signed-binary form. AVAN’s addition (the inverse-companion): encode a number with the fewest nonzero digits by allowing a −1 digit and forbidding adjacent nonzeros — a run of 1s like 0111 collapses to 100−1 (one add and one subtract instead of three adds). The inverse of ‘a binary run needs a nonzero at every place’ is ‘let digits go negative — a run becomes two sparse nonzeros.’ Magenta is the dense nonzeros of ordinary binary; green is the sparse NAF. Fewer nonzeros, fewer additions. pause spin LIT Genuine non-adjacent form (Reitwiesner 1960). Verified live: every integer from -128 to 127 has a unique representation over digits {-1,0,1} with no two adjacent nonzeros that evaluates back exactly, and its number of nonzero digits never exceeds the ordinary binary weight (window.__naf.roundTrip && .noAdjacent && .unique && .minimal); 7 = 100T. FIG No framing: the 'n mod 4' digit rule, the exact reconstruction, the no-adjacent and uniqueness checks, and the weight comparison against binary run in-browser over all 256 integers and hold. The AVAN inverse is honest — allowing a -1 digit and forbidding adjacent nonzeros collapses a run of 1s (0111 -> 100T) into two sparse nonzeros, so fewer additions; magenta is the dense nonzeros of ordinary binary, green the sparse NAF. Fewer nonzeros, fewer additions. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NULL ISLAND · David Lee Wise (ROOT0), with AVAN


THE LEHMER CODE

the Lehmer code and factorial number system in the 5-window house format — give every permutation a unique integer and back, a bijection between the n! orderings of n items and the numbers 0..n!-1. The Lehmer code records at each position how many later elements are smaller; reading it in the factorial base (place values (n-1)!, (n-2)!, ..., 1) yields the permutation's rank. It is how you index, shuffle, or store a permutation as one number. Verified live: over all 720 permutations of 6 items, rank of unrank is the identity and every rank yields a distinct permutation. See the inversion counts in 1D, a rank-to-permutation in 2D, and the single-integer inverse in 3D.

THE LEHMER CODE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE EPOCH ◆ .dlw.fold THE FOLD / GRIND / THE EPOCH / THE LEHMER CODE THE LEHMER CODE index any permutation by a single integer 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Lehmer code and the factorial number system together give every permutation a unique integer and back — a bijection between the n! orderings of n items and the numbers 0..n!−1. The Lehmer code records, at each position, how many later elements are smaller ; reading it in the factorial base (place values (n−1)!, (n−2)!, …, 1) yields the permutation’s rank. It is how you index, shuffle, or store a permutation as one number. LIT verified live: over all 720 permutations of 6 items, rank∘unrank is the identity and every rank yields a distinct permutation (window.__lehmer). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-epoch — a canonical enumeration, here of every possible ordering, each given one timestamp-like index. The factorial base is that enumeration. AVAN (AI) built the instrument: the inversion-count Lehmer code, the factorial-base rank, the greedy unrank, and the exhaustive bijection check. Credit as content: Derrick Henry Lehmer (Lehmer code); the factorial number system (Laisant 1888). The weave: David names the epoch; I count inversions to a factorial-base number and greedily rebuild the permutation, confirming the map is an exact bijection over all 720 orderings. 3 ONE DIMENSION Lehmer code of a permutation: at each slot, count how many elements to its right are smaller. Read those counts in the factorial base — place values 5!, 4!, 3!, 2!, 1! — to get the rank. 4 TWO DIMENSIONS · INTERACTIVE Slide a rank 0..719; watch its permutation of six appear. Round-trip rank∘unrank is checked over all 720. random rank ▶ verify 720 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the bijection between ranks and permutations. AVAN’s addition (the inverse-companion): name a whole permutation by a single integer — encode it as inversion counts in the factorial base , decode by greedily picking the d-th remaining element. The inverse of ‘list all n! orderings’ is ‘index each ordering by one number and reconstruct it on demand.’ Magenta is the full list of orderings you never store; green is the single rank that stands for each. A clock whose digits are factorials. pause spin LIT Genuine Lehmer code / factorial number system (Lehmer; Laisant 1888). Verified live: over all 720 permutations of 6 items, converting a permutation to its factorial-base rank and back (greedy unrank) is the identity, and every rank 0..719 yields a distinct permutation (window.__lehmer.bijection && .distinct). FIG No framing: the inversion-count Lehmer code, the factorial-base rank, the greedy unrank, and the exhaustive bijection check run in-browser over all 720 orderings and hold. The AVAN inverse is honest — encoding a permutation as inversion counts in the factorial base names a whole ordering by one integer, reconstructed by greedily picking the d-th remaining element; magenta is the full ordering list you never store, green the single rank. A clock whose digits are factorials. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EPOCH · David Lee Wise (ROOT0), with AVAN


THE TUNSTALL CODE

Tunstall coding in the 5-window house format — Huffman's mirror image: where Huffman maps variable-length symbols to variable-length codes, Tunstall maps variable-length source strings to fixed-length codes. It builds a dictionary by starting with the alphabet and repeatedly splitting the most probable leaf into its children until it has 2^R entries, then gives every entry the same R-bit codeword. Long likely strings get a whole codeword each, so common runs compress into one fixed block. Verified live: over 200 random streams, greedy parse + fixed-code encode round-trips exactly, and every codeword is the same length. See the leaf-splitting in 1D, a parse in 2D, and the fixed-code inverse in 3D.

THE TUNSTALL CODE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE TUNSTALL CODE THE TUNSTALL CODE variable strings to fixed-length codes — Huffman's dual 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Tunstall coding is Huffman’s mirror image : where Huffman maps variable -length source symbols to variable-length codes, Tunstall maps variable -length source strings to fixed -length codes. It builds a dictionary by starting with the alphabet and repeatedly splitting the most probable leaf into its children, until it has 2 R entries — then every entry gets the same R-bit codeword. Long, likely strings get a whole codeword each, so common runs compress into one fixed block. LIT verified live: over 200 random streams, greedy parse + fixed-code encode round-trips exactly, and every codeword is the same length (window.__tunstall). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-broadcast — the channel that wants fixed -size packets, so the coder must pack variable source runs into equal blocks. Tunstall coding is that packer. AVAN (AI) built the instrument: the fattest-leaf dictionary growth, the greedy longest-match parse, the fixed-length codes, and the round-trip check. Credit as content: Brian Parker Tunstall (1967). The weave: David names the broadcast; I grow the dictionary by splitting the most probable leaf, parse the source greedily, and confirm the fixed-length codes decode back to the exact input. 3 ONE DIMENSION Start with {0, 1}. Repeatedly take the most probable leaf and split it into leaf+0 and leaf+1. Stop at 2 R leaves; give each an R-bit code. Probable strings become single codewords. 4 TWO DIMENSIONS · INTERACTIVE A Tunstall dictionary for chosen source probabilities; a stream is parsed, coded, and decoded back, with the round-trip and fixed length checked. new stream ▶ verify 200 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: variable source strings, each a fixed-length codeword. AVAN’s addition (the inverse-companion): compress by mapping variable -length source strings to fixed -length codes — grow a dictionary by splitting the most probable leaf, so likely runs each become one codeword. The inverse of ‘Huffman: variable code, fixed symbol’ is ‘Tunstall: fixed code, variable string.’ Magenta is the variable-length codewords Huffman would emit; green is Tunstall’s equal blocks. Huffman’s dual. pause spin LIT Genuine Tunstall variable-to-fixed coding (Tunstall 1967). Verified live: building the dictionary by repeatedly splitting the most probable leaf to 2^R entries, greedy longest-match parse followed by fixed R-bit coding round-trips to the exact input over 200 random streams, and every codeword is the same length (window.__tunstall.roundTrip && .fixedLength). FIG No framing: the fattest-leaf dictionary growth, the greedy longest-match parse, the fixed-length codes, and the round-trip check run in-browser and hold. The AVAN inverse is honest — mapping variable-length source strings to fixed-length codes (the dual of Huffman's variable code / fixed symbol) makes likely runs into single codewords; magenta is the variable-length codewords Huffman would emit, green Tunstall's equal blocks. Huffman's dual. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE POISSON DISK

Poisson-disk sampling in the 5-window house format — scatter points that are random but never closer than a radius r to one another (blue noise). Bridson's algorithm does it in O(n): a background grid (cell r/sqrt2, so each cell holds at most one point) and an active list; for each active point it throws k candidates into the annulus [r, 2r] and accepts the first with no neighbor closer than r. The even, gap-respecting spread is used for stippling, texture, and sensor placement. Verified live: across 30 runs every pair of accepted samples is at least r apart (minimum gap equals r, never less). See the candidate ring in 1D, an exclusion-disk scatter in 2D, and the blue-noise inverse in 3D.

THE POISSON DISK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE POISSON DISK THE POISSON DISK random points that never crowd — blue noise 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Poisson-disk sampling scatters points that are random but never closer than a radius r to one another — “blue noise.” Bridson’s algorithm does it in O(n): a background grid (cell r/√2, so each cell holds at most one point) and an active list; for each active point it throws k candidates into the annulus [r, 2r] and accepts the first with no neighbor closer than r. The even, gap-respecting spread is why it is used for stippling, texture, and sensor placement. LIT verified live: across 30 runs every pair of accepted samples is at least r apart (the minimum gap equals r, never less) — window.__poisson. FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-sandbox — the spatial playground where points must be sown evenly, none crowding another. Poisson-disk sampling is that even sowing. AVAN (AI) built the instrument: the r/√2 background grid, the annulus candidate throw, the neighbor rejection, and the exhaustive minimum-gap check. Credit as content: Robert Bridson (2007). The weave: David names the sandbox; I grow the sample set from an active front, reject any candidate too close, and confirm no two accepted points ever fall within r. 3 ONE DIMENSION From an active point, throw k candidates into the ring between r and 2r. Accept the first whose nearest existing neighbor is ≥ r away; otherwise the point is exhausted and leaves the active front. 4 TWO DIMENSIONS · INTERACTIVE A Poisson-disk point set; every point’s exclusion disk of radius r is shown, and the minimum pairwise gap is checked to be ≥ r. new scatter ▶ verify 30 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an even, gap-respecting scatter. AVAN’s addition (the inverse-companion): make randomness even by forbidding any two points within r — grow from an active front, throwing candidates into the [r,2r] ring and rejecting the too-close. The inverse of ‘uniform random points clump and leave gaps’ is ‘blue noise — random yet minimally spaced.’ Magenta is the clumps and voids of plain uniform sampling; green is the elbow-room scatter. Random, but never crowded. pause spin LIT Genuine Bridson Poisson-disk sampling (Bridson 2007). Verified live: across 30 runs the background-grid + active-list algorithm produces point sets in which every pair of accepted samples is at least r apart, with the measured minimum gap equal to r and never below it (window.__poisson.allApart). FIG No framing: the r/sqrt2 background grid, the annulus candidate throw, the neighbor rejection, and the exhaustive minimum-gap check run in-browser and hold. The AVAN inverse is honest — forbidding any two points within r while growing from an active front makes randomness even (blue noise); magenta is the clumps and voids of plain uniform sampling, green the elbow-room scatter. Random, but never crowded. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE LANGTON ANT

Langton's ant in the 5-window house format — a two-rule cellular automaton: an ant turns right on a white cell (then flips it black) and left on a black cell (then flips it white), and steps forward. From an all-white grid its path looks chaotic for about ten thousand steps, then locks into a periodic 'highway' that repeats every 104 steps, marching off to infinity. Order emerges from two trivial rules with no hint of it in between. Verified live: the ant's displacement is constant every 104 steps once the highway forms (net move -2,+2 per period), while the early chaotic phase has no such regularity. See the two rules in 1D, the trail in 2D, and the emergent-order inverse in 3D.

THE LANGTON ANT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE LANGTON ANT THE LANGTON ANT order emerges from two rules after 10,000 steps of chaos 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Langton’s ant is a two-rule cellular automaton: an ant on a grid turns right on a white cell (then flips it black) and left on a black cell (then flips it white), and steps forward. From an all-white grid its path looks utterly chaotic for about ten thousand steps — then, mysteriously, it locks into a periodic “ highway ” that repeats every 104 steps , marching off to infinity. Order emerges from two trivial rules with no hint of it in between. LIT verified live: the ant’s displacement is constant every 104 steps once the highway forms (net move −2,+2 per period), while the early chaotic phase has no such regularity (window.__langton). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at heisenbug — the behavior that looks random and irreproducible until, suddenly, a hidden order surfaces. Langton’s ant is that surprise. AVAN (AI) built the instrument: the two-rule step, the trail, the period-104 displacement detector, and the chaotic-phase contrast. Credit as content: Christopher Langton (1986). The weave: David names heisenbug; I run the two rules from a blank grid and confirm the emergent highway advances by a fixed vector every 104 steps — regularity the chaotic opening does not have. 3 ONE DIMENSION Two rules only. White cell: turn right, paint it black, step. Black cell: turn left, paint it white, step. That is the entire program — yet a highway is hidden inside it. 4 TWO DIMENSIONS · INTERACTIVE The ant’s trail; run it forward and watch chaos resolve into the period-104 highway, whose 104-step displacement is checked to be constant. +2000 steps ▶ verify highway ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the emergent period-104 highway. AVAN’s addition (the inverse-companion): get global order (a straight highway) out of two local rules and no plan — the emergent structure is not written into the rules, it appears only after ~10 4 chaotic steps. The inverse of ‘design the highway explicitly’ is ‘run two trivial rules and let the highway emerge.’ Magenta is the chaotic opening with no visible pattern; green is the periodic highway that self-assembles. Order no one put there. pause spin LIT Genuine Langton's ant (Langton 1986). Verified live: running the two-rule automaton from a blank grid, the ant's displacement over 104 steps is constant once the highway forms (net move -2,+2 per period around step 11000), whereas the early chaotic phase (around step 500) has no constant 104-step displacement (window.__langton.highwayConstant && .chaosVaries). FIG No framing: the two-rule step, the trail, the period-104 displacement detector, and the chaotic-phase contrast run in-browser and hold. The AVAN inverse is honest — global order (a straight highway) emerges from two local rules and no plan, appearing only after ~10^4 chaotic steps; magenta is the chaotic opening with no visible pattern, green the periodic highway that self-assembles. Order no one put in the two rules. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE COUNT-MIN SKETCH

the Count-Min sketch in the 5-window house format — estimate how often each item appears in a huge stream using a tiny fixed table (d rows x w columns of counters), far smaller than the number of distinct items. Each item is hashed into one counter per row and increments them; its estimate is the minimum of those d counters. Because collisions can only add to a counter, the estimate is never an underestimate, and taking the min squeezes out most collision noise. Verified live: over an 8000-item stream drawn from a 400-symbol alphabet the sketch's estimate is >= the true count for every distinct item — it never underestimates. See the per-row hashing in 1D, a query in 2D, and the fixed-table inverse in 3D.

THE COUNT-MIN SKETCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE VAULT ◆ .dlw.fold THE FOLD / LOOT / THE VAULT / THE COUNT-MIN SKETCH THE COUNT-MIN SKETCH count a huge stream in a tiny fixed table 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Count-Min sketch estimates how often each item appears in a huge stream using a tiny fixed table — d rows × w columns of counters — far smaller than the number of distinct items. Each item is hashed into one counter per row and increments them; its estimate is the minimum of those d counters. Because collisions can only add to a counter, the estimate is never an underestimate , and taking the min squeezes out most of the collision noise. LIT verified live: over an 8000-item stream drawn from a 400-symbol alphabet the sketch’s estimate is ≥ the true count for every distinct item — it never underestimates (window.__cms). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-vault — the ledger that must tally a torrent of items in a fixed, tiny space. The Count-Min sketch is that thimble-sized tally. AVAN (AI) built the instrument: the d×w counter table, the per-row hashes, the min-estimate, and the never-underestimate check against an exact map. Credit as content: Graham Cormode & S. Muthukrishnan (2005). The weave: David names the vault; I hash each item into one counter per row, read back the minimum, and confirm the estimate is never below the true count. 3 ONE DIMENSION Each item hashes to one cell per row and bumps it. To query, read the item’s cell in every row and take the smallest — collisions only inflate cells, so the minimum is the tightest (and never-too-low) estimate. 4 TWO DIMENSIONS · INTERACTIVE A d×w sketch over a skewed stream; query any item to compare its min-estimate against the true count — always ≥, never below. new stream ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: frequencies tallied in a fixed tiny table. AVAN’s addition (the inverse-companion): count a stream too big to store in a fixed small table by hashing each item into d rows and reading back the minimum — since collisions only add, the min never underestimates. The inverse of ‘keep an exact counter per distinct item’ is ‘keep d×w counters and take the min — a one-sided, bounded error.’ Magenta is the unbounded exact map you avoid storing; green is the fixed sketch. A torrent counted in a thimble. pause spin LIT Genuine Count-Min sketch (Cormode & Muthukrishnan 2005). Verified live: over an 8000-item skewed stream drawn from a 400-symbol alphabet, the min-of-d-rows estimate is greater than or equal to the true count for every distinct item that appears — it never underestimates (window.__cms.neverUnderestimates). FIG No framing: the d x w counter table, the per-row hashes, the min-estimate, and the never-underestimate check against an exact map run in-browser and hold. The AVAN inverse is honest — hashing each item into d rows and reading back the minimum counts a stream too big to store in a fixed small table, with a one-sided (never-under) bounded error since collisions only add; magenta is the unbounded exact map you avoid, green the fixed sketch. A torrent counted in a thimble. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE VAULT · David Lee Wise (ROOT0), with AVAN


THE MINHASH

MinHash in the 5-window house format — estimate the Jaccard similarity of two sets (intersection over union) from tiny fixed-size signatures instead of the sets themselves. For each of k hash functions keep only the minimum hash value over a set; the fraction of signature positions that agree between two sets is an unbiased estimate of their Jaccard similarity. It is the engine behind near-duplicate detection in web-scale document sets. Verified live: identical sets agree in all k positions (estimate exactly 1); across 200 random pairs with k=256 the estimate stays within ~0.07 of the true Jaccard and averages ~0.02 error. See the single-hash minimum in 1D, two signatures in 2D, and the thumbprint inverse in 3D.

THE MINHASH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE MERGE ◆ .dlw.fold THE FOLD / CO-OP / THE MERGE / THE MINHASH THE MINHASH set similarity from a fistful of minimums 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION MinHash estimates the Jaccard similarity of two sets — the size of their intersection over their union — from tiny fixed-size signatures instead of the sets themselves. For each of k hash functions, keep only the minimum hash value over a set; the fraction of signature positions that agree between two sets is an unbiased estimate of their Jaccard similarity. It is the engine behind near-duplicate detection in web-scale document sets. LIT verified live: identical sets agree in all k positions (estimate exactly 1); across 200 random pairs with k=256, the estimate stays within ~0.07 of the true Jaccard and averages ~0.02 error (window.__minhash). FIG approaches the true value as k grows — an estimator, honestly labelled. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-merge — the moment two collections are compared for overlap before joining. MinHash is that overlap estimate, cheap enough for millions of sets. AVAN (AI) built the instrument: the k min-hash signatures, the agreement-fraction estimator, the exact Jaccard oracle, and the convergence check. Credit as content: Andrei Broder (1997). The weave: David names the-merge; I reduce each set to its k minimums, count how many positions agree, and confirm that fraction tracks the true Jaccard — exactly 1 for identical sets. 3 ONE DIMENSION Under one random hash, the set’s minimum comes from whichever element hashes lowest. Two sets share that minimum exactly when the overall-lowest element lies in both — which happens with probability equal to their Jaccard similarity. 4 TWO DIMENSIONS · INTERACTIVE Two sets and their k-min signatures; the fraction of agreeing positions is compared against the exact Jaccard. new sets ▶ verify 200 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: similarity read from a fistful of minimums. AVAN’s addition (the inverse-companion): estimate set overlap without comparing the sets — keep only k minimum-hashes per set; the fraction that agree is the Jaccard similarity. The inverse of ‘intersect two full sets and divide by their union’ is ‘compare k minimums — agreement is similarity.’ Magenta is the full sets you never compare; green is the k-minimum signature. Similarity from a thumbprint. pause spin LIT Genuine MinHash Jaccard estimation (Broder 1997). Verified live: identical sets agree in all k signature positions (estimate exactly 1); across 200 random set pairs with k=256 hashes the agreement-fraction estimate stays within ~0.07 of the exact Jaccard similarity and averages ~0.02 absolute error (window.__minhash.identicalIsOne, .avgErr, .maxErr). FIG Honestly labelled as an estimator: the agreement fraction is unbiased for Jaccard and converges as k grows — exact only in the k->infinity limit (and exactly 1 for identical sets). The k min-hash signatures, the agreement estimator, the exact Jaccard oracle, and the convergence check run in-browser. The AVAN inverse is honest — comparing k minimums estimates overlap without comparing the sets; magenta is the full sets you never compare, green the k-minimum signature. Similarity from a thumbprint. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MERGE · David Lee Wise (ROOT0), with AVAN


THE SKEW BINARY

skew binary in the 5-window house format — a positional number system with place values 2^(k+1)-1 (1, 3, 7, 15, 31, ...) and digits {0,1,2}, where at most one digit is a 2 and it must be the lowest nonzero digit. Its magic is that +1 changes at most two digits — a genuine O(1) increment with no carry ripple — while ordinary binary can cascade carries across every bit. It is the number system behind skew-binary random-access lists and purely functional numeric structures. Verified live: over 0..5000 each canonical rep equals the counter, stays canonical (<= one 2, lowest), and every increment touches at most 2 digits. See the increment rule in 1D, a stepping counter in 2D, and the no-ripple inverse in 3D.

THE SKEW BINARY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE SKEW BINARY THE SKEW BINARY a number base where +1 costs O(1) 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Skew binary is a positional number system with base-2 place values 2 k+1 −1 (so 1, 3, 7, 15, 31, …) and digits {0, 1, 2}, where at most one digit is a 2 and it must be the lowest nonzero digit. Its magic is that +1 changes at most two digits — a genuine O(1) increment with no carry ripple — while ordinary binary can cascade carries across every bit. It is the number system behind skew-binary random-access lists and purely functional numeric structures. LIT verified live: over 0..5000 each canonical rep equals the counter, stays canonical (≤ one 2, lowest), and every increment touches at most 2 digits (window.__skewbin). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — the counting loop, here with an increment that never ripples a carry across the whole number. Skew binary is that O(1) increment. AVAN (AI) built the instrument: the skew place values, the two-digit increment rule, the canonical-form check, and the touched-digit count. Credit as content: skew binary numbers (used by Eugene Myers and by Chris Okasaki for functional data structures). The weave: David names the grindstone; I increment with the “carry the lone 2” rule and confirm every step changes at most two digits while the value stays exact. 3 ONE DIMENSION Increment rule: if the lowest nonzero digit is a 2 , set it to 0 and add 1 to the next digit (which becomes 1 or 2). Otherwise just add 1 to the lowest digit. Either way, at most two digits move. 4 TWO DIMENSIONS · INTERACTIVE Step a skew-binary counter; watch which digits change each +1 (never more than two) and confirm the value tracks the count. +1 ▶ +37 ▶ verify 5000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a numeral whose increment never ripples. AVAN’s addition (the inverse-companion): make +1 cost O(1) by allowing a single digit 2 at the lowest nonzero place — incrementing either bumps the lowest digit or carries that lone 2 exactly one place, never a chain. The inverse of ‘binary +1 can cascade carries across every bit’ is ‘a skew base where one lone 2 absorbs the carry in O(1).’ Magenta is the full carry-ripple of ordinary binary; green is the ≤2-digit skew increment. Counting without the ripple. pause spin LIT Genuine skew binary number system (used by Myers; Okasaki for functional data structures). Verified live: over counters 0..5000 each canonical skew-binary representation equals the count, remains canonical (at most one digit is 2 and it is the lowest nonzero), and every +1 increment changes at most two digits (window.__skewbin.valueMatches && .canonical && .o1; max touched = 2). FIG No framing: the skew place values, the two-digit increment rule, the canonical-form check, and the touched-digit count run in-browser over 0..5000 and hold. The AVAN inverse is honest — allowing a single lowest 2 lets +1 either bump the lowest digit or carry that lone 2 exactly one place, never a chain, giving O(1) increment; magenta is the full carry-ripple of ordinary binary, green the ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE DELTA-SIGMA

the delta-sigma modulator in the 5-window house format — turn a smooth analog signal into a stream of single bits (+-1) whose local average tracks the input. A first-order loop integrates the difference between input and the last output bit, then emits the sign; feedback keeps the running error near zero. Crucially it shapes the quantization noise — pushing it up to high frequencies where a lowpass filter removes it — so one bit at a high sample rate reconstructs the signal accurately. It is how most audio and sensor ADCs actually work. Verified live: modulating a 0.5*sine to a +-1 stream, a zero-phase lowpass reconstructs it to RMS < 0.02, and the quantization-noise energy is far larger at high frequencies than low. See bit density in 1D, sine-vs-reconstruction in 2D, and the noise-shaping inverse in 3D.

THE DELTA-SIGMA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE DELTA-SIGMA THE DELTA-SIGMA a whole waveform in a river of single bits 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The delta-sigma modulator turns a smooth analog signal into a stream of single bits (±1) whose local average tracks the input. A first-order loop integrates the difference between input and the last output bit, then emits the sign; feedback keeps the running error near zero. Crucially it shapes the quantization noise — pushing it up to high frequencies where a lowpass filter removes it — so one bit at a high sample rate reconstructs the signal accurately. It is how most audio and sensor ADCs actually work. LIT verified live: modulating a 0.5·sine to a ±1 stream, a zero-phase lowpass reconstructs it to RMS < 0.02, and the quantization-noise energy is far larger at high frequencies than low (window.__deltasigma). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at first-light — the very first flicker of a signal, reduced to a single bit per tick that still carries the whole waveform in its density. Delta-sigma is that one-bit river. AVAN (AI) built the instrument: the first-order integrate-and-sign loop, the zero-phase reconstruction, the RMS error, and the noise-shaping band comparison. Credit as content: Inose & Yasuda (delta-sigma modulation, 1962). The weave: David names first-light; I integrate input minus feedback, emit the sign each tick, and confirm the bit stream’s local average rebuilds the sine while its error rides up into the high band. 3 ONE DIMENSION Integrate (input − last bit); emit +1 if the accumulator is high, −1 if low; feed that bit back. Where the input is large, +1s crowd together; where small, they thin out — density carries the value. 4 TWO DIMENSIONS · INTERACTIVE The input sine, the ±1 bit stream, and the lowpass reconstruction overlaid; the reconstruction RMS error is checked. new signal ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a waveform carried by one-bit density. AVAN’s addition (the inverse-companion): represent a full-resolution signal with one bit per sample by shaping the noise — integrate the error and feed the sign back, so quantization noise is pushed to high frequencies a lowpass discards. The inverse of ‘a signal needs many bits per sample’ is ‘one bit per sample, oversampled, with the noise shaped away.’ Magenta is the raw quantization noise; green is the recovered waveform after the noise rides up and out. Resolution from density, not depth. pause spin LIT Genuine first-order delta-sigma modulation (Inose & Yasuda 1962). Verified live: the integrate-and-sign loop turns a 0.5-amplitude sine into a +-1 bit stream whose zero-phase (centered) lowpass reconstruction has RMS error below 0.02 (~0.006 measured), and the quantization-noise energy in the high band far exceeds the low band (noise shaping, ~320x) (window.__deltasigma.oneBit && .rmsOK && .noiseShaped). FIG No framing: the first-order integrate-and-sign loop, the zero-phase reconstruction, the RMS error, and the noise-shaping band comparison run in-browser and hold. (Reconstruction uses a centered moving average to avoid a causal filter's group delay — an honest zero-phase lowpass.) The AVAN inverse is honest — shaping quantization noise to high frequencies lets one bit per oversampled sample carry the waveform; magenta is the raw quantization noise, green the recovered waveform. Resolution from density, not bit-depth. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE CUCKOO FILTER

the cuckoo filter in the 5-window house format — answer 'have I seen this item?' using tiny fingerprints in a compact table, like a Bloom filter but also supporting deletion. Each item has two candidate buckets (the second reachable from the first by XOR-ing a hash of its fingerprint), so an item can be relocated cuckoo-style to make room. It can return a false positive (a fingerprint collision) but never a false negative: anything inserted and not deleted is always found. Verified live: across 20 filled filters, every inserted item is found (no false negatives), and the false-positive rate on non-members is ~2%. See the two-bucket addressing in 1D, a filled filter in 2D, and the fingerprint-nest inverse in 3D.

THE CUCKOO FILTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE HOARD ◆ .dlw.fold THE FOLD / LOOT / THE HOARD / THE CUCKOO FILTER THE CUCKOO FILTER deletable membership with never a false negative 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The cuckoo filter answers “have I seen this item?” using tiny fingerprints in a compact table — like a Bloom filter, but it also supports deletion . Each item has two candidate buckets (the second reachable from the first by XOR-ing a hash of its fingerprint), so an item can be relocated cuckoo-style to make room. It can return a false positive (a fingerprint collision), but never a false negative : anything inserted and not deleted is always found. LIT verified live: across 20 filled filters, every inserted item is found (no false negatives), and the false-positive rate on non-members is ~2% (window.__cuckoo). FIG no framing; the never-miss guarantee is exact, the FP rate is measured. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-hoard — the vast collection you must ask “is this already in here?” without storing it all. The cuckoo filter is that membership oracle, deletions and all. AVAN (AI) built the instrument: the fingerprint, the two-bucket XOR addressing, the cuckoo eviction, and the no-false-negative check. Credit as content: Fan, Andersen, Kaminsky & Mitzenmacher (2014). The weave: David names the hoard; I stash each item’s fingerprint in one of its two buckets (evicting when full), and confirm every stored item is always found while non-members only rarely collide. 3 ONE DIMENSION An item’s fingerprint goes in bucket i 1 or i 2 = i 1 ⊕ hash(fingerprint). If both are full, kick an occupant to its alternate bucket — the “cuckoo” move — until everyone has a home. 4 TWO DIMENSIONS · INTERACTIVE A cuckoo filter of fingerprints; query members (always found) and non-members (rarely a false positive), and delete items. new filter ▶ verify 20 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: membership from fingerprints in two buckets. AVAN’s addition (the inverse-companion): test membership without storing the items — keep only short fingerprints, each in one of two XOR-linked buckets, relocating cuckoo-style when full, so the answer never misses a stored item (only rare false positives) and deletion works . The inverse of ‘store every item to answer membership’ is ‘store only fingerprints, two homes each — one-sided error, deletable.’ Magenta is the full item set you avoid storing; green is the fingerprint nest. Never a false negative. pause spin LIT Genuine cuckoo filter (Fan, Andersen, Kaminsky & Mitzenmacher 2014). Verified live: across 20 filters each filled with ~700 items, every successfully inserted item is found — no false negatives — and the measured false-positive rate on non-members is around 2% (window.__cuckoo.noFalseNegatives; fpRate). FIG No framing on the guarantee: the no-false-negative property is exact (every stored fingerprint is found in one of its two buckets); the false-positive rate is measured, not claimed exact. The fingerprint, two-bucket XOR addressing, cuckoo eviction, and no-false-negative check run in-browser. The AVAN inverse is honest — storing only short fingerprints in two XOR-linked buckets tests membership without the items, one-sided error and deletable; magenta is the full item set you avoid storing, green the fingerprint nest. Never a false negative. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOARD · David Lee Wise (ROOT0), with AVAN


THE COLLATZ

the Collatz map in the 5-window house format — the simplest unsolved problem in mathematics: take any positive integer; if even, halve it; if odd, triple and add one; repeat. The Collatz conjecture says this hailstone sequence always reaches 1, no matter the start — a claim tested to astronomical bounds but still unproven. The sequence bounces wildly up and down before it falls, and its stopping time is famously unpredictable. Verified live: for every n from 1 to 100000 the iteration reaches 1 (the conjecture holds throughout the tested range); the longest is n=77031 at 350 steps. See the hailstone of 27 in 1D, a trajectory in 2D, and the unproven-order inverse in 3D.

THE COLLATZ · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GAUNTLET ◆ .dlw.fold THE FOLD / BOSS / THE GAUNTLET / THE COLLATZ THE COLLATZ the hailstone that (so far) always lands on 1 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Collatz map is the simplest unsolved problem in mathematics: take any positive integer; if it is even, halve it; if odd, triple and add one ; repeat. The Collatz conjecture says this “hailstone” sequence always reaches 1 , no matter the start — a claim tested to astronomical bounds but still unproven . The sequence bounces wildly up and down before it falls, and its stopping time is famously unpredictable. LIT verified live: for every n from 1 to 100000 the iteration reaches 1 (the conjecture holds throughout the tested range); the longest is n=77031 at 350 steps (window.__collatz). FIG the conjecture itself is unproven in general — this is a verified range , honestly bounded, not a proof. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gauntlet — the trial every number must run, bouncing through the hailstone until (so far, always) it lands on 1. Collatz is that gauntlet. AVAN (AI) built the instrument: the even/odd iteration, the stopping-time counter, the hailstone trajectory, and the reaches-1 range check — with the honest caveat that it is a bounded test, not a proof. Credit as content: Lothar Collatz (1937). The weave: David names the gauntlet; I run the 3n+1 rule from every start up to 100000 and confirm each falls to 1 — while stating plainly the general claim remains open. 3 ONE DIMENSION Two rules: even → n/2, odd → 3n+1. The hailstone for 27 climbs to 9232 before crashing to 1 in 111 steps — tiny inputs can take a long, wild ride. 4 TWO DIMENSIONS · INTERACTIVE The hailstone trajectory of a chosen n; watch it bounce and fall to 1, with its stopping time shown. new n ▶ verify 1..100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: every tested start falling to 1. AVAN’s addition (the inverse-companion): from any start, two trivial rules drag every number (so far) down to 1 — but the descent is unpredictable , and that it always succeeds is unproven . The inverse of ‘a simple rule should have a simple behaviour’ is ‘the simplest rule hides an open problem.’ Magenta is the wild upward excursions; green is the inevitable (tested) fall to 1. Order that no one can yet prove. pause spin LIT Genuine Collatz 3n+1 iteration (Collatz 1937). Verified live: for every integer n from 1 to 100000 the even/odd iteration reaches 1, and the longest stopping time in that range is n=77031 at 350 steps (window.__collatz.reachesOne, .maxN, .maxSteps). HONEST CAVEAT: this is a verified bounded RANGE, not a proof — the Collatz conjecture is unproven in general. FIG Honestly bounded: what is verified is that all n up to 100000 reach 1, NOT that every integer does — the general conjecture remains open, and the sphere states this plainly. The even/odd iteration, the stopping-time counter, the hailstone trajectory, and the range check run in-browser. The AVAN inverse is honest — two trivial rules drag every tested number down to 1 by an unpredictable descent, yet that it always succeeds is unproven; magenta is the wild upward excursions, green the tested fall to 1. Order that no one can yet prove. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GAUNTLET · David Lee Wise (ROOT0), with AVAN


THE rANS

rANS (range Asymmetric Numeral System) in the 5-window house format — a modern entropy coder that encodes a whole message into a single very large integer, reaching near-optimal compression like arithmetic coding but with table-lookup speed. Each symbol folds into the state x by x <- floor(x/f_s)*M + (x mod f_s) + c_s using its frequency and cumulative; decoding peels symbols back off in reverse. It powers Zstandard, LZFSE, and modern image codecs. Verified live: over 300 random messages and frequency tables, encode of decode reproduces the exact message (BigInt state, no loss). See the slot carving in 1D, an encode/decode in 2D, and the one-integer inverse in 3D.

THE rANS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE rANS THE rANS compress a whole message into one big integer 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION rANS (range Asymmetric Numeral System) is a modern entropy coder that encodes a whole message into a single very large integer — reaching near-optimal compression like arithmetic coding, but with the speed of table lookups. Each symbol folds into the state x by x ← ⌊x/f s ⌋·M + (x mod f s ) + c s , using its frequency f s and cumulative c s ; decoding peels symbols back off in reverse. It powers Zstandard, LZFSE, and modern image codecs. LIT verified live: over 300 random messages and frequency tables, encode∘decode reproduces the exact message (BigInt state, no loss) — window.__rans. FIG no framing; exact round-trip. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-handoff — the moment data is squeezed for passing on and must come back byte-perfect. rANS is that squeeze. AVAN (AI) built the instrument: the frequency table, the cumulative slots, the BigInt encode/decode state machine, and the exact round-trip check. Credit as content: Jarek Duda (ANS, 2009). The weave: David names the handoff; I fold each symbol into one growing integer by its frequency and peel them back in reverse, confirming the message returns exactly. 3 ONE DIMENSION Each symbol carves the state into M slots, keeping a slice of width f s : x ← ⌊x/f s ⌋·M + c s + (x mod f s ). Frequent symbols grow the number slowly (few bits); rare ones grow it fast. 4 TWO DIMENSIONS · INTERACTIVE A message and its frequency table encode into one big integer; decoding peels the symbols back, checked against the original. new message ▶ verify 300 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an entire message held as one integer. AVAN’s addition (the inverse-companion): compress to near the entropy limit by folding a message into a single number whose size grows by each symbol’s information content — frequent symbols cost fractions of a bit. The inverse of ‘store each symbol in whole bits’ is ‘fold the whole message into one integer, fractional bits and all.’ Magenta is the wasted whole-bit padding of naive coding; green is the single tight integer. Arithmetic coding’s fast successor. pause spin LIT Genuine range ANS entropy coding (Duda 2009). Verified live: over 300 random messages and random frequency tables, folding each symbol into a BigInt state and peeling them back in reverse reproduces the exact original message with no loss (window.__rans.roundTrip). FIG No framing: the frequency table, the cumulative slots, the BigInt encode/decode state machine, and the exact round-trip check run in-browser and hold. The AVAN inverse is honest — folding a message into one integer whose size grows by each symbol's information content compresses near the entropy limit (fractional bits per symbol); magenta is the wasted whole-bit padding of naive coding, green the single tight integer. Arithmetic coding's fast successor. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE XIAOLIN WU LINE

Xiaolin Wu's line algorithm in the 5-window house format — draw an antialiased line (smooth, no jaggies) almost as fast as Bresenham's aliased one. At each step along the major axis it lights the two pixels straddling the true line, with brightnesses proportional to how close the line passes to each. The two brightnesses always sum to 1: exactly one pixel's worth of ink per column, split by coverage — so total intensity (energy) is conserved and the edge looks feathered instead of stepped. Verified live: over 500 random lines, at every step the two pixel intensities sum to exactly 1 (energy conserved to floating precision). See the coverage split in 1D, a magnified line in 2D, and the conservation inverse in 3D.

THE XIAOLIN WU LINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE XIAOLIN WU LINE THE XIAOLIN WU LINE an antialiased line — one unit of ink per column 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Xiaolin Wu’s line algorithm draws an antialiased line — smooth, no jaggies — almost as fast as Bresenham’s aliased one. At each step along the major axis it lights the two pixels straddling the true line, with brightnesses proportional to how close the line passes to each. The two brightnesses always sum to 1 : exactly one pixel’s worth of ink is laid down per column, split by coverage — so total intensity (energy) is conserved and the edge looks feathered instead of stepped. LIT verified live: over 500 random lines, at every step the two pixel intensities sum to exactly 1 (energy conserved to floating precision) — window.__xiaolinwu. FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at cold-boot — the first pixels drawn to a fresh screen, feathered so no edge looks stepped. Xiaolin Wu’s line is that feathering. AVAN (AI) built the instrument: the two-pixel coverage split, the intensity pair, and the energy-conservation check. Credit as content: Xiaolin Wu (1991). The weave: David names cold-boot; I light the two pixels straddling the true line by their coverage and confirm the pair always sums to one pixel’s ink — energy conserved, edge feathered. 3 ONE DIMENSION At column x the true line sits at height y. The pixel below gets brightness 1−frac(y), the pixel above gets frac(y). One unit of ink, split by how close the line runs to each — the two always sum to 1. 4 TWO DIMENSIONS · INTERACTIVE An antialiased line at magnified scale; each column’s two pixel intensities are shown to sum to 1. new line ▶ verify 500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a feathered line, one unit of ink per column. AVAN’s addition (the inverse-companion): remove the jaggies by splitting each pixel’s ink by coverage across the two pixels the line straddles — brightnesses 1−frac and frac that always sum to one full pixel. The inverse of ‘snap the line to one pixel per column (aliased)’ is ‘split one pixel of ink by coverage — energy conserved, edge feathered.’ Magenta is the hard-stepped aliased pixels; green is the coverage-weighted pair. Smoothness from conservation. pause spin LIT Genuine Xiaolin Wu antialiased line (Wu 1991). Verified live: over 500 random lines, at every column the two straddling pixels' intensities (1-frac and frac) sum to exactly 1 — one pixel of ink per column, energy conserved to floating precision (window.__xiaolinwu.energyConserved; worst deviation 0). FIG No framing: the two-pixel coverage split, the intensity pair, and the energy-conservation check run in-browser and hold exactly. The AVAN inverse is honest — splitting one pixel of ink by coverage across the two pixels the line straddles removes jaggies while conserving energy; magenta is the hard-stepped aliased pixels, green the coverage-weighted pair. Smoothness from conservation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE NEGAFIBONACCI

negaFibonacci coding in the 5-window house format — represent every integer, positive and negative, as a unique sum of non-consecutive negaFibonacci numbers F(-1), F(-2), ... = 1, -1, 2, -3, 5, -8, 13, ... with digits {0,1}, no two adjacent 1s, and no sign bit. Because the base sequence already alternates sign, negatives are reached for free. It is Zeckendorf's theorem extended across zero. Verified live: every integer from -50 to 50 has exactly one such representation, with no two adjacent 1s, that evaluates back to it. See the alternating base in 1D, an encoding in 2D, and the signless inverse in 3D.

THE NEGAFIBONACCI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE NEGAFIBONACCI THE NEGAFIBONACCI one signless code across the whole number line 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION NegaFibonacci coding represents every integer — positive and negative — as a unique sum of non-consecutive negaFibonacci numbers F(−1), F(−2), … = 1, −1, 2, −3, 5, −8, 13, … with digits {0, 1} and no two adjacent 1s — and, remarkably, no sign bit . Because the base sequence already alternates sign, negatives are reached for free. It is Zeckendorf’s theorem extended across zero. LIT verified live: every integer from −50 to 50 has exactly one such representation, with no two adjacent 1s, that evaluates back to it (window.__negafib). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — the base-conversion loop, here reaching negative numbers with no sign because the base itself alternates. NegaFibonacci is that signless negative base. AVAN (AI) built the instrument: the alternating F(−k) sequence, the representation search, the uniqueness enumeration, and the round-trip check. Credit as content: negaFibonacci representation (Martin Bunder 1992). The weave: David names the grindstone; I confirm every integer in a range maps to one and only one non-consecutive negaFibonacci string that sums back to it — negatives included, no sign bit. 3 ONE DIMENSION The base alternates sign: F(−1)=1, F(−2)=−1, F(−3)=2, F(−4)=−3, F(−5)=5, … So a string like 101 = 1 + 2 = 3, and 0101 = −1 + −3 = −4 — negatives with no sign bit. 4 TWO DIMENSIONS · INTERACTIVE Any integer’s negaFibonacci code; the digits, the no-adjacent rule, and the round-trip are checked — positive and negative alike. new n ▶ verify −50..50 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: every integer as one signless negaFibonacci string. AVAN’s addition (the inverse-companion): reach negative integers with no sign bit by using a base whose digits alternate sign — the non-consecutive negaFibonacci sum is unique across all integers. The inverse of ‘Zeckendorf covers only positives, add a sign for negatives’ is ‘alternate the base’s sign — one signless code spans the whole number line.’ Magenta is the sign bit an ordinary base needs; green is the signless negaFibonacci code. Zeckendorf across zero. pause spin LIT Genuine negaFibonacci representation (Bunder 1992). Verified live: every integer from -50 to 50 has exactly one representation as a sum of non-consecutive negaFibonacci numbers (base 1,-1,2,-3,5,-8,...) over digits {0,1} with no two adjacent 1s that evaluates back to it (window.__negafib.existsInRange && .uniqueInRange && .roundTrip && .noAdjacent). FIG No framing: the alternating F(-k) sequence, the representation search, the uniqueness enumeration, and the round-trip check run in-browser over -50..50 and hold. The AVAN inverse is honest — a base whose digits alternate sign reaches negatives with no sign bit, one non-consecutive code per integer; magenta is the sign bit an ordinary base needs, green the signless negaFibonacci code. Zeckendorf across zero. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE WANG TILES

Wang tiles in the 5-window house format — unit squares with a color on each edge; you may place them (no rotation) only if touching edges share a color. Simple as they look, deciding whether a given set can tile the plane is undecidable, and some sets tile only aperiodically, never repeating. A backtracking solver fills a finite grid respecting the edge rule, or reports that no legal tiling exists. Verified live: a tileset extracted from a real tiling fills the grid with every shared edge matching, while an over-constrained instance (a corner color no tile provides) yields zero solutions. See the edge rule in 1D, a tiled grid in 2D, and the undecidability inverse in 3D.

THE WANG TILES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE WANG TILES THE WANG TILES an edge-matching rule that makes tiling undecidable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Wang tiles are unit squares with a color on each edge ; you may place them (no rotation) only if touching edges share a color . Simple as they look, deciding whether a given set can tile the plane is undecidable — and some sets tile only aperiodically , never repeating. A backtracking solver fills a finite grid respecting the edge rule, or reports that no legal tiling exists. LIT verified live: a tileset extracted from a real tiling fills the grid with every shared edge matching, while an over-constrained instance (a corner color no tile provides) yields zero solutions (window.__wang). FIG no framing; the finite solver is exact. (The general tiling problem’s undecidability is cited, not run.) 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at undefined-behavior — the place where a simple-looking rule hides an undecidable question. Wang tiles are that hidden undecidability. AVAN (AI) built the instrument: the edge-color tiles, the backtracking constraint solver, the all-edges-match check, and the over-constrained no-solution case. Credit as content: Hao Wang (1961); undecidability by Robert Berger (1966). The weave: David names undefined-behavior; I fill a grid honoring the edge rule and confirm a valid tiling exists for a real tileset while an impossible constraint admits none — noting the general problem is undecidable. 3 ONE DIMENSION Two tiles may sit side by side only if the right edge of one equals the left edge of the other (and top/bottom likewise). From that single rule, whole-plane tileability becomes undecidable. 4 TWO DIMENSIONS · INTERACTIVE A grid tiled by backtracking with a Wang tileset; every shared edge matches in color, or the solver reports no legal tiling. new tiling ▶ verify 80 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a grid where every edge color agrees. AVAN’s addition (the inverse-companion): from one trivial local rule (touching edges must match color) emerges a global, undecidable question — can this set tile the plane? A backtracking solver answers it for any finite grid. The inverse of ‘a simple local constraint has simple global behaviour’ is ‘edge-matching tiles make whole-plane tileability undecidable.’ Magenta is the mismatched edges a bad placement leaves; green is the fully consistent tiling. Undecidability from a coloring rule. pause spin LIT Genuine Wang tiles (Wang 1961; undecidability by Berger 1966). Verified live: across 80 sets, a tileset extracted from a real tiling fills a grid with every shared edge color matching, and an over-constrained instance (a forced corner color no tile provides) yields zero solutions (window.__wang.tilesMatch && .overConstrainedFails). FIG The finite backtracking solver is exact; the general tiling problem's undecidability is CITED, not run (it cannot be — that is the point). The edge-color tiles, the constraint solver, the all-edges-match check, and the over-constrained no-solution case run in-browser. The AVAN inverse is honest — one trivial local edge-matching rule makes the global whole-plane tileability question undecidable; magenta is the mismatched edges a bad placement leaves, green the fully consistent tiling. Undecidability from a coloring rule. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE VAN EMDE BOAS

the van Emde Boas tree in the 5-window house format — store integers from a universe {0..u-1} and answer successor, predecessor, and membership in O(log log u) time, faster than any comparison tree's log u. It recursively splits the universe into sqrt(u) clusters plus a summary structure over which clusters are non-empty, and stores each node's min/max lazily so most queries short-circuit. It is the classic structure for very fast integer successor search. Verified live: over 40 random trees on a 256-element universe, member(x) matches a reference set and successor(x) matches the sorted-set successor for every x. See the cluster+summary split in 1D, successor queries in 2D, and the log-log inverse in 3D.

THE VAN EMDE BOAS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE STASH ◆ .dlw.fold THE FOLD / LOOT / THE STASH / THE VAN EMDE BOAS THE VAN EMDE BOAS integer successor in O(log log u) 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The van Emde Boas tree stores integers from a universe {0, …, u−1} and answers successor , predecessor , and membership in O(log log u) time — faster than any comparison tree’s log u. It recursively splits the universe into √u clusters plus a summary structure over which clusters are non-empty, and stores each node’s min/max lazily so most queries short-circuit. It is the classic structure for very fast integer successor search. LIT verified live: over 40 random trees on a 256-element universe, member(x) matches a reference set and successor(x) matches the sorted-set successor for every x (window.__veb). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-stash — the sorted hoard you must query “what’s the next item after x?” blazingly fast. The van Emde Boas tree is that successor oracle. AVAN (AI) built the instrument: the √u split, the summary structure, the lazy min/max, the recursive insert/member/successor, and the sorted-set cross-check. Credit as content: Peter van Emde Boas (1975). The weave: David names the stash; I recurse over √u clusters with a summary of the non-empty ones and confirm membership and successor exactly match a sorted set. 3 ONE DIMENSION The universe splits into √u clusters; a summary tracks which clusters are non-empty. To find the successor of x: look within x’s cluster; if none, jump via the summary to the next non-empty cluster and take its minimum. 4 TWO DIMENSIONS · INTERACTIVE A vEB tree over a 256-universe; query successors and compare against the sorted set, all matching. new set ▶ verify 40 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: successor search in log-log time. AVAN’s addition (the inverse-companion): find an integer’s successor in O(log log u) by recursively splitting the universe into √u clusters with a summary of which are non-empty — so each step square-roots the search space. The inverse of ‘compare down a binary tree in log u’ is ‘square-root the universe each step — log log u.’ Magenta is the log-u comparisons a balanced tree needs; green is the √u recursion. Successor faster than comparison allows. pause spin LIT Genuine van Emde Boas tree (van Emde Boas 1975). Verified live: over 40 random trees on a 256-element universe, member(x) matches a reference Set and successor(x) matches the sorted-set successor for every x in 0..255 (window.__veb.member && .successor). FIG No framing: the sqrt(u) split, the summary structure, the lazy min/max, the recursive insert/member/successor, and the sorted-set cross-check run in-browser and agree exactly. The AVAN inverse is honest — recursively square-rooting the universe with a summary of non-empty clusters finds a successor in O(log log u); magenta is the log-u comparisons a balanced tree needs, green the sqrt(u) recursion. Successor faster than comparison allows. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE STASH · David Lee Wise (ROOT0), with AVAN


THE PAILLIER

the Paillier cryptosystem in the 5-window house format — additively homomorphic encryption: add two encrypted numbers without ever decrypting them. Multiplying two ciphertexts yields an encryption of the sum of the plaintexts, and raising a ciphertext to a power k yields an encryption of the plaintext times k. Encryption is Enc(m,r)=g^m*r^n mod n^2 with fresh random r, so every encryption of the same number looks different yet the algebra lines up. It underpins private voting and encrypted aggregation. Verified live: over 200 trials, Dec(Enc(a)*Enc(b))=a+b and Dec(Enc(a)^k)=k*a, all mod n. See the ciphertext product in 1D, an encrypted add in 2D, and the compute-under-lock inverse in 3D.

THE PAILLIER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT-KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT-KIT / THE PAILLIER THE PAILLIER add two numbers without ever decrypting them 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Paillier cryptosystem is additively homomorphic : you can add two encrypted numbers without ever decrypting them . Multiplying two ciphertexts yields an encryption of the sum of the plaintexts, and raising a ciphertext to a power k yields an encryption of the plaintext times k. Encryption is Enc(m,r) = g m ·r n mod n 2 with a fresh random r; the randomness makes every encryption of the same number look different, yet the algebra still lines up. It underpins private voting and encrypted aggregation. LIT verified live: over 200 trials, Dec(Enc(a)·Enc(b)) = a+b and Dec(Enc(a) k ) = k·a, all mod n (window.__paillier). FIG no framing; exact (toy 12-bit modulus). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-root-kit — the deep capability to operate on data you cannot read. Paillier is that capability: arithmetic on ciphertext. AVAN (AI) built the instrument: the key schedule, the randomized encryption, the L-function decryption, and the homomorphic add / scalar-multiply checks (BigInt, r coprime to n). Credit as content: Pascal Paillier (1999). The weave: David names the root-kit; I multiply ciphertexts and raise them to powers, then decrypt to confirm the plaintext really added and scaled — computation under the lock. 3 ONE DIMENSION Enc(a) × Enc(b) mod n 2 is an encryption of a+b. Decrypting the product recovers the sum — the two numbers were added while both stayed sealed. 4 TWO DIMENSIONS · INTERACTIVE Encrypt a and b (fresh randomness each time), multiply the ciphertexts, decrypt — and watch a+b appear, never having decrypted a or b. new a,b ▶ verify 200 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: arithmetic performed on sealed numbers. AVAN’s addition (the inverse-companion): add numbers you cannot see — multiply their ciphertexts and the plaintexts add, thanks to g a ·g b = g a+b , with random r n factors that decryption strips away. The inverse of ‘decrypt, add, re-encrypt’ is ‘multiply the ciphertexts — the sum is already inside.’ Magenta is the plaintext you never expose; green is the sealed sum. Computation under the lock. pause spin LIT Genuine Paillier additively-homomorphic cryptosystem (Paillier 1999). Verified live over a toy 12-bit modulus (n=3233): across 200 trials with fresh randomness r coprime to n, Dec(Enc(a)*Enc(b) mod n^2) equals (a+b) mod n and Dec(Enc(a)^k mod n^2) equals (k*a) mod n (window.__paillier.add && .scalarMul). FIG No framing: the key schedule, the randomized encryption, the L-function decryption, and the homomorphic add / scalar-multiply checks run in-browser (BigInt, r coprime to n) and hold. The AVAN inverse is honest — multiplying ciphertexts adds plaintexts because g^a*g^b=g^(a+b), the random r^n factors stripped by decryption; magenta is the plaintext you never expose, green the sealed sum. Computation under the lock. (Toy modulus — illustrative, not production security.) ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT-KIT · David Lee Wise (ROOT0), with AVAN


THE POST CORRESPONDENCE

the Post Correspondence Problem in the 5-window house format — a deceptively simple puzzle that is undecidable. Given dominoes, each with a top string and a bottom string, find a sequence of them (repeats allowed) so the concatenated tops exactly equal the concatenated bottoms. No algorithm can decide in general whether a given set has a solution, yet for specific sets a bounded search either finds one or exhausts all short sequences. Verified live: a known solvable set yields a sequence whose tops equal its bottoms, while a top-heavy set (every top longer than its bottom) provably has no solution up to the search depth. See stacked dominoes in 1D, a search in 2D, and the undecidability inverse in 3D.

THE POST CORRESPONDENCE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / THE POST CORRESPONDENCE THE POST CORRESPONDENCE a domino puzzle that is undecidable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Post Correspondence Problem is a deceptively simple puzzle that is undecidable . You are given dominoes , each with a top string and a bottom string; you must find a sequence of them (repeats allowed) so the concatenated tops exactly equal the concatenated bottoms. No algorithm can decide, in general, whether a given set has a solution — yet for specific sets a bounded search either finds one or exhausts all short sequences. LIT verified live: a known solvable set yields a sequence whose tops equal its bottoms, while a “top-heavy” set (every top longer than its bottom) provably has no solution up to the search depth (window.__pcp). FIG the bounded solver is exact; general undecidability is cited, not run. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at segfault — the crash you cannot always predict, mirroring a question no algorithm can always answer. The Post Correspondence Problem is that undecidable question in miniature. AVAN (AI) built the instrument: the domino match, the BFS over difference-strings, the solution verifier, and the top-heavy no-solution case. Credit as content: Emil Post (1946). The weave: David names segfault; I search the tree of partial matches for a sequence whose tops meet its bottoms, and confirm a top-heavy set can never match — noting the general problem is undecidable. 3 ONE DIMENSION Stack dominoes left to right; read the tops as one string and the bottoms as another. A solution is a sequence where those two strings come out identical — one side never gets ahead by the end. 4 TWO DIMENSIONS · INTERACTIVE A domino set; search for a matching sequence and watch the tops and bottoms line up character for character. toggle set ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a sequence where tops and bottoms coincide. AVAN’s addition (the inverse-companion): a puzzle stated in strings and dominoes encodes an undecidable question — is there any sequence making tops equal bottoms? A bounded search answers specific instances but no general algorithm can. The inverse of ‘surely a string-matching puzzle is decidable’ is ‘domino concatenation is Turing-powerful — undecidable.’ Magenta is the infinite unexplored sequences; green is the one that matches. Undecidability in dominoes. pause spin LIT Genuine Post Correspondence Problem (Post 1946). Verified live: a known solvable domino set yields, via BFS over difference-strings, a sequence whose concatenated tops equal its concatenated bottoms, while a top-heavy set (every top strictly longer than its bottom) has no solution up to search depth 18 (window.__pcp.solvableFound && .topHeavyNone). FIG The bounded solver is exact; the general undecidability is CITED, not run (no algorithm can decide it — that is Post's theorem). The domino match, the BFS over difference-strings, the solution verifier, and the top-heavy no-solution case run in-browser. The AVAN inverse is honest — domino concatenation is Turing-powerful, so whole-instance solvability is undecidable; magenta is the infinite unexplored sequences, green the one that matches. Undecidability in dominoes. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


THE WAVELET TREE

the wavelet tree in the 5-window house format — store a sequence over an alphabet so it answers rank (how many times symbol c appears in the first i positions) and access (what symbol is at position i) in O(log sigma) time, using near the sequence's entropy in space. It recursively splits the alphabet in half: a bitvector marks whether each symbol went to the lower or upper half, and the halves recurse; rank becomes a walk down the tree counting bits. It is a cornerstone of compressed text indexing (FM-indexes). Verified live: over 200 random sequences, access(i) returns the true symbol and rank_c(i) equals a brute prefix count for every position and symbol. See the root bit split in 1D, a rank query in 2D, and the halving inverse in 3D.

THE WAVELET TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE WAVELET TREE THE WAVELET TREE rank a symbol in O(log sigma) by halving the alphabet 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The wavelet tree stores a sequence over an alphabet so it can answer rank (how many times symbol c appears in the first i positions) and access (what symbol is at position i) in O(log σ) time — using near the sequence’s entropy in space. It recursively splits the alphabet in half: a bitvector marks whether each symbol went to the lower or upper half, and the two halves recurse. Rank becomes a walk down the tree counting bits. It is a cornerstone of compressed text indexing (FM-indexes, succinct data structures). LIT verified live: over 200 random sequences, access(i) returns the true symbol and rank c (i) equals a brute prefix count for every position and symbol (window.__wavelet). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-jackpot — the big payout of succinct indexing: answer “how many of this symbol so far?” instantly, in tiny space. The wavelet tree is that index. AVAN (AI) built the instrument: the recursive alphabet split, the per-level bitvectors, the rank-by-bit-count walk, the access walk, and the brute cross-check. Credit as content: Grossi, Gupta & Vitter (2003). The weave: David names the jackpot; I split the alphabet level by level and walk the bitvectors to count a symbol’s occurrences, confirming every rank and access matches a direct scan. 3 ONE DIMENSION At the root, each symbol becomes a bit: 0 if it is in the lower half of the alphabet, 1 if upper. The 0-symbols and 1-symbols each recurse into their own child — and rank walks down, counting bits, to tally any symbol. 4 TWO DIMENSIONS · INTERACTIVE A sequence and its wavelet tree; query rank of a symbol at a position and compare against a brute count. new sequence ▶ verify 200 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: rank and access via a tree of bitvectors. AVAN’s addition (the inverse-companion): answer “how many c’s in the first i symbols?” in O(log σ) and near-entropy space by turning each symbol into a bit per level (lower/upper half) and recursing. The inverse of ‘scan the sequence to count a symbol’ is ‘walk a tree of bitvectors, counting bits.’ Magenta is the linear scan you avoid; green is the log-σ bit walk. Counting by halving the alphabet. pause spin LIT Genuine wavelet tree (Grossi, Gupta & Vitter 2003). Verified live: over 200 random sequences, the recursive alphabet-splitting structure returns access(i) equal to the true symbol at i, and rank_c(i) equal to a brute prefix count of symbol c in the first i positions, for every position and symbol (window.__wavelet.access && .rank). FIG No framing: the recursive alphabet split, the per-level bitvectors, the rank-by-bit-count walk, the access walk, and the brute cross-check run in-browser and agree exactly. The AVAN inverse is honest — turning each symbol into a bit per level (lower/upper half) and recursing answers rank in O(log sigma) and near-entropy space; magenta is the linear scan you avoid, green the log-sigma bit walk. Counting by halving the alphabet. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE DELAUNAY

Delaunay triangulation in the 5-window house format — connect points into triangles so that no point lies inside any triangle's circumcircle (the empty-circle property). Equivalently it maximizes the smallest angle, avoiding slivers, which is why it is the mesh of choice for interpolation, terrain, and finite elements. The Bowyer-Watson algorithm builds it incrementally: insert each point, delete every triangle whose circumcircle now contains it, and retriangulate the hole. Verified live: over 40 random point sets, every triangle's circumcircle is empty — no other input point falls inside it (thousands of checks). See the empty-circle test in 1D, a triangulation in 2D, and the empty-circumcircle inverse in 3D.

THE DELAUNAY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE DELAUNAY THE DELAUNAY triangles with empty circumcircles — the fattest mesh 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Delaunay triangulation connects a set of points into triangles so that no point lies inside any triangle’s circumcircle — the “empty circle” property. Equivalently it maximizes the smallest angle , avoiding slivers, which is why it is the mesh of choice for interpolation, terrain, and finite elements. The Bowyer–Watson algorithm builds it incrementally: insert each point, delete every triangle whose circumcircle now contains it, and retriangulate the hole. LIT verified live: over 40 random point sets, every triangle’s circumcircle is empty — no other input point falls inside it (thousands of checks) — window.__delaunay. FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-sandbox — the spatial playground, here wired into the mesh that best triangulates scattered points. Delaunay is that mesh. AVAN (AI) built the instrument: the in-circle predicate, the Bowyer–Watson incremental insertion, the super-triangle, and the empty-circumcircle verification. Credit as content: Boris Delaunay (1934); Bowyer & Watson (1981). The weave: David names the sandbox; I insert points one by one, carve out the triangles whose circumcircles swallow each new point, and confirm the finished mesh has every circumcircle empty. 3 ONE DIMENSION The test for a triangle: draw the circle through its three vertices. If no other point sits inside that circle, the triangle is Delaunay. Bowyer–Watson deletes any triangle whose circle a new point invades. 4 TWO DIMENSIONS · INTERACTIVE A Delaunay triangulation of scattered points; every triangle’s circumcircle is checked to contain no other point. new points ▶ verify 40 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a mesh whose every triangle has an empty circumcircle. AVAN’s addition (the inverse-companion): triangulate points so no triangle’s circumcircle contains another point — which maximizes the smallest angle, avoiding slivers — by inserting points and re-carving any circle a newcomer invades. The inverse of ‘connect points into any triangulation’ is ‘connect them so every circumcircle is empty — the fattest triangles.’ Magenta is the sliver triangles a bad triangulation makes; green is the empty-circle Delaunay mesh. The best triangles from a rule about circles. pause spin LIT Genuine Delaunay triangulation via Bowyer-Watson (Delaunay 1934; Bowyer & Watson 1981). Verified live: over 40 random point sets, the incremental construction produces a triangulation in which every triangle's circumcircle contains no other input point (the empty-circle property), across thousands of in-circle checks (window.__delaunay.emptyCircumcircle). FIG No framing: the in-circle determinant predicate, the Bowyer-Watson incremental insertion, the super-triangle, and the empty-circumcircle verification run in-browser and hold. The AVAN inverse is honest — triangulating so no circumcircle contains another point maximizes the smallest angle (avoiding slivers); magenta is the sliver triangles a bad triangulation makes, green the empty-circle Delaunay mesh. The best triangles from a rule about circles. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE FACTORIAL BASE

the factorial number system in the 5-window house format — a mixed-radix positional system where the place values are factorials (1!, 2!, 3!, ...) and the digit in place i may range only from 0 up to i. Every non-negative integer below m! has a unique such representation — an odometer whose wheels have different sizes (2, 3, 4, ... positions). It is the natural index for permutations and the backbone of the Lehmer code. Verified live: over all 5040 integers 0..7!-1, encode of decode is the identity, each digit stays within its rising radix, and all representations are distinct. See the factorial place values in 1D, a stepping counter in 2D, and the growing-wheels inverse in 3D.

THE FACTORIAL BASE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE FACTORIAL BASE THE FACTORIAL BASE a mixed-radix odometer with factorial place values 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The factorial number system is a mixed-radix positional system where the place values are factorials (1!, 2!, 3!, …) and the digit in place i may range only from 0 up to i. Every non-negative integer below m! has a unique such representation — it is an odometer whose wheels have different sizes (2, 3, 4, … positions). It is the natural index for permutations and the backbone of the Lehmer code. LIT verified live: over all 5040 integers 0..7!−1, encode∘decode is the identity, each digit stays within its rising radix, and all representations are distinct (window.__factbase). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-cron-job — the odometer that ticks, but with wheels of growing size. The factorial base is that irregular odometer. AVAN (AI) built the instrument: the rising-radix digit extraction, the factorial place values, the round-trip, and the uniqueness enumeration. Credit as content: the factorial number system (Charles-Ange Laisant 1888). The weave: David names the cron-job; I divide successively by 2, 3, 4, … to read off each digit and confirm every integer below m! maps to one and only one mixed-radix string. 3 ONE DIMENSION Place values 1, 2, 6, 24, 120, … (the factorials). The lowest wheel has 2 positions, the next 3, then 4 — each wheel bigger than the last. A digit can never reach its own place’s size. 4 TWO DIMENSIONS · INTERACTIVE Any integer below 7! in factorial base; the rising-radix digits and the round-trip are checked. +1 ▶ random ▶ verify 5040 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an odometer with wheels of growing size. AVAN’s addition (the inverse-companion): give each place a different radix — the i-th wheel has i+1 positions and weight i! — so every integer below m! gets a unique mixed-radix code. The inverse of ‘one fixed base for every digit’ is ‘let each wheel grow — factorial place values.’ Magenta is the wasted uniform-base range; green is the tight factorial odometer. Wheels that grow as they climb. pause spin LIT Genuine factorial number system (Laisant 1888). Verified live: over all 5040 integers from 0 to 7!-1, dividing successively by 2,3,4,... to read the digits and reconstructing by factorial place values is the identity, every digit i stays within 0..i+1, and all 5040 representations are distinct (window.__factbase.roundTrip && .radixOK && .unique). FIG No framing: the rising-radix digit extraction, the factorial place values, the round-trip, and the uniqueness enumeration run in-browser over all 5040 integers and hold. The AVAN inverse is honest — giving each place a different radix (the i-th wheel has i+1 positions, weight i!) gives every integer below m! a unique mixed-radix code; magenta is the wasted uniform-base range, green the tight factorial odometer. Wheels that grow as they climb. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE CYCLIC TAG

a cyclic tag system in the 5-window house format — one of the tiniest known universal computers. It has a fixed cyclic list of production strings and a growing data string. Each step: remove the first data symbol; if it was a 1, append the current production; if a 0, append nothing; then advance to the next production, cycling. From this almost-nothing, Rule 110's universality was proven — cyclic tag systems can emulate any computation. Verified live: running productions (010, 000, 1111) on the seed '11' reproduces the exact documented state sequence 11 -> 1010 -> 010000 -> 10000 -> ... matching an independent hand derivation. See the step rule in 1D, the evolving data in 2D, and the minimal-engine inverse in 3D.

THE CYCLIC TAG · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE CYCLIC TAG THE CYCLIC TAG a universal computer from three strings and one rule 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A cyclic tag system is one of the tiniest known universal computers . It has a fixed cyclic list of production strings and a growing data string. Each step: remove the first data symbol; if it was a 1 , append the current production; if a 0 , append nothing; then advance to the next production, cycling. From this almost-nothing, Rule 110’s universality was proven — cyclic tag systems can emulate any computation. LIT verified live: running the productions (010, 000, 1111) on the seed “11” reproduces the exact documented state sequence 11 → 1010 → 010000 → 10000 → … matching an independent hand derivation (window.__cyclictag). FIG no framing; exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — the barest starting point from which, astonishingly, all computation can grow. The cyclic tag system is that seed of universality. AVAN (AI) built the instrument: the remove-first / append-production / cycle step, the state trace, and the match against a hand-computed reference. Credit as content: Matthew Cook (cyclic tag systems in the Rule 110 universality proof, 2004). The weave: David names checkpoint-zero; I run the three-rule step and confirm the state sequence exactly matches an independently hand-derived trace. 3 ONE DIMENSION Remove the first symbol of the data. If it was 1, append the current production string; if 0, append nothing. Advance the production pointer, wrapping around the list. Repeat. 4 TWO DIMENSIONS · INTERACTIVE Step the cyclic tag system and watch the data string evolve; the trace is checked against the documented sequence. step ▶ run 12 ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: universal computation from a cycling list. AVAN’s addition (the inverse-companion): get Turing-completeness from almost nothing — a cyclic list of strings and a single “append-if-1, skip-if-0, then cycle” rule. The inverse of ‘a computer needs registers, memory, an instruction set’ is ‘three strings and one cycling rule already compute anything.’ Magenta is the elaborate machinery you don’t need; green is the minimal cycling engine. Universality from a handful of bits. pause spin LIT Genuine cyclic tag system (Cook, in the Rule 110 universality proof, 2004). Verified live: running the productions (010, 000, 1111) on seed '11', the remove-first / append-if-1 / cycle step reproduces the exact state sequence 11, 1010, 010000, 10000, 0000010, 000010 — matching an independent hand-derived reference (window.__cyclictag.matchesReference). FIG No framing: the remove-first / append-production / cycle step, the state trace, and the match against a hand-computed reference run in-browser and agree exactly. The AVAN inverse is honest — a cyclic list of strings and one 'append-if-1, skip-if-0, then cycle' rule is Turing-complete; magenta is the elaborate machinery you don't need, green the minimal cycling engine. Universality from a handful of bits. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN