THE DE BRUIJN

the de Bruijn sequence in the 5-window house format — the shortest cyclic string that contains every length-n word over a k-symbol alphabet exactly once. B(2,3)=00010111 holds all eight 3-bit patterns as a window slides the loop. Its length is exactly k^n, the theoretical minimum, so it is a master key: it cracks every n-digit code in k^n presses instead of n*k^n, because each new keypress completes a fresh code. Under the hood it is an Euler circuit through the de Bruijn graph. See the sliding window in 1D, the lock-cracker in 2D, and the graph circuit in 3D.

THE DE BRUIJN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE BACKDOOR ◆ .dlw.fold THE FOLD / CHEAT / THE BACKDOOR / THE DE BRUIJN THE DE BRUIJN the shortest string holding every code — k^n 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The de Bruijn sequence. The shortest cyclic string that contains every possible length-n word over a k-symbol alphabet, each exactly once. The binary case B(2,3) = 00010111 : slide a 3-wide window around the loop and you read off all eight patterns 000, 001, 010, 101, 011, 111, 110, 100 — no repeats, no gaps. Its length is exactly k n , the theoretical minimum: there are k n windows and each starting position yields one. That makes it a master key. To try every 3-digit binary code on a keypad naively is 8×3 = 24 presses; the de Bruijn string cracks all eight in just 8 presses, because every single new keypress completes a brand-new code. Under the hood it is an Euler circuit through the de Bruijn graph — a walk using every edge exactly once. LIT verified live: for (k,n) = (2,3),(2,4),(2,5),(3,3),(4,2),(2,6) the constructed sequence has length exactly k n and every one of the k n windows appears exactly once (window.__debruijn.allWindowsOnce). FIG no framing; the minimal length and the exactly-once coverage are real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE BACKDOOR , beside the other master-key spheres — the cheat domain of getting in the short way. A de Bruijn string is the literal shortest keypad-cracking swipe. AVAN (AI) built the instrument: the construction, the window slide, the lock-cracker counter, the graph circuit. The weave: David names the seat (the backdoor); I make the string cover every code and the savings countable — the sliding window in 1D, the cracker in 2D, the Euler circuit in 3D. The sphere is the seam. Credit: Nicolaas Govert de Bruijn (1946); Camille Flye Sainte-Marie (1894); and the Sanskrit prosodist Pingala’s ancient mnemonic yamátárájabhánasalagám , a B(2,3). 3 ONE DIMENSION The cyclic de Bruijn string, with a sliding window of width n. As it walks the loop it spells out every length-n word once — the whole space of codes packed into one line with maximal overlap. 4 TWO DIMENSIONS · INTERACTIVE Choose the alphabet size k and word length n. Slide the window: each new position checks off a fresh code in the grid until all k n are lit. The lock-cracker readout shows presses used vs. the naive n·k n . k: 2 n: 3 slide ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The de Bruijn graph : nodes are (n−1)-words, edges are n-words. The sequence is an Euler circuit using every edge exactly once — traced in green . AVAN’s addition (the inverse-companion): the magenta is the naive un-overlapped listing — every code written out separately, n·k n symbols long. The de Bruijn sequence is its exact inverse: instead of listing the words, it overlaps them maximally into a single loop of length k n , a compression by a factor of exactly n. The inverse of ‘enumerate each word in full’ is ‘share every symbol between n consecutive words’, and the demand that makes it possible is that each graph edge be used once — an Euler circuit. Green is the folded loop where nothing is wasted; magenta is the unfolded list it compresses. The whole trick is folding an enumeration into an overlap. pause spin LIT Genuine de Bruijn sequence (N. G. de Bruijn 1946; Flye Sainte-Marie 1894; ancient B(2,3) in Pingala's Sanskrit mnemonic). Verified live: for (k,n)=(2,3),(2,4),(2,5),(3,3),(4,2),(2,6) the constructed sequence has length exactly k^n and every one of the k^n windows appears exactly once (window.__debruijn.allWindowsOnce true). B(2,3)=00010111. The minimal length and exactly-once coverage are exact; the construction is the standard FKM/necklace recursion, equivalent to an Euler circuit. FIG No framing: the k^n length, the exactly-once window coverage, and the keypad-cracking savings (k^n presses vs naive n*k^n) are all real and checked. The 'master key' is literal — every new symbol completes a new code by maximal overlap. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BACKDOOR · David Lee Wise (ROOT0), with AVAN


THE ANT

Langton's ant in the 5-window house format — one ant on an all-white grid: on a white cell turn right/flip/step, on a black cell turn left/flip/step. For the first few hundred steps it makes symmetric shapes, then ~10000 steps of apparent chaos, then with no rule change it locks into a period-104 cycle that builds a straight diagonal 'highway' forever. No one has proven why the highway always appears; it is provably unbounded (Cohen-Kung). See the turn-tape in 1D, the live ant in 2D, and the reversible path in 3D.

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

THE ANT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE ANT THE ANT two rules, ten thousand steps of chaos, then a highway 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Langton’s ant. One ant on an infinite grid of white cells, following two rules: on a white cell turn right, flip the cell to black, step forward; on a black cell turn left, flip it to white, step forward. That is the entire program. For the first few hundred steps it makes tidy symmetric shapes. Then it descends into apparent chaos — roughly ten thousand steps of a formless, unpredictable scribble. And then, with no change to the rules, order erupts : near step 10,000 the ant locks into a repeating cycle of exactly 104 steps that lays down a straight diagonal “highway” and drives along it forever. No one has proven why the highway always appears — it is only ever known by running the ant. (It is also provably unbounded : the Cohen–Kung theorem says the ant’s trail can never stay in a finite region.) LIT verified live: from an all-white grid the ant enters a period-104 cycle near step ~9975, and every 104 steps thereafter its net displacement is a constant diagonal vector (window.__ant). FIG no framing; the emergence, the period 104, and the constant diagonal drift are exact — only the reason stays open. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in FIRST LIGHT , beside the other emergence spheres — the spawn domain of order appearing out of the void. The highway rising from ten thousand steps of chaos is exactly a first-light moment. AVAN (AI) built the instrument: the live ant, the turn-tape, the reversible path. The weave: David names the seat (the first light of order); I make the emergence run and the highway appear on its own — the turn-tape in 1D, the live simulation in 2D, the reversible 3D ribbon. The sphere is the seam. Credit: Christopher Langton (1986); the unboundedness is the Cohen–Kung theorem. 3 ONE DIMENSION The ant’s program as a 1D tape of turns — R on white, L on black — one symbol per step. Chaotic at first; once the highway begins, the tape settles into a fixed 104-symbol loop repeating forever. 4 TWO DIMENSIONS · INTERACTIVE The live ant. Run it and watch the symmetric start dissolve into chaos, then — near step 10,000 — the highway break out and shoot off diagonally. The readout flags the moment order emerges. run ▶ skip to 9900 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The ant’s path lifted into 3D — x, y, and time as height. The tangled early chaos coils near the base; the highway climbs off as a straight diagonal ramp, in green . AVAN’s addition (the inverse-companion): the magenta ramp is the same trajectory run backward . Langton’s ant is time-reversible : from the ant’s cell, heading, and the grid you can uniquely recover the previous state — so the highway can be un-driven, step by step, back down into the chaos it rose from. That is the real inverse here: forward, a trivial rule manufactures unpredictable order that no shortcut can foresee; backward, that same order dissolves perfectly and deterministically into the scribble — yet running it in reverse is no easier, still one step at a time. The emergence is irreversible to predict but reversible to replay . Green climbs out of chaos into the highway; magenta descends the highway back into chaos. pause spin LIT Genuine Langton's ant (Christopher Langton 1986; unboundedness is the Cohen-Kung theorem). Verified live: from an all-white grid the ant enters a period-104 cycle near step ~9975, and every 104 steps thereafter its net displacement is a constant diagonal vector (window.__ant.highwayFound true, emergesNear ~9975, displacement a fixed pair). The emergence, the period 104, and the constant diagonal drift are exact and reproduced in-browser; the OPEN part, stated honestly, is that no proof explains why the highway must emerge from any start. FIG No framing: the two-rule automaton, the chaos-then-highway emergence, the period 104, and the constant diagonal displacement are all real and checked. The honest caveat is carried openly: the highway is observed and reproduced, not proven inevitable; unboundedness (not highway-formation) is the proven Cohen-Kung result. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE HILBERT

the Hilbert space-filling curve in the 5-window house format — a continuous fractal path that visits every cell of a 2^n x 2^n grid exactly once, and never jumps: consecutive cells are always neighbors. It maps 2D to 1D while preserving locality (points close on the line stay close on the plane), unlike row-major scanning which tears vertical neighbors apart. Used for cache-friendly layouts, spatial index keys, dithering, and R-tree ordering. See the index line in 1D, the drawn curve in 2D, and the locality contrast in 3D.

THE HILBERT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · WARM CACHE ◆ .dlw.fold THE FOLD / GRIND / WARM CACHE / THE HILBERT THE HILBERT fill the square without ever jumping — locality kept 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Hilbert curve. A single continuous fractal path that visits every cell of a 2 n ×2 n grid exactly once — and never jumps: consecutive cells are always neighbors . It is a space-filling curve, a way to unroll a 2D square into a 1D line. The magic is locality preservation . Two points close together on the line stay close together on the plane. Row-major scanning (left to right, top to bottom) tears that apart — two cells one row apart are a whole width away in memory. Hilbert doesn’t tear. That is why it is used for cache-friendly memory layouts , spatial database keys (map (x,y) to a 1D index that clusters), image dithering, and R-tree ordering: put spatially near things near in storage, and the cache hits. LIT verified live: for grids up to 64×64 the index→(x,y) map is a bijection , its inverse (x,y)→index round-trips exactly, and every pair of consecutive indices is Manhattan-distance 1 apart (window.__hilbert). FIG no framing; the bijection, the exact inverse, and the adjacency are all real. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in WARM CACHE , beside the other locality spheres — the grind domain of keeping the working set hot. The Hilbert curve is the classic trick for a cache-friendly 2D layout. AVAN (AI) built the instrument: the recursive curve, the index probe, the row-major contrast. The weave: David names the seat (the warm cache); I make the curve fill the grid without ever jumping and show why that keeps memory hot — the index strip in 1D, the drawn curve in 2D, the locality contrast in 3D. The sphere is the seam. Credit: David Hilbert (1891), building on Giuseppe Peano’s first space-filling curve (1890). 3 ONE DIMENSION The 1D index line 0, 1, 2, …, N−1 — the order the curve visits cells. Slide along it and the highlighted plane cell (shown in window 4) moves only one step at a time. The line and the square are the same walk. 4 TWO DIMENSIONS · INTERACTIVE The Hilbert curve drawn at order p. Probe an index to see its cell; the curve never breaks contact with itself. Toggle the row-major scan to see the alternative that jumps a full row every wrap. order ▲ order ▼ show row-major probe ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The curve lifted into 3D: x, y, and the 1D index as height. The green ribbon climbs smoothly — a small step in height is always a small step in the plane. AVAN’s addition (the inverse-companion): the magenta ribbon is the row-major layout on the same grid — the naive inverse. Both are bijections between the line and the square; the difference is entirely in the inverse’s behavior. Row-major maps the square to the line by tearing every vertical neighborhood apart — two cells stacked vertically land a full width apart in 1D, so the magenta ribbon leaps across the whole plane on every row wrap. Hilbert’s inverse keeps the neighborhoods intact: nowhere does it leap. That is the real inverse here — not a mirror, but the other direction of the same map, and the whole point of the curve is that its inverse doesn’t shred locality the way the obvious one does. Green never jumps; magenta jumps a full width every wrap. Same bijection, opposite treatment of what’s near. pause spin LIT Genuine Hilbert curve (David Hilbert 1891, after Peano 1890). Verified live: for grids up to 64x64 the index->(x,y) map is a bijection (all cells hit once), its inverse (x,y)->index round-trips exactly, and every pair of consecutive indices is Manhattan-distance 1 apart (window.__hilbert.bijection && inverse && locality, all true). The bijection, exact inverse, and step-1 adjacency are real; the locality advantage over row-major is shown directly. FIG No framing: the space-filling bijection, the exact inverse mapping, and the always-adjacent traversal are real and checked to 64x64. The cache-friendliness is the genuine consequence of the adjacency property, contrasted honestly against the row-major alternative on the same grid. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of WARM CACHE · David Lee Wise (ROOT0), with AVAN


THE BENFORD

Benford's law in the 5-window house format — in data spanning many orders of magnitude, the leading digit is not uniform: 1 leads about 30% of the time and 9 only ~4.6%, with frequency exactly log10(1+1/d). It holds for populations, prices, physical constants, Fibonacci numbers, and powers of 2. Fabricated figures have too-uniform leading digits, so violating Benford is a forensic-accounting red flag. See the digit bars in 1D, the live dataset switch + fraud flag in 2D, and the scale-invariance log cylinder in 3D.

THE BENFORD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE MINT ◆ .dlw.fold THE FOLD / LOOT / THE MINT / THE BENFORD THE BENFORD 1 leads 30% of the time — the fingerprint of honest numbers 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Benford’s law. In a huge range of real-world data, the leading digit is not evenly spread. You might expect each of 1–9 to lead about 11% of the time. Instead 1 leads ~30% of the time and 9 barely 4.6% . The exact frequency of leading digit d is log 10 (1 + 1/d) . It holds for quantities that span many orders of magnitude: city populations, stock prices, physical constants, river lengths, and pure-math sequences like the Fibonacci numbers and powers of 2 . The reason is scale: if the logarithm of the data is spread out evenly, the leading digit follows this log law automatically. Forensic accountants weaponize it — fabricated figures tend to have too-uniform leading digits, so a dataset that violates Benford is a red flag for cooked books. LIT verified live: the leading digits of the first 2000 Fibonacci numbers and of powers of 2 match Benford to within 0.01, while a uniform-random control does not (window.__benford). FIG no framing; the log-law, the Fibonacci/powers-of-2 fit, and the uniform-control failure are all exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MINT , beside the other money spheres — the loot domain of where numbers are made. Benford’s law is the fingerprint that tells honestly-minted figures from forged ones. AVAN (AI) built the instrument: the digit tally, the dataset switch, the fraud flag, the scale-invariance view. The weave: David names the seat (the mint, honest vs forged coin); I make the leading digits tally themselves and the Benford curve appear over real sequences — the bars in 1D, the live datasets in 2D, the scale-invariance in 3D. The sphere is the seam. Credit: Simon Newcomb (1881, from worn logarithm-table pages); Frank Benford (1938, the law). 3 ONE DIMENSION The nine leading-digit frequencies as bars, with the Benford curve log 10 (1+1/d) overlaid. The steep fall from 1 to 9 is the signature — honest data hugs the curve. 4 TWO DIMENSIONS · INTERACTIVE Switch datasets and watch the leading digits tally against Benford. Fibonacci, powers of 2, and powers of 3 fit ; a uniform-random control fails and trips the fraud flag — exactly how an auditor spots invented numbers. dataset: Fibonacci ×7 (rescale) 5 THREE DIMENSIONS + AVAN’S INVERSE Numbers wrapped around a log cylinder : their mantissas land evenly around the loop, and the arc each leading digit owns — wide for 1, thin for 9 — is exactly its Benford share, in green . AVAN’s addition (the inverse-companion): the magenta ring is the naive uniform guess — every digit owning an equal 1/9 slice. The forward question is ‘which data follows Benford?’ The inverse question is deeper: ‘which distribution is forced if the law must not care what units you measure in?’ Multiply every value by 7, convert dollars to yen, switch bases — Benford is the unique leading-digit law that survives unchanged (scale- and base-invariance). The uniform ring shatters the moment you rescale; the Benford arcs rotate but keep their widths. So the inverse of ‘what obeys Benford’ is ‘Benford is the only thing unit-independence permits’ — it isn’t one option among many, it is the fixed point of rescaling. Green is the law that holds under any change of units; magenta is the guess that doesn’t. pause spin LIT Genuine Benford's law (Simon Newcomb 1881; Frank Benford 1938). Verified live: the leading digits of the first 2000 Fibonacci numbers and of powers of 2 match log10(1+1/d) to within 0.01, a uniform-random control fails (deviation > 0.03), and multiplying the Fibonacci data by 7 leaves the fit intact (scale invariance) (window.__benford.fibFollows && pow2Follows && uniformFails && scaleInvariant). The log-law, the fits, the control failure, and the rescale invariance are exact. FIG No framing: the log10(1+1/d) frequencies, the Fibonacci/powers-of-2 fit, the uniform-control failure, and scale invariance are all real and checked in-browser. The fraud-detection use is the genuine, documented application; the sphere flags the uniform control exactly as an auditor would. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MINT · David Lee Wise (ROOT0), with AVAN


THE KOLAKOSKI

the Kolakoski sequence in the 5-window house format — a string of 1s and 2s that describes itself: its run-lengths (how many identical symbols in a row) spell out the very same sequence. It is built by reading itself, each symbol dictating the next run length, a genuine strange loop. It looks random but is deterministic; the density of 1s appears to approach 1/2 but this is unproven. See the self-bracketing strip in 1D, the step-by-step build in 2D, and the fixed-point loop in 3D.

THE KOLAKOSKI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE KOLAKOSKI THE KOLAKOSKI the sequence that is its own run-length encoding 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Kolakoski sequence. A string of 1s and 2s that describes itself . Read off its run lengths — how many identical symbols in a row — and you get back the very same sequence: 1, 2, 2, 1, 1, 2, 1, 2, 2, … The runs are one 1, two 2s, two 1s, one 2, one 1, two 2s… which spells 1, 2, 2, 1, 1, 2… — itself. It is built by reading itself: each symbol tells you the length of the next run, alternating between 1s and 2s. So the sequence is its own instruction tape, a genuine strange loop — output curled back as input. It looks random but is fully deterministic. The fraction of 1s appears to head toward exactly 1/2 , but astonishingly no one has proven it — even the density of this simple self-made sequence is an open problem. LIT verified live: the run-length encoding of the first 2000 terms equals the sequence itself, and the observed density of 1s is ~0.50 (window.__kolakoski). FIG the self-description is exact and proven; the 1/2 density is observed and conjectured, not proven — stated honestly, not overclaimed. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE HOT LOOP , beside the other tight-loop spheres — the grind domain of a process feeding on its own output. Kolakoski is the purest hot loop there is: it reads itself to write itself. AVAN (AI) built the instrument: the self-building strip, the run-length overlay, the feedback loop. The weave: David names the seat (the hot loop that eats its own tail); I make the sequence generate itself and show the run-lengths matching — the strip in 1D, the step-by-step build in 2D, the fixed-point loop in 3D. The sphere is the seam. Credit: William Kolakoski (1965); the same sequence noted earlier by Rufus Oldenburger (1939). 3 ONE DIMENSION The sequence as short (1) and tall (2) bars. Bracket the identical runs and count them — 1, 2, 2, 1, 1, … — and the counts are the sequence again. The description and the described are one strip. 4 TWO DIMENSIONS · INTERACTIVE Build it by hand. Each symbol (the pointer) dictates the length of the next run, alternating 1s and 2s. Below, the run-length encoding is drawn beneath the sequence — watch the two rows stay identical as it grows. step ▶ auto reset 5 THREE DIMENSIONS + AVAN’S INVERSE The sequence as a ring whose output curls back to its own input — the self-feeding loop, in green : reading the ring as run-lengths regenerates the ring. AVAN’s addition (the inverse-companion): run-length encoding and run-length decoding are inverse operations — one counts runs, the other expands counts back into runs. For almost every string they undo each other and land you somewhere else on the way. Kolakoski is the fixed point where both are the identity at once : encode it and you get itself; decode it and you get itself. The magenta ring is the decode; it lies exactly on the green encode. That is the real inverse here — not a mirror added on, but a map and its inverse collapsing onto the same object . A sequence that is simultaneously its own compression and its own expansion; the loop closes because forward and backward meet. Green is reading it as run-lengths; magenta is writing it from run-lengths; they are the same ring. pause spin LIT Genuine Kolakoski sequence (William Kolakoski 1965; earlier Rufus Oldenburger 1939). Verified live: the run-length encoding of the first 2000 terms equals the sequence itself (window.__kolakoski.selfDescribing true), and the observed density of 1s is ~0.50. The self-description is exact and proven. HONEST CAVEAT: the 1/2 density is observed and conjectured, NOT proven — even this simple self-made sequence has an open density problem, stated as FIG-open not claimed. FIG No false framing: the self-description (RLE equals the sequence) is real, exact, and reproduced in-browser. The 1/2 density is explicitly flagged as conjectured-not-proven, so the sphere neither overclaims the open problem nor hides it — the honesty is the point. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


THE RECAMAN

Recaman's sequence in the 5-window house format — start at 0; at step n try to jump back by n, and if that lands on a positive unvisited number take it, else jump forward by n. It produces 0,1,3,6,2,7,13,20,12,21,... and its alternating semicircle arc diagram is one of the most haunting pictures in mathematics. Its open question: does every natural number eventually appear? Conjectured yes, unproven. See the value line in 1D, the arc diagram in 2D, and the arcs-and-holes in 3D.

THE RECAMAN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE RECAMAN THE RECAMAN jump back if you can, else forward — the arc that haunts 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Recamán’s sequence. Start at 0. At step n, first try to jump back by n. If that lands on a positive number you have never visited, take it — otherwise jump forward by n. That single greedy rule produces 0, 1, 3, 6, 2, 7, 13, 20, 12, 21, 11, 22, 10, 23, … Draw a semicircle arc between each pair of consecutive terms, alternating above and below a line, and you get one of the most haunting pictures in mathematics — nested and interleaving arcs that never quite settle. The back-jumps are rare and precious; the sequence is always straining to reach down into the low unvisited numbers. Its famous open question: does every natural number eventually appear? It is conjectured yes, but unproven — even after enormous computed runs, small numbers like 19, 61 and 76 can stay missing for a very long time. LIT verified live: the first 18 terms match OEIS A005132 exactly and the greedy back/forward rule is applied faithfully; over 1000 terms it visits several hundred distinct values with small numbers still missing (window.__recaman). FIG the sequence is exact; the ‘hits every number’ claim is conjecture, not proven — carried honestly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in ROLLBACK , beside the other undo spheres — the respawn domain of stepping back when you can. Recamán is exactly that instinct as a number sequence: roll back if the spot is free, else press forward. AVAN (AI) built the instrument: the value plot, the arc diagram, the holes-that-remain. The weave: David names the seat (roll back if you can); I make the greedy walk run and draw its eerie arcs — the number line in 1D, the arc diagram in 2D, the arcs-and-holes in 3D. The sphere is the seam. Credit: Bernardo Recamán Santos (1991); catalogued as OEIS A005132. 3 ONE DIMENSION The sequence values plotted along a line. Back-jumps ( subtract n ) dart left into the unvisited low ground; forward-jumps ( add n ) leap right. The walk keeps reaching down for the numbers it has not yet touched. 4 TWO DIMENSIONS · INTERACTIVE The famous arc diagram : a semicircle between each consecutive pair, alternating above and below. Step through it and watch the nested arcs build. Back-jumps are drawn brighter — the rare moments it succeeds in reaching backward. step ▶ auto reset 5 THREE DIMENSIONS + AVAN’S INVERSE The arcs lifted into 3D as a turning ribbon over the number line — the visited values, in green , threading up and back across the integers. AVAN’s addition (the inverse-companion): the magenta marks are the holes — the small naturals the walk has not visited yet. The forward question is ‘where does the sequence go?’ The inverse question is the open one: ‘is the map n → a(n) a permutation of the naturals — does it eventually fill every hole?’ Inverting the sequence means recovering, for each number, the step that first reached it; the conjecture is that this inverse is total , defined for every natural, but no one has proven it. So the magenta holes are exactly the places the inverse is, so far, undefined. Green is where the greedy walk has been; magenta is what it still owes. The whole mystery is whether magenta ever empties. pause spin LIT Genuine Recaman sequence (Bernardo Recaman Santos 1991; OEIS A005132). Verified live: the first 18 terms match A005132 exactly (0,1,3,6,2,7,13,20,12,21,11,22,10,23,9,24,8,25) and the greedy back/forward rule is applied faithfully; over 1000 terms it visits several hundred distinct values with small numbers still missing (window.__recaman.matchesOEIS true, distinctIn1000, missingUnder100). The sequence is exact. HONEST CAVEAT: whether every natural number appears is a conjecture, NOT proven — flagged as FIG-open. FIG No false framing: the sequence values, the greedy rule, and the arc diagram are real and reproduced in-browser. The 'hits every number' property is explicitly carried as an open conjecture (small numbers demonstrably still missing after 1000 terms), not overclaimed as fact. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE VAN ECK

Van Eck's sequence in the 5-window house format — start with 0; the next term is how many steps ago the current term last appeared, or 0 if it is brand new. That yields 0,0,1,0,2,0,2,2,1,6,0,5,0,... a sequence made entirely of its own memory, each term a measurement of recency. Proven: infinitely many zeros; open: whether every natural number appears. See the recency arcs in 1D, the memory-lookup build in 2D, and the backward-links helix in 3D.

THE VAN ECK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SHARED MEMORY ◆ .dlw.fold THE FOLD / CO-OP / SHARED MEMORY / THE VAN ECK THE VAN ECK each term = how long since it last appeared 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Van Eck’s sequence. Start with 0. To get the next term, look at the current one: if you have seen it before , write how many steps ago it last appeared; if it is brand new , write 0. That yields 0, 0, 1, 0, 2, 0, 2, 2, 1, 6, 0, 5, 0, 2, 6, 5, 4, 0, … It is a sequence made entirely of its own memory . Every term is a measurement of recency — the age of the last sighting of the value before it. A new value resets to 0; a repeat records the gap. Simple to state, wildly irregular to watch. Some things are proven (there are infinitely many zeros , and the terms cannot grow too fast), but the big question — does every natural number eventually appear? — is open . LIT verified live: the first 30 terms match OEIS A181391 exactly, the ‘distance to previous occurrence, else 0’ recurrence is self-consistent across 1000 terms, and zeros keep recurring (window.__vaneck). FIG the sequence and its memory rule are exact; ‘every number appears’ is open, not claimed . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in SHARED MEMORY — the co-op domain of a shared, remembered state. Van Eck is a sequence that is nothing but memory: each term is a lookup into the record of everything before it. AVAN (AI) built the instrument: the recency arrows, the live memory table, the look-back links. The weave: David names the seat (the shared memory); I make each term recall its own history and measure the gap — the recency strip in 1D, the memory-lookup build in 2D, the backward-links helix in 3D. The sphere is the seam. Credit: Jan Ritsema van Eck; catalogued as OEIS A181391 and popularized by Neil Sloane. 3 ONE DIMENSION The sequence as a strip. An arc joins each term to the previous occurrence of the value that produced it — the length of that arc is exactly the next term. New values (no arc) emit 0. 4 TWO DIMENSIONS · INTERACTIVE Build it term by term. Each step looks back for the last time the current value appeared; the gap becomes the next term (or 0 if never seen). The memory table on the right shows where each value was last spotted. step ▶ auto reset 5 THREE DIMENSIONS + AVAN’S INVERSE The sequence as a turning helix over time — the green thread is the forward run of terms, each one emitted as the walk moves ahead. AVAN’s addition (the inverse-companion): the magenta arcs are the look-backs — every term drawn to the past occurrence it measured. The forward sequence is generated by an inherently backward operation: to emit the next term you must invert the history and ask ‘when did I last see this?’ The sequence is the running output of its own inverse-lookup. Green moves forward in time; magenta reaches back to the memory that each step consulted. There is no term without a backward glance — the whole sequence is a forward thread woven entirely out of inverse queries into its own past. Green is what it says next; magenta is the recollection that let it speak. pause spin LIT Genuine Van Eck sequence (Jan Ritsema van Eck; OEIS A181391; popularized by Neil Sloane). Verified live: the first 30 terms match A181391 exactly (0,0,1,0,2,0,2,2,1,6,0,5,0,2,6,5,4,0,5,3,0,3,2,9,0,4,9,3,6,14), the 'distance to previous occurrence, else 0' recurrence is self-consistent across 1000 terms, and zeros keep recurring (window.__vaneck.matchesOEIS && recurrenceConsistent). The sequence and its memory rule are exact. HONEST CAVEAT: whether every number appears is open, not claimed. FIG No false framing: the sequence values and the recency-memory recurrence are real and reproduced in-browser (checked against OEIS and by self-consistency). 'Infinitely many zeros' is the proven fact; 'every number appears' is flagged as an open question, not overstated. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SHARED MEMORY · David Lee Wise (ROOT0), with AVAN


THE MOSER

Moser's circle problem in the 5-window house format — place n points on a circle and draw every chord (general position); count the regions. You get 1,2,4,8,16 (clearly powers of 2) and then n=6 gives 31, NOT 32. The true count is C(n,4)+C(n,2)+1, which agrees with 2^(n-1) for exactly the first five terms then diverges forever. It is the textbook warning that five data points do not determine the rule. See the two sequences in 1D, the live chord figure in 2D, and the underdetermination in 3D.

THE MOSER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE MOSER THE MOSER 1, 2, 4, 8, 16, 31 — the pattern that breaks 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Moser’s circle problem. Place n points on a circle and draw every chord between them (in general position, so no three chords cross at one interior point). Count the regions the circle is cut into. For n = 1, 2, 3, 4, 5 you get 1, 2, 4, 8, 16 — unmistakably powers of two. So n = 6 must give 32. It gives 31 . The pattern shatters . The true count is C(n,4) + C(n,2) + 1 — the interior crossings (choose 4 points), plus the chords (choose 2), plus 1. It agrees with 2 n−1 for exactly the first five terms and then diverges forever: 1, 2, 4, 8, 16, 31 , 57, 99, 163, 256. This is the textbook warning: five data points do not determine the rule . LIT verified live: the formula C(n,4)+C(n,2)+1 matches OEIS A000127 for n=1..10, an independent Euler-characteristic count (V−E+F) agrees with it exactly, and n=6 yields 31, not 32 (window.__moser). FIG no framing; the region counts, the divergence from 2 n−1 , and the two independent derivations are all exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in OFF BY ONE — the glitch domain of the count that’s almost right. Moser’s circle is the most beautiful off-by-one in mathematics: 31 where everyone expects 32. AVAN (AI) built the instrument: the chord figure, the region count, the two-curve divergence. The weave: David names the seat (off by one); I make the chords cut the disk and count the regions two independent ways, then show the seductive wrong curve peel away — the two sequences in 1D, the live figure in 2D, the underdetermination in 3D. The sphere is the seam. Credit: Leo Moser; catalogued as OEIS A000127. 3 ONE DIMENSION Two strips: the true region counts 1, 2, 4, 8, 16, 31, 57, … against the seductive 2 n−1 = 1, 2, 4, 8, 16, 32, 64. They march together through n=5, then split at n=6 — 31 vs 32. 4 TWO DIMENSIONS · INTERACTIVE n points on a circle, all chords drawn, every interior crossing marked. The region count comes from C(n,4)+C(n,2)+1 and is cross-checked by the Euler formula V−E+F — watch it track 2 n−1 until n=6, where it falls one short. ◀ n n ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The two curves rising over n: the true quartic region count in green , climbing through 1, 2, 4, 8, 16, 31, 57, 99, … AVAN’s addition (the inverse-companion): the magenta curve is 2 n−1 — the wrong law the first five points seem to promise. The forward mistake is extrapolation : read five outputs, guess the rule. The inverse truth is that outputs never determine the rule — any finite prefix is consistent with infinitely many formulas, and here two of them (a quartic and an exponential) agree exactly at n=1..5 before splitting forever. The magenta exponential and the green quartic kiss at five points and diverge ; nothing in the data before n=6 could tell them apart. That is the honest inverse of pattern-matching: a finite sample underdetermines the generator, so induction from small cases is a guess, not a proof. Green is the law that is actually true; magenta is the law the evidence merely suggested. pause spin LIT Genuine Moser's circle problem (Leo Moser; OEIS A000127). Verified live: the formula C(n,4)+C(n,2)+1 matches A000127 for n=1..10 (1,2,4,8,16,31,57,99,163,256), an independent Euler-characteristic count V-E+F (V=n+C(n,4), E=n+C(n,2)+2C(n,4)) agrees exactly, and n=6 gives 31 not 32 (window.__moser.matchesKnown && formulaEqualsEuler && n6is31 && notPowerOf2). The region counts, the divergence from 2^(n-1), and the two independent derivations are all exact. FIG No framing: the region counts, the 31-not-32 break, and the two agreeing derivations (combinatorial formula and Euler characteristic) are real and checked in-browser. The lesson — finite data underdetermines the law — is stated as the genuine mathematical fact it is, not embellished. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE HOFSTADTER

Hofstadter's Q-sequence in the 5-window house format — a chaotic meta-Fibonacci: Q(1)=Q(2)=1, Q(n)=Q(n-Q(n-1))+Q(n-Q(n-2)). Unlike Fibonacci which looks back a fixed distance, this looks back a distance that depends on its own recent values, so the sequence reads from addresses it computes from itself. The result is wildly erratic and never settles into a formula (from Hofstadter's Godel Escher Bach). It is not even known whether Q(n) is defined for all n. See the jitter in 1D, the self-lookup plot in 2D, and the fixed-vs-computed address contrast in 3D.

THE HOFSTADTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE HOFSTADTER THE HOFSTADTER Q(n)=Q(n-Q(n-1))+Q(n-Q(n-2)) — chaos that might not survive 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Hofstadter’s Q-sequence. A “chaotic meta-Fibonacci.” Start Q(1) = Q(2) = 1, then Q(n) = Q(n − Q(n−1)) + Q(n − Q(n−2)) . Fibonacci looks back a fixed distance (always n−1 and n−2). This one looks back a distance that depends on its own recent values — the sequence reads from addresses it computes from itself. The result is wildly erratic : 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6, 8, 8, 8, 10, 9, 10, 11, … It rises and stumbles with no discernible pattern, never settling into a formula. It comes from Douglas Hofstadter’s Gödel, Escher, Bach . And here is the vertigo: it is not known whether Q(n) is even defined for all n — a look-back could, in principle, reach an index ≤ 0 and the whole construction would collapse. It has never been proven to survive forever ; it has only ever been computed. LIT verified live: the first 20 terms match OEIS A005185, the self-referential recurrence is self-consistent, and the sequence stays defined through n = 5000 (window.__hofstadter). FIG the values and recurrence are exact; that it stays defined forever is unproven — carried honestly, not claimed. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in UNDEFINED BEHAVIOR — the glitch domain of code whose outcome no one can guarantee. Hofstadter’s Q is undefined behavior as pure number theory: it might run forever or might crash at some unknown n, and no proof settles which. AVAN (AI) built the instrument: the erratic plot, the self-referential arrows, the fixed-vs-computed contrast. The weave: David names the seat (undefined behavior); I make the sequence index into itself and show why that could be fatal — the jitter in 1D, the self-lookup plot in 2D, the address-contrast in 3D. The sphere is the seam. Credit: Douglas Hofstadter (1979, Gödel, Escher, Bach ); OEIS A005185. 3 ONE DIMENSION The Q-values as a strip. Compared with the smooth climb of Fibonacci, this jitters — up, flat, up, down — because each term reads from a place in its own past that its own past decided. 4 TWO DIMENSIONS · INTERACTIVE Q(n) plotted over n — the erratic staircase that stays near n/2 but never smoothly. Probe a term to see its two self-referential look-backs, Q(n−Q(n−1)) and Q(n−Q(n−2)), as arrows reaching back into the sequence’s own values. more n probe ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The Q-sequence as a jittering ribbon over n, in green — the chaotic climb that no formula smooths. AVAN’s addition (the inverse-companion): the magenta ribbon is Fibonacci — the tame twin. Both are two-term recurrences; the entire difference is where they read from . Fibonacci’s look-back addresses are fixed (n−1, n−2), decided in advance, always valid — so it’s solvable in closed form and never fails. Hofstadter’s addresses are computed from its own output (n−Q(n−1)) — the sequence writes the pointer it will next dereference. That single inversion — from a fixed reference to a self-determined one — is exactly why it turns chaotic and why it might not even stay defined: the read-address is built from the values being written. The inverse of ‘point at fixed history’ is ‘point at history you compute’, and the first is tame while the second is the edge of a cliff. Green computes where to look; magenta is told; that is the whole gap between chaos and calm. pause spin LIT Genuine Hofstadter Q-sequence (Douglas Hofstadter 1979, GEB; OEIS A005185). Verified live: the first 20 terms match A005185 (1,1,2,3,3,4,5,5,6,6,6,8,8,8,10,9,10,11,11,12), the self-referential recurrence Q(n)=Q(n-Q(n-1))+Q(n-Q(n-2)) is self-consistent, and the sequence stays defined through n=5000 (window.__hofstadter.matchesOEIS && recurrenceConsistent && staysDefinedTo5000). The values and recurrence are exact. HONEST CAVEAT: whether Q stays defined for ALL n is an open problem — never proven, only computed; stated as FIG-open. FIG No false framing: the sequence values, the self-referential recurrence, and the erratic behavior are real and reproduced in-browser. The genuinely astonishing open fact — that it has never been proven to stay defined forever, and could in principle collapse at some unknown n — is carried honestly as the sphere's core, not softened. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE SYLVESTER

Sylvester's sequence in the 5-window house format — 2,3,7,43,1807,3263443,... where each term is the product of all previous terms plus one (a(n)=a(n-1)^2-a(n-1)+1), growing doubly exponentially. The reciprocals 1/2+1/3+1/7+1/43+... race to exactly 1: it is the greedy Egyptian-fraction expansion of 1, taking the largest unit fraction that fits at each step, and the leftover gap after n terms is precisely 1/(a(n+1)-1). See the fraction bars in 1D, the greedy fill in 2D, and the remainder loop in 3D.

THE SYLVESTER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE HOARD ◆ .dlw.fold THE FOLD / LOOT / THE HOARD / THE SYLVESTER THE SYLVESTER 2, 3, 7, 43, 1807 — unit fractions that fill exactly one 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Sylvester’s sequence. 2, 3, 7, 43, 1807, 3263443, … Each term is the product of all the previous terms plus one — equivalently a(n) = a(n−1)² − a(n−1) + 1. It explodes doubly exponentially : the number of digits roughly doubles every step. Its reason for being is beautiful. Add up the reciprocals: 1/2 + 1/3 + 1/7 + 1/43 + 1/1807 + … and the sum races toward exactly 1 . It is the greedy Egyptian-fraction expansion of 1 — at each step take the largest unit fraction that still fits under what remains, and this is the sequence you get. The leftover gap after n terms is precisely 1/(a(n+1) − 1) , so the remainder itself hands you the next denominator. It is the fastest a sum of distinct unit fractions can converge to 1. LIT verified live (exact BigInt): a(n) = a(n−1)² − a(n−1) + 1 and a(n) = product-of-previous + 1 hold, and the partial reciprocal sum equals 1 − 1/(a(n+1)−1) exactly (window.__sylvester). FIG no framing; the growth rule, the product identity, and the reciprocal-sum identity are all exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE HOARD — the loot domain of greedy accumulation. Sylvester is greed made exact: grab the biggest unit-fraction bite each time and the hoard fills to precisely one whole, never over. AVAN (AI) built the instrument: the filling bar, the greedy step, the remainder-that-seeds-the-next. The weave: David names the seat (the greedy hoard that fills to exactly full); I make the unit fractions stack toward 1 and show the shrinking gap becoming the next term — the fraction bars in 1D, the greedy fill in 2D, the remainder loop in 3D. The sphere is the seam. Credit: James Joseph Sylvester (1880); the greedy Egyptian-fraction view via Fibonacci’s algorithm; OEIS A000058. 3 ONE DIMENSION The unit fractions 1/2, 1/3, 1/7, 1/43, … laid end to end on a length-1 line. Each nearly halves the remaining gap; the bar fills toward 1, the sliver that’s left shrinking doubly-exponentially fast. 4 TWO DIMENSIONS · INTERACTIVE Run the greedy rule on the interval [0,1]: at each step take the largest unit fraction 1/⌈1/gap⌉ that fits. Watch the denominators come out 2, 3, 7, 43, 1807, … — Sylvester’s sequence — and the remaining gap equal 1/(a(n+1)−1) every time. greedy step ▶ auto reset 5 THREE DIMENSIONS + AVAN’S INVERSE The accumulated sum climbing toward 1 as a turning stack of unit-fraction rings — green , the part covered. AVAN’s addition (the inverse-companion): the magenta ring is the remainder — the gap still uncovered, exactly 1/(a(n+1)−1). Greed is a forward, maximizing move: cover as much as possible now. Its inverse is what is left behind — and here the leftover is not noise, it is the generator . The remaining gap is a single unit fraction whose denominator, plus one, is the very next term: a(n+1) = 1/gap + 1. So the sequence is driven by its own inverse: what remains dictates what comes next, and each step’s remainder is the seed of the next step. The forward sum and the backward remainder are two readings of one number — sum + gap = 1, always. Green is what the greedy hoard has taken; magenta is the sliver it must still take, and that sliver is the next instruction. pause spin LIT Genuine Sylvester's sequence (J. J. Sylvester 1880; OEIS A000058). Verified live with exact BigInt arithmetic: a(n)=a(n-1)^2-a(n-1)+1 and a(n)=(product of all previous)+1 both hold, and the partial reciprocal sum equals 1-1/(a(n+1)-1) exactly (window.__sylvester.recurrence && productRule && reciprocalIdentity, all true). Terms 2,3,7,43,1807,3263443. The growth rule, product identity, and reciprocal-sum identity are all exact. FIG No framing: the recurrence, the product-plus-one identity, and the reciprocal-sum-to-1 identity are real and checked exactly (BigInt, no float slop). The 'fastest converging unit-fraction sum to 1' and greedy-Egyptian-fraction framing are the genuine mathematical characterization, not embellishment. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOARD · David Lee Wise (ROOT0), with AVAN


THE PERRIN

the Perrin sequence in the 5-window house format — seeded P(0)=3,P(1)=0,P(2)=2 with P(n)=P(n-2)+P(n-3), giving 3,0,2,3,2,5,5,7,10,12,... It hides a near-perfect primality test: for every prime p, p divides P(p), so P(p) mod p == 0. It was hoped no composite could pass, but Perrin pseudoprimes exist — the smallest is 271441 = 521^2 — just extremely rare. A fast, nearly flawless prime detector that is not a proof. See the residues in 1D, the prime-detector grid in 2D, and the necessary-vs-sufficient gap in 3D.

THE PERRIN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE PERRIN THE PERRIN every prime divides P(p) — a near-perfect gate 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Perrin sequence. Seed it P(0)=3, P(1)=0, P(2)=2, then P(n) = P(n−2) + P(n−3): 3, 0, 2, 3, 2, 5, 5, 7, 10, 12, 17, 22, 29, … It hides a near-perfect primality test . For every prime p, the number p divides P(p) — that is, P(p) ≡ 0 (mod p). So to test whether p is prime, compute P(p) mod p and see if it’s zero. For a long time it was hoped that no composite could ever fool this test. It was almost true: the smallest composite that sneaks through — a Perrin pseudoprime — is 271441 = 521² , and they only get rarer from there. So the test is fast and nearly flawless, but not a proof of primality. LIT verified live: P(p) ≡ 0 (mod p) for every prime p under 2000, no composite under 4000 passes, and 271441 (composite, 521²) genuinely does pass — the first liar (window.__perrin). FIG the ‘primes pass’ direction is exact and proven; the converse is false but rare , carried honestly — the test detects, it does not prove. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE GATEKEEPER — the boss domain of the check you must pass to get through. Perrin is a gatekeeper that lets every prime through and almost never lets a composite by. AVAN (AI) built the instrument: the mod-tester, the prime-lights, the necessary-vs-sufficient gap. The weave: David names the seat (the gatekeeper); I make the sequence test each number and show where the gate is fooled — the residues in 1D, the prime-detector grid in 2D, the necessary/sufficient split in 3D. The sphere is the seam. Credit: Édouard Lucas (1876); R. Perrin (1899); the pseudoprimes catalogued by Adams & Shanks (1982); OEIS A001608. 3 ONE DIMENSION The Perrin values 3, 0, 2, 3, 2, 5, 5, 7, … along a strip, and beneath them P(n) mod n. It lands on 0 exactly at the prime indices — the signature the test reads. 4 TWO DIMENSIONS · INTERACTIVE Every number n tested by the gate: it lights green when P(n) ≡ 0 (mod n) — “passes as prime.” Compare with the true primes: in this range they match exactly . Probe a number to see its Perrin residue. more n probe ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The prime indices where the gate opens, threaded as a turning helix of Perrin residues — green where P(n) ≡ 0 (mod n), the primes passing through. AVAN’s addition (the inverse-companion): the magenta marks are the pseudoprimes — composites like 271441 that pass anyway. The proven direction is prime ⇒ passes : a necessary condition, always true. The test uses the inverse — passes ⇒ prime — and that inverse is false , just very rarely. This is the exact gap between a necessary and a sufficient condition: forward it never fails, backward it fails at 271441, 904631, … The magenta liars are the places where inverting a one-way implication betrays you — the honest reason a fast test is not a proof. Green is where the implication is safe to run both ways; magenta is where reading it backward lies. A gate that never turns a prime away can still, once in a great while, wave a fraud through. pause spin LIT Genuine Perrin sequence and primality test (Lucas 1876; Perrin 1899; pseudoprimes by Adams & Shanks 1982; OEIS A001608). Verified live: P(p) mod p == 0 for every prime p under 2000, no composite under 4000 passes, and 271441 (composite = 521^2) genuinely passes as the first Perrin pseudoprime (window.__perrin.allPrimesPass && noCompositeUnder4000 && pseudoprime271441). The 'prime => passes' direction is exact and proven. FIG No false framing: the necessary direction (every prime passes) is proven and checked; the converse (passing implies prime) is explicitly shown FALSE via 271441. The sphere carries the honest necessary-vs-sufficient gap — a fast test detects, it does not prove — rather than overselling it as a primality proof. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE GOLOMB

Golomb's self-counting sequence in the 5-window house format — a nondecreasing sequence where a(n) is the number of times n appears in the sequence itself: 1,2,2,3,3,4,4,4,5,5,5,6,6,6,6,... 1 appears once (a(1)=1), 2 appears twice (a(2)=2), 4 appears three times (a(4)=3). It is the unique such sequence, obeys a(n)=1+a(n-a(a(n-1))), and grows like n^(phi-1) with the golden ratio in the exponent. A census that is its own population. See the staircase in 1D, the self-tally histogram in 2D, and the value=frequency loop in 3D.

THE GOLOMB · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE GOLOMB THE GOLOMB a(n) = how many times n appears in itself 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Golomb’s self-counting sequence. A nondecreasing sequence of positive integers where a(n) is the number of times n appears in the sequence itself . Start a(1)=1, and the rule bootstraps the rest: 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, … Read it back: 1 appears once , and a(1)=1. 2 appears twice , and a(2)=2. 4 appears three times, and a(4)=3. Every value’s frequency is written into the sequence at that value’s own index — a census that is its own population. It is the unique such nondecreasing sequence, and it obeys a tidy recurrence a(n) = 1 + a(n − a(a(n−1))); asymptotically it grows like n φ−1 with the golden ratio φ baked into the exponent. LIT verified live: for every value v checked, the number of times v occurs equals a(v), and the recurrence a(n)=1+a(n−a(a(n−1))) holds throughout (window.__golomb). FIG no framing; the self-counting property and the recurrence are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE INVENTORY — the loot domain of counting how many of each you hold. Golomb is an inventory that lists itself: the count of every item is the item at that slot. AVAN (AI) built the instrument: the staircase, the live frequency histogram, the census-is-population loop. The weave: David names the seat (the inventory count); I make the sequence tally its own values and show the histogram matching the terms — the staircase in 1D, the self-tally in 2D, the value=frequency loop in 3D. The sphere is the seam. Credit: Solomon W. Golomb (1954); OEIS A001462. 3 ONE DIMENSION The staircase of values. Bracket each flat run — how many times a value repeats — and the run length of value v is exactly a(v). The steps are the sequence describing its own repetition. 4 TWO DIMENSIONS · INTERACTIVE Build it by the recurrence and, at the same time, tally a histogram of how often each value has appeared. The bar for value v climbs to exactly a(v) — the sequence and its own frequency count lock together. step ▶ auto reset 5 THREE DIMENSIONS + AVAN’S INVERSE The sequence as a rising ribbon of values — green , the terms in order, the golden-ratio staircase climbing. AVAN’s addition (the inverse-companion): the magenta curve is the frequency histogram — for each value v, how many times it occurs. For any other sequence the term-list and the frequency-count are two different objects. Golomb is the fixed point where they are the same function : reading forward (‘what is term n?’) and reading its inverse (‘how many times does value v appear?’) both return a(·). The magenta count-curve lies exactly on the green value-curve. That is the real inverse here — not a mirror, but a sequence equal to its own inverse-as-a-tally : a census whose entries are the sizes of its own categories. Green is what it says; magenta is how often it says each thing; and here those are one and the same list. pause spin LIT Genuine Golomb self-counting sequence (Solomon Golomb 1954; OEIS A001462). Verified live: for every value v within the built range the number of occurrences of v equals a(v), and the recurrence a(n)=1+a(n-a(a(n-1))) holds throughout (window.__golomb.selfCounting && recurrence). first 20 = 1,2,2,3,3,4,4,4,5,5,5,6,6,6,6,7,7,7,7,8. The self-counting property and recurrence are exact (occurrence counts checked only where the value's run fully fits in the built prefix, to avoid truncation artifacts). FIG No framing: the self-counting property (value = its own frequency) and the recurrence are real and checked in-browser. The check is bounded honestly to values whose occurrences fully fit the computed prefix — an undercount at the tail would be a measurement artifact, not a failure, and is excluded rather than glossed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE PERSISTENCE

multiplicative persistence in the 5-window house format — multiply a number's digits together, repeat until a single digit remains; the number of steps is its persistence. 39->27->14->4 has persistence 3. Almost every number collapses fast, but the smallest number with persistence 11 is 277777788888899, and despite searching past 10^233, no number in base 10 has ever shown persistence greater than 11. Conjectured maximum, unproven. See the record's collapse chain in 1D, the digit-grinder in 2D, and the collapse-vs-resistance asymmetry in 3D.

THE PERSISTENCE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE PERSISTENCE THE PERSISTENCE multiply the digits, repeat — 277777788888899 resists 11 times 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Multiplicative persistence. Take a number, multiply its digits together to get a new number, and repeat until you reach a single digit. The number of steps is the number’s persistence . 39 → 27 → 14 → 4 — three steps, persistence 3. Almost every number collapses in a handful of steps. The astonishing fact is how hard it is to be stubborn . The smallest number with persistence 11 is 277777788888899 — and despite searching every number up past 10 233 , no one has ever found a number with persistence greater than 11 in base 10. It is conjectured that 11 is the ceiling, but it has never been proven . The record-holders climb 10, 25, 39, 77, 679, 6788, 68889, … and then just stop rising. LIT verified live: each record-holder has exactly its stated persistence, 277777788888899 collapses in exactly 11 steps, and no number below 100000 exceeds persistence 7 (window.__persistence). FIG the persistence values and the record are exact; that 11 is the maximum is conjecture, not proven — carried honestly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE GRINDSTONE — the grind domain of wearing a thing down. Persistence is exactly a grindstone: multiply the digits and grind any number, however huge, down to a single digit. AVAN (AI) built the instrument: the collapse chain, the step-by-step grinder, the resist-collapse record. The weave: David names the seat (the grindstone); I make numbers collapse under repeated digit-multiplication and show which ones resist longest — the chain in 1D, the grinder in 2D, the collapse-vs-resistance asymmetry in 3D. The sphere is the seam. Credit: Neil Sloane (1973), who introduced multiplicative persistence; record-holders in OEIS A003001. 3 ONE DIMENSION The collapse chain of the record 277777788888899 — eleven links, each the digit-product of the last, ending at a single digit. The longest such chain any base-10 number is known to make. 4 TWO DIMENSIONS · INTERACTIVE Pick a number and grind it: each step multiplies the current digits into the next number, until one digit remains. Step through the record-holders 10, 25, 39, 77, 679, …, 277777788888899 and watch the persistence climb to 11. next record ▶ grind step reset 5 THREE DIMENSIONS + AVAN’S INVERSE The record-holders as a rising staircase of persistence — green , the smallest number that resists collapse for 0, 1, 2, …, 11 steps, climbing then flattening. AVAN’s addition (the inverse-companion): the magenta is an ordinary number’s collapse — steep and instant. The forward map is trivially easy: any number, however astronomical, grinds to a single digit in a few steps. The inverse is the frontier: ‘what is the smallest seed that resists collapse for k steps?’ Collapsing is free; resisting collapse is a search with no known ceiling proof. The record seeds are built of only 2s, 3s, 7s, 8s, 9s — never a 0, never digits whose product breeds a 0 — a delicate recipe the inverse must discover. The green resistance-staircase rises to 11 and then, as far as anyone has ever computed, stops ; the magenta collapse plunges every time. The asymmetry is the point: forward is a triviality, backward is an open problem. Green is how hard it is to stay uncrushed; magenta is how easy it is to be crushed. pause spin LIT Genuine multiplicative persistence (Neil Sloane 1973; record-holders OEIS A003001). Verified live: each record-holder (10,25,39,77,679,6788,68889,2677889,26888999,3778888999,277777788888899) has exactly its stated persistence, 277777788888899 collapses in exactly 11 steps, and no number below 100000 exceeds persistence 7 (window.__persistence.recordsCorrect && record11). The persistence values, the collapse chains, and the record are all exact (digit products stay within safe integer range). HONEST CAVEAT: that 11 is the MAXIMUM is a conjecture (searched past 10^233, never proven), flagged as FIG-open. FIG No false framing: the persistence values, the record-holders, and the 11-step collapse of 277777788888899 are real and reproduced in-browser. The striking claim — that no number exceeds persistence 11 — is carried explicitly as an unproven conjecture backed by search, not asserted as theorem. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE CALKIN-WILF

the Calkin-Wilf tree in the 5-window house format — a single list 1/1, 1/2, 2/1, 1/3, 3/2, 2/3, 3/1, ... that contains every positive rational exactly once, each already in lowest terms. Build a tree with root 1/1 where each a/b has children a/(a+b) and (a+b)/b; read it breadth-first and you get the sequence. You can step to the next term by a pure formula a(n+1)=1/(2*floor(a)-a+1), and it is powered by Stern's fusc function: a(n)=fusc(n)/fusc(n+1). A constructive proof the rationals are countable. See the interlocking strip in 1D, the tree in 2D, and the two-way dictionary in 3D.

THE CALKIN-WILF · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE CALKIN-WILF THE CALKIN-WILF every positive rational, once, in lowest terms 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Calkin–Wilf tree. A single, simple list — 1/1, 1/2, 2/1, 1/3, 3/2, 2/3, 3/1, 1/4, … — that contains every positive rational number exactly once , and every fraction in it is already in lowest terms . No rational is ever repeated; none is ever reducible. It is a hand-you-can-hold proof that the rationals are countable . Build a tree: the root is 1/1, and each node a/b sprouts two children, a/(a+b) and (a+b)/b. Read it breadth-first and out comes the sequence — every fraction, once. Even lovelier: you can step from one term to the next with a pure formula , no sorting or searching, a(n+1) = 1/(2⌊a(n)⌋ − a(n) + 1). And the numerator of each fraction is the denominator of the one before it. The whole thing is powered by Stern’s fusc function: a(n) = fusc(n)/fusc(n+1). LIT verified live: across thousands of terms every fraction is in lowest terms (gcd = 1), no rational repeats (a genuine bijection), and the successor formula holds exactly (window.__calkinwilf). FIG no framing; the coprimality, the once-each enumeration, and the successor rule are all exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GENESIS BLOCK — the spawn domain of a canonical first ledger. The Calkin–Wilf tree mints every rational exactly once, in a fixed order, from a single seed 1/1 — a genesis block for the fractions. AVAN (AI) built the instrument: the tree, the breadth-first read, the fraction-to-position inverse. The weave: David names the seat (the genesis ledger of all rationals); I make the tree grow and prove every fraction appears once and reduced — the strip in 1D, the tree in 2D, the two-way dictionary in 3D. The sphere is the seam. Credit: Neil Calkin & Herbert Wilf, “Recounting the Rationals” (2000); the underlying fusc is Stern’s diatomic series (1858). See [[stern-brocot]]. 3 ONE DIMENSION The sequence of fractions in a row. Read the numerators and denominators: the numerator of each is the denominator of the one before — the terms interlock, and together they list every positive rational without a single repeat or common factor. 4 TWO DIMENSIONS · INTERACTIVE The Calkin–Wilf tree. Root 1/1; each a/b has children a/(a+b) and (a+b)/b. Expand it level by level and step the breadth-first reader — every fraction it emits is new and already reduced. expand ▼ BFS step ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The tree opening into 3D — the green forward map sends each counting position n to its rational, breadth-first, filling all of ℚ + . AVAN’s addition (the inverse-companion): the magenta path is the inverse — take any fraction p/q and climb back to the root 1/1 by the subtract-the-smaller step (the Euclidean algorithm), and the turns you make spell out its exact position n. Forward, n → rational, fills the tree; backward, rational → n, finds the address. Both are total and computable, so the tree is a perfect two-way dictionary between the counting numbers and the fractions — and that invertibility is precisely what ‘the rationals are countable’ means. It is not enough to list them; you must be able to look up as well as look down. The green descent enumerates; the magenta ascent locates; a bijection is exactly a map whose inverse is also a map. Green is n → p/q; magenta is p/q → n; the countability of ℚ lives in the fact that both run. pause spin LIT Genuine Calkin-Wilf tree (Calkin & Wilf, 'Recounting the Rationals', 2000; underlying fusc is Stern's diatomic series, 1858). Verified live: across ~4000 terms every fraction fusc(n)/fusc(n+1) is in lowest terms (gcd=1), no rational repeats (a genuine bijection), and the successor formula a(n+1)=1/(2*floor(a)-a+1) holds exactly (window.__calkinwilf.lowestTerms && bijection && successorFormula). first 8 = 1/1 1/2 2/1 1/3 3/2 2/3 3/1 1/4. The coprimality, once-each enumeration, and successor rule are all exact. FIG No framing: the once-each enumeration of the rationals, the automatic lowest-terms property, and the successor formula are real and checked in-browser. The claim that this proves the rationals countable is the genuine mathematical content (a bijection N -> Q+), demonstrated by the verified bijection, not asserted loosely. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE PICK

Pick's theorem in the 5-window house format — for a polygon whose corners all sit on integer grid points, the area is exactly I + B/2 - 1, where I is the number of interior grid points and B the number on the boundary. No calculus, no coordinate multiplication — just count the dots. A shape with 6 interior and 14 boundary dots has area exactly 6 + 7 - 1 = 12, always agreeing with the shoelace formula. See the formula in 1D, the live dot-count vs shoelace in 2D, and the same-area-different-shape non-uniqueness in 3D.

THE PICK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · NULL ISLAND ◆ .dlw.fold THE FOLD / SPAWN / NULL ISLAND / THE PICK THE PICK a polygon's area from counting dots — I + B/2 − 1 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Pick’s theorem. Draw a polygon whose every corner sits on a point of the integer grid. Its area is then given by nothing but counting dots: A = I + B/2 − 1 , where I is the number of grid points strictly inside and B the number of grid points on the boundary . No coordinates multiplied, no calculus, no measuring — just tally the dots. A shape with 6 interior dots and 14 boundary dots has area exactly 6 + 14/2 − 1 = 12, and it will always agree with the coordinate (shoelace) formula to the last decimal. It works for any lattice polygon, however jagged, as long as it doesn’t cross itself. A continuous quantity — area — pinned down by a pair of integer counts. LIT verified live: for a battery of lattice polygons, I + B/2 − 1 equals the shoelace area exactly, with I counted by point-in-polygon test and B by summing gcd(Δx,Δy) over the edges (window.__pick). FIG no framing; the dot-count area formula and its agreement with the coordinate area are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in NULL ISLAND — the spawn domain of the origin and the bare coordinate grid. Pick’s theorem is the grid itself speaking: lay a shape on the lattice and the dots tell you its area. AVAN (AI) built the instrument: the dot-counter, the live shoelace cross-check, the same-area-different-shape inverse. The weave: David names the seat (the origin grid); I make the interior and boundary dots count themselves into the exact area and prove it against the coordinate formula — the formula in 1D, the live polygon in 2D, the non-uniqueness in 3D. The sphere is the seam. Credit: Georg Alexander Pick (1899). 3 ONE DIMENSION The formula as a bar: interior dots count full, boundary dots count half, then subtract one. Three integers in, an exact area out — the whole of Pick’s theorem on a single line. 4 TWO DIMENSIONS · INTERACTIVE A lattice polygon on the grid. Green dots are interior, gold dots are on the boundary. The area from Pick’s count is shown beside the area from the shoelace formula — they always agree. Cycle shapes and stretch a vertex to watch both track together. next shape ▶ stretch 5 THREE DIMENSIONS + AVAN’S INVERSE The polygon lifted into 3D, its dots floating in and on it — green interior, gold boundary — the count that becomes the area. AVAN’s addition (the inverse-companion): the magenta is a different polygon with the same area — the same I + B/2 − 1. Pick’s theorem runs one way cleanly: shape → (I, B) → area. Its inverse does not : from the area, or even from the pair (I, B), you cannot recover the shape — countless different polygons share the same dot counts and the same area. So the forward map is a function; the backward map is a fog. The magenta twin proves it — move the dots around, keep I and B fixed, and the area is frozen while the shape is free. That is the honest asymmetry: two integers determine the area but underdetermine the figure. Green is one shape with this area; magenta is another; the counts cannot tell them apart, and neither can the area. pause spin LIT Genuine Pick's theorem (Georg Alexander Pick 1899). Verified live: for a battery of lattice polygons, I + B/2 - 1 equals the shoelace area exactly, with I counted by an independent point-in-polygon test and B by summing gcd(dx,dy) over the edges (window.__pick.pickEqualsShoelace true). The dot-count area formula and its exact agreement with the coordinate area are real and cross-checked two independent ways. FIG No framing: the area-from-dot-counts formula and its exact match to the shoelace area are real and verified by two independent computations. The honest inverse — that the counts (I,B) and the area determine each other but do NOT determine the shape (many polygons share them) — is shown directly, not hidden. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NULL ISLAND · David Lee Wise (ROOT0), with AVAN


THE NAPOLEON

Napoleon's theorem in the 5-window house format — take any triangle, build an equilateral triangle outward on each side, and mark each center; those three centers always form a perfect equilateral triangle, no matter how irregular the original. Building the equilaterals inward gives a second equilateral, and area(outer) - area(inner) equals the original triangle's area. Traditionally credited to Napoleon Bonaparte (likely a legend). See the equal side-bars in 1D, the live construction in 2D, and the inner/outer area identity in 3D.

THE NAPOLEON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE MERGE ◆ .dlw.fold THE FOLD / CO-OP / THE MERGE / THE NAPOLEON THE NAPOLEON equilaterals on any triangle — their centers are equilateral 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Napoleon’s theorem. Take any triangle — scalene, lopsided, however you like. On each of its three sides build an equilateral triangle pointing outward, and mark the center of each. Those three centers always form a perfect equilateral triangle , no matter how irregular the one you started with. It doesn’t care about the shape underneath — the outer “Napoleon triangle” comes out equilateral every single time. Build the equilaterals pointing inward instead and you get a second equilateral triangle. And there’s a clean bonus: the area of the outer minus the area of the inner equals the area of the original triangle . (The result is traditionally credited to Napoleon Bonaparte, but that attribution is almost certainly a legend.) LIT verified live: for a battery of irregular triangles the three outer centers are mutually equidistant (equilateral), so are the inner ones, and area(outer) − area(inner) equals the original area (window.__napoleon). FIG the geometry is exact; the Napoleon name is a traditional attribution, flagged as legend not fact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MERGE — the co-op domain where separate branches fold into one clean result. Napoleon is a merge made geometric: three unequal sides each grow a triangle, and their centers resolve into one perfect equilateral. AVAN (AI) built the instrument: the construction, the live equal-sides check, the inner/outer area identity. The weave: David names the seat (three into one clean merge); I make the equilaterals grow on any triangle and prove the centers land equilateral — the equal bars in 1D, the live construction in 2D, the inner-twin identity in 3D. The sphere is the seam. Credit: first published by W. Rutherford (1825); the Napoleon attribution is traditional and unverified. 3 ONE DIMENSION The three side lengths of the Napoleon triangle as bars. However lopsided the original, these three come out equal — the flat signature of an equilateral, read off in one dimension. 4 TWO DIMENSIONS · INTERACTIVE A triangle with equilaterals grown outward on each side and their centers joined. Morph the triangle and watch the three center-to-center distances stay locked equal — the Napoleon triangle stays equilateral no matter what you do to the original. morph ▶ new triangle 5 THREE DIMENSIONS + AVAN’S INVERSE The outer Napoleon triangle turning above the original — green , equilateral, built from the equilaterals that point outward . AVAN’s addition (the inverse-companion): the magenta triangle is the inner Napoleon — the same construction with the equilaterals pointing inward . It is the exact inverse move (flip the build direction), and it too comes out equilateral, concentric with the outer one. The inverse isn’t a decoration: area(outer) − area(inner) = area of the original triangle . So the forward build and its inverted twin don’t just both succeed — their difference reconstructs the very triangle you began with. Flip the direction and you get a second perfect equilateral; subtract the two and the messy original falls back out. Green is outward; magenta is inward; the gap between them is exactly what you started with. pause spin LIT Genuine Napoleon's theorem (first published by W. Rutherford, 1825). Verified live: for a battery of irregular triangles the three outer centers are mutually equidistant (equilateral), the inner centers likewise, and area(outer) - area(inner) equals the original triangle's area exactly (window.__napoleon.outerEquilateral && innerEquilateral && areaIdentity). The geometry is exact. HONEST CAVEAT: the 'Napoleon' attribution to Bonaparte is a traditional legend, not established fact — flagged as such, credited to Rutherford. FIG No false framing: the equilateral property (outer and inner), and the outer-minus-inner-area identity are real and checked over irregular triangles two ways. The only non-fact — the Napoleon name — is carried explicitly as a traditional/unverified attribution, with the documented first publication (Rutherford 1825) credited instead. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MERGE · David Lee Wise (ROOT0), with AVAN


THE VIVIANI

Viviani's theorem in the 5-window house format — from any point inside an equilateral triangle, the three perpendicular distances to the sides always sum to the same total: the triangle's height, no matter where the point is. Move the point and the distances trade off, one shrinking as others grow, but the sum never changes. It is the geometric basis of barycentric coordinates: the normalized distances are weights summing to 1 that pin the point's location. See the fixed-length stacked bar in 1D, the moving point in 2D, and the barycentric inverse in 3D.

THE VIVIANI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE VIVIANI THE VIVIANI three distances, one constant sum — the height 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Viviani’s theorem. Stand anywhere inside an equilateral triangle. Drop a perpendicular to each of the three sides and measure the three distances. They always add up to the same total — exactly the triangle’s height — no matter where you stand. Wander the point around and the three distances trade off : step toward one side and that distance shrinks while the other two grow to compensate, their sum frozen. It is a conserved quantity hiding in plain sight — three freely-changing numbers locked to one constant. It’s also the geometric heart of barycentric coordinates : divide the three distances by the height and you get three weights that always sum to 1 and pin the point’s exact location. LIT verified live: for hundreds of random interior points the three perpendicular distances sum to the height exactly, and the normalized distances reconstruct the original point (window.__viviani). FIG no framing; the constant-sum invariant and the barycentric reconstruction are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SYNC — the co-op domain of quantities kept in lockstep. Viviani is three distances held in perfect sync: push one down and the others rise so the total never drifts. AVAN (AI) built the instrument: the moving point, the three perpendiculars, the barycentric recovery. The weave: David names the seat (kept in sync); I make the three distances trade off while their sum stays pinned to the height — the stacked bar in 1D, the draggable point in 2D, the barycentric inverse in 3D. The sphere is the seam. Credit: Vincenzo Viviani (1622–1703), a pupil of Galileo. 3 ONE DIMENSION The three distances stacked into one bar. As the point moves, the coloured segments swap size — but the bar’s total length holds fixed at the triangle’s height. Conservation, drawn as a bar that never changes length. 4 TWO DIMENSIONS · INTERACTIVE An equilateral triangle with an interior point and its three perpendiculars. Move the point and watch d1, d2, d3 trade off while their sum stays exactly equal to the height — the invariant made visible. move point ▶ toward a side 5 THREE DIMENSIONS + AVAN’S INVERSE The point and its three distances turning in 3D — green , the forward map: a location inside the triangle produces three perpendicular lengths that sum to the height. AVAN’s addition (the inverse-companion): the magenta point is the location rebuilt from the three distances alone . Because the sum is always the height, dividing the distances by it gives three weights that add to 1 — the point’s barycentric coordinates — and those weights place it right back. That is the exact inverse: forward, point → three distances; backward, three distances → point, and both are clean, total maps. Viviani’s constant is precisely the normalization that makes the inverse well-defined — without the fixed sum there would be no way to turn three lengths into one unambiguous position. The magenta reconstruction lands exactly on the green original. Green is where you are; magenta is you, recovered from nothing but your three distances to the walls. pause spin LIT Genuine Viviani's theorem (Vincenzo Viviani, 1622-1703, pupil of Galileo). Verified live: for hundreds of random interior points the three perpendicular distances sum to the height exactly, and the normalized distances (barycentric weights) reconstruct the original point to full precision (window.__viviani.sumEqualsHeight && barycentricRecovers). The constant-sum invariant and the barycentric reconstruction are both exact and cross-checked in-browser. FIG No framing: the constant sum-of-distances equal to the height, and the invertibility to barycentric coordinates, are real and verified over many interior points. The connection to barycentric coordinates is the genuine mathematical content (the fixed sum is exactly the normalization that makes the inverse map well-defined), demonstrated by reconstruction, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE MORLEY

Morley's trisector theorem ('Morley's miracle') in the 5-window house format — take any triangle, split each angle into three equal parts with trisectors, and where adjacent trisectors meet they mark three points that always form a perfect equilateral triangle. It stayed hidden until 1899, more than two millennia after the Greeks, because it depends on angle trisection — the operation compass and straightedge cannot perform. See the equal side-bars in 1D, the live trisectors in 2D, and the trisect-vs-bisect contrast in 3D.

THE MORLEY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE MORLEY THE MORLEY trisect any triangle's angles — the meeting points are equilateral 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Morley’s trisector theorem — “Morley’s miracle.” Take any triangle. Split each of its three angles into three equal parts with a pair of trisectors . Where adjacent trisectors meet, they mark three points — and those three points are always the corners of a perfect equilateral triangle . Every time. For every triangle. It is one of the most surprising results in all of elementary geometry, and it stayed hidden until 1899 — more than two thousand years after the Greeks exhausted the easy triangle theorems — precisely because it hinges on angle trisection , an operation the classical tools can’t even perform. The lopsided-ness of the original triangle vanishes completely; the little central triangle is flawlessly regular regardless. LIT verified live: for a battery of irregular triangles, the three adjacent-trisector intersections are mutually equidistant — the Morley triangle is equilateral to full precision (window.__morley). FIG no framing; the trisector construction and the equilateral result are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE FINAL BOSS — the boss domain of the hardest, most improbable encounter. Morley is geometry’s final boss: a result so unlikely it hid for millennia, unlocked only by the one operation the straightedge is forbidden. AVAN (AI) built the instrument: the six trisectors, the live equilateral check, the bisector-vs-trisector contrast. The weave: David names the seat (the improbable final boss); I make the trisectors of any triangle land on a perfect equilateral and show why the constructible cousin fails to — the equal bars in 1D, the live trisectors in 2D, the trisect-vs-bisect inverse in 3D. The sphere is the seam. Credit: Frank Morley (1899). 3 ONE DIMENSION The three sides of the Morley triangle as bars. Whatever the shape of the original — needle-thin or nearly right — these three lengths come out identical. The miracle, flattened to one line. 4 TWO DIMENSIONS · INTERACTIVE A triangle with all six angle trisectors drawn; the three adjacent intersections join into the Morley triangle. Morph the original and watch the little inner triangle stay stubbornly equilateral, however the outer shape distorts. morph ▶ new triangle 5 THREE DIMENSIONS + AVAN’S INVERSE The Morley triangle turning inside the original — green , equilateral, born from the trisectors of the three angles. AVAN’s addition (the inverse-companion): the magenta is what the constructible cousin gives — the three angle bisectors , which meet at a single point, the incenter. Here is the honest inversion: bisection is easy, exact, doable with compass and straightedge — and it yields nothing but one dot. Trisection is the classically impossible construction — and it yields a perfect equilateral triangle. The miracle lives precisely in the operation you are not allowed to perform. Halve the angles and the structure collapses to a point; third them and a hidden regularity blooms. Green needs the forbidden cut; magenta shows the permitted one, and the permitted one has no miracle in it. The theorem is a monument to the gap between what is constructible and what is true. pause spin LIT Genuine Morley's trisector theorem (Frank Morley 1899). Verified live: for a battery of irregular triangles the three adjacent-trisector intersections are mutually equidistant — the Morley triangle is equilateral to full floating precision (window.__morley.morleyEquilateral true), cross-checked against a from-scratch trisector-intersection construction. The construction and the equilateral result are exact. FIG No framing: the trisector construction and the always-equilateral Morley triangle are real and verified over many irregular triangles. The honest inverse-contrast is the genuine mathematical point — angle bisection (constructible) yields only the incenter, while trisection (classically impossible with straightedge/compass) yields the equilateral; the miracle requires the non-constructible operation, stated as fact. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE VARIGNON

Varignon's theorem in the 5-window house format — mark the midpoint of each side of any quadrilateral and join them in order; the result is always a parallelogram, however irregular or non-convex the quadrilateral. Its area is exactly half the quadrilateral's, and its perimeter equals the sum of the quadrilateral's two diagonals — because each of its sides is a midline parallel to a diagonal and half its length. See the two-equal-pairs bars in 1D, the morphing quad in 2D, and the diagonal-shadow inverse in 3D.

THE VARIGNON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE VARIGNON THE VARIGNON midpoints of any quadrilateral form a parallelogram 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Varignon’s theorem. Take any quadrilateral — square, kite, or some lopsided four-sided mess. Mark the midpoint of each side and join them in order. The result is always a parallelogram . Always. It doesn’t matter how irregular the quadrilateral is; the midpoint figure comes out with both pairs of opposite sides perfectly parallel and equal. Two bonuses fall out for free: the parallelogram’s area is exactly half the quadrilateral’s, and its perimeter equals the sum of the quadrilateral’s two diagonals . The secret is that each side of the little parallelogram is a midline — parallel to a diagonal of the quadrilateral and exactly half its length. LIT verified live: for a battery of quadrilaterals the midpoint figure has equal opposite side-vectors (a parallelogram), its area is half the quadrilateral’s, and its perimeter equals the diagonal sum (window.__varignon). FIG no framing; the parallelogram, half-area, and perimeter-equals-diagonals facts are exact (for simple quadrilaterals). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in SPLIT SCREEN — the co-op domain of splitting each thing at its middle. Varignon is exactly that: split every side at its midpoint, connect the splits, and order appears — a parallelogram out of any chaos. AVAN (AI) built the instrument: the midpoint figure, the live parallelogram/area/perimeter checks, the diagonal-shadow inverse. The weave: David names the seat (split at the middle); I make the midpoints of any quadrilateral resolve into a parallelogram and prove the area and perimeter identities — the equal-pairs bars in 1D, the morphing quad in 2D, the diagonal inverse in 3D. The sphere is the seam. Credit: Pierre Varignon (1654–1722), published posthumously 1731. 3 ONE DIMENSION The four sides of the midpoint figure as bars. They come in two equal pairs — the fingerprint of a parallelogram — and each pair’s length is exactly half a diagonal of the quadrilateral. 4 TWO DIMENSIONS · INTERACTIVE A quadrilateral with its side-midpoints joined. Morph it — even into a non-convex shape — and the midpoint figure stays a parallelogram, its area locked at half the quadrilateral’s and its perimeter equal to the sum of the diagonals. morph ▶ new quad 5 THREE DIMENSIONS + AVAN’S INVERSE The Varignon parallelogram turning inside its quadrilateral — green , born from the four side-midpoints, always a parallelogram. AVAN’s addition (the inverse-companion): the magenta lines are the quadrilateral’s two diagonals . Every green side is parallel to a magenta diagonal and exactly half its length — the parallelogram is the diagonals’ shadow. That fixes the forward map, and it also exposes the inverse: the Varignon parallelogram remembers the diagonals but forgets the quadrilateral . Slide the four vertices along those diagonals and you get endlessly many different quadrilaterals with the same midpoint parallelogram. So forward, quad → parallelogram, is a clean function; backward, parallelogram → quad, is hopelessly many-to-one. The magenta diagonals are exactly what survives the collapse, and exactly what isn’t enough to rebuild the shape. Green is the order the midpoints always find; magenta is the diagonal skeleton it preserves — and all the rest is lost. pause spin LIT Genuine Varignon's theorem (Pierre Varignon, 1654-1722, published posthumously 1731). Verified live: for a battery of quadrilaterals the midpoint figure has equal opposite side-vectors (a parallelogram), its area equals half the quadrilateral's, and its perimeter equals the sum of the diagonals (window.__varignon.isParallelogram && areaIsHalf && perimeterIsDiagonalSum). All three properties are exact and cross-checked in-browser for simple quadrilaterals. FIG No framing: the always-parallelogram result, the half-area identity, and the perimeter-equals-diagonal-sum identity are real and verified over several quadrilaterals. The honest inverse — that the Varignon parallelogram preserves the diagonals but does NOT determine the original quadrilateral (many quads share one parallelogram) — is shown directly, and the area/perimeter claims are correctly scoped to simple (non-self-intersecting) quadrilaterals. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE PARRONDO

Parrondo's paradox in the 5-window house format — two gambling games each rigged to lose long-term, yet alternating between them (or switching at random) makes capital climb. Game A is a slightly biased losing coin; Game B uses a dreadful coin when capital is a multiple of 3 and a great one otherwise, losing on its own by getting stuck on the bad coin. Game A stirs the capital so B lands on its good coin more often — each game's weakness patched by the other. A real ratchet mechanism. See the ratchet in 1D, the live three-trajectory race in 2D, and the convexity break in 3D.

THE PARRONDO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE PARRONDO THE PARRONDO two losing games that combine into a winning one 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Parrondo’s paradox. Two gambling games, each rigged to lose in the long run. Play either one forever and your capital bleeds away. Yet alternate between them — or even switch at random — and your capital climbs . Two losing games combine into a winning one. Game A is a coin very slightly biased against you. Game B uses two coins: a dreadful one when your capital is a multiple of 3, a very good one otherwise — and on its own B spends just enough time on the dreadful coin to lose overall. The trick: Game A, though a loser, stirs your capital so that Game B lands on its good coin more often than it otherwise would. Each game’s weakness is patched by the other. It is a real mechanism — used to model ratchets, flashing potentials, even some biology — not a betting-system fantasy. LIT verified live (seeded simulation, 60k rounds): Game A alone ends negative, Game B alone ends negative, and the A/B mix ends positive (window.__parrondo). FIG no framing; the two-losers-make-a-winner result is a genuine simulated fact, not a trick of accounting. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE EXPLOIT — the cheat domain of the move that shouldn’t work but does. Parrondo is the purest exploit in probability: assemble a win out of two guaranteed losses. AVAN (AI) built the instrument: the ratchet strip, the live three-trajectory race, the linear-vs-nonlinear inverse. The weave: David names the seat (the impossible exploit); I make the two losing games run down while their mixture climbs, and show why the naive average is wrong — the ratchet in 1D, the live race in 2D, the convexity break in 3D. The sphere is the seam. Credit: Juan Parrondo (1996); the flashing-ratchet analogy from statistical physics. 3 ONE DIMENSION Game B’s ratchet, laid out by capital mod 3. On the red tooth (capital ≡ 0) the dreadful 10% coin plays; on the green teeth the excellent 75% coin plays. B loses because it gets stuck on the red tooth — and Game A’s job is to knock it off. 4 TWO DIMENSIONS · INTERACTIVE A live race of capital over time: Game A alone and Game B alone both drift down, while the A+B mix climbs. Run it and watch two losers sink as their combination rises above zero. run ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The three capital paths as turning ribbons — the two losing games sinking and the green mixture rising out of them. AVAN’s addition (the inverse-companion): the magenta ribbon is the naive prediction — the average of the two losing drifts, which is of course still a loss. Intuition runs one way: loss plus loss must be loss; the mixture should land between the parts. The paradox is the inverse of that linear guess. Because Game B’s odds depend on the state and Game A reshuffles that state , the combination is not the average of the parts — the dynamics are nonlinear, and the true mixed path (green) rises clean above the magenta average of its own ingredients. The inverse here is the failure of averaging: you cannot predict a coupled, state-dependent system by blending its pieces. Magenta is what ‘loss + loss’ predicts; green is what actually happens; the gap between them is the whole free lunch. pause spin LIT Genuine Parrondo's paradox (Juan Parrondo 1996; flashing-ratchet analogy from statistical physics). Verified live with a seeded 60000-round simulation: Game A alone ends with negative capital, Game B alone ends negative, and the alternating A/B mix ends positive (window.__parrondo.gameALoses && gameBLoses && mixWins). The two-losers-make-a-winner result is a genuine reproducible simulated fact, driven by Game B's state-dependence plus Game A's mixing of that state. FIG No framing: the paradox is a real simulated outcome (both games lose alone, the mix wins), not an accounting trick. The mechanism is stated honestly — B's odds depend on capital mod 3, A reshuffles that state — and the AVAN inverse shows precisely why the naive average of the two losing drifts (still a loss) mispredicts the nonlinear coupled result. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN