THE KEITH NUMBER

Keith numbers (repfigits — 'replicating Fibonacci digits') in the 5-window house format — numbers that appear in a sequence seeded by their own digits. Take an n-digit number, start a Fibonacci-like sequence with its n digits, and let each new term be the sum of the previous n terms; if the original number turns up, it is a Keith number. 197 has digits 1,9,7; the sequence 1,9,7,17,33,57,107,197 — and there it is. They are startlingly rare: only a handful below each power of ten. Verified live: the Keith numbers up to 100000 are exactly 14,19,28,47,61,75,197,742,1104,1537,…,93993. See a self-seeded sequence in 1D, a number reappearing in 2D, and the self-genesis inverse in 3D.

THE KEITH NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE KEITH NUMBER THE KEITH NUMBER numbers that appear in their own digit-sequence 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Keith numbers (repfigits — “replicating Fibonacci digits”) are numbers that appear in a sequence seeded by their own digits . Take an n-digit number, start a Fibonacci-like sequence with its n digits, and let each new term be the sum of the previous n terms. If the original number turns up, it is a Keith number. 197 has digits 1, 9, 7; the sequence 1, 9, 7, 17, 33, 57, 107, 197 — and there it is. They are startlingly rare: only a handful below each power of ten. LIT verified live: the Keith numbers up to 100000 are exactly 14, 19, 28, 47, 61, 75, 197, 742, 1104, 1537, …, 93993 — each appearing in its own digit-seeded sequence (window.__keith). FIG no framing; exact integer sequence checks. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at genesis-block — the number seeds a sequence from its own digits, and block by block that sequence grows until the number itself reappears as a later term. Keith numbers are that self-genesis. AVAN (AI) built the instrument: the digit-seeded n-term Fibonacci sequence, the does-the-number-appear test, and the exhaustive census to 100000. Credit as content: Mike Keith (repfigit / Keith numbers, 1987). The weave: David names genesis-block; I seed a sequence with a number’s digits, sum the last n terms repeatedly, and confirm exactly which numbers reappear in the sequence they themselves began. 3 ONE DIMENSION 197 → seed 1, 9, 7; each term = sum of last 3: 17, 33, 57, 107, 197. The number reappears ⇒ Keith. 14 → 1, 4, 5, 9, 14 (sum of last 2). 4 TWO DIMENSIONS · INTERACTIVE A number’s digit-seeded sequence climbing toward it; whether it lands exactly on the number, checked. new number ▶ a Keith number ▶ census ≤100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number reappearing in its own sequence. AVAN’s addition (the inverse-companion): test a number by seeding a Fibonacci-like sequence with its own digits and asking whether the number returns as a later term. The inverse of ‘is n special by a digit formula?’ is ‘let n’s digits generate a sequence — does n reappear?’ Magenta is the number’s value; green is its self-seeded sequence landing back on it. A number that generates itself. pause spin LIT Genuine Keith numbers / repfigits (Mike Keith 1987). Verified live: an exhaustive scan to 100000 finds exactly the numbers that reappear in their own digit-seeded n-term Fibonacci sequence — {14,19,28,47,61,75,197,742,1104,1537,2208,2580,3684,4788,7385,7647,7909,31331,34285,34348,55604,62662,86935,93993} (window.__keith.allCorrect) — exact integer sequence checks. FIG No framing: the digit-seeded n-term Fibonacci sequence, the does-the-number-appear test, and the exhaustive census to 100000 run in-browser with exact integers and agree. The AVAN inverse is honest — testing a number by seeding a Fibonacci-like sequence with its own digits and asking whether it returns as a later term genuinely differs from a digit formula; magenta is the number's value, green its self-seeded sequence landing back on it. A number that generates itself. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE SOLOVAY-STRASSEN

The Solovay–Strassen test in the 5-window house format — decide primality using the Jacobi symbol (a/n), a generalization of the Legendre symbol computable by a fast quadratic-reciprocity recursion without factoring. Euler's criterion: for a prime n, a^((n−1)/2) ≡ (a/n) (mod n) for every a coprime to n; for an odd composite this fails for at least half of all bases, so a few random bases catch composites. Verified live: the Jacobi symbol equals the Legendre symbol for primes, the test matches trial division for odd n below 50000, and the composite witness fraction is always ≥ 1/2. See witnesses vs liars in 1D, a verdict in 2D, and the symbol-not-factor inverse in 3D.

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

THE SOLOVAY-STRASSEN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE SOLOVAY-STRASSEN THE SOLOVAY-STRASSEN test primality by the Jacobi symbol 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Solovay–Strassen test decides primality using the Jacobi symbol (a/n) — a generalization of the Legendre symbol computable by a fast quadratic-reciprocity recursion, without factoring n. Euler’s criterion says that for a prime n, a (n−1)/2 ≡ (a/n) (mod n) for every a coprime to n. For an odd composite , this congruence fails for at least half of all bases — so a few random bases catch composites with high probability. It was one of the first practical randomized primality tests. LIT verified live: the Jacobi symbol equals the Legendre symbol for primes; the test matches trial division for odd n below 50000; and the composite witness fraction is always ≥ 1/2 (window.__solovay). FIG no framing; exact modular arithmetic vs a trial oracle. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gatekeeper — the guard that admits n as prime only if Euler’s congruence with the Jacobi symbol holds for every tried base. AVAN (AI) built the instrument: the Jacobi-symbol recursion, the a (n−1)/2 ≡ (a/n) test, the trial-division oracle, and the ≥1/2 witness-density count. Credit as content: Robert Solovay & Volker Strassen (1977). The weave: David names the-gatekeeper; I compute the Jacobi symbol by quadratic reciprocity, check Euler’s criterion against it, and confirm the verdict matches factoring — with at least half of all bases exposing any composite. 3 ONE DIMENSION n prime ⇒ a (n−1)/2 ≡ (a/n) (mod n) for all coprime a. n composite ⇒ at least half the a break it. The Jacobi symbol (a/n) is computed by reciprocity, no factoring. 4 TWO DIMENSIONS · INTERACTIVE Test a number; see which bases witness compositeness via the Jacobi congruence, checked against trial division. new number ▶ verify <50000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: primality by the Jacobi congruence. AVAN’s addition (the inverse-companion): decide primality by whether Euler’s criterion holds with the Jacobi symbol — computable by reciprocity without factoring — since composites break it for ≥ half of all bases. The inverse of ‘factor n to test it’ is ‘check a (n−1)/2 ≡ (a/n) for a few bases — a mismatch proves composite.’ Magenta is the factorization; green is the Jacobi congruence. Compositeness by a symbol, not a factor. pause spin LIT Genuine Solovay–Strassen primality test (Robert Solovay & Volker Strassen 1977). Verified live: the Jacobi symbol (by quadratic-reciprocity recursion) equals the Legendre symbol for primes (window.__solovay.jacobiCorrect), the a^((n−1)/2)≡(a/n) test with fixed bases matches trial division for odd n FIG No framing: the Jacobi-symbol recursion, the Euler-criterion test, the trial oracle, and the ≥1/2 witness-density count run in-browser with exact modular arithmetic and agree. The AVAN inverse is honest — deciding primality by whether Euler's criterion holds with the Jacobi symbol (no factoring needed; composites break it for ≥half of bases) genuinely replaces factoring; magenta is the factorization, green the Jacobi congruence. Compositeness by a symbol, not a factor. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE NARAYANA COW

Narayana's cows sequence in the 5-window house format — from a 14th-century puzzle: a cow produces one calf a year, and each calf, from its fourth year, does the same. The herd grows by a(n) = a(n−1) + a(n−3): 1,1,1,2,3,4,6,9,13,19,28,41,… The ratio of consecutive terms converges to the supergolden ratio ψ ≈ 1.4655712 — the unique real root of x³ = x² + 1, a cousin of the golden and plastic ratios. Verified live: the recurrence holds, and a(n)/a(n−1) converges to the real root of x³−x²−1. See the sequence in 1D, growth converging in 2D, and the its-own-constant inverse in 3D.

THE NARAYANA COW · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE NARAYANA COW THE NARAYANA COW a sequence at the supergolden ratio 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Narayana’s cows sequence comes from a 14th-century puzzle: a cow produces one calf a year, and each calf, from its fourth year, does the same. The herd grows by a(n) = a(n−1) + a(n−3): 1, 1, 1, 2, 3, 4, 6, 9, 13, 19, 28, 41, … The ratio of consecutive terms converges to the supergolden ratio ψ ≈ 1.4655712 — the unique real root of x³ = x² + 1, a cousin of the golden and plastic ratios. LIT verified live: the recurrence holds, and the ratio a(n)/a(n−1) converges to the real root of x³−x²−1 (window.__narayana). FIG no framing; exact integer recurrence, ratio matched to the algebraic root. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — the herd grows from save points three years back, when each calf matures, settling toward the supergolden ratio. Narayana’s cows are that growth. AVAN (AI) built the instrument: the a(n)=a(n−1)+a(n−3) recurrence, the ratio→ψ check against x³=x²+1, and the cubic-root confirmation. Credit as content: Narayana Pandita (India, 14th century). The weave: David names checkpoint-zero; I grow the herd by the three-year maturation rule and confirm the consecutive ratio approaches the real root of x³=x²+1 — the supergolden ratio, born from cows. 3 ONE DIMENSION a(n) = a(n−1) + a(n−3): 1,1,1,2,3,4,6,9,13,19,28,41,… The ratio tends to ψ ≈ 1.4656, the root of x³ = x² + 1 (the supergolden ratio). 4 TWO DIMENSIONS · INTERACTIVE The herd growing and its ratio converging to the supergolden ratio, checked against the cubic root. grow ▶ reset verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: growth at the supergolden ratio. AVAN’s addition (the inverse-companion): grow toward yet another irrational limit — reach one and three terms back (not two, not the last-three) and the ratio settles at the supergolden ψ, root of x³=x²+1. The inverse of ‘sum the last two → φ’ is ‘add the last and the three-back → supergolden ψ.’ Magenta is the golden-ratio Fibonacci; green is the supergolden Narayana. Every reach, its own constant. pause spin LIT Genuine Narayana's cows sequence (Narayana Pandita, India, 14th century). Verified live: a(n)=a(n−1)+a(n−3) holds (window.__narayana.recurrence), the consecutive ratio converges to ψ=1.465571232… (window.__narayana.ratioToPsi), the Newton root of x³−x²−1, and ψ³=ψ²+1 is checked (cubic). FIG No framing: the a(n)=a(n−1)+a(n−3) recurrence, the ratio→ψ check against x³=x²+1, and the cubic-root confirmation run in-browser and agree. The AVAN inverse is honest — reaching one and three terms back (the three-year maturation) so the growth rate is the supergolden ψ rather than φ is a genuine different constant; magenta is the golden-ratio Fibonacci, green the supergolden Narayana. Every reach, its own constant. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE LCA

The lowest common ancestor by binary lifting in the 5-window house format — the LCA of two tree nodes is their deepest shared ancestor, where their paths to the root first meet. Binary lifting answers LCA queries in O(log n) after O(n log n) preprocessing: for each node it stores its 2^k-th ancestors. To find the LCA, lift the deeper node to the other's depth, then jump both upward in powers of two as far as possible without meeting — one step above lands on the LCA. Verified live: over hundreds of random trees and node pairs, the binary-lifting LCA equals the naive ancestor-walk LCA. See the jumps in 1D, a tree LCA in 2D, and the convergence-by-doubling inverse in 3D.

THE LCA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE LCA THE LCA the meeting point of two nodes in one leap 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The lowest common ancestor (LCA) of two nodes in a rooted tree is their deepest shared ancestor — where their paths to the root first meet. Binary lifting answers LCA queries in O(log n) after O(n log n) preprocessing: for each node it stores its 2 k -th ancestors (parent, grandparent, great-great-grandparent, …). To find the LCA, lift the deeper node to the other’s depth, then jump both upward in powers of two as far as possible without meeting — one step above lands on the LCA. LIT verified live: over hundreds of random trees and node pairs, the binary-lifting LCA equals the naive ancestor-walk LCA (window.__lca). FIG no framing; exact tree traversal comparison. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-push — two nodes push up their branches until they reach the common point they both came from; the LCA is where the pushes converge. AVAN (AI) built the instrument: the 2 k -ancestor table, the depth-equalize-then-jump query, and the match against a naive ancestor walk. Credit as content: the binary-lifting LCA (Bender–Farach-Colton and folklore of competitive programming). The weave: David names the-push; I precompute each node’s power-of-two ancestors, lift the deeper node level, then jump both upward in halving steps to just below their meeting point — confirming it matches walking the ancestors directly. 3 ONE DIMENSION Equalize depths, then jump both nodes up by 2 k while their ancestors differ (large k first). When no jump keeps them apart, one step up is the LCA — O(log n) leaps. 4 TWO DIMENSIONS · INTERACTIVE A tree with two chosen nodes and their LCA highlighted; checked against the naive ancestor walk. new tree ▶ new pair ▶ verify 500 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the meeting point found in log-many leaps. AVAN’s addition (the inverse-companion): find where two nodes’ paths meet without walking up one step at a time — precompute power-of-two ancestors and leap in halving jumps. The inverse of ‘climb parent by parent until the paths cross’ is ‘jump 2 k ancestors at a time — O(log n) leaps to the meeting point.’ Magenta is the step-by-step ancestor walk; green is the binary-lifting jumps. The convergence found by doubling. pause spin LIT Genuine binary-lifting LCA (Bender–Farach-Colton and competitive-programming folklore). Verified live: over 500 random trees and 20 queries each, the 2^k-ancestor table with depth-equalize-then-jump query returns the same node as a naive ancestor-walk LCA (window.__lca.matchesNaive). FIG No framing: the 2^k-ancestor table, the depth-equalize-then-jump query, and the match against a naive ancestor walk run in-browser and agree. The AVAN inverse is honest — finding where two nodes' paths meet by leaping power-of-two ancestors (halving jumps) genuinely replaces climbing parent by parent; magenta is the step-by-step ancestor walk, green the binary-lifting jumps. The convergence found by doubling. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE BAUM-SWEET

The Baum–Sweet sequence in the 5-window house format — a string of 0s and 1s read from the binary digits of each index: b(n)=1 if the binary of n contains no block of consecutive 0s of odd length, else 0. So b(2)=0 (binary 10 has a single 0, odd) and b(9)=1 (1001, the 00 block is even). It is an automatic sequence — generated by a finite automaton reading binary — and obeys a clean recurrence: b(2n+1)=b(n), b(4n)=b(n), b(4n+2)=0. Verified live: the recurrence generates exactly the direct definition for every n up to 100000. See the sequence in 1D, a number's 0-blocks in 2D, and the spoken-in-binary inverse in 3D.

THE BAUM-SWEET · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE BAUM-SWEET THE BAUM-SWEET a bit-pattern sequence read by 0-blocks 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Baum–Sweet sequence is a string of 0s and 1s read from the binary digits of each index: b(n) = 1 if the binary of n contains no block of consecutive 0s of odd length , else 0. So b(2)=0 (binary 10 has a single 0, odd-length), b(4)=1 (100, the 00 block is even), b(9)=1 (1001, the 00 block is even). It is an automatic sequence — generated by a finite automaton reading binary — and obeys a clean recurrence: b(2n+1)=b(n), b(4n)=b(n), b(4n+2)=0. LIT verified live: the recurrence generates exactly the direct definition (scan binary for odd-length 0-blocks) for every n up to 100000 (window.__baumsweet). FIG no framing; exact bit-pattern checks. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at off-by-one — the whole sequence turns on the parity of a run of zeros; one zero too many (odd) flips a term to 0. The Baum–Sweet sequence is that parity. AVAN (AI) built the instrument: the direct odd-0-block scanner, the b(2n+1)/b(4n)/b(4n+2) recurrence, and their exhaustive agreement. Credit as content: Leonard Baum & Melvin Sweet (1976). The weave: David names off-by-one; I read each index’s binary, mark it 1 only if every run of zeros has even length, and confirm the two-and-four recurrence reproduces exactly the same sequence — a pattern from bit-block parity. 3 ONE DIMENSION b(n)=1 iff binary of n has no odd-length run of 0s. b: 1,1,0,1,1,0,0,1,0,1,0,0,1,0,0,1,… Recurrence: b(2n+1)=b(n), b(4n)=b(n), b(4n+2)=0. 4 TWO DIMENSIONS · INTERACTIVE A number’s binary with its 0-blocks marked; b(n) shown, with the recurrence checked against the direct scan. new number ▶ verify ≤100000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a sequence read from bit-block parity. AVAN’s addition (the inverse-companion): define a 0/1 sequence not by a formula on n but by a property of n’s binary digits — are all its runs of zeros even? — computable by a tiny automaton or a two-and-four recurrence. The inverse of ‘a(n) = f(n) arithmetically’ is ‘a(n) = a predicate on the base-2 digits of n.’ Magenta is an arithmetic formula; green is the bit-pattern predicate. A sequence spoken in binary. pause spin LIT Genuine Baum–Sweet sequence (Leonard Baum & Melvin Sweet 1976). Verified live: the recurrence b(2n+1)=b(n), b(4n)=b(n), b(4n+2)=0 generates exactly the same 0/1 value as the direct definition (binary of n has no odd-length run of zeros) for every n up to 100000 (window.__baumsweet.recurrenceMatchesDirect). FIG No framing: the direct odd-0-block scanner, the b(2n+1)/b(4n)/b(4n+2) recurrence, and their exhaustive agreement run in-browser with exact bit-pattern checks. The AVAN inverse is honest — defining a 0/1 sequence by a property of n's binary digits (are all runs of zeros even?), computable by a tiny automaton, genuinely differs from an arithmetic formula; magenta is that formula, green the bit-pattern predicate. A sequence spoken in binary. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE WIEFERICH

Wieferich primes in the 5-window house format — primes so rare that only two are known. Fermat's little theorem gives 2^(p−1) ≡ 1 (mod p) for every odd prime; a Wieferich prime satisfies the far stronger congruence modulo p²: 2^(p−1) ≡ 1 (mod p²). Only 1093 and 3511 qualify below 6.7×10¹⁵ — despite vast searches, no third is known. They are tied to Fermat's Last Theorem: any first-case prime-exponent counterexample would have to be Wieferich. Verified live (exact BigInt): among all primes below 20000, exactly 1093 and 3511 satisfy 2^(p−1) ≡ 1 (mod p²). See the sharpened congruence in 1D, a prime tested in 2D, and the one-more-power inverse in 3D.

THE WIEFERICH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE VAULT ◆ .dlw.fold THE FOLD / LOOT / THE VAULT / THE WIEFERICH THE WIEFERICH the vanishingly rare Wieferich primes 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Wieferich primes are primes p so rare that only two are known. Fermat’s little theorem says 2 p−1 ≡ 1 (mod p) for every odd prime; a Wieferich prime satisfies the far stronger congruence modulo p² : 2 p−1 ≡ 1 (mod p²). Only 1093 and 3511 qualify below 6.7×10 15 — despite vast searches, no third is known. They are tied to Fermat’s Last Theorem: any prime exponent counterexample of the first case would have to be Wieferich. LIT verified live (exact BigInt): among all primes below 20000, exactly 1093 and 3511 satisfy 2 p−1 ≡ 1 (mod p²) (window.__wieferich). FIG no framing; exact big-integer modular exponentiation. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-vault — the deepest lock, holding the vanishingly rare primes that pass Fermat’s test one level stronger, modulo p². Wieferich primes are that vault. AVAN (AI) built the instrument: the BigInt 2 p−1 mod p² test and the exhaustive scan finding exactly 1093 and 3511. Credit as content: Arthur Wieferich (1909). The weave: David names the-vault; I raise 2 to the p−1 modulo p² in exact big integers and confirm that among all primes under 20000, only 1093 and 3511 land on 1 — the rarest of primes. 3 ONE DIMENSION Every odd prime: 2 p−1 ≡ 1 (mod p). Wieferich: 2 p−1 ≡ 1 (mod p²) — a much rarer coincidence. Only 1093 and 3511 are known. 4 TWO DIMENSIONS · INTERACTIVE A prime and its Fermat quotient mod p²; the two Wieferich primes stand out, checked over a range. new prime ▶ scan <20000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: primes passing Fermat one level deeper. AVAN’s addition (the inverse-companion): sharpen Fermat’s test from mod p to mod p² — asking not just that 2 p−1 leave remainder 1 modulo p, but modulo p² — and almost no prime survives. The inverse of ‘2 p−1 ≡ 1 (mod p) always’ is ‘does it hold mod p² — the vanishingly rare Wieferich condition?’ Magenta is Fermat mod p (every prime); green is Fermat mod p² (only two known). Rarity from one more power. pause spin LIT Genuine Wieferich primes (Arthur Wieferich 1909). Verified live with exact BigInt modular exponentiation: among all primes p below 20000, exactly 1093 and 3511 satisfy 2^(p−1) ≡ 1 (mod p²) (window.__wieferich.onlyKnown) — the only two Wieferich primes known anywhere (none found below 6.7×10¹⁵). FIG No framing: the BigInt 2^(p−1) mod p² test and the exhaustive scan finding exactly 1093 and 3511 run in-browser and agree. Honest scope: this confirms the two known Wieferich primes below 20000 — it does not (and cannot) settle whether infinitely many exist, an open problem. The AVAN inverse is honest — sharpening Fermat's test from mod p (every prime) to mod p² (almost none) is the genuine Wieferich condition; magenta is Fermat mod p, green Fermat mod p². Rarity from one more power. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE VAULT · David Lee Wise (ROOT0), with AVAN


THE LEONARDO

The Leonardo numbers in the 5-window house format — Fibonacci's numbers with a +1: L(0)=L(1)=1, L(n) = L(n−1) + L(n−2) + 1, running 1,1,3,5,9,15,25,41,67,109,… They connect to Fibonacci by the exact identity L(n) = 2·F(n+1) − 1. They matter in computing: Dijkstra used them for smoothsort, an in-place sort whose heap sizes are Leonardo numbers, giving adaptive O(n) behavior on nearly-sorted input. Verified live (exact BigInt): the +1 recurrence holds, and L(n) = 2·F(n+1) − 1 for n up to 90. See the sequence in 1D, the identity in 2D, and the constant-nudge inverse in 3D.

THE LEONARDO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE LEONARDO THE LEONARDO a Fibonacci-plus-one sequence 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Leonardo numbers are Fibonacci’s numbers with a +1 : L(0)=L(1)=1, L(n) = L(n−1) + L(n−2) + 1 . They run 1, 1, 3, 5, 9, 15, 25, 41, 67, 109, … and connect back to Fibonacci by the exact identity L(n) = 2·F(n+1) − 1 . They matter in computing: Edsger Dijkstra used them to build smoothsort , an in-place sort whose heap sizes are Leonardo numbers, giving it adaptive O(n) behavior on nearly-sorted input. LIT verified live (exact BigInt): the +1 recurrence holds, and L(n) = 2·F(n+1) − 1 for n up to 90 (window.__leonardo). FIG no framing; exact big-integer arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at checkpoint-zero — growth from two save points plus a constant nudge of one, the sizes Dijkstra used to shape smoothsort’s heaps. The Leonardo numbers are that growth. AVAN (AI) built the instrument: the +1 recurrence and the L(n)=2·F(n+1)−1 identity in exact big integers. Credit as content: the Leonardo numbers (Leonardo of Pisa lineage; used by Edsger Dijkstra in smoothsort, 1981). The weave: David names checkpoint-zero; I grow the sequence by adding the last two and one more, and confirm it equals twice the next Fibonacci minus one — Fibonacci’s close relative, shaped for sorting. 3 ONE DIMENSION L(n) = L(n−1) + L(n−2) + 1: 1,1,3,5,9,15,25,41,67,… Identity L(n) = 2·F(n+1) − 1 (F Fibonacci). Smoothsort’s heaps have exactly these sizes. 4 TWO DIMENSIONS · INTERACTIVE The sequence beside twice-Fibonacci-minus-one; the recurrence and identity checked term by term. shift window ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: Fibonacci nudged by one. AVAN’s addition (the inverse-companion): add a constant +1 to the Fibonacci rule and get a new sequence tied to it by L(n)=2·F(n+1)−1 — the sizes that make smoothsort’s heaps. The inverse of ‘sum the last two (Fibonacci)’ is ‘sum the last two plus one (Leonardo).’ Magenta is the plain Fibonacci; green is the +1 Leonardo. A constant nudge, a new sequence. pause spin LIT Genuine Leonardo numbers (Leonardo of Pisa lineage; used by Edsger Dijkstra in smoothsort, 1981). Verified live with exact BigInt arithmetic: L(n)=L(n−1)+L(n−2)+1 (window.__leonardo.recurrence) and the identity L(n)=2·F(n+1)−1 with F the Fibonacci numbers (window.__leonardo.identity), for n up to 90. FIG No framing: the +1 recurrence and the L(n)=2·F(n+1)−1 identity run in-browser in exact big integers and agree. The AVAN inverse is honest — adding a constant +1 to the Fibonacci rule produces a new sequence tied to it by L(n)=2·F(n+1)−1 (the sizes smoothsort's heaps use); magenta is the plain Fibonacci, green the +1 Leonardo. A constant nudge, a new sequence. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE VAMPIRE NUMBER

Vampire numbers in the 5-window house format — numbers that hide a factorization inside their own digits. A number with 2k digits is a vampire if it equals the product of two k-digit 'fangs' that together use exactly the original digits, in some order, and the fangs aren't both multiples of ten. The smallest: 1260 = 21 × 60 (digits 1,2,6,0 rearranged); also 1395 = 15 × 93, 1435 = 35 × 41. The number wears the very digits of its factors. Verified live: the four-digit vampire numbers are exactly 1260, 1395, 1435, 1530, 1827, 2187, 6880. See the fang split in 1D, a candidate checked in 2D, and the digit-preserving-factor inverse in 3D.

THE VAMPIRE NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE VAMPIRE NUMBER THE VAMPIRE NUMBER numbers that factor into fangs from their own digits 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Vampire numbers hide a factorization inside their own digits. A number with an even count of 2k digits is a vampire if it equals the product of two k-digit “fangs” that together use exactly the original digits , in some order — and the fangs aren’t both multiples of ten. The smallest: 1260 = 21 × 60 (digits 1,2,6,0 rearranged). Also 1395 = 15 × 93, 1435 = 35 × 41. The number wears the very digits of its factors. LIT verified live: the four-digit vampire numbers are exactly 1260, 1395, 1435, 1530, 1827, 2187, 6880 — each factoring into two two-digit fangs that permute its digits (window.__vampire). FIG no framing; exact digit-multiset and factor checks. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at heisenbug — a number that looks ordinary until you split it just so, and its factors are hiding in its own digits, appearing only under the right decomposition. Vampire numbers are that hidden bite. AVAN (AI) built the instrument: the fang search (divisors of the right digit-length), the not-both-trailing-zero rule, the digit-permutation test, and the exhaustive four-digit census. Credit as content: vampire numbers (Clifford Pickover, 1994). The weave: David names heisenbug; I look for two half-length factors whose digits, combined, are a rearrangement of the number’s own, and enumerate exactly the four-digit vampires — factors dressed in the number’s digits. 3 ONE DIMENSION 1260 = 21 × 60 (digits {1,2,6,0} = {2,1} ∪ {6,0}). 1395 = 15 × 93. Two half-length fangs whose digits permute the whole — not both ending in 0. 4 TWO DIMENSIONS · INTERACTIVE A number and its candidate fangs; whether the digits match, and the four-digit census checked. new number ▶ a vampire ▶ census ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number wearing its factors’ digits. AVAN’s addition (the inverse-companion): find numbers whose factorization is encoded in their own digits — two half-length fangs whose digits, pooled, are a permutation of the number. The inverse of ‘factor n into any two parts’ is ‘factor n into two fangs that reuse exactly n’s digits.’ Magenta is an ordinary factorization; green is the digit-preserving fang split. Factors hidden in the digits. pause spin LIT Genuine vampire numbers (Clifford Pickover 1994). Verified live: an exhaustive scan of 1000..9999 finds exactly the numbers equal to a product of two two-digit fangs whose combined digits are a permutation of the number's, with the not-both-trailing-zero rule — {1260, 1395, 1435, 1530, 1827, 2187, 6880} (window.__vampire.census). FIG No framing: the fang search (divisors of the right digit-length), the not-both-trailing-zero rule, the digit-permutation test, and the exhaustive four-digit census run in-browser with exact digit-multiset and factor checks. The AVAN inverse is honest — finding numbers whose factorization is encoded in their own digits (two half-length fangs that reuse exactly the number's digits) genuinely differs from an ordinary factorization; magenta is that ordinary factorization, green the digit-preserving fang split. Factors hidden in the digits. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE DE BOOR

De Boor's algorithm in the 5-window house format — evaluate a B-spline curve at a parameter t by repeated linear interpolation, the B-spline analogue of de Casteljau for Béziers. Given control points and a knot vector, it finds the active knot span, takes the handful of control points influencing t, and blends them in successive rounds of interpolation (weights from the knots) until one point remains: the curve at t. It is numerically stable and needs no explicit basis functions. Verified live: over 1000 random B-splines and parameters, de Boor's result equals the direct Cox–de Boor basis-function sum Σ N_i,p(t)·P_i. See the blend in 1D, a curve in 2D, and the corner-cutting inverse in 3D.

THE DE BOOR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE DE BOOR THE DE BOOR evaluate a B-spline by nested interpolation 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION De Boor’s algorithm evaluates a B-spline curve at a parameter t by repeated linear interpolation — the B-spline analogue of de Casteljau for Béziers. Given control points and a knot vector, it finds the active knot span , takes the handful of control points that influence t, and blends them in successive rounds of interpolation (the blend weights come from the knots) until a single point remains: the curve at t. It is numerically stable and needs no explicit basis functions. LIT verified live: over 1000 random B-splines and parameters, de Boor’s result equals the direct Cox–de Boor basis-function sum Σ N i,p (t)·P i (window.__deboor, worst ~1e-14). FIG no framing; exact agreement of two evaluations. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at first-light — the first smooth curve a scene draws; de Boor blends the control points into the point on the B-spline, frame by frame. AVAN (AI) built the instrument: the knot-span finder, the nested de Boor interpolation, the Cox–de Boor basis sum, and their agreement check. Credit as content: Carl de Boor (1972). The weave: David names first-light; I evaluate the B-spline by blending the influencing control points through rounds of knot-weighted interpolation, and confirm the result matches summing the basis functions directly — the same curve, two ways. 3 ONE DIMENSION Find the span containing t; take p+1 control points; blend adjacent pairs by knot-weighted interpolation, round after round, until one point remains — the curve C(t). 4 TWO DIMENSIONS · INTERACTIVE Control points and the B-spline curve de Boor traces; a point at t checked against the basis-function sum. new spline ▶ verify 1000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a curve from nested interpolation. AVAN’s addition (the inverse-companion): evaluate a spline by repeatedly interpolating control points , not by summing basis functions — only the few points near t matter, blended by knot-weights until one remains. The inverse of ‘compute every N i,p (t) and sum P i ’ is ‘blend the local control points in rounds — the last point is the curve.’ Magenta is the basis-function sum; green is the nested interpolation. A curve by corner-cutting. pause spin LIT Genuine de Boor's algorithm (Carl de Boor 1972). Verified live: over 1000 random B-splines (random degree 1–3, control points, clamped uniform knot vectors) and parameters, the nested knot-weighted de Boor interpolation equals the direct Cox–de Boor basis-function sum Σ N_i,p(t)·P_i (window.__deboor.matchesBasis, worst ~1e-14). FIG No framing: the knot-span finder, the nested de Boor interpolation, the Cox–de Boor basis sum, and their agreement check run in-browser and agree to floating precision. The AVAN inverse is honest — evaluating a spline by repeatedly interpolating only the local control points (blended by knot-weights) genuinely replaces computing every basis function and summing; magenta is the basis-function sum, green the nested interpolation. A curve by corner-cutting. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE MERTENS

The Mertens function in the 5-window house format — the running sum of the Möbius function: M(n) = μ(1)+μ(2)+…+μ(n), where μ(k) is +1, −1, or 0 by the parity and squarefreeness of k's prime factorization. It jitters around zero. The famous Mertens conjecture claimed |M(n)| < √n for all n — it holds for every n anyone can compute, yet Odlyzko and te Riele proved it FALSE for some enormous n. A conjecture true as far as the eye can see, but ultimately wrong. Verified live: the μ sieve matches direct factorization, and |M(n)| < √n holds for every n from 2 to 10000. See μ and M in 1D, M vs ±√n in 2D, and the evidence-is-not-proof inverse in 3D.

THE MERTENS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE MERTENS THE MERTENS a conjecture that holds then fails 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Mertens function M(n) is the running sum of the Möbius function : M(n) = μ(1) + μ(2) + … + μ(n), where μ(k) is +1, −1, or 0 by the parity and squarefreeness of k’s prime factorization. It jitters around zero. The famous Mertens conjecture claimed |M(n)| < √n for all n — it holds for every n anyone can compute, yet Odlyzko and te Riele proved it false for some enormous n. A conjecture true as far as the eye can see, but ultimately wrong. LIT verified live: the μ sieve matches direct factorization, and |M(n)| < √n holds for every n from 2 to 10000 (window.__mertens). FIG honest: the bound holds in this range but is known to fail for some vast n — the conjecture is false, not merely open. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at undefined-behavior — the spec’s dark corner; the Mertens bound looks ironclad for every n you can reach, then fails somewhere unimaginably far out. AVAN (AI) built the instrument: the linear-sieve Möbius, the running Mertens sum, the direct-factorization cross-check, and the |M(n)|<√n test over the honest range. Credit as content: Franz Mertens (conjecture, 1897); disproved by Andrew Odlyzko & Herman te Riele (1985). The weave: David names undefined-behavior; I sum the Möbius function, confirm it against factorization, and check the √n bound holds through 10000 — while flagging plainly that the conjecture is false for some colossal n. 3 ONE DIMENSION μ(n): +1 (even # of distinct primes, squarefree), −1 (odd #), 0 (a square factor). M(n)=Σμ jitters near 0. |M(n)| < √n holds here — but is false for some gigantic n. 4 TWO DIMENSIONS · INTERACTIVE M(n) plotted against ±√n; the Möbius cross-check and the bound over the range. zoom range ▶ verify ≤10000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a running sum bounded — until it isn’t. AVAN’s addition (the inverse-companion): study primality through the summed Möbius function and its growth — a bound that appears to hold forever can still be false beyond all reach. The inverse of ‘a pattern true for every computed n is true’ is ‘a conjecture can hold to 10 huge and still fail.’ Magenta is “true as far as tested”; green is the Mertens sum that eventually breaks the bound. Evidence is not proof. pause spin LIT Genuine Mertens function and conjecture (Franz Mertens 1897; disproved by Andrew Odlyzko & Herman te Riele 1985). Verified live: the linear-sieve Möbius function matches direct factorization for n≤2000 (window.__mertens.muMatchesDirect), and the running sum M(n) satisfies |M(n)| FIG Honestly scoped: the bound |M(n)| ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE SPARSE SET

The sparse set in the 5-window house format — store a set of small integers with O(1) insert, remove, and membership, needing no array initialization. It keeps two arrays: dense, a packed list of members, and sparse, indexed by value, pointing back into dense. Membership is a double-lookup: x is present iff sparse[x] points to a slot in dense that holds x. Because both directions must agree, uninitialized garbage in sparse can never falsely report membership, and iteration is just walking dense. Verified live: over hundreds of random insert/remove/query sequences, the sparse set's membership and dense contents exactly match a reference set. See the double-index in 1D, the arrays in 2D, and the self-validating inverse in 3D.

THE SPARSE SET · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE SPARSE SET THE SPARSE SET a set with no array to initialize 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The sparse set stores a set of small integers with O(1) insert, remove, and membership — and, remarkably, needs no array initialization . It keeps two arrays: dense , a packed list of the members, and sparse , indexed by value, pointing back into dense. Membership is a double-lookup: x is present iff sparse[x] points to a slot in dense that holds x. Because both directions must agree, uninitialized garbage in sparse can never falsely report membership. Iteration is just walking dense. LIT verified live: over hundreds of random insert/remove/query sequences, the sparse set’s membership and its dense contents exactly match a reference set (window.__sparseset). FIG no framing; exact set comparison. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-inventory — hold what you’ve earned with instant add, drop, and lookup, and a members list you can iterate without scanning. The sparse set is that inventory. AVAN (AI) built the instrument: the dense/sparse double-index, the swap-with-last removal, the double-lookup membership, and the match against a reference set. Credit as content: the sparse set (Briggs & Torczon, “An efficient representation for sparse sets,” 1993). The weave: David names the-inventory; I keep a packed dense list and a sparse back-index, add by appending, remove by swapping with the last, and test membership by the two-way agreement — confirming it tracks a reference set exactly. 3 ONE DIMENSION dense = packed members. sparse[x] = x’s slot in dense. Present iff dense[sparse[x]] == x — both must agree, so garbage can’t lie. Remove: swap x with the last member, shrink. 4 TWO DIMENSIONS · INTERACTIVE The dense and sparse arrays as you add and remove; membership by the double-lookup, checked against a set. add ▶ remove ▶ verify 400 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a set with instant ops and no init. AVAN’s addition (the inverse-companion): make a set’s membership self-validating by a two-way index — dense points to values, sparse points back — so uninitialized memory can never falsely claim membership, and no clearing is needed. The inverse of ‘zero a big boolean array to use it’ is ‘keep a packed list plus a back-index that must agree.’ Magenta is the initialized bitset; green is the self-checking sparse set. Membership that validates itself. pause spin LIT Genuine sparse set (Briggs & Torczon, 'An efficient representation for sparse sets,' 1993). Verified live: over 400 random insert/remove/query sequences, the dense/sparse double-index (add by appending, remove by swap-with-last, membership by two-way agreement) matches a reference set both in membership over the whole universe and in its dense contents (window.__sparseset.matchesReference). FIG No framing: the dense/sparse double-index, the swap-with-last removal, the double-lookup membership, and the match against a reference set run in-browser with exact set comparison and agree. The AVAN inverse is honest — making membership self-validating by a two-way index (dense↔sparse must agree) so uninitialized memory can never falsely claim membership and no clearing is needed genuinely differs from a zeroed bitset; magenta is that initialized bitset, green the self-checking sparse set. Membership that validates itself. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE WOLSTENHOLME

Wolstenholme's theorem in the 5-window house format — for every prime p ≥ 5, the central binomial coefficient satisfies C(2p, p) ≡ 2 (mod p³). Ordinary primality only forces this modulo p; Wolstenholme lifts it two full powers higher, to p-cubed, and only for primes five and up (it fails for 2 and 3). Equivalently, the numerator of 1 + 1/2 + … + 1/(p−1) is divisible by p². Verified live with exact BigInt: C(2p,p) ≡ 2 (mod p³) for every prime 5..101, while p=3 gives residue 18. See the congruence in 1D, a prime checked in 2D, and the depth-of-a-congruence inverse in 3D.

THE WOLSTENHOLME · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE WOLSTENHOLME THE WOLSTENHOLME a binomial congruence mod p-cubed for primes five and up 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Wolstenholme’s theorem is a startlingly strong congruence: for every prime p ≥ 5 , the central binomial coefficient satisfies C(2p, p) ≡ 2 (mod p 3 ) . Ordinary primes only guarantee this modulo p (that’s in every binomial-mod-prime fact); Wolstenholme lifts it two whole powers higher, to p-cubed. It fails for p = 2 and p = 3, so five is the true floor. Equivalently, the numerator of the harmonic sum 1 + 1/2 + … + 1/(p−1) is divisible by p 2 . It is a cornerstone of p-adic combinatorics. LIT verified live (exact BigInt): C(2p,p) ≡ 2 (mod p 3 ) for every prime p from 5 to 101, and p = 3 gives residue 18, not 2 — so the p≥5 floor is real (window.__wolstenholme). FIG no framing; exact big-integer modular arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-final-boss — the ordinary fact (binomial mod p) is the henchman; Wolstenholme is the boss behind it, the same coefficient pinned two powers deeper, mod p-cubed, and only for primes five and up. AVAN (AI) built the instrument: the exact central-binomial in big integers, the mod-p 3 reduction, the sweep over primes 5..101, and the p=3 counterexample. Credit as content: Joseph Wolstenholme (1862). The weave: David names the-final-boss; I compute C(2p,p) exactly, reduce it modulo p-cubed, and confirm it equals 2 for every prime from 5 to 101 while 3 falls short — a congruence far stronger than primality alone requires. 3 ONE DIMENSION C(10,5) = 252 ≡ 2 (mod 5 3 =125): 252 − 2 = 250 = 2·125. C(14,7) = 3432 ≡ 2 (mod 343). But C(6,3) = 20 ≡ 18 (mod 27) — p=3 fails, so p ≥ 5. 4 TWO DIMENSIONS · INTERACTIVE A prime p, its C(2p,p) and the residue mod p-cubed; the sweep over primes 5..101 checked. next prime ▶ verify 5..101 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a congruence pinned two powers deep. AVAN’s addition (the inverse-companion): take the weak fact ‘C(2p,p) ≡ 2 (mod p)’ and ask how deep it really holds — the answer is mod p 3 , for primes five and up. The inverse of ‘a congruence holds mod p’ is ‘how many powers of p does it truly survive.’ Magenta is the shallow mod-p fact; green is the deep mod-p 3 Wolstenholme congruence. Strength measured in powers of p. pause spin LIT Genuine Wolstenholme's theorem (Joseph Wolstenholme, 1862). Verified live with exact big-integer arithmetic: the central binomial coefficient C(2p,p) reduced modulo p³ equals 2 for every prime p from 5 to 101 (window.__wolstenholme.holds), and p=3 yields residue 18 (window.__wolstenholme.p3fails), confirming the p≥5 floor is genuine. FIG No framing: C(2p,p) is computed exactly in big integers, reduced mod p-cubed, and equals 2 across all primes 5..101, with p=3 falling short — all in-browser. The AVAN inverse is honest — asking how many powers of p a congruence survives (the answer: p³ for Wolstenholme, versus only p for ordinary primality) is a real strengthening; magenta is the shallow mod-p fact, green the deep mod-p³ congruence. Strength measured in powers of p. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE WEIRD NUMBER

Weird numbers in the 5-window house format — a number is abundant when its proper divisors sum to more than itself, and semiperfect when some subset of those divisors sums to exactly itself. A weird number is abundant but NOT semiperfect: it overflows, yet no combination of its parts reconstructs it. The smallest is 70 (divisors 1,2,5,7,10,14,35 sum to 74 > 70, but no subset totals 70). They are scarce — only sixteen below 13000. Verified live: an exhaustive scan (abundance test, then a subset-sum DP) finds exactly 70, 836, 4030, 5830, …, 12670. See the definition in 1D, a number tested in 2D, and the excess-without-expressibility inverse in 3D.

THE WEIRD NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · DIVIDE BY ZERO ◆ .dlw.fold THE FOLD / GLITCH / DIVIDE BY ZERO / THE WEIRD NUMBER THE WEIRD NUMBER abundant numbers no subset of divisors can total 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Weird numbers are a rare pathology of divisors. A number is abundant when its proper divisors sum to more than itself, and semiperfect when some subset of those divisors sums to exactly itself. A weird number is abundant but not semiperfect — it overflows, yet no combination of its parts can reconstruct it. The smallest is 70 : divisors 1, 2, 5, 7, 10, 14, 35 sum to 74 (> 70), but no subset totals 70. They are surprisingly scarce: 70, 836, 4030, 5830, … LIT verified live: an exhaustive scan (each candidate tested for abundance, then a subset-sum check for semiperfectness) finds exactly 70, 836, 4030, 5830, 7192, 7912, 9272, 10430, 10570, 10792, 10990, 11410, 11690, 12110, 12530, 12670 below 13000 (window.__weird). FIG no framing; exact divisor sums and subset-sum DP. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at divide-by-zero — the pathological corner: a number whose divisors overflow it, yet refuse to add back up to it in any combination. That refusal is the weirdness. AVAN (AI) built the instrument: the proper-divisor sum, the abundance test, the subset-sum dynamic program for semiperfectness, and the exhaustive census. Credit as content: weird numbers (Stan Benkoski, 1972; studied by Benkoski & Erdős). The weave: David names divide-by-zero; I sum each number’s proper divisors, keep the abundant ones, then run a subset-sum to ask whether any combination equals the number — the ones that say no are weird. 3 ONE DIMENSION 70: divisors {1,2,5,7,10,14,35} sum 74 > 70 (abundant). No subset sums to 70 (not semiperfect) ⇒ weird. Compare 12 = 1+2+3+6 (semiperfect, not weird). 4 TWO DIMENSIONS · INTERACTIVE A number, its divisor sum, and whether a subset reaches it; the census below 13000 checked. new number ▶ a weird one ▶ census ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: parts that overflow but never reassemble. AVAN’s addition (the inverse-companion): among abundant numbers, isolate the ones where no subset of divisors reconstructs the whole — excess without expressibility. The inverse of ‘abundant means the parts are more than enough’ is ‘but can any combination of them actually total the number?’ Magenta is a semiperfect abundant number (a subset works); green is the weird number (none does). Enough parts, no valid sum. pause spin LIT Genuine weird numbers (Stan Benkoski, 1972; studied with Paul Erdős). Verified live: each candidate's proper divisors are summed for abundance, then a subset-sum dynamic program tests semiperfectness; the abundant-but-not-semiperfect numbers below 13000 are exactly {70, 836, 4030, 5830, 7192, 7912, 9272, 10430, 10570, 10792, 10990, 11410, 11690, 12110, 12530, 12670} (window.__weird.census). FIG No framing: the proper-divisor sum, the abundance test, and the subset-sum DP for semiperfectness run in-browser with exact integer arithmetic. The AVAN inverse is honest — isolating abundant numbers where no subset of divisors reconstructs the whole is a real distinction (excess without expressibility); magenta is a semiperfect abundant number (a subset works), green the weird number (none does). Enough parts, no valid sum. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of DIVIDE BY ZERO · David Lee Wise (ROOT0), with AVAN


THE SMITH NUMBER

Smith numbers in the 5-window house format — a composite whose digit sum equals the sum of the digits of all its prime factors (with multiplicity). The smallest is 4 = 2×2 (digitsum 4 = 2+2). Also 22 = 2×11 (4 = 2+1+1), 27 = 3³ (9 = 3+3+3), 58 = 2×29 (13 = 2+2+9). Primes are excluded (they would match trivially). Named after Harold Smith, whose phone number 4937775 is one. Verified live: an exhaustive scan (factor each composite, compare digit sums) reproduces the known fifty Smith numbers below 1100. See the coincidence in 1D, a number factored in 2D, and the digits-of-the-factors inverse in 3D.

THE SMITH NUMBER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE BOUNTY ◆ .dlw.fold THE FOLD / LOOT / THE BOUNTY / THE SMITH NUMBER THE SMITH NUMBER numbers whose digit sum equals their factors' 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Smith numbers are composites with a digit coincidence: the sum of the number’s own digits equals the sum of the digits of all its prime factors , counted with multiplicity. The smallest is 4 = 2×2 : digit sum of 4 is 4, and 2 + 2 = 4. Also 22 = 2×11 (2+2 = 2+1+1 = 4), 27 = 3 3 (9 = 3+3+3), 58 = 2×29 (13 = 2+2+9). Primes are excluded by definition (they would trivially match). Named after Harold Smith, whose phone number 493-7775 is one. LIT verified live: an exhaustive scan (factor each composite, compare digit sums) reproduces the known census 4, 22, 27, 58, 85, 94, 121, … below 1100 — fifty Smith numbers (window.__smith). FIG no framing; exact factorization and digit sums. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-bounty — a found curio: a composite whose digits secretly sum to the very same total as the digits of its prime factors. That coincidence is the bounty. AVAN (AI) built the instrument: the digit-sum, the trial-division factorization with multiplicity, the composite filter, and the exhaustive census. Credit as content: Smith numbers (Albert Wilansky, 1982, named for his brother-in-law Harold Smith). The weave: David names the-bounty; I add up a number’s digits, then add up the digits of every prime in its factorization, and collect the composites where the two totals coincide. 3 ONE DIMENSION 4 = 2×2: digitsum(4)=4, 2+2=4 ✓. 58 = 2×29: digitsum(58)=13, digitsum(2)+digitsum(29)=2+2+9=13 ✓. 27 = 3 3 : 9 = 3+3+3 ✓. 4 TWO DIMENSIONS · INTERACTIVE A number’s factorization, its two digit sums side by side; the census below 1100 checked. new number ▶ a Smith ▶ census ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number whose digits echo its factors’. AVAN’s addition (the inverse-companion): instead of adding a number’s digits, add the digits of its prime factorization — and collect the composites where the two sums agree. The inverse of ‘read the digits of n’ is ‘read the digits of what n is made of.’ Magenta is the number’s digit sum; green is its factors’ digit sum. When they meet, a Smith number. pause spin LIT Genuine Smith numbers (Albert Wilansky, 1982, named for his brother-in-law Harold Smith). Verified live: each composite is factored by trial division with multiplicity, its digit sum compared to the summed digit sums of its prime factors; the Smith numbers below 1100 reproduce the known census of fifty {4, 22, 27, 58, 85, 94, 121, …, 1086} (window.__smith.census). FIG No framing: the digit-sum, the trial-division factorization with multiplicity, the composite filter, and the census all run in-browser with exact arithmetic. The AVAN inverse is honest — summing the digits of a number's prime factorization (rather than the number itself) and collecting the composites where the two agree is a genuine construction; magenta is the number's digit sum, green its factors' digit sum. When they meet, a Smith number. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BOUNTY · David Lee Wise (ROOT0), with AVAN


THE HULL–DOBELL

The Hull–Dobell theorem in the 5-window house format — exactly when a linear congruential generator x → (a·x + c) mod m visits every residue before repeating (full period m, from any seed). The three conditions: (1) gcd(c, m) = 1; (2) a − 1 is divisible by every prime factor of m; (3) if 4 divides m, then 4 divides a − 1. Meet all three and the generator permutes all m residues; miss one and it stalls into a short cycle. Verified live: for every LCG with modulus m ≤ 60 and all (a, c), the theorem's full-period prediction matches the actually measured cycle length. See the conditions in 1D, an orbit drawn in 2D, and the predict-vs-measure inverse in 3D.

THE HULL–DOBELL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT KIT / THE HULL–DOBELL THE HULL–DOBELL when a linear congruential generator hits full period 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hull–Dobell theorem tells you exactly when a linear congruential generator x → (a·x + c) mod m visits every residue before repeating — a full period of length m, from any seed. The three conditions: (1) c and m are coprime; (2) a − 1 is divisible by every prime factor of m; (3) if 4 divides m, then 4 divides a − 1. Meet all three and the generator is a permutation of all m residues; miss any one and it stalls into a short cycle. It is the theorem behind every well-tuned LCG. LIT verified live: for every LCG with modulus m up to 60 and all (a, c), the theorem’s prediction of full period matches the actually measured cycle length — full iff the three conditions hold (window.__hulldobell). FIG no framing; predicted vs directly simulated periods. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-root-kit — the hidden recipe: three arithmetic conditions that secretly decide whether a generator sweeps all of memory or loops in a rut. Know them and you own the period. AVAN (AI) built the instrument: the three-condition predictor, the direct cycle-length measurement, and their exhaustive agreement over all small LCGs. Credit as content: Thomas Hull & Alexander Dobell (1962). The weave: David names the-root-kit; I check the coprime, prime-factor, and mod-4 conditions, then actually run each generator to measure its cycle, and confirm ‘predicted full period’ matches ‘measured full period’ for every small case. 3 ONE DIMENSION m=16: a=5, c=1 ⇒ a−1=4 divisible by 2 (only prime of 16) and by 4 ✓, gcd(1,16)=1 ✓ ⇒ full period 16. a=3, c=1 ⇒ a−1=2 not divisible by 4 ⇒ short cycle. 4 TWO DIMENSIONS · INTERACTIVE The orbit of an LCG drawn as a ring; the three conditions and the measured period; the full sweep checked. new a,c,m ▶ a full-period one ▶ verify all m≤60 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an orbit that touches every residue. AVAN’s addition (the inverse-companion): instead of running a generator to see its period, read three arithmetic conditions that predict whether it is full — coprimality, prime-factor divisibility, the mod-4 rule. The inverse of ‘simulate and measure the cycle’ is ‘decide the cycle from a, c, m alone.’ Magenta is a stalled short cycle (a condition fails); green is the full-period orbit (all three hold). The period, foretold. pause spin LIT Genuine Hull–Dobell theorem (Thomas Hull & Alexander Dobell, 1962). Verified live: for every modulus m from 2 to 60 and all multipliers a and increments c, the three-condition full-period predictor is compared against the directly simulated cycle length, and 'predicted full' matches 'measured full period m' in every case (window.__hulldobell.matches). FIG No framing: the coprimality, prime-factor, and mod-4 conditions are checked, each generator is actually run to measure its cycle, and predictions match measurements exhaustively for m ≤ 60 — all in-browser. The AVAN inverse is honest — deciding a generator's period from a, c, m by three arithmetic conditions genuinely replaces running it to see; magenta is a stalled short cycle (a condition fails), green the full-period orbit (all three hold). The period, foretold. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT KIT · David Lee Wise (ROOT0), with AVAN


THE EKG SEQUENCE

The EKG sequence in the 5-window house format — start 1, 2, and each next term is the smallest positive integer not yet used that shares a common factor with the previous term. It runs 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15, … Its plot looks like a heartbeat trace. It is conjectured (and largely proven) to be a permutation of all positive integers, and a proven structural fact holds: every prime p first appears immediately after 2p and is immediately followed by 3p. Verified live: over 3000 terms, consecutive terms always share a factor > 1, all are distinct, every integer 1..1000 appears, and each interior prime p sits between 2p and 3p. See the walk in 1D, the heartbeat in 2D, and the reordered-by-factors inverse in 3D.

THE EKG SEQUENCE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · SECOND WIND ◆ .dlw.fold THE FOLD / RESPAWN / SECOND WIND / THE EKG SEQUENCE THE EKG SEQUENCE a sequence walking by shared factors 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The EKG sequence (its plot looks like a heartbeat trace) grows by a single greedy rule: start 1, 2, and each next term is the smallest positive integer not yet used that shares a common factor with the previous term. It runs 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15, … It is conjectured (and largely proven) to be a permutation of all positive integers — every number appears exactly once. A proven structural fact: every prime p first appears immediately after 2p , and is immediately followed by 3p . LIT verified live: over the first 3000 terms, consecutive terms always share a factor > 1, all terms are distinct, every integer 1..1000 appears, and each interior prime p is preceded by 2p and followed by 3p (window.__ekg). FIG honest: full permutation is proven in the literature; here the defining rule and the 2p/3p structure are checked over a finite prefix. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at second-wind — each step revives the smallest number left unspent that still shares a factor with where you are; the sequence keeps finding a way onward. That revival is the second wind. AVAN (AI) built the instrument: the greedy smallest-unused-with-shared-factor rule, the gcd-chain check, the distinctness and coverage checks, and the 2p-before / 3p-after prime structure. Credit as content: the EKG sequence (Jonathan Ayres; analysed by Lagarias, Rains & Sloane, 2002; OEIS A064413). The weave: David names second-wind; I extend the sequence by always taking the least unused number sharing a factor with the last, then confirm consecutive terms are never coprime, nothing repeats, the small integers all arrive, and every prime sits between 2p and 3p. 3 ONE DIMENSION 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15, 18, 14, 7, 21, … each term shares a factor with the last. 7 (prime) arrives right after 14 = 2·7 and is followed by 21 = 3·7. 4 TWO DIMENSIONS · INTERACTIVE The sequence as a heartbeat trace; the gcd-chain, distinctness, coverage, and 2p/3p prime rule checked. scroll ▶ verify 3000 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a walk that never runs out of shared factors. AVAN’s addition (the inverse-companion): order the integers not by size but by who shares a factor with whom — always step to the smallest unused neighbour in the divisibility graph. The inverse of ‘count 1, 2, 3, 4’ is ‘walk the integers by common factors, taking the least available each time.’ Magenta is the plain counting order; green is the shared-factor EKG walk. The same integers, reordered by their factors. pause spin LIT Genuine EKG sequence (Jonathan Ayres; analysed by Jeffrey Lagarias, Eric Rains & N.J.A. Sloane, 2002; OEIS A064413). Verified live: the greedy 'smallest unused sharing a factor' rule generates 3000 terms where consecutive terms are never coprime (window.__ekg.gcdChain), all terms are distinct (window.__ekg.distinct), 1..1000 all appear (window.__ekg.covers), and every interior prime p is preceded by 2p and followed by 3p (window.__ekg.structural). FIG No framing: the greedy generation, the gcd-chain check, distinctness, coverage, and the 2p/3p prime structure all run in-browser with exact arithmetic. Honest scope: the full permutation-of-the-integers property is proven in the literature; here the defining rule and the proven 2p/3p structure are checked over a finite 3000-term prefix (primes appear late, so coverage is bounded at 1..1000 below the frontier). The AVAN inverse is honest — ordering the integers by shared factors rather than by size (least available neighbour in the divisibility graph) genuinely reorders them; magenta is the plain counting order, green the shared-factor EKG walk. The same integers, reordered by their factors. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SECOND WIND · David Lee Wise (ROOT0), with AVAN


THE LEGENDRE FORMULA

Legendre's formula in the 5-window house format — the exact exponent of a prime p in n! without ever building the factorial: v_p(n!) = ⌊n/p⌋ + ⌊n/p²⌋ + ⌊n/p³⌋ + …, terminating once pᵏ exceeds n. There is a striking closed form too: v_p(n!) = (n − s_p(n))/(p − 1), where s_p(n) is n's digit sum in base p. A consequence: the trailing zeros of n! equal v₅(n!). Verified live: the floor-sum equals the true exponent and equals the digit-sum form for all n≤2000 and primes 2,3,5,7,11,13, and trailing zeros of n! (exact BigInt) equal v₅(n!). See the sum in 1D, both forms in 2D, and the count-without-the-product inverse in 3D.

THE LEGENDRE FORMULA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE LEGENDRE FORMULA THE LEGENDRE FORMULA count how many times a prime divides a factorial 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Legendre’s formula counts exactly how many times a prime p divides n! without ever building the factorial: the exponent is v p (n!) = ⌊n/p⌋ + ⌊n/p 2 ⌋ + ⌊n/p 3 ⌋ + … , a sum that terminates once p k exceeds n. There is a second, striking closed form: v p (n!) = (n − s p (n)) / (p − 1) , where s p (n) is the sum of n’s digits in base p. A direct consequence: the number of trailing zeros of n! equals v 5 (n!), since fives are the scarce factor. LIT verified live: the floor-sum equals the true exponent (summing v p of each factor) and equals the digit-sum form (n − s p (n))/(p−1) for all n up to 2000 and primes 2,3,5,7,11,13; and trailing zeros of n! (exact BigInt) equal v 5 (n!) (window.__legendre). FIG no framing; exact integer arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-cron-job — a scheduled sweep that keeps dividing by higher powers of p and tallying the hits, one pass per power, until the power outruns n. That repeated division is the cron job. AVAN (AI) built the instrument: the floor-sum, the direct per-factor exponent count, the base-p digit-sum closed form, and the trailing-zeros cross-check. Credit as content: Adrien-Marie Legendre (1808). The weave: David names the-cron-job; I add up ⌊n/p⌋ + ⌊n/p²⌋ + …, confirm it equals both the true exponent of p in n! and the digit-sum formula (n − s p (n))/(p−1), and check that fives alone set the count of trailing zeros. 3 ONE DIMENSION v 2 (10!) = ⌊10/2⌋+⌊10/4⌋+⌊10/8⌋ = 5+2+1 = 8. Also (10 − s 2 (10))/(2−1): 10 = 1010 2 , digit sum 2, (10−2)/1 = 8. 100! ends in v 5 =24 zeros. 4 TWO DIMENSIONS · INTERACTIVE A choice of n and p, the floor-sum terms and the digit-sum form side by side; the sweep checked. new n,p ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a factorial’s prime content, counted without the factorial. AVAN’s addition (the inverse-companion): instead of multiplying out n! and factoring it, count the prime directly — each power p k contributes ⌊n/p k ⌋ multiples. The inverse of ‘build n! then extract p’ is ‘sum ⌊n/p k ⌋ and never build n! at all.’ Magenta is the impossibly large factorial; green is the small floor-sum that names its p-content exactly. The content without the product. pause spin LIT Genuine Legendre's formula (Adrien-Marie Legendre, 1808). Verified live with exact integer arithmetic: Σ⌊n/pᵏ⌋ equals the true exponent of p in n! (summing v_p of every factor) and equals the base-p digit-sum form (n − s_p(n))/(p−1) for all n up to 2000 and primes {2,3,5,7,11,13} (window.__legendre.sumMatchesDirect, .formulaMatches); and the trailing zeros of n! computed as an exact BigInt equal v₅(n!) (window.__legendre.trailingZeros). FIG No framing: the floor-sum, the direct per-factor exponent count, the base-p digit-sum closed form, and the trailing-zeros cross-check all run in-browser with exact arithmetic. The AVAN inverse is honest — counting a prime's multiplicity in n! by summing ⌊n/pᵏ⌋ genuinely avoids ever forming the astronomically large factorial; magenta is the impossibly large product, green the small floor-sum that names its p-content exactly. The content without the product. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE TETRATION

Tetration in the 5-window house format — iterated exponentiation, the power tower. ᵏa = a^a^…^a with k copies, evaluated top-down: ³2 = 2^(2^2) = 16, ⁴2 = 2^16 = 65536, ⁵2 dwarfs the universe. Yet modulo m the tower stops growing: ¹a, ²a, ³a, … (mod m) becomes constant after a small height, because exponents reduce mod φ(m) (generalized Euler) and φ iterated on m reaches 1 in a few steps. Verified live: the tower-mod recursion (exact BigInt for short towers, generalized-Euler lift for tall ones) matches the direct tower where feasible, and ᵏa mod m is constant for all tall k across many (a,m). See the freeze in 1D, the climb-then-freeze in 2D, and the finite-fingerprint inverse in 3D.

THE TETRATION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / THE TETRATION THE TETRATION a power tower reduced modulo m settles down 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Tetration is iterated exponentiation — a power tower . k a means a a · · a with k copies of a, evaluated top-down: 3 2 = 2 2 2 = 2 4 = 16, 4 2 = 2 16 = 65536, and 5 2 already dwarfs the observable universe. Yet modulo m , the tower stops growing : the sequence 1 a, 2 a, 3 a, … (mod m) becomes constant after a small height. The reason is the generalized Euler theorem : exponents can be reduced mod φ(m) (with a lift), and φ iterated on m reaches 1 in a few steps. LIT verified live: the tower-mod recursion (exact BigInt for short towers, generalized-Euler lift for tall ones) matches the directly-computed tower where feasible, and k a (mod m) is constant for all tall k across many (a, m) (window.__tetration). FIG no framing; exact modular arithmetic vs a direct big-integer tower. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-raid — a boss with impossibly towering HP: the number 5 2 is beyond astronomical, yet reduced mod m it collapses to a single fixed value that never changes however much taller you build. That collapse is how you beat the raid. AVAN (AI) built the instrument: the φ-reducing tower recursion with the generalized-Euler lift, the direct BigInt tower for short cases, and the stabilization check. Credit as content: tetration / the power tower (Reuben Goodstein coined “tetration,” 1947; the mod result rests on Euler’s theorem, 1763). The weave: David names the-raid; I evaluate the tower one exponent at a time, reducing each modulo φ of the level above, and confirm that beyond a small height the tower mod m never changes again. 3 ONE DIMENSION 3 2 = 2 2 2 = 16. 4 2 = 2 16 = 65536 ≡ 36 (mod 100). 5 2 is astronomical but ≡ 36 (mod 100) too — the tower mod 100 freezes at 36 from height 4 on. 4 TWO DIMENSIONS · INTERACTIVE A base a and modulus m; the tower 1 a … k a (mod m) climbing then freezing; the checks run. new a,m ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an infinite tower with a finite shadow. AVAN’s addition (the inverse-companion): a number too large to write can still be pinned exactly modulo m — reduce each exponent by φ of the level above, and the tower’s residue settles after a few floors. The inverse of ‘compute the tower then reduce’ is ‘reduce as you climb, and never compute the tower.’ Magenta is the unbounded tower; green is its frozen residue mod m. An infinite object, a finite fingerprint. pause spin LIT Genuine tetration / the power tower (term coined by Reuben Goodstein, 1947; the modular collapse rests on Euler's theorem, 1763). Verified live: a recursion that computes short towers exactly in BigInt and reduces tall towers by the generalized Euler lift (exponent mod φ(m), plus φ(m)) matches the directly-computed tower modulo m wherever the tower is small enough to build (window.__tetration.matchesDirect), and ᵏa (mod m) is constant for all tall k over many bases and moduli (window.__tetration.stabilizes). FIG No framing: the φ-reducing tower recursion, the direct BigInt tower for short cases, and the stabilization check all run in-browser with exact modular arithmetic. The AVAN inverse is honest — pinning a number too large to write down exactly modulo m (reducing each exponent by φ of the level above) is a real technique, and the residue provably freezes after a small height; magenta is the unbounded tower, green its frozen residue mod m. An infinite object, a finite fingerprint. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE CONTINUED FRACTION OF e

The continued fraction of e in the 5-window house format — while e = 2.71828… looks random in decimal, its continued fraction is perfectly regular: e = [2; 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, …] — a 2, then repeating triples (1, 2m, 1) for m = 1, 2, 3, … Truncations give the convergents, the best rational approximations to e: 2, 3, 8/3, 11/4, 19/7, 87/32, 106/39, 193/71, … Verified live: the pattern a[3m−1]=2m holds, and the convergents (exact BigInt) approach e to within 1e−12, checked against e = Σ 1/j! computed as an exact fraction. See the terms in 1D, the shrinking error in 2D, and the order-beneath-the-constant inverse in 3D.

THE CONTINUED FRACTION OF e · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE CONTINUED FRACTION OF e THE CONTINUED FRACTION OF e the continued fraction of e and its convergents 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The continued fraction of e is one of the most beautiful patterns in mathematics. While e = 2.71828… looks random in decimal, its continued fraction is perfectly regular: e = [2; 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, …] — a 2, then repeating triples (1, 2m, 1) for m = 1, 2, 3, … The truncations of this fraction give convergents , the best rational approximations to e: 2, 3, 8/3, 11/4, 19/7, 87/32, 106/39, 193/71, … each closer than any simpler fraction. LIT verified live: the pattern a[3m−1] = 2m holds, and the convergents computed from it (exact BigInt) approach e to within 10 −12 , checked against e = Σ 1/j! computed as an exact fraction (window.__cfe). FIG no framing; exact big-integer convergents vs a high-precision rational e. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at cold-boot — the transcendental constant e booting up from nothing but the plainest integer pattern 1, 2, 1, 1, 4, 1, … a whole irrational number cold-started from a rule a child could recite. AVAN (AI) built the instrument: the triple-pattern term generator, the convergent recurrence p k = a k p k−1 + p k−2 , and the comparison to e as an exact series-fraction. Credit as content: the continued fraction of e (Leonhard Euler, 1737, who first proved the pattern). The weave: David names cold-boot; I lay down the terms 2, 1, 2, 1, 1, 4, …, fold them into convergents by the standard recurrence, and confirm they close in on e — a regular pattern generating an irregular-looking number. 3 ONE DIMENSION e = [2; 1,2,1, 1,4,1, 1,6,1, …]. Convergents: 2, 3, 8/3≈2.667, 11/4=2.75, 19/7≈2.714, 87/32≈2.719, 106/39≈2.7179, … → e = 2.71828… 4 TWO DIMENSIONS · INTERACTIVE The terms and their convergents; the error to e shrinking with each step; the pattern and convergence checked. add terms ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a wild constant with a tame skeleton. AVAN’s addition (the inverse-companion): read a transcendental number not by its chaotic digits but by its orderly continued fraction — where e hides a simple arithmetic progression. The inverse of ‘e looks patternless in base ten’ is ‘e is perfectly patterned as [2; 1,2,1, 1,4,1, …].’ Magenta is the decimal expansion (no visible rule); green is the continued fraction (a clean progression). The order beneath the constant. pause spin LIT Genuine continued fraction of e (Leonhard Euler, 1737, who first proved the [2;1,2,1,1,4,…] pattern). Verified live: the term generator satisfies a[3m−1]=2m (window.__cfe.pattern), and the convergents built by the recurrence pₖ=aₖpₖ₋₁+pₖ₋₂ in exact big integers approach e — computed independently as the exact fraction Σⱼ 1/j! — to within 1e−12 (window.__cfe.converges). FIG No framing: the triple-pattern term generator, the BigInt convergent recurrence, and the comparison against e as an exact series-fraction all run in-browser. The AVAN inverse is honest — reading e by its orderly continued fraction rather than its chaotic decimal digits genuinely reveals a simple arithmetic progression hidden in a transcendental number; magenta is the patternless decimal, green the clean continued fraction. The order beneath the constant. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE VECTOR CLOCK

Vector clocks in the 5-window house format — capturing causality in a distributed system with no shared clock. Each of N processes keeps a vector of N counters; it bumps its own entry on every event, and on receiving a message takes the componentwise maximum of its vector and the sender's, then bumps its own. The payoff is exact: event a happened-before b if and only if VC(a) < VC(b) componentwise; if neither dominates, the events are concurrent. Verified live: over hundreds of random event graphs (process timelines plus messages), VC(a) < VC(b) matches graph reachability for every pair of events. See the merge in 1D, an event graph in 2D, and the order-without-a-clock inverse in 3D.

THE VECTOR CLOCK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE VECTOR CLOCK THE VECTOR CLOCK vector clocks and the shape of causality 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Vector clocks capture causality in a distributed system with no shared clock. Each of N processes keeps a vector of N counters; it bumps its own entry on every event, and on receiving a message it takes the componentwise maximum of its vector and the sender’s, then bumps its own. The payoff is exact: event a happened-before b (a could have caused b) if and only if VC(a) < VC(b) componentwise. If neither clock dominates, the events are concurrent — causally independent. It is how systems reason about order without a global clock. LIT verified live: over hundreds of random event graphs (process timelines plus messages), VC(a) < VC(b) matches graph reachability (a can reach b) for every pair of events (window.__vectorclock). FIG no framing; vector-clock order compared to exact transitive-closure reachability. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-push — every event carries and pushes its clock forward; a message hands its vector to the receiver, who merges it by taking the max. That push-and-merge is how causality travels. AVAN (AI) built the instrument: the per-event vector bump, the max-merge on receive, the transitive-closure reachability oracle, and the pairwise agreement check. Credit as content: vector clocks (Colin Fidge & Friedemann Mattern, independently, 1988). The weave: David names the-push; I advance each event’s vector, merge sender vectors on receive, then confirm that one clock precedes another exactly when one event can causally reach the other — and that incomparable clocks mean concurrency. 3 ONE DIMENSION P0: [1,0]→[2,0]. P1 receives P0’s [2,0], merges: [2,1]. Now [2,0] < [2,1] ⇒ that send happened-before the receive. Two events with neither clock dominating are concurrent. 4 TWO DIMENSIONS · INTERACTIVE Process timelines with messages; each event’s vector clock; pick two events to compare order; the pairwise check runs. new scenario ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: order recovered without a clock. AVAN’s addition (the inverse-companion): decide whether one event could have caused another using only local counters that travel with messages — no global time. The inverse of ‘timestamp everything by one shared clock’ is ‘let each process count for itself and merge on contact; the partial order falls out.’ Magenta is the illusion of one global timeline; green is the causal partial order from vector clocks. Order without a clock. pause spin LIT Genuine vector clocks (Colin Fidge and Friedemann Mattern, independently, 1988). Verified live: over 300 random scenarios (process timelines plus messages forming a DAG), the vector-clock relation VC(a) FIG No framing: the per-event vector bump, the max-merge on receive, the transitive-closure reachability oracle, and the pairwise agreement check all run in-browser. The AVAN inverse is honest — deciding whether one event could have caused another using only local counters that travel with messages (no global clock) genuinely recovers the causal partial order; magenta is the illusion of one global timeline, green the causal order from vector clocks. Order without a clock. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE DUDENEY

Dudeney numbers in the 5-window house format — a positive integer that is a cube whose cube root equals the sum of its own digits: n = (digit sum of n)³. The example that started it: 512 = 8³, and 5+1+2 = 8. There are exactly six: 1, 512, 4913 (= 17³), 5832 (= 18³), 17576 (= 26³), and 19683 (= 27³). After that, cubes grow faster than any digit sum can reach, so the list is complete and finite. Verified live: scanning cubes k³ and keeping those whose digit sum equals k yields exactly {1, 512, 4913, 5832, 17576, 19683}. See the coincidence in 1D, a cube tested in 2D, and the self-closing-cube inverse in 3D.

THE DUDENEY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE DROP ◆ .dlw.fold THE FOLD / LOOT / THE DROP / THE DUDENEY THE DUDENEY numbers equal to the cube of their own digit sum 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Dudeney numbers are a perfect little coincidence: a positive integer that is a cube whose cube root equals the sum of its own digits . That is, n = (digit sum of n) 3 . The example that started it: 512 = 8 3 , and 5 + 1 + 2 = 8. There are exactly six of them: 1, 512, 4913 (= 17 3 , digits sum to 17), 5832 (= 18 3 ), 17576 (= 26 3 ), and 19683 (= 27 3 ). After that, cubes simply grow faster than any digit sum can reach — so the list is complete and finite. LIT verified live: scanning cubes k 3 and keeping those whose digit sum equals k yields exactly {1, 512, 4913, 5832, 17576, 19683} (window.__dudeney). FIG no framing; exact cube and digit-sum arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-drop — a rare drop: out of every cube, only six carry the exact coincidence that their digits sum back to their own cube root. Those six are the loot. AVAN (AI) built the instrument: the digit-sum, the cube test, and the exhaustive scan proving there are exactly six. Credit as content: Dudeney numbers (named for Henry Ernest Dudeney, the English puzzlist, 1857–1930). The weave: David names the-drop; I cube each candidate root, add up the digits of the result, and collect the cases where the digit sum lands exactly back on the root — finding all six and no more. 3 ONE DIMENSION 512 = 8³, 5+1+2 = 8 ✓. 4913 = 17³, 4+9+1+3 = 17 ✓. 19683 = 27³, 1+9+6+8+3 = 27 ✓. Only six exist: 1, 512, 4913, 5832, 17576, 19683. 4 TWO DIMENSIONS · INTERACTIVE A cube root, its cube, and whether the cube’s digits sum back to it; the census of six checked. new cube ▶ a Dudeney ▶ census ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a cube that sums back to its root. AVAN’s addition (the inverse-companion): demand that cubing and digit-summing be inverse on a number — digit-sum then cube must return the number itself. The inverse of ‘cube the root’ is ‘sum the digits’, and Dudeney numbers are the fixed points where both agree. The inverse of ‘n → digit sum → cube’ closes the loop only six times. Magenta is an ordinary cube; green is the self-closing Dudeney cube. A number that cubes back to itself through its digits. pause spin LIT Genuine Dudeney numbers (named for Henry Ernest Dudeney, the English puzzlist, 1857–1930). Verified live: cubing each candidate root k, summing the digits of k³, and keeping the cases where the digit sum equals k yields exactly the six numbers {1, 512, 4913, 5832, 17576, 19683} (window.__dudeney.census). FIG No framing: the digit-sum, the cube test, and the exhaustive scan proving there are exactly six all run in-browser with exact arithmetic. The AVAN inverse is honest — demanding that cubing and digit-summing be mutually inverse on a number (digit-sum then cube returns the number) is a genuine fixed-point condition that closes only six times; magenta is an ordinary cube, green the self-closing Dudeney cube. A number that cubes back to itself through its digits. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE DROP · David Lee Wise (ROOT0), with AVAN


THE LIOUVILLE

The Liouville function in the 5-window house format — λ(n) = (−1)^Ω(n), where Ω(n) counts prime factors with multiplicity: +1 for an even count, −1 for odd. Its beautiful divisor identity: Σ_{d|n} λ(d) = 1 if n is a perfect square, 0 otherwise — a flawless square-detector. Its running total L(n) drives Pólya's conjecture (L(n) ≤ 0 for n ≥ 2), true for hundreds of millions of terms yet ultimately false (first counterexample n = 906150257). Verified live: the divisor-sum equals [n is square] for n≤2000, λ is multiplicative, and L(n)≤0 for 2≤n≤600. See the square-detector in 1D, the L-walk in 2D, and the evidence-is-not-proof inverse in 3D.

THE LIOUVILLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE LIOUVILLE THE LIOUVILLE a sign that flips by the parity of prime factors 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Liouville function λ(n) = (−1) Ω(n) , where Ω(n) counts the prime factors of n with multiplicity . It is +1 when n has an even number of prime factors, −1 when odd. Its most beautiful property is a divisor identity: Σ d|n λ(d) = 1 if n is a perfect square, and 0 otherwise — the sum over divisors is a flawless square-detector. Its running total L(n) = λ(1) + … + λ(n) drives Pólya’s conjecture (L(n) ≤ 0 for all n ≥ 2), which is true for hundreds of millions of terms yet ultimately false . LIT verified live: Σ d|n λ(d) equals 1 exactly on perfect squares (n up to 2000), λ is multiplicative on coprime pairs, and L(n) ≤ 0 holds for 2 ≤ n ≤ 600 (window.__liouville). FIG honest: Pólya’s conjecture holds in this range but is known false — the first counterexample is n = 906150257. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at undefined-behavior — the same dark corner as Mertens: a running sign-sum that looks safely one-signed for every n you can reach, then flips far beyond sight. That deferred flip is the undefined behavior. AVAN (AI) built the instrument: the Ω-parity sign, the divisor-sum square-detector, the multiplicativity check, and the Pólya sum over the honest range. Credit as content: Joseph Liouville (the function, mid-1800s); the summatory conjecture by George Pólya (1919), disproved by C. B. Haselgrove (1958), least counterexample later pinned to n = 906150257. The weave: David names undefined-behavior; I sign each n by the parity of its prime-factor count, confirm the divisor sum detects squares exactly, and check Pólya’s bound over the reachable range — flagging plainly that it fails far out. 3 ONE DIMENSION λ(n) = (−1) Ω(n) : λ(12) = −1 (12 = 2·2·3, Ω=3), λ(16) = +1 (Ω=4). Σ d|9 λ(d) = λ(1)+λ(3)+λ(9) = 1−1+1 = 1 (9 is a square). 4 TWO DIMENSIONS · INTERACTIVE λ(n) as a walk and the divisor-sum square-detector; the identity and Pólya’s bound checked. zoom ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a sign that sums to a square-detector. AVAN’s addition (the inverse-companion): sign every integer by the parity of its prime-factor count , and the divisor-sum turns into a perfect square detector — while the running total hides a conjecture true for ages then false. The inverse of ‘a bound true for every computed n is true’ is ‘it can hold past 10 8 and still fail.’ Magenta is “one-signed as far as tested”; green is the Liouville sum that eventually breaks Pólya. Evidence is not proof. pause spin LIT Genuine Liouville function (Joseph Liouville, mid-1800s). Verified live: the divisor-sum Σ_{d|n}λ(d) (computed by sieve) equals 1 exactly on perfect squares for all n up to 2000 (window.__liouville.divisorSum), λ is multiplicative on coprime pairs (window.__liouville.multiplicative), and Pólya's bound L(n)≤0 holds for 2≤n≤600 (window.__liouville.polya). FIG No framing: the Ω-parity sign, the sieve-based divisor-sum square-detector, the multiplicativity check, and the Pólya sum all run in-browser with exact integer arithmetic. Honest scope: Pólya's conjecture holds throughout the reachable range but is known FALSE, with least counterexample n=906150257 — the same 'true then false' lesson as Mertens. The AVAN inverse is honest — signing integers by prime-factor parity turns the divisor-sum into a perfect square-detector, while the running total hides a conjecture true for ages then false; magenta is 'one-signed as far as tested', green the Liouville sum that eventually breaks Pólya. Evidence is not proof. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE ERDŐS–GALLAI

The Erdős–Gallai theorem in the 5-window house format — deciding whether a list of numbers can be the degrees of a real simple graph. A non-increasing sequence is graphical iff its sum is even and, for every k, Σ_{i≤k} d_i ≤ k(k−1) + Σ_{i>k} min(d_i, k). The left side is the demand of the top k vertices; the right is the most those edges can be absorbed. It is the exact companion to the Havel–Hakimi reduction by a different route. Verified live: over 3000 random sequences the Erdős–Gallai verdict matches the independent Havel–Hakimi reduction, and every graphical sequence is realized by a constructed simple graph with exactly those degrees. See the criterion in 1D, a realizing graph in 2D, and the degrees-back-into-a-graph inverse in 3D.

THE ERDŐS–GALLAI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PULL REQUEST ◆ .dlw.fold THE FOLD / CO-OP / THE PULL REQUEST / THE ERDŐS–GALLAI THE ERDŐS–GALLAI when a list of degrees can be a real graph 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Erdős–Gallai theorem decides whether a list of numbers can be the degrees of a real simple graph . A non-increasing sequence d 1 ≥ … ≥ d n is graphical if and only if its sum is even and, for every k , Σ i≤k d i ≤ k(k−1) + Σ i>k min(d i , k). The left side is the demand of the top k vertices; the right side is the most those edges can be absorbed — k(k−1) among themselves plus what the rest can accept. It is the exact companion to the Havel–Hakimi reduction, reached by a completely different route. LIT verified live: over thousands of random sequences the Erdős–Gallai verdict matches the independent Havel–Hakimi reduction, and whenever a sequence is graphical a simple graph is constructed that realizes exactly those degrees (window.__erdosgallai). FIG no framing; two independent criteria and an explicit realization. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-pull-request — a proposed list of degrees is submitted; the theorem reviews it and either merges it into a real graph or rejects it as unrealizable. That review-and-merge is the pull request. AVAN (AI) built the instrument: the k-by-k Erdős–Gallai inequalities, the independent Havel–Hakimi reduction, and the constructive realization that recovers the degrees. Credit as content: Paul Erdős & Tibor Gallai (1960); the companion reduction by Václav Havel (1955) & S. L. Hakimi (1962). The weave: David names the-pull-request; I test the even-sum and the k-inequalities, confirm the verdict against Havel–Hakimi, and when a sequence passes I build a graph that actually has those degrees. 3 ONE DIMENSION [3,3,3,3] is graphical (the 4-cycle plus diagonals, K₄). [3,3,1,1] is not: the two degree-3 vertices must connect to everyone, forcing the last two to degree 2, not 1. 4 TWO DIMENSIONS · INTERACTIVE A degree sequence, the k-inequalities, and a realizing graph when one exists; the verdict cross-checked. new sequence ▶ a graphical one ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a list of degrees that becomes a graph. AVAN’s addition (the inverse-companion): go backward from a wish-list of vertex degrees to a graph that has them — or a proof that none can. The inverse of ‘count the degrees of a graph’ is ‘given the degrees, is there a graph, and build it.’ Magenta is an unrealizable sequence (some inequality fails); green is a graphical one, drawn as a real graph. Degrees back into a graph. pause spin LIT Genuine Erdős–Gallai theorem (Paul Erdős & Tibor Gallai, 1960); companion reduction by Václav Havel (1955) & S.L. Hakimi (1962). Verified live: over 3000 random sequences the Erdős–Gallai k-inequalities give the same graphical/not verdict as an independent Havel–Hakimi reduction (window.__erdosgallai.agree), and every graphical sequence is realized by a constructed simple graph whose degrees match exactly (window.__erdosgallai.realizes). FIG No framing: the k-by-k Erdős–Gallai inequalities, the independent Havel–Hakimi reduction, and the constructive realization all run in-browser with exact arithmetic and cross-check each other. The AVAN inverse is honest — going backward from a wish-list of vertex degrees to a graph that has them (or a proof none exists) is a genuine inverse of degree-counting; magenta is an unrealizable sequence, green a graphical one drawn as a real graph. Degrees back into a graph. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


THE THREE SQUARES

Legendre's three-square theorem in the 5-window house format — a non-negative integer n is a sum of three squares a²+b²+c² if and only if n is NOT of the form 4^a(8b+7). So 7, 15, and 28=4·7 fail, but everything else works, from 6=1+1+4 to 30=1+4+25. It is the sharp companion to Lagrange's four-square theorem (four squares always suffice): three suffice for all but a thin, precisely-described family. Verified live: an exhaustive search for a²+b²+c²=n agrees with the arithmetic test 'n is not 4^a(8b+7)' for every n up to 3000. See the forbidden forms in 1D, a representation in 2D, and the name-the-exception inverse in 3D.

THE THREE SQUARES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE THREE SQUARES THE THREE SQUARES which numbers are sums of three squares 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Legendre’s three-square theorem pins down exactly which numbers are a sum of three squares. A non-negative integer n is expressible as a 2 + b 2 + c 2 if and only if n is not of the form 4 a (8b + 7) . So 7 fails (it is 8·0+7), 28 = 4·7 fails, 15 fails — but every other number, from 6 = 1+1+4 to 30 = 1+4+25, works. It is the sharp companion to Lagrange’s four-square theorem (four squares always suffice): three squares suffice for all but a thin, precisely-described family. LIT verified live: an exhaustive search for a 2 +b 2 +c 2 = n agrees with the arithmetic test “n is not 4 a (8b+7)” for every n up to 3000 (window.__threesquares). FIG no framing; brute-force representability vs the closed-form forbidden set. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-choke-point — almost every number passes as a sum of three squares; only the thin channel 4 a (8b+7) is blocked. That forbidden channel is the choke point. AVAN (AI) built the instrument: the exhaustive three-square search, the 4 a (8b+7) forbidden-form test, and their exact agreement. Credit as content: Adrien-Marie Legendre (1797–1798); Carl Friedrich Gauss gave a deeper count. The weave: David names the-choke-point; I try every a, b, c for each n, and confirm the successes are exactly the numbers that are not 4 a (8b+7) — a sharp line between the representable and the blocked. 3 ONE DIMENSION 6 = 1+1+4, 30 = 1+4+25 — fine. Forbidden: 7 = 8·0+7, 15 = 8·1+7, 28 = 4·7, 60 = 4·15, 112 = 16·7. Everything not of the form 4 a (8b+7) is a sum of three squares. 4 TWO DIMENSIONS · INTERACTIVE A number, a three-square representation if one exists, and the forbidden-form test; the agreement checked to 3000. new number ▶ a forbidden one ▶ verify ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: three squares for almost every number. AVAN’s addition (the inverse-companion): instead of searching every triple to test one number, name the exception set directly — a number needs a fourth square exactly when it is 4 a (8b+7). The inverse of ‘search for a,b,c’ is ‘a single arithmetic test decides representability.’ Magenta is a forbidden 4 a (8b+7) number; green is a number shown as three squares. The blocked, named exactly. pause spin LIT Genuine Legendre three-square theorem (Adrien-Marie Legendre, 1797–98; deeper counting by Gauss). Verified live: an exhaustive search over a,b,c for each n agrees with the closed-form forbidden-set test 'n ≠ 4^a(8b+7)' for every n from 1 to 3000 (window.__threesquares.matches). FIG No framing: the exhaustive three-square search and the 4^a(8b+7) forbidden-form test run in-browser with exact arithmetic and agree exactly. The AVAN inverse is honest — replacing a triple-search with a single arithmetic test that names the exception set directly (a number needs a fourth square exactly when it is 4^a(8b+7)) is a real closed-form characterization; magenta is a forbidden number, green a number shown as three squares. The blocked, named exactly. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN