THE SIMPSON

Simpson's paradox in the 5-window house format — a trend that holds in every subgroup can reverse when the subgroups are pooled. On genuine 1986 kidney-stone data, treatment A beats B for small stones (93% vs 87%) and for large stones (73% vs 69%), yet pooled, B wins (83% vs 78%). The cause is a lurking variable: A was used mostly on the hard (large-stone) cases, B on the easy ones, so the pooled rate is a weighted blend whose uneven weights flip the verdict. See the flipping bars in 1D, the case-mix pooling in 2D, and the mediant-vector inverse in 3D.

THE SIMPSON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE SIMPSON THE SIMPSON A wins every subgroup, B wins the total 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Simpson’s paradox. A trend that holds in every subgroup can reverse when the subgroups are pooled. It is not a rounding glitch — it is a real feature of how ratios combine, and it has changed real medical and legal conclusions. The textbook case is genuine kidney-stone data (Charig, 1986). Treatment A beats Treatment B for small stones (93% vs 87%) and for large stones (73% vs 69%) — A wins both. Pool the numbers and B wins (83% vs 78%). The culprit is a lurking variable : A was given mostly to the hard cases (large stones), B mostly to the easy ones. The pooled rate is a weighted blend, and the uneven weights flip the verdict. It’s the reason a headline average means nothing until you ask how the groups were mixed. LIT verified live: on the exact 1986 figures A’s success rate exceeds B’s in both stone-size subgroups, yet B’s pooled rate exceeds A’s (window.__simpson). FIG no framing; the reversal is arithmetic fact on real, cited data. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in HEISENBUG — the glitch domain of the defect that changes when you look at it. Simpson’s paradox is the ultimate heisenbug: the winner flips depending on whether you view the parts or the whole. AVAN (AI) built the instrument: the subgroup-vs-pooled bars, the reweighting, the mediant-vector inverse. The weave: David names the seat (the answer that changes when observed differently); I make A win every subgroup and lose the total, and expose the lurking weight that does it — the flipping bars in 1D, the pooling in 2D, the vector-addition inverse in 3D. The sphere is the seam. Credit: Edward Simpson (1951); earlier Yule & Pearson (~1899); data from Charig et al. (1986). 3 ONE DIMENSION Success rates as bars. In the small-stone pair and the large-stone pair, A (green) stands taller than B (gold). But the pooled pair on the right flips — B taller than A. Same numbers, opposite winner. 4 TWO DIMENSIONS · INTERACTIVE Each treatment’s cases as a mosaic, sized by how many patients. A wins each subgroup, but B was handed the easy small stones in bulk while A took the hard large ones — slide the case-mix and watch the overall winner cross over. shift case-mix ▶ real 1986 data 5 THREE DIMENSIONS + AVAN’S INVERSE Each treatment-subgroup drawn as a vector (attempts across, successes up); its slope is the success rate. A’s two green vectors are each steeper than B’s matching one. AVAN’s addition (the inverse-companion): add each treatment’s two vectors tip-to-tail and the resultant slope is the pooled rate — and B’s magenta resultant comes out steeper than A’s, though every one of A’s parts was steeper. This is the exact inverse of ‘true of each part ⇒ true of the whole’. Summing fractions is the mediant , and the mediant does not preserve order: (a₁+a₂)/(b₁+b₂) lands wherever the weights b drag it. The lurking variable is that weight — A’s steep vectors are short (few easy cases), B’s shallow ones are long (many), so the long shallow vector wins the sum. The green parts each beat their magenta rival; the magenta whole beats the green whole. You cannot add your way from the parts to the truth without knowing the weights. pause spin LIT Genuine Simpson's paradox (Edward Simpson 1951; earlier Yule & Pearson ~1899) on real cited data (Charig et al. 1986 kidney-stone treatment). Verified live: on the exact figures (A small 81/87, A large 192/263, B small 234/270, B large 55/80) treatment A's success rate exceeds B's in both subgroups, yet B's pooled rate (289/350) exceeds A's (273/350) (window.__simpson.aWinsSmall && aWinsLarge && bWinsOverall). The reversal is exact arithmetic on real data. FIG No framing: the subgroup-vs-pooled reversal is arithmetic fact on real, cited medical data, not a manufactured example. The mechanism (a confounder unevenly distributed across treatments, making the pooled rate a mediant that ignores order) is stated honestly as the genuine cause, and the AVAN inverse shows it geometrically via vector addition of fractions. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE SECRETARY

the secretary problem (optimal stopping) in the 5-window house format — candidates arrive one at a time in random order; you must accept or reject each on the spot with no going back, and you want to hire the single best. The optimal rule: reject the first n/e (~37%) while noting the best among them, then hire the first later candidate who beats them all. This wins the best with probability ~1/e ~ 37%, and that rate does not fade as n grows. See the look-then-leap run in 1D, the success-vs-cutoff curve in 2D, and the explore/exploit inverse in 3D.

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

THE SECRETARY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE SECRETARY THE SECRETARY reject the first 37%, then leap — win the best 1/e of the time 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The secretary problem. Candidates arrive one at a time in random order . After each, you must accept or reject on the spot — no going back, no recalling anyone you passed. You want to hire the single best of them all. What strategy gives the best odds? The answer is startlingly clean: reject the first 37% automatically, just noting the best among them, then hire the first later candidate who beats everyone seen so far . The magic fraction is 1/e ≈ 0.368 — look at n/e candidates, then leap. This wins the very best with probability ≈ 1/e ≈ 37% , and — the surprising part — that success rate does not fade as the number of candidates grows. A hundred applicants or a million, you still catch the best more than a third of the time. LIT verified live (seeded simulation, n=100): sweeping the cutoff, the success probability peaks near a 37% cutoff at a value near 1/e, beating every other threshold (window.__secretary). FIG no framing; the 1/e optimal cutoff and the ≈1/e win rate are genuine simulated facts matching the theory. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in SUDDEN DEATH — the boss domain of the irreversible one-shot call. The secretary problem is sudden death by design: every choice is final, no rewind, and you get exactly one hire. AVAN (AI) built the instrument: the look-then-leap run, the cutoff sweep, the explore/exploit inverse. The weave: David names the seat (the one-shot, no-takebacks decision); I make the optimal 37% rule earn its 1/e and show why more or less looking both lose — the look/leap line in 1D, the success curve in 2D, the explore-vs-exploit inverse in 3D. The sphere is the seam. Credit: popularized by Martin Gardner (1960); the 1/e result by Lindley (1961) and others. 3 ONE DIMENSION One run of candidates in random order. The first 37% are the look phase (rejected, only the best-so-far remembered); after the line, the leap phase accepts the first candidate that beats them all. The chosen one is marked. 4 TWO DIMENSIONS · INTERACTIVE Success probability plotted against how long you look. Run trials and the curve fills in, peaking at a 37% cutoff and a height near 1/e . Set a cutoff and read its odds — look too little or too much and both fall away. run trials ▶ cutoff: 37% reset 5 THREE DIMENSIONS + AVAN’S INVERSE The success curve as a turning ridge over the cutoff axis — green , cresting at 1/e where looking and leaping are perfectly balanced. AVAN’s addition (the inverse-companion): the strategy is a single tension between two inverse moves — look (learn, commit to nothing) and leap (commit, learn nothing). The magenta line is the cost of looking: the probability that the very best candidate falls inside the rejected look phase and is thrown away, which climbs straight up as the cutoff grows. Look too little and you leap before you know the standard; look too long and the magenta cost says the best is probably already gone, unrecallable. The green optimum sits exactly where one more glance stops being worth the rising risk of having passed the winner — the balance point of explore against exploit. Green is the reward of patience; magenta is its price; 1/e is where they cross, and every optimal-stopping problem is a version of this same cut. pause spin LIT Genuine secretary problem / 1/e optimal-stopping rule (popularized by Martin Gardner 1960; result by Lindley 1961 and others). Verified live with a seeded n=100 simulation: sweeping the cutoff, success probability peaks near a 37% cutoff (n/e) at a value near 1/e~0.368, beating every other threshold (window.__secretary.optimalNearOneOverE && peakNearOneOverE). The optimal 1/e cutoff and the ~1/e win rate are genuine simulated facts matching the closed-form theory (the win curve approximates x*ln(1/x), maximized at x=1/e). FIG No framing: the 37% cutoff optimum and the ~1/e success rate are real, reproduced by seeded simulation and matching the analytic x*ln(1/x) curve. The counterintuitive true fact — that the win probability stays ~37% regardless of n — is stated as the genuine result, and the AVAN inverse frames it honestly as the explore/exploit balance point. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE PENNEY

Penney's game in the 5-window house format — two players each pick a length-3 coin sequence, then flip until one appears; whoever's shows first wins. It looks symmetric but isn't: whatever the first player picks, the second can always pick a sequence that wins more than half the time. Conway's rule: beat ABC with (not-B)AB; against HHH the counter THH wins 7 of 8. The sequences are nontransitive — an endless rock-paper-scissors with no best choice. See the coin-stream race in 1D, the live win-tally in 2D, and the beats-cycle in 3D.

THE PENNEY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE PENNEY THE PENNEY pick any coin-triple, the second player beats it 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Penney’s game. You and I each pick a sequence of three coin flips — say HTH. We flip a fair coin over and over until one of our two patterns shows up in a row; whoever’s pattern appears first wins. It looks perfectly symmetric. It is not . Whatever you choose first, I can always choose a sequence that beats yours more than half the time — going second is a huge advantage. Conway’s rule: to beat your ABC , I pick (not-B) A B . If you pick HHH, I pick THH and win 7 games out of 8 . The sequences are nontransitive , an endless rock-paper-scissors: every sequence has another that preys on it, so there is no best choice at all . Pick anything and something beats it. LIT verified live (seeded simulation): the second-player counter beats every one of the 8 first-player sequences with probability > 1/2, and HHH-vs-THH comes out near 7/8 (window.__penney). FIG no framing; the second-mover win and the nontransitivity are genuine simulated facts. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GOD MODE — the cheat domain of the unfair advantage that always works. Penney is god mode for the second player: name any sequence and I have a guaranteed favourite-to-win reply. AVAN (AI) built the instrument: the flip-stream race, the live win-rate tally, the nontransitive-cycle inverse. The weave: David names the seat (the always-wins second move); I make the counter beat every choice and expose that there is no best sequence — the coin stream in 1D, the live match in 2D, the beat-cycle in 3D. The sphere is the seam. Credit: Walter Penney (1969); the odds algorithm by John H. Conway. 3 ONE DIMENSION A stream of coin flips. Your sequence and the counter each “win” the moment they first appear in the run — and across many streams the counter tends to complete first. One race, drawn on a line. 4 TWO DIMENSIONS · INTERACTIVE Pick your sequence; the counter appears automatically by Conway’s rule. Run many matches and watch the tally — the counter’s win rate climbs above 50% and settles near the known odds (up to 7/8 against HHH or TTT). your seq: HHH run matches ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The eight sequences as nodes; a green arrow runs from your pick to the counter that beats it — the second-mover’s guaranteed reply. AVAN’s addition (the inverse-companion): the magenta arrows close the loop — the “beats” relation runs in a cycle , not a line. The natural inverse question is ‘which sequence is best ?’ — sort them, crown a winner. But there is no winner: the relation is nontransitive , so any attempt to rank them best-to-worst runs into a magenta arrow pointing back. The inverse of a total order is a cycle , and Penney’s game lives in the cycle. That is exactly why going second wins: you are never choosing the ‘best’ sequence — there isn’t one — you are choosing the specific predator of whatever your opponent just committed to. Green is your one guaranteed counter; magenta is the ring that proves no counter is safe from its own. To rank them is to chase your tail. pause spin LIT Genuine Penney's game (Walter Penney 1969; odds algorithm by John H. Conway). Verified live with a seeded simulation: the second-player counter (not-B, A, B) beats every one of the 8 first-player sequences with probability > 1/2, and HHH-vs-THH comes out near 7/8 (window.__penney.counterBeatsAll && hhhNear7of8). The second-mover advantage and the nontransitivity are genuine simulated facts matching Conway's exact odds. FIG No framing: the always-winning second move and the nontransitive beats-cycle are real, reproduced by seeded simulation and matching known exact odds (7/8, 3/4, 2/3). The counterintuitive true fact — that there is no best sequence because the relation is a cycle, not an order — is the genuine mathematical content, shown directly in the graph. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE ST PETERSBURG

the St. Petersburg paradox in the 5-window house format — flip a fair coin until heads; if the first heads is on flip n, win $2^n. The expected winnings are 1/2*$2 + 1/4*$4 + 1/8*$8 + ... = $1 + $1 + $1 + ... = infinite, so expected-value logic says pay any finite price to play, yet almost no one would pay even $10. The resolution is diminishing utility: the expected log2 of the payout is finite, exactly 2, giving a value near $4. See the dollar-per-term EV ladder in 1D, the never-settling running mean in 2D, and the linear-vs-log inverse in 3D.

THE ST PETERSBURG · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE ST PETERSBURG THE ST PETERSBURG infinite expected value, worth about $4 to play 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The St. Petersburg paradox. A casino offers a game: flip a fair coin until it lands heads. If the first heads is on flip n, you win 2 n dollars. Heads at once pays $2; tails-then-heads pays $4; three flips pays $8, and so on. The expected winnings are ½·$2 + ¼·$4 + ⅛·$8 + … = $1 + $1 + $1 + … = infinite . Each term contributes exactly one dollar, forever. By the textbook rule — pay up to the expected value — you should hand over any finite sum to play once: a thousand dollars, a million. Yet almost no one would pay even $10 . That is the paradox: an infinite mathematical expectation attached to a game worth, to any real person, a few bucks. The classic resolution is that money has diminishing utility — and remarkably, the expected log of the payout is not infinite at all; it is exactly 2 . LIT verified live: each payout term equals $1 so the partial expected value equals N and diverges , while the expected value of log₂(payout) converges to exactly 2 (window.__petersburg). FIG no framing; the divergent expectation and the finite log-expectation are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE JACKPOT — the loot domain of the unbounded prize. St. Petersburg is the ultimate jackpot: an expected payout of infinity that is worth almost nothing to actually buy. AVAN (AI) built the instrument: the dollar-per-term ladder, the never-settling running mean, the linear-vs-log inverse. The weave: David names the seat (the infinite jackpot); I make the expectation diverge a dollar at a time while the real value stays small, and show the log-utility that tames it — the EV ladder in 1D, the wandering average in 2D, the expectation-vs-utility inverse in 3D. The sphere is the seam. Credit: posed by Nicolas Bernoulli (1713); utility resolution by Daniel Bernoulli (1738), published in the St. Petersburg Academy — hence the name. 3 ONE DIMENSION The payout ladder: outcome n has probability 2 −n and pays $2 n , so each rung adds exactly $1 to the expected value. The running total climbs 1, 2, 3, … and never stops — the expectation is a staircase with no top. 4 TWO DIMENSIONS · INTERACTIVE Play the game thousands of times and plot the running average payout. It doesn’t converge — it drifts upward in sudden jumps, each rare long run of tails yanking the mean higher. There is no “fair price” it settles on. play ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The running average payout as a turning ribbon — green , climbing without bound (roughly like ½ log₂ of the number of plays), never flattening to a value. AVAN’s addition (the inverse-companion): the magenta line is the certainty equivalent under log utility — what a rational person would actually pay, and it sits flat near $4 . Expected value is supposed to be the inverse of averaging: the law of large numbers promises the sample mean converges to the expectation. Here that inverse breaks — the expectation is infinite, so there is nothing for the average to converge to, and the green mean wanders up forever. The fix is to invert the money instead: value grows like the log of wealth, and the expected log payout is finite (exactly 2), giving a certainty-equivalent of 2² = $4. Green is the divergent linear expectation that says ‘pay anything’; magenta is the finite log-utility value that says ‘pay about four dollars’. The paradox is the whole gap between them — and the resolution is choosing the right inverse to take. pause spin LIT Genuine St. Petersburg paradox (posed by Nicolas Bernoulli 1713; utility resolution by Daniel Bernoulli 1738). Verified live: each payout term (2^-n)*(2^n) equals exactly $1, so the partial expected value equals N and diverges, while the expected value of log2(payout) = sum n*2^-n converges to exactly 2 (window.__petersburg.eachTermIsOne && evDiverges && logEVFiniteNear2). The divergent linear expectation and the finite log-expectation (=2, certainty-equivalent 2^2=$4) are both exact. FIG No framing: the divergent expectation (partial sum = N) and the finite log-utility expectation (exactly 2) are real and computed exactly. The paradox — infinite mathematical expectation but small real value — is stated honestly, with the diminishing-utility resolution (Daniel Bernoulli) as the genuine account, not a hand-wave; the simulated running mean genuinely fails to converge. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE FANO

the Fano plane in the 5-window house format — the smallest projective plane, just 7 points and 7 lines, where every two points lie on exactly one line and every two lines meet in exactly one point. Each line holds 3 points; each point lies on 3 lines. Drawn as a triangle with its edge-midpoints and center plus a circle for the seventh line, it is the (7,3,1) Steiner triple system, the plane PG(2,2), and the octonion multiplication rule, carrying 168 symmetries. See the triples in 1D, the classic clickable diagram in 2D, and the point/line self-duality in 3D.

THE FANO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · HELLO WORLD ◆ .dlw.fold THE FOLD / SPAWN / HELLO WORLD / THE FANO THE FANO 7 points, 7 lines — the smallest projective plane 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fano plane. The smallest possible projective plane — just 7 points and 7 lines , and yet a complete little universe of geometry. It is built so that every two points lie on exactly one line , and every two lines meet in exactly one point : a perfect symmetry between points and lines, with no exceptions and no parallels. Each line holds exactly 3 points; each point sits on exactly 3 lines. Drawn the usual way it is a triangle with its three edge-midpoints and centre, plus a circle serving as the seventh “line.” It is the same object as the (7,3,1) Steiner triple system , the projective plane over the two-element field PG(2,2), and the multiplication rule of the octonions — a tiny structure carrying 168 symmetries. LIT verified live: the 7 lines each contain 3 points, each point lies on 3 lines, every pair of points determines exactly one line, and every pair of lines meets in exactly one point (window.__fano.valid). FIG no framing; all four incidence axioms hold exactly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in HELLO WORLD — the spawn domain of the smallest complete working example. The Fano plane is geometry’s hello-world: the minimal object where every axiom of a projective plane is already fully alive. AVAN (AI) built the instrument: the incidence checker, the click-two-points-get-a-line diagram, the point/line duality. The weave: David names the seat (the minimal complete example); I make the seven points and lines satisfy every axiom and expose their perfect duality — the triples in 1D, the classic diagram in 2D, the self-dual structure in 3D. The sphere is the seam. Credit: Gino Fano (1892); the structure is PG(2,2) and the (7,3,1) Steiner system. 3 ONE DIMENSION The seven lines as triples of points. Read across: every one has exactly three points, every point turns up in exactly three lines, and any two points you name share exactly one of these triples. 4 TWO DIMENSIONS · INTERACTIVE The classic Fano diagram: 7 points, 6 straight lines and 1 circle. Step a point to light up the three lines through it, or step through pairs of points to see the single line that always joins them — the axioms, made clickable. mode: point → lines step ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The incidence as a turning bipartite graph — green point-nodes linked to the lines that contain them, every point reaching exactly three lines. AVAN’s addition (the inverse-companion): the magenta side is the dual — the same graph read with points and lines swapped . In any projective plane, ‘point’ and ‘line’ are interchangeable: exchange the two words and every axiom survives intact. That is not a coincidence bolted on — it is the deepest inverse the Fano plane has: the map point ↔ line is an involution that carries the whole structure onto itself . Ask forward ‘which lines pass through this point?’ and inverse ‘which points lie on this line?’ and you get the same shape both times — each answer is three, each graph is 3-regular, the green and magenta halves are mirror images. The Fano plane is its own dual; its inverse is itself. Green is points-to-lines; magenta is lines-to-points; and you cannot tell which was the original. pause spin LIT Genuine Fano plane (Gino Fano 1892; = PG(2,2) = the (7,3,1) Steiner triple system). Verified live: the 7 lines each contain exactly 3 points, each point lies on exactly 3 lines, every pair of points determines exactly one line, and every pair of lines meets in exactly one point (window.__fano.valid, all four incidence axioms true) — checked on the standard geometric embedding (triangle + edge-midpoints + center + incircle). All incidence properties are exact. FIG No framing: the four projective-plane incidence axioms are real and verified exhaustively over all point-pairs and line-pairs. The self-duality (point line is a structure-preserving involution) is the genuine mathematical content, demonstrated by the identical 3-regular incidence on both sides, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HELLO WORLD · David Lee Wise (ROOT0), with AVAN


THE HADAMARD

the Hadamard matrix in the 5-window house format — a square grid of only +1 and -1 whose rows are all mutually orthogonal (any two different rows agree in exactly half their entries), so H*H^T = nI. Sylvester's doubling builds one at every power of two: start with [1] and tile four copies with the bottom-right negated. The rows are Walsh/Hadamard codes — non-interfering signals behind CDMA — and an error-correcting code (the [32,6] Hadamard code flew on Mariner 9). See the orthogonal Walsh waveforms in 1D, the checkerboard matrix in 2D, and the self-inverse encode/decode in 3D.

THE HADAMARD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE HADAMARD THE HADAMARD a ±1 matrix with every row orthogonal — H·Hᵀ = nI 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Hadamard matrix is a square grid filled with only +1 and −1 whose rows are all mutually orthogonal : any two different rows agree in exactly half their entries and disagree in the other half, so their dot product is zero . Compactly, H·Hᵀ = nI. Sylvester’s doubling builds one at every power of two: start with [1], then repeatedly tile four copies in a 2×2 block with the bottom-right negated. The rows are the Walsh / Hadamard codes — perfectly non-interfering signals that let many transmitters share one channel at once (the maths behind CDMA ). They also form an error-correcting code : the [32,6] Hadamard code flew aboard Mariner 9 to beam photographs back from Mars through heavy noise. Orthogonality is the whole trick — mix the coded streams together and each can be pulled back out cleanly. LIT verified live: the Sylvester matrices up to 32×32 have only ±1 entries and satisfy H·Hᵀ = nI (every distinct row-pair orthogonal), and H is its own inverse up to the factor 1/n (window.__hadamard). FIG no framing; the orthogonality and self-inverse are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE BROADCAST — the co-op domain of many voices sharing one channel. A Hadamard matrix is exactly a broadcast trick: orthogonal codes that let everyone transmit at once and still be separated. AVAN (AI) built the instrument: the Walsh waveform, the checkerboard matrix, the encode/decode self-inverse. The weave: David names the seat (many share one channel); I make the rows come out orthogonal and show a mixed signal separating cleanly — the waveform in 1D, the matrix in 2D, the self-inverse transform in 3D. The sphere is the seam. Credit: Jacques Hadamard (1893); Sylvester’s construction (1867); Walsh functions (1923); flown on Mariner 9 (1971). 3 ONE DIMENSION Two Walsh rows as ±1 waveforms. Multiply them entry by entry and the pluses and minuses cancel exactly — the running sum returns to zero. That vanishing dot product is what “orthogonal” means, drawn on a line. 4 TWO DIMENSIONS · INTERACTIVE The Hadamard matrix as a tile grid — white +1, black −1 — with its self-similar fractal pattern. Pick two rows and read their dot product: 0 for any two different rows, n for a row with itself. Grow the size and the orthogonality holds at every scale. size: 8 pick rows ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE Several Walsh-coded streams summed into one noisy channel — the green forward step: many messages mixed together into a single broadcast. AVAN’s addition (the inverse-companion): the magenta step pulls one stream back out — and it uses the very same matrix . Because H·H = nI, multiplying the mixed signal by a Walsh row cancels every other stream to zero and leaves just that one, scaled by n. The decode is the encode run again: H is, up to the factor 1/n, its own inverse . So the forward ‘mix everyone together’ and the inverse ‘separate one out’ are not two machines but one machine used twice — orthogonality is exactly the property that makes a transform undo itself. Green mixes the voices into a single channel; magenta applies the same Hadamard step and recovers a single voice untouched. The inverse of broadcasting is listening, and here they are the identical operation. pause spin LIT Genuine Hadamard matrix (Jacques Hadamard 1893; Sylvester's construction 1867; Walsh functions 1923; the [32,6] Hadamard code flown on Mariner 9, 1971). Verified live: the Sylvester matrices up to 32x32 have only +-1 entries and satisfy H*H^T = nI (every distinct row-pair orthogonal, each row with itself = n), and H8*H8 = 8I so H is its own inverse up to 1/n (window.__hadamard.orthogonal && selfInverse). The orthogonality and self-inverse are exact. FIG No framing: the +-1 entries, the mutual row-orthogonality (H*H^T = nI), and the self-inverse property are real and checked exhaustively over all row-pairs up to 32x32. The CDMA/Walsh-code and Mariner-9 error-correction uses are genuine documented applications; the encode-equals-decode inverse is demonstrated (mix streams, multiply by a row, recover one), not merely claimed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE GOLOMB RULER

the Golomb ruler in the 5-window house format — a ruler whose marks are placed so no two pairs are the same distance apart, every pairwise distance unique. The 4-mark {0,1,4,6} measures 1..6 each exactly once. Finding the shortest ruler for a given mark count (the Optimal Golomb Ruler) is hard, with no formula and multi-year distributed searches. Rulers of <=4 marks are perfect (measure every length once); 5+ cannot be. Used for radio-telescope antenna placement, frequency assignment, crystallography, and codes. See the distance arcs in 1D, the collision-detecting difference grid in 2D, and the turnpike inverse in 3D.

THE GOLOMB RULER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE MAINFRAME ◆ .dlw.fold THE FOLD / GRIND / THE MAINFRAME / THE GOLOMB RULER THE GOLOMB RULER marks whose every pairwise distance is distinct 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Golomb ruler is a ruler whose marks are placed so that no two pairs of marks are the same distance apart — every pairwise distance is unique. The four-mark ruler {0, 1, 4, 6} measures the distances 1, 2, 3, 4, 5, 6, each exactly once . Finding the shortest ruler with a given number of marks — the Optimal Golomb Ruler — is genuinely hard: there is no formula, and the record searches run for years on distributed computers. Rulers of four marks or fewer are “ perfect ,” measuring every length up to their end exactly once; from five marks on, perfection becomes impossible . The distinct-distance property is exactly what you want when no two measurements may collide : placing radio-telescope antennas so no baseline repeats, assigning conference-call frequencies to dodge interference, X-ray crystallography, and error-correcting codes. LIT verified live: the known optimal rulers up to 8 marks have all pairwise distances distinct and match their record lengths (6, 11, 17, 25, 34…), the ≤4-mark rulers are perfect while the 5-mark is not, and a non-Golomb set is correctly rejected (window.__golombruler). FIG no framing; distinctness, the optimal lengths, and the perfection cutoff are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MAINFRAME — the grind domain of squeezing the most out of scarce, shared resource. A Golomb ruler is exactly that: pack the marks so every distance does double duty for none — maximal information, zero redundancy. AVAN (AI) built the instrument: the distance arcs, the collision-detecting difference grid, the turnpike inverse. The weave: David names the seat (no wasted capacity); I make every distance measured once and show a collision the moment a mark slips — the ruler in 1D, the difference grid in 2D, the reconstruction inverse in 3D. The sphere is the seam. Credit: Solomon W. Golomb; optimal rulers verified by the distributed OGR search project. 3 ONE DIMENSION The ruler itself: a few marks on a line, and an arc for every pair. Each arc is a different length — the distances never repeat, so a short ruler measures a surprising number of lengths with a handful of marks. 4 TWO DIMENSIONS · INTERACTIVE Choose an order and see its optimal ruler with the full difference grid — every pairwise distance in a table, all distinct. Nudge a mark off its optimal spot and watch two distances collide and flash red: proof that the exact placement is what makes it a Golomb ruler. order: 5 nudge a mark optimal 5 THREE DIMENSIONS + AVAN’S INVERSE The ruler’s marks turning on a track, with the green forward step drawing every pairwise distance — marks in, the full set of distinct distances out. AVAN’s addition (the inverse-companion): the magenta is the inverse problem — given only the set of distances , rebuild the marks. Going forward (marks → distances) is instant. Going backward (distances → marks) is the turnpike problem , and it is genuinely hard: many mark-sets can produce the same distance multiset, and reconstructing positions from pairwise distances is the same puzzle that DNA restriction mapping and X-ray phase retrieval must solve. The magenta reconstruction has to branch and backtrack where the green measurement just reads off. So a Golomb ruler is easy to use and hard to invert : its distinct distances are a fingerprint that hides how they were laid down. Green measures every gap once; magenta tries to recover the ruler from the gaps alone, and finds the road runs only one way cheaply. pause spin LIT Genuine Golomb rulers (Solomon Golomb; optimal rulers verified by the distributed OGR project). Verified live: the known optimal rulers up to 8 marks ({0,1,4,6}, {0,1,4,9,11}, {0,1,4,10,12,17}, {0,1,4,10,18,23,25}, {0,1,4,9,15,22,32,34}) have all pairwise distances distinct and match their record lengths (6,11,17,25,34), the FIG No framing: the distinct-distance property, the optimal-ruler lengths, and the order-4-perfect / order-5-imperfect cutoff are real and checked exhaustively. The hardness of the inverse (reconstructing marks from the distance set = the turnpike problem, also faced in DNA restriction mapping) is the genuine asymmetry, stated as fact — the forward direction is checked, the inverse difficulty is a known result not re-proven here. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MAINFRAME · David Lee Wise (ROOT0), with AVAN


THE LANGFORD

the Langford pairing in the 5-window house format — arrange the numbers 1,1,2,2,...,n,n in a row so the two copies of each k have exactly k numbers between them. For n=3: 2,3,1,2,1,3. Such an arrangement exists if and only if n is congruent to 0 or 3 mod 4, so n=3,4,7,8 work while n=1,2,5,6 are impossible. Langford spotted it watching his son's blocks; solution counts explode (n=7:26, n=8:150, n=16: over 46 billion). See the gap-arcs in 1D, the solver-or-impossibility in 2D, and the parity obstruction in 3D.

THE LANGFORD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE LANGFORD THE LANGFORD arrange 1,1,2,2,…,n,n so the two k's are k apart 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Langford pairing arranges the numbers 1, 1, 2, 2, 3, 3, …, n, n in a row so that the two copies of each k have exactly k numbers between them . For n = 3 the answer is 2, 3, 1, 2, 1, 3 : the two 1s have one number between, the two 2s have two, the two 3s have three. The astonishing fact is when it can be done : a Langford pairing exists if and only if n ≡ 0 or 3 (mod 4) . So n = 3, 4, 7, 8, 11, 12, … all work — and n = 1, 2, 5, 6, 9, 10 are flatly impossible , no matter how long you try. C. Dudley Langford spotted the puzzle while watching his young son line up coloured blocks. When solutions do exist their number explodes: 1 for n=3, 26 for n=7, 150 for n=8, and over 46 billion for n=16. LIT verified live (exhaustive search): for n = 1..8 a pairing exists exactly when n ≡ 0 or 3 (mod 4), with the right solution counts (n=3→1, n=7→26, n=8→150), and the classic constructions check out (window.__langford). FIG no framing; the exact-gap arrangements and the mod-4 existence law are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE CRON JOB — the grind domain of things timed to exact gaps. A Langford pairing is a scheduling miracle: every job’s two runs separated by a precise interval, all interlocking without collision. AVAN (AI) built the instrument: the gap-arcs, the solver, the parity-obstruction inverse. The weave: David names the seat (exact-gap scheduling); I make the copies land at their required spacing and show which n can never be scheduled at all — the arcs in 1D, the solver in 2D, the parity invariant in 3D. The sphere is the seam. Credit: C. Dudley Langford (1958), from his son’s blocks; the mod-4 condition by Roy Davies (1959). 3 ONE DIMENSION A valid pairing on a line, with an arc over each pair. The arc for k spans exactly k+1 places — k numbers sit between its endpoints — and all the arcs interlock without ever demanding the same slot twice. 4 TWO DIMENSIONS · INTERACTIVE Pick n. When n ≡ 0 or 3 (mod 4) a solution appears with every gap labelled; step through the different solutions. When n ≡ 1 or 2 (mod 4) the search comes back empty — the arrangement genuinely cannot exist, and the panel says why. n: 4 next solution ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE A solution’s pairs drawn as turning chords — the green forward result: a real arrangement, found by search, that satisfies every gap. AVAN’s addition (the inverse-companion): the magenta is the obstruction — the parity argument that decides existence without searching at all . Add up the positions of every copy: each pair at slots p and p+k+1 contributes 2p + k + 1, while the positions 1..2n sum to n(2n+1). Match the two and the +k+1 terms force a parity that can only balance when n ≡ 0 or 3 (mod 4). So the inverse of ‘construct an arrangement’ is ‘compute an invariant’: for the impossible n, no amount of green searching helps, because a single magenta parity count already proves there is nothing to find. Constructing possibility takes work; certifying impossibility takes one sum. Green is a solution you build; magenta is the invariant that, half the time, tells you not to bother. The fastest way to fail is to check the parity first. pause spin LIT Genuine Langford pairing (C. Dudley Langford 1958; mod-4 existence condition by Roy Davies 1959). Verified live by exhaustive search: for n=1..8 a pairing exists exactly when n mod 4 is 0 or 3, with correct solution counts up to reversal (n=3->1, n=4->1, n=7->26, n=8->150; n=1,2,5,6->0), and the classic constructions 2,3,1,2,1,3 and 2,3,4,2,1,3,1,4 are valid (window.__langford.existenceRuleHolds && construction34valid). The exact-gap arrangements and the mod-4 existence law are exact. FIG No framing: the exact-gap arrangements, the solution counts, and the n=0,3 mod 4 existence law are all real and verified by exhaustive in-browser search (impossibility for n=1,2,5,6 is a genuine zero-count result, not an unfinished search). The AVAN inverse — that a parity/position-sum invariant certifies impossibility without searching — is the honest mathematical reason behind the mod-4 law. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE COSTAS

the Costas array in the 5-window house format — an n x n grid with one dot per row and column (a permutation) placed so all displacement vectors between pairs of dots are distinct. This gives an ideal thumbtack autocorrelation: slide a copy over itself and at every nonzero shift at most one dot coincides — exactly what sonar and radar need for unambiguous range/Doppler. John Costas invented them for sonar (1965); the Welch construction builds size p-1 from a primitive root mod a prime p. See the difference triangle in 1D, the array and its self-overlap in 2D, and the autocorrelation inverse in 3D.

THE COSTAS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE COSTAS THE COSTAS one dot per row & column, every displacement distinct 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Costas array is an n×n grid with exactly one dot in every row and every column — a permutation — placed so that all the vectors between pairs of dots are distinct . No two pairs of dots share the same displacement. That single rule gives an ideal autocorrelation : slide a copy of the pattern over itself and, at every nonzero shift, at most one dot ever coincides. A “thumbtack” — a sharp spike at zero shift and almost nothing anywhere else. It is exactly what a sonar or radar wants: a time-frequency chirp whose echo can never be confused with a shifted copy of itself, so range and Doppler read out unambiguously. John Costas invented them at GE for sonar; the Welch construction builds one of size p−1 from a primitive root modulo a prime p. LIT verified live: the Welch arrays for p = 5, 7, 11, 13 have all displacement vectors distinct (genuine Costas arrays), while a plain identity permutation is correctly rejected (window.__costas). FIG no framing; the distinct-vector property and the construction are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SYNC — the co-op domain of locking cleanly onto a signal. A Costas array is synchronization made perfect: its echo aligns with itself at exactly one shift and nowhere else, so a receiver locks without ambiguity. AVAN (AI) built the instrument: the dot grid, the sliding autocorrelation, the thumbtack inverse. The weave: David names the seat (clean lock-on); I make every displacement vector distinct and show the autocorrelation collapse to a spike — the difference triangle in 1D, the array and its self-overlap in 2D, the autocorrelation inverse in 3D. The sphere is the seam. Credit: John P. Costas (1965, for sonar); the Welch and Lempel–Golomb algebraic constructions. 3 ONE DIMENSION The permutation as a row of columns, and the difference triangle beneath it. Each row of the triangle holds the gaps at one spacing — and in a Costas array no value repeats within any row , the compact certificate that every displacement is unique. 4 TWO DIMENSIONS · INTERACTIVE The Costas array of dots, and its autocorrelation : shift a ghost copy by any (dx, dy) and count how many dots line up. For a Costas array the answer is never more than 1 at any nonzero shift. Flip to a non-Costas permutation and watch shifts suddenly stack up two or more. array: Welch p=7 shift ▶ show non-Costas 5 THREE DIMENSIONS + AVAN’S INVERSE The array’s dots turning in space — the green forward object: a permutation whose every pairwise displacement is different. AVAN’s addition (the inverse-companion): the magenta cloud is the autocorrelation — the array read through its own difference vectors. Forward, you place the dots; the inverse view is the full set of displacements between them, and that set is the autocorrelation function. Because every vector occurs exactly once, the magenta cloud is a scatter of singletons — a perfect thumbtack: height n at zero shift, at most 1 everywhere else. The Costas property and the ideal autocorrelation are the same fact seen from two sides : distinct differences forward, flat sidelobes inverse. And like a Golomb ruler, running the inverse the hard way — rebuilding the array from its autocorrelation alone — is ambiguous and difficult. Green is where the dots are; magenta is every gap between them, each appearing once; the clean signal and the clean array are one object. pause spin LIT Genuine Costas arrays (John P. Costas 1965; Welch and Lempel-Golomb constructions). Verified live: the Welch arrays for p=5,7,11,13 (built from primitive roots) have all displacement vectors distinct — genuine Costas arrays — while a plain identity permutation is correctly rejected for repeated displacements (window.__costas.welchAllCostas && identityFails). The distinct-vector property and the Welch construction are exact, and the ideal ( FIG No framing: the distinct-displacement property, the Welch construction, and the resulting thumbtack autocorrelation (every nonzero shift overlaps at most one dot) are real and verified. The identity of 'distinct differences' with 'ideal autocorrelation' is the genuine mathematical content, shown by the sliding-overlap demo; the difficulty of the reverse (array from autocorrelation) is noted honestly as analogous to the turnpike problem. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE QUINE

the quine in the 5-window house format — a program that takes no input and prints its own source code exactly, without reading its own file. It splits into a data part (a string describing the code) and a code part that prints the data twice: once quoted, once interpreted. The classic JS quine (function a(){return "("+a+")()"})() evaluates to its own text. Kleene's recursion theorem proves every Turing-complete language has quines; the same self-reference underlies computer viruses and von Neumann self-replication. See the data/code split in 1D, the run-and-compare in 2D, and the fixed-point ouroboros in 3D.

THE QUINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE QUINE THE QUINE a program that prints its own source, exactly 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A quine is a program that takes no input and prints its own source code — exactly, character for character — without cheating by reading its own file. It sounds impossible: to contain a copy of itself, the program would need a copy of the copy, and so on forever. The escape is to split the program into two parts: a chunk of data that describes the code as a string, and a chunk of code that prints that data twice — once as literal data, once interpreted as code. A classic one line of JavaScript, (function a(){return "("+a+")()"})() , evaluates to precisely its own text. It is not a party trick: Kleene’s recursion theorem proves every Turing-complete language has quines, and the same self-reference is the seed of computer viruses and of von Neumann’s self-replicating machines. LIT verified live: the program is evaluated and its output is compared to its source — they are identical, character for character (window.__quine.isQuine). FIG no framing; the program genuinely reproduces its own text, checked by direct string equality. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in COLD BOOT — the spawn domain of bringing a system up from nothing. A quine is the coldest boot of all: a program that pulls its entire self out of its own logic, needing no source on disk to reproduce. AVAN (AI) built the instrument: the run-and-compare, the data/code split, the fixed-point ouroboros. The weave: David names the seat (bootstrap from nothing); I make the program emit its own text and prove it matches, character by character — the two parts in 1D, the run/compare in 2D, the fixed-point loop in 3D. The sphere is the seam. Credit: the term coined by Douglas Hofstadter after logician W. V. O. Quine; existence guaranteed by Kleene’s recursion theorem; self-replication traced to John von Neumann. 3 ONE DIMENSION The quine split into its two parts: a data string that spells out the code, and the code that prints the data — first as a quoted string, then run as instructions. Neither half alone can copy itself; together they close the loop. 4 TWO DIMENSIONS · INTERACTIVE Run the quine. Its source sits on top, its output below, and every character is compared — all green where they match. Press run and watch the program hand back exactly the text it was written in. run the quine ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The program feeding its own text back to itself as a turning ring — the green forward step: run the source, get the output. AVAN’s addition (the inverse-companion): the magenta ring is the identity — and a quine is the one place where running a program and doing nothing to it coincide. Normally ‘execute’ sends a program to some output different from itself; its inverse would be undoing that. A quine is a fixed point of execution: eval(q) = q, so the forward map and its own inverse both land on the same text. Kleene’s recursion theorem is exactly the promise that such a fixed point always exists — for any transformation you like, some program behaves as if it were handed its own source. The magenta identity loop lies exactly on the green execution loop; run and leave-alone are the same arrow. A quine is where a program and its own reflection are one, and the inverse of running it is running it again. pause spin LIT Genuine quine (term coined by Douglas Hofstadter after logician W. V. O. Quine; existence guaranteed by Kleene's recursion theorem; self-replication traced to von Neumann). Verified live: the program (function a(){return "("+a+")()"})() is evaluated in-browser and its output is compared to its source by direct string equality — they match character for character (window.__quine.isQuine true). The self-reproduction is real, not a file read. FIG No framing: the program genuinely outputs its own source, verified by exact string comparison of eval(source) against source in-browser. The fixed-point framing (a quine is where eval(q)=q, the fixed point guaranteed by Kleene's recursion theorem) is the honest mathematical content, not embellishment. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE Y-COMBINATOR

the Y combinator in the 5-window house format — a function that manufactures recursion out of nothing, letting a nameless function call itself. It satisfies Y f = f (Y f); in pure lambda calculus Y = lambda f.(lambda x.f(x x))(lambda x.f(x x)), where self-application (x x) feeds a function itself (eager languages use the delayed Z variant). With it you build factorial from a function that never names itself — write 'given self, return n*self(n-1)' and Y supplies the self. It is the theoretical heart of how recursion exists. See the fixed-point tower in 1D, the self-supplying recursion in 2D, and the fixed-point inverse in 3D.

THE Y-COMBINATOR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · STACK OVERFLOW ◆ .dlw.fold THE FOLD / GLITCH / STACK OVERFLOW / THE Y-COMBINATOR THE Y-COMBINATOR recursion with no name — Y f = f (Y f) 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Y combinator manufactures recursion out of nothing . Recursion normally needs a function to call itself by name — but a truly anonymous function has no name to call. Y fixes that: it hands a nameless function a copy of itself to recurse with, satisfying Y f = f (Y f) . In pure lambda calculus it is Y = λf.(λx.f(x x))(λx.f(x x)) — and the whole trick is self-application , the x x that feeds a function itself. (In eager languages you delay it a hair, giving the Z combinator.) With it you can build factorial from a function that never mentions its own name : write “given self , return n·self(n−1)” and Y supplies the self . It is the theoretical heart of how recursion can exist at all — and it lends its name to the famous startup accelerator. LIT verified live: a Y combinator built in-browser turns nameless functions into working factorial and Fibonacci, matching the known values (fact(10)=3628800, fib(10)=55) with no named recursion anywhere (window.__ycombinator). FIG no framing; the recursion is genuinely produced by the combinator, checked against exact values. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in STACK OVERFLOW — the glitch domain of recursion pushed to its edge. The Y combinator lives right there: self-application is one delay away from an infinite stack, and only the fixed-point structure keeps it finite. AVAN (AI) built the instrument: the fixed-point tower, the self-supplying factorial, the converge-to-fixed-point inverse. The weave: David names the seat (the edge of infinite recursion); I make a nameless function recurse and land on the right answer, self supplied by Y — the tower in 1D, the stepping recursion in 2D, the fixed-point inverse in 3D. The sphere is the seam. Credit: the lambda calculus of Alonzo Church (1930s); the combinator associated with Haskell Curry; the accelerator Y Combinator named for it. 3 ONE DIMENSION Y f unrolls into f(f(f(…))) — each layer is the same function handed one more copy of itself. The tower would run forever except that the base case (n≤1) snips it off at the right depth. 4 TWO DIMENSIONS · INTERACTIVE Compute factorial (or Fibonacci) through the Y combinator and step down the recursion: at each level the nameless function is given self and calls it, until the base case returns and the products unwind back up. The function never names itself — Y does the naming. n: 5 factorial step ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The self-application x x spiralling inward — the green forward step: keep applying f, f(f(f(…))), each pass one level deeper. AVAN’s addition (the inverse-companion): the magenta point is the fixed point — the value Y f the spiral is converging to, the one place where f(Y f) = Y f . Applying f is the forward move; its inverse is asking ‘what does f leave unchanged ?’ — and that is exactly the fixed point. Y doesn’t crawl the green spiral one step at a time; it jumps straight to the magenta centre , the fixed point of f, and hands it back as a working recursive function. This is the same shape as a quine, where running a program leaves it unchanged — there the fixed point of eval , here the fixed point of a function transformer . The green unrolling shows recursion happening; the magenta centre is the fixed point that is the recursion, reached in one move. To recurse is to sit still at the place f can no longer move you. pause spin LIT Genuine Y/Z fixed-point combinator (lambda calculus of Alonzo Church, 1930s; combinator associated with Haskell Curry). Verified live: a Y combinator built in-browser turns nameless functions into working factorial and Fibonacci matching known values — factorials 1,1,2,6,24,120,720,5040, fact(10)=3628800, fib(10)=55 — with no named recursion in the function bodies (window.__ycombinator.factCorrect && fibCorrect). The recursion is genuinely produced by the combinator's self-application, checked against exact values. FIG No framing: the combinator really produces recursion from anonymous functions (self supplied by Y, never by name), verified against exact factorial/Fibonacci values in-browser. The fixed-point framing — Y f is the fixed point of f, where f(Y f)=Y f, the same shape as a quine being eval's fixed point — is the honest mathematical content. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of STACK OVERFLOW · David Lee Wise (ROOT0), with AVAN


THE CHURCH

Church numerals in the 5-window house format — encode the whole numbers as pure functions, no digits or arithmetic primitives: the number n means 'do f, n times', so 3 = lambda f.lambda x. f(f(f(x))) and zero applies f not at all. From this, all arithmetic follows with only function application: successor wraps one more f, addition runs one numeral's applications after another, multiplication nests them, and exponentiation is just applying one numeral to another (m^n = n m). Decode by feeding a numeral 'add 1' and 0. Alonzo Church's proof that numbers and all computation reduce to the single idea of a function. See the application chain in 1D, the pure-function calculator in 2D, and the encode/decode inverse in 3D.

THE CHURCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE CHURCH THE CHURCH numbers as pure functions — 3 = λf.λx. f(f(f(x))) 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Church numerals encode the whole numbers as pure functions — no digits, no built-in arithmetic, just functions applying functions. The number n means “ do f, n times ”: 3 = λf.λx. f(f(f(x))); zero applies f not at all. From that single idea you get all of arithmetic with nothing but function application. Successor wraps one more f. Addition runs one numeral’s applications after the other. Multiplication nests them. And exponentiation is startlingly just applying one numeral to another: m n = n m. To read a numeral back out, hand it the function “add 1” and the starting value 0, and count. This is Alonzo Church showing that numbers — and, through the lambda calculus, all of computation — can be built from the single notion of a function, with no other material at all. LIT verified live: numerals built purely from functions decode to 0..7, and the function-only definitions of +, ×, and ^ give 3+4=7, 3×4=12, 2 5 =32 (window.__church). FIG no framing; the encodings and the pure-function arithmetic are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in GENESIS BLOCK — the spawn domain of the first canonical thing minted from nothing. Church numerals are the genesis block of number itself: the integers, conjured out of pure function application with no prior arithmetic assumed. AVAN (AI) built the instrument: the application chain, the pure-function calculator, the encode/decode inverse. The weave: David names the seat (numbers from nothing); I make arithmetic run with functions alone and decode back to ordinary integers — the application chain in 1D, the function calculator in 2D, the count-the-applications inverse in 3D. The sphere is the seam. Credit: Alonzo Church (1930s), the lambda calculus. 3 ONE DIMENSION The numeral 3 spelled out as f(f(f(x))) — a chain of three applications wrapped around a seed x. The number is not a symbol here; it is literally how many times the function is applied. 4 TWO DIMENSIONS · INTERACTIVE Pick two numbers and an operation. The Church numerals combine by pure function application — nested boxes, no arithmetic — and the result is decoded by feeding it “add 1” and 0. It always matches ordinary +, ×, ^. m: 3 n: 4 op: × 5 THREE DIMENSIONS + AVAN’S INVERSE The numeral as a turning tower of applications — the green forward encoding: the number n is the act of applying f exactly n times. AVAN’s addition (the inverse-companion): the magenta counter is the decode — recovering the ordinary number by running that very iteration on a tally. Encoding turns a number into the act of iterating ; the inverse is simply to count the iterations : hand the numeral the function “+1” and the seed 0, and the applications tick a counter up to n. Forward, n becomes a machine that repeats; backward, you watch the machine repeat and read off how many times. The two are exact inverses, and between them they say something startling — a number and ‘the action of doing something that-many times’ are the same object . The green tower is the number as pure repetition; the magenta counter is the ordinary integer falling back out of it. To be the number three is to be threefold application, and to invert that is only to count. pause spin LIT Genuine Church numerals (Alonzo Church, 1930s, lambda calculus). Verified live: numerals built purely from functions decode to 0..7, and the function-only definitions give add 3+4=7, mult 3*4=12, exp 2^5=32 (window.__church.allCorrect true) — no numeric literal used inside the encodings or operations, only function application, with decode via n(k=>k+1)(0). The encodings and pure-function arithmetic are exact. FIG No framing: the numbers really are pure functions and the arithmetic really runs on function application alone (verified by decoding to exact integers in-browser). The deep claim — that a number and 'the action of doing something n times' are the same object — is the genuine content of Church encoding, demonstrated by the encode/decode round-trip, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE SKI

SKI combinator calculus in the 5-window house format — a model of computation with no variables at all, just two operators and application: K x y = x (keep the first, drop the second) and S x y z = x z (y z) (hand the third argument to both others). Astonishingly, S and K alone express every lambda-calculus function and therefore everything computable, with no bound variables; the identity is I = S K K. Moses Schonfinkel showed variables can be eliminated from logic entirely (point-free / combinatory logic). See the three rules in 1D, the step reducer in 2D, and the point-free/point-ful inverse in 3D.

THE SKI · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · NOCLIP ◆ .dlw.fold THE FOLD / CHEAT / NOCLIP / THE SKI THE SKI two operators, no variables — S and K compute everything 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION SKI combinator calculus is a model of computation with no variables at all — just two operators and the act of applying one thing to another. The rules are tiny: K x y = x (keep the first argument, throw away the second) and S x y z = x z (y z) (hand the third argument to both of the others). That is the entire language. Astonishingly, those two combinators are enough for everything : every function of the lambda calculus — and therefore everything computable at all — can be rewritten using only S and K, with no bound variables anywhere . The identity function is simply I = S K K . Booleans, numbers, even recursion all become trees of S and K. Moses Schönfinkel showed variables can be eliminated from logic entirely ; this “point-free” style is the ancestor of pipeline-and-compose programming. LIT verified live: an in-browser reducer confirms I a→a, K a b→a, S a b c→(ac)(bc), and S K K acting as the identity on every atom — the identity built from S and K alone (window.__ski). FIG no framing; the reduction rules and combinatorial completeness (I = SKK) are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in NOCLIP — the cheat domain of moving through what should stop you. SKI noclips straight through the need for variables: computation walks on, nameless, as if the walls of binding weren’t there. AVAN (AI) built the instrument: the rewrite rules, the step reducer, the point-free/point-ful inverse. The weave: David names the seat (pass through the constraint); I make two operators compute everything and reduce expressions to their value with no variable ever named — the rules in 1D, the reducer in 2D, the variables-vs-none inverse in 3D. The sphere is the seam. Credit: Moses Schönfinkel (1924); combinatory logic developed by Haskell Curry. 3 ONE DIMENSION The whole language on one line: I x → x , K x y → x , S x y z → x z (y z) . Three rewrite arrows, no variables to bind — and yet enough to express every computable function. 4 TWO DIMENSIONS · INTERACTIVE Pick an expression and step it toward normal form. Watch S K K x grind down to just x — the identity function, manufactured from S and K with no I and no variable in sight. Each step applies one rewrite rule. expr: SKKx reduce ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The combinator expression as a turning tree of S and K nodes — the green forward form: a whole computation, expressed with no variables . AVAN’s addition (the inverse-companion): the magenta is the lambda term with variables that the SKI tree came from. The forward translation — bracket abstraction — takes a named function like λx.x and grinds every variable out of it until only S and K remain (λx.x becomes SKK). Its inverse reads a nameless combinator tree and reconstructs a lambda term with variables that means the same thing. So point-free and point-ful are two encodings of one function, and you can compile either way. What the pair proves is quietly radical: variables are a convenience, not a necessity — the identical computation exists with names and without them, and SKI is the without-them witness. Green is the variable-free tree that actually runs; magenta is the friendly named version we usually write; between them, nothing computable is lost. pause spin LIT Genuine SKI combinator calculus (Moses Schonfinkel 1924; combinatory logic by Haskell Curry). Verified live by an in-browser reducer: I a->a, K a b->a, S a b c->(ac)(bc), and S K K acting as the identity on every atom tested — the identity function built from S and K alone (window.__ski.allCorrect true). The reduction rules and combinatorial completeness (I = SKK, so variables are eliminable) are exact. FIG No framing: the reduction rules and the fact that S K K reduces any argument to itself (identity from S,K with no variables) are real and checked by an actual reducer in-browser. The deep claim — variables are a convenience, not a necessity, since bracket abstraction compiles any lambda term to variable-free S/K form — is the genuine content of combinatory logic, demonstrated by SKK = I, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NOCLIP · David Lee Wise (ROOT0), with AVAN


THE TAG

the Post tag system in the 5-window house format — one of the simplest computers: hold a string, look at the first symbol, delete the first m symbols from the front, and append a production to the back based on that symbol. A 2-tag system is Turing-complete and its halting is undecidable. The specific system a->bc, b->a, c->aaa secretly computes the Collatz sequence: start with n copies of 'a' and the all-'a' states you pass through trace the Collatz trajectory of n. See the tag step in 1D, the live Collatz-computing queue in 2D, and the computational-irreducibility inverse in 3D.

THE TAG · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE TAG THE TAG delete the front, grow the tail — a universal computer in 3 rules 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A tag system is one of the simplest computers imaginable. You hold a string and follow a single rule: look at the first symbol, delete the first m symbols from the front, and append a short production to the back depending on what that first symbol was. Repeat until the string is too short. Emil Post invented them in the 1920s. For all its childlike simplicity, a 2-tag system (delete two, append) is Turing-complete — it can compute anything any computer can, and whether one halts is undecidable . And a particular 2-tag system, with rules a→bc, b→a, c→aaa , secretly computes the Collatz sequence : start with n copies of ‘a’, and the all-‘a’ states it passes through trace the Collatz trajectory of n. A universal computer and one of maths’ most famous open problems, hiding in three rewrite rules. LIT verified live: running the a→bc, b→a, c→aaa system from a n , the pure-‘a’ checkpoints form a subsequence of the Collatz trajectory of n, for n = 3, 5, 6, 7 (window.__tag). FIG the tag rules and the Collatz correspondence are exact; Collatz’s own termination for all n remains unproven, and the tag system inherits that openness. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SANDBOX — the spawn domain of the smallest self-contained machine you can play in. A 2-tag system is a whole universal computer that fits in a sandbox: three rules, one string, and everything computable is in reach. AVAN (AI) built the instrument: the delete-front/append-back queue, the live Collatz trace, the undecidability inverse. The weave: David names the seat (the minimal machine); I make three trivial rules run and reveal the Collatz sequence hiding inside — the tag step in 1D, the live queue in 2D, the irreducibility inverse in 3D. The sphere is the seam. Credit: Emil Leon Post (1920s); 2-tag Turing-completeness by Cocke & Minsky (1964); the Collatz encoding by Liesbeth De Mol (2008). 3 ONE DIMENSION One tag step on a line: read the first symbol, chop the first two off the front , glue that symbol’s production onto the back . A string that eats its head and grows its tail — the entire mechanism. 4 TWO DIMENSIONS · INTERACTIVE Run the Collatz tag system from a n . The string churns — front deleted, tail grown — and every time it becomes pure ‘a’, its length is logged. Those checkpoints line up as a subsequence of the Collatz numbers for n, all the way down to 1. n: 3 run ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The string as a turning queue — symbols leave the head, productions join the tail — the green forward run, deterministic and plain. AVAN’s addition (the inverse-companion): the magenta is the Collatz trajectory the queue is secretly computing — and the honest inverse here is that there is no shortcut back . Running the tag system forward is trivial; the inverse question — ‘ will it halt, and where? ’ — is undecidable for tag systems in general, and for this one it is exactly the open Collatz conjecture. You cannot answer it by any formula; you can only run the machine and watch. That is computational irreducibility : a system whose future is defined by dead-simple rules yet cannot be predicted faster than by simulation. The green queue steps on obliviously; the magenta Collatz numbers it traces have resisted proof for ninety years. The inverse of a trivial forward step is, sometimes, an unanswerable question — simplicity in the rules is no promise of simplicity in the fate. pause spin LIT Genuine Post tag system (Emil Post 1920s; 2-tag Turing-completeness by Cocke & Minsky 1964; Collatz encoding by Liesbeth De Mol 2008). Verified live: running the a->bc, b->a, c->aaa system from a^n, the pure-'a' checkpoints form a subsequence of the Collatz trajectory of n for n=3,5,6,7 (window.__tag.checkpointsAreCollatzSubsequence true; n=3 checkpoints 3,5,8,4,2,1 within Collatz 3,10,5,16,8,4,2,1). The tag rules and the Collatz correspondence are exact. FIG No framing: the tag mechanism and the Collatz correspondence (all-'a' checkpoints as a Collatz subsequence) are real and reproduced by an actual simulator in-browser. The honesty is doubled: Collatz's own termination for all n is unproven, so the tag system genuinely inherits that open problem, and the AVAN inverse states the undecidability of tag-system halting as the real reason there is no shortcut — computational irreducibility, not overclaimed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE CARMICHAEL

Carmichael numbers in the 5-window house format — composites that pass Fermat's primality test (a^(n-1) = 1 mod n) for every base a coprime to them, having no Fermat witness to their compositeness at all. The smallest is 561 = 3*11*17. Korselt's criterion: n is Carmichael iff squarefree and (p-1) divides (n-1) for every prime factor p. There are infinitely many (proved 1994), and even 1729 is one. They are why real primality testing uses the stronger Miller-Rabin test, which they cannot fool. See the base wall in 1D, the witness scan in 2D, and the Fermat-vs-Miller-Rabin inverse in 3D.

THE CARMICHAEL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT KIT / THE CARMICHAEL THE CARMICHAEL a composite that fools the Fermat test to every base 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Carmichael numbers are composites that perfectly impersonate primes . Fermat’s test says: if n is prime, then a n−1 ≡ 1 (mod n) for every base a coprime to n — so a single failing base exposes a composite. A Carmichael number has no failing base at all : it passes Fermat’s test for every coprime a, despite being composite. The smallest is 561 = 3×11×17 . Korselt’s criterion pins them exactly: n is Carmichael if and only if it is squarefree and (p−1) divides (n−1) for every prime factor p. There are infinitely many (proved in 1994). Even 1729, the famous Hardy–Ramanujan taxicab number, is one. They are the reason serious primality testing abandoned Fermat’s test for the stronger Miller–Rabin test — which Carmichael numbers cannot fool. LIT verified live: 561, 1105, 1729, 2465, 2821 all satisfy Korselt and pass Fermat’s test to every coprime base, an ordinary composite (15) does not, and Miller–Rabin base 2 unmasks 561 where Fermat is fooled (window.__carmichael). FIG no framing; the impersonation, Korselt’s criterion, and the Miller–Rabin unmasking are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE ROOT KIT — the cheat domain of a thing disguised as trusted system. A Carmichael number is a rootkit in number theory: a composite wearing a prime’s credentials so completely that Fermat’s test never raises an alarm. AVAN (AI) built the instrument: the all-bases scan, the Korselt breakdown, the Fermat-vs-Miller-Rabin inverse. The weave: David names the seat (the perfect disguise); I make a composite pass every Fermat base and then show the stronger test that catches it — the base line in 1D, the witness scan in 2D, the necessary-vs-sufficient inverse in 3D. The sphere is the seam. Credit: Robert Carmichael (1910); Korselt’s criterion (1899); infinitude by Alford, Granville & Pomerance (1994). 3 ONE DIMENSION Every base a tested against 561: compute a 560 mod 561. For a genuine prime this returns 1 for all a; for 561 it also returns 1 for every coprime base — a wall of green with no witness in sight, though 561 is composite. 4 TWO DIMENSIONS · INTERACTIVE Pick a candidate and scan every base. Green = passes Fermat (looks prime), red = a witness proving compositeness. A Carmichael number shows all green among coprime bases; an ordinary composite lights up red witnesses everywhere. The Korselt check explains why. n: 561 scan bases ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The bases fanning around 561, all reporting “prime” — the green forward test: prime ⇒ passes Fermat, run in reverse as if passing meant prime. AVAN’s addition (the inverse-companion): the magenta is the Miller–Rabin test, and it is exactly where the broken inverse gets repaired. Fermat’s test is a necessary condition read backwards as if it were sufficient — and a Carmichael number is the total failure of that inverse: every base falsely certifies it prime. Miller–Rabin strengthens the test by also checking the square roots of 1 along the way, and a Carmichael number can no longer hide: base 2 alone produces a genuine witness to 561’s compositeness. So the green Fermat fan is unanimously fooled; the single magenta Miller–Rabin probe is not. The inverse of ‘primes pass’ is safe to run only with the stronger test — the lesson that a necessary condition, no matter how many bases confirm it, is never a proof. Green is the disguise everyone believes; magenta is the one closer look that sees through it. pause spin LIT Genuine Carmichael numbers (Robert Carmichael 1910; Korselt's criterion 1899; infinitude by Alford, Granville & Pomerance 1994). Verified live: 561, 1105, 1729, 2465, 2821 all satisfy Korselt (squarefree, (p-1)|(n-1)) and pass Fermat's test for every coprime base, an ordinary composite 15 does not, and Miller-Rabin base 2 produces a composite witness for 561 where Fermat is fooled (window.__carmichael.allCarmichael && foolFermatAllBases && millerRabinCatches561). The impersonation and the unmasking are exact. FIG No framing: the all-bases Fermat impersonation, Korselt's criterion, and the Miller-Rabin unmasking are real and checked in-browser by exhaustive base scan and an actual strong-test witness. The necessary-vs-sufficient lesson (a Carmichael is the total failure of reading Fermat's necessary condition as sufficient; Miller-Rabin repairs it) is the honest content, demonstrated not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT KIT · David Lee Wise (ROOT0), with AVAN


THE PELL

Pell's equation in the 5-window house format — x^2 - D y^2 = 1 for non-square D. For D=2 the smallest solution is (3,2) since 9-8=1, and from that fundamental solution all others cascade by (x,y)->(3x+4y, 2x+3y): (17,12),(99,70),(577,408),... infinitely many. Equivalently they are the powers (3+2√2)^k, and each ratio x/y is a razor-sharp approximation to √2 (the convergents of [1;2,2,2,...]). It runs from Brahmagupta and Bhaskara's chakravala through Fermat to Lagrange, and is misnamed after John Pell. See the ratios in 1D, the cascade in 2D, and the group-inverse on the hyperbola in 3D.

THE PELL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE PELL THE PELL one seed solution breeds infinitely many — x²−2y²=1 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Pell’s equation is x² − D y² = 1 for a non-square D. For D = 2 the smallest positive answer is (3, 2) : 3² − 2·2² = 9 − 8 = 1. From that single fundamental solution , all the others cascade out by one fixed recurrence, (x, y) → (3x + 4y, 2x + 3y): (17, 12), (99, 70), (577, 408), … infinitely many, each roughly six times the last. Equivalently the solutions are the powers (3 + 2√2) k , and each one’s ratio x/y is a razor-sharp rational approximation to √2 — they are exactly the convergents of the continued fraction √2 = [1; 2, 2, 2, …]. The equation runs from ancient India (Brahmagupta’s identity, Bhaskara’s chakravala ) through Fermat to Lagrange, and it is misnamed : Euler credited John Pell, but Pell had little to do with it. LIT verified live: the generated solutions all satisfy x² − 2y² = 1, the powers of (3+2√2) reproduce them, and the ratios x/y converge to √2 (window.__pell). FIG no framing; the solutions, the recurrence, and the √2 convergence are exact; the ‘Pell’ name is a known misattribution, flagged. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in CHECKPOINT ZERO — the spawn domain of the one saved seed everything else respawns from. Pell’s fundamental solution is checkpoint zero exactly: a single small answer from which the entire infinite family is regenerated. AVAN (AI) built the instrument: the solution ladder, the √2 convergence, the conjugate-unit inverse. The weave: David names the seat (the seed that spawns all); I make one solution breed the infinite family and sharpen √2 at every rung — the ratios in 1D, the cascade in 2D, the group-inverse on the hyperbola in 3D. The sphere is the seam. Credit: Brahmagupta (628), Bhaskara II’s chakravala (1150), Fermat’s challenge, Lagrange’s proof; misattributed to John Pell by Euler. 3 ONE DIMENSION The solution ratios x/y laid on a line closing in on √2. Each new Pell solution overshoots and undershoots by less — the rational approximations tighten doubly fast, the convergents of √2’s continued fraction. 4 TWO DIMENSIONS · INTERACTIVE Choose D and generate the cascade from its fundamental solution. Each (x, y) is checked against x² − D y² = 1, and the ratio x/y is plotted racing toward √D. One seed, an endless exact family. D: 2 next solution ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The solutions as points marching out along the hyperbola x² − 2y² = 1 — the green forward ladder, each rung the previous one multiplied by the fundamental unit 3 + 2√2. AVAN’s addition (the inverse-companion): the magenta points are what the inverse unit generates — multiply by (3 + 2√2) −1 = 3 − 2√2 and you walk back down the ladder toward (1, 0), and onto the mirror branch. The Pell solutions are not a mere list — they form a group , the units of the ring ℤ[√2], and the fundamental solution is a single generator. Going forward multiplies by the unit; the inverse divides by it, which is the same as taking the conjugate √2 → −√2. So the whole infinite family is one element and its inverse, applied over and over — climb with 3 + 2√2, descend with its conjugate 3 − 2√2, and their product is exactly 1. Green climbs the hyperbola away from the seed; magenta is the conjugate walking home. The infinite is one invertible step, taken both ways. pause spin LIT Genuine Pell equation (Brahmagupta 628; Bhaskara II chakravala 1150; Lagrange's proof; misattributed to John Pell by Euler). Verified live: the solutions generated from the fundamental (3,2) all satisfy x^2 - 2y^2 = 1, they equal the powers of (3+2√2), and the ratios x/y converge to √2 (window.__pell.allSatisfy && ratioConvergesToSqrt2). Solutions (1,0),(3,2),(17,12),(99,70),(577,408). The recurrence, the exact solutions, and the √2 convergence are exact; the 'Pell' name is flagged as a known misattribution. FIG No framing: the solution cascade, the x^2-Dy^2=1 identity at every step, and the convergence of x/y to √D are real and checked in-browser. The group structure (solutions are units of Z[√D], generated by the fundamental unit, inverse = conjugate with (3+2√2)(3-2√2)=1) is the genuine content of the AVAN inverse. The misattribution to Pell is stated honestly rather than propagated. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE FAREY

the Farey sequence in the 5-window house format — all fractions in [0,1] in lowest terms with denominator <= n, in order of size. Two miracles: neighbours a/b < c/d satisfy bc - ad = 1 (unimodular, as tight as coprime fractions get), and the first fraction to appear between two neighbours is their mediant (a+c)/(b+d). Ford circles visualize it: a circle of radius 1/(2q^2) on each p/q tangent to the line, and two circles kiss exactly when their fractions are Farey neighbours. See the ordered sequence in 1D, the Ford-circle packing in 2D, and the mediant/un-mediant inverse in 3D.

THE FAREY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE MERGE ◆ .dlw.fold THE FOLD / CO-OP / THE MERGE / THE FAREY THE FAREY fractions in order, mediants, and kissing Ford circles 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Farey sequence F n is every fraction in [0,1], in lowest terms, with denominator at most n, listed in order of size. F 5 = 0/1, 1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 1/1. It hides two small miracles. First, any two neighbours a/b < c/d satisfy bc − ad = 1 — “unimodular,” as close as two coprime fractions can possibly sit. Second, the very first fraction to appear between two neighbours, as n grows, is their mediant (a+c)/(b+d) — the “wrong” way to add fractions that here is exactly right. Ford circles make it visible: rest a circle of radius 1/(2q²) on each fraction p/q, tangent to the number line, and two circles kiss precisely when their fractions are Farey neighbours. It is the geometry of how the rationals pack the line. LIT verified live: for F 7 every neighbour pair is unimodular, each neighbour’s mediant lies strictly between them, the Ford circles of neighbours are tangent, and a non-neighbour pair is not (window.__farey). FIG no framing; the unimodular, mediant, and Ford-tangency properties are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE MERGE — the co-op domain where two things fold into one. The Farey mediant is a merge made arithmetic: two neighbouring fractions combine, numerator-plus-numerator over denominator-plus-denominator, into the exact fraction that belongs between them. AVAN (AI) built the instrument: the ordered fractions, the kissing Ford circles, the mediant/un-mediant inverse. The weave: David names the seat (two merge into one); I make the mediant land exactly between its parents and the Ford circles kiss just at the neighbours — the sequence in 1D, the circle packing in 2D, the parent-recovery inverse in 3D. The sphere is the seam. Credit: John Farey (1816); proof by Cauchy; Ford circles by Lester R. Ford (1938). See [[stern-brocot]], [[calkin-wilf]]. 3 ONE DIMENSION F n laid on the unit interval. Between every adjacent pair the label bc−ad = 1 confirms they are as tightly packed as coprime fractions get — the sequence is a lattice of perfect neighbours. 4 TWO DIMENSIONS · INTERACTIVE The Ford circles of F n . Raise n and new circles appear — each a mediant, nestling tangent between the two circles that made it. Every kiss between circles is a Farey-neighbour pair; the smaller the fraction’s denominator, the bigger its circle. n ▲ n ▼ 5 THREE DIMENSIONS + AVAN’S INVERSE The mediant tree turning — the green forward step: two neighbour fractions merge into their mediant (a+c)/(b+d), which drops in exactly between them. AVAN’s addition (the inverse-companion): the magenta is the un-merge — given a fraction, recover the two Farey parents whose mediant it is, by walking up the tree with the Euclidean algorithm. Forward, two fractions combine into one; the inverse splits one back into the unique pair that produced it. What makes both directions clean is the unimodular law bc−ad = 1 — a determinant of exactly 1, the signature of an invertible integer matrix (the tree is an SL(2,ℤ) structure). Because every step has determinant 1, every merge can be undone with integer arithmetic alone; nothing is lost. Green merges two neighbours into their mediant; magenta reverses it into the parents; and the whole rational line is this one invertible fold, taken down and back up. To average two fractions the ‘wrong’ way is, on this tree, perfectly reversible. pause spin LIT Genuine Farey sequence and Ford circles (John Farey 1816; proof by Cauchy; Ford circles by Lester R. Ford 1938). Verified live: for F_7 every neighbour pair satisfies bc - ad = 1, each neighbour's mediant lies strictly between them, the Ford circles of neighbours are tangent, and a non-neighbour pair (0/1, 2/3) is not tangent (window.__farey.unimodularNeighbors && mediantBetween && fordNeighborsTangent && nonNeighborNotTangent). The unimodular, mediant, and Ford-tangency properties are exact. FIG No framing: the unimodular-neighbour law, the mediant-between property, and the Ford-circle tangency (kissing iff Farey neighbours) are all real and checked in-browser. The invertibility of the mediant merge (determinant-1 / SL(2,Z) structure lets the Euclidean algorithm recover parents) is the genuine content of the AVAN inverse, tied to the same lattice as Stern-Brocot and Calkin-Wilf. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MERGE · David Lee Wise (ROOT0), with AVAN


THE PYTHAGOREAN TREE

the Barning-Hall Pythagorean tree in the 5-window house format — every primitive Pythagorean triple (right triangle with coprime integer sides) grown from the single seed (3,4,5). Each triple has exactly three children, obtained by multiplying its column vector by three fixed 3x3 integer matrices A, B, C: (3,4,5) -> (5,12,13),(21,20,29),(15,8,17), and so on. The theorem: this ternary tree contains every primitive triple exactly once — none missing, none repeated. It is the additive cousin of Euclid's m,n formula (Barning 1963, Hall 1970). See the seed and children in 1D, the tree in 2D, and the infinite-descent inverse in 3D.

THE PYTHAGOREAN TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · FIRST LIGHT ◆ .dlw.fold THE FOLD / SPAWN / FIRST LIGHT / THE PYTHAGOREAN TREE THE PYTHAGOREAN TREE every primitive right triangle grown from (3,4,5) 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Pythagorean (Barning–Hall) tree grows every primitive Pythagorean triple — every right triangle with whole-number sides sharing no common factor — from the single seed (3, 4, 5) . Each triple has exactly three children , obtained by multiplying its column vector by three fixed 3×3 integer matrices A, B, C. From (3,4,5) the matrices give (5,12,13), (21,20,29), (15,8,17); each of those spawns three more, and so on forever. The remarkable theorem: this ternary tree contains every primitive triple exactly once — none missing, none repeated. So all the infinitely many right triangles with coprime integer sides are organised into one clean family tree with a single root. It is the additive cousin of Euclid’s m,n formula, discovered by F. J. M. Barning (1963) and rediscovered by A. Hall (1970). LIT verified live: every node the tree produces is a primitive triple, no triple appears twice, and every independently-enumerated primitive triple up to c≤100 is found in the tree (window.__pythtree). FIG no framing; the tree’s output is exact and its once-each coverage is checked against an independent enumeration. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in FIRST LIGHT — the spawn domain of order first appearing. Every right triangle in whole numbers there ever was, springing in ordered branches from one small seed, is a first-light moment. AVAN (AI) built the instrument: the three-matrix growth, the primitive-triple checker, the descent-to-root inverse. The weave: David names the seat (the first light of all right triangles); I make (3,4,5) branch into every primitive triple exactly once and prove the coverage — the triples in 1D, the tree in 2D, the infinite-descent inverse in 3D. The sphere is the seam. Credit: F. J. M. Barning (1963); A. Hall (1970); the m,n parametrisation from Euclid. 3 ONE DIMENSION The seed and its three children on a line: (3,4,5) → (5,12,13), (21,20,29), (15,8,17). Each is checked live — a²+b²=c² and gcd(a,b)=1 — a genuine primitive right triangle, three born from one. 4 TWO DIMENSIONS · INTERACTIVE The ternary tree, root (3,4,5) at the top, each node branching into three via matrices A, B, C. Expand the depth and every node that appears is a fresh primitive triple — no repeats, and the whole infinite family is reachable. expand ▼ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The triples as points (a/c, b/c) on the unit circle — every primitive triple a rational point — the green forward tree filling the arc as it branches. AVAN’s addition (the inverse-companion): the magenta path is the descent — from any primitive triple, multiply by the inverse matrices and you climb to its unique parent , and from that parent to its parent, always arriving at the root (3,4,5). The forward tree branches three ways; the inverse collapses each node to exactly one parent, and that single-parent property is precisely what makes the coverage ‘each triple once’ true. It is Fermat’s infinite descent made concrete: every right triangle in integers reduces, step by unique step, down to the smallest one. Green grows outward, three children at a time; magenta walks any triple home to (3,4,5) with no choices to make. The tree covers everything because the descent from everything lands in the same place. pause spin LIT Genuine Barning-Hall tree (F. J. M. Barning 1963; A. Hall 1970). Verified live: every node the three matrices produce is a primitive Pythagorean triple (a^2+b^2=c^2, gcd(a,b)=1), no triple appears twice within the search bound, and every independently-enumerated primitive triple with c FIG No framing: the three-matrix growth, the primitivity of every node, the no-duplicates property, and the coverage of all primitive triples up to c ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of FIRST LIGHT · David Lee Wise (ROOT0), with AVAN


THE RECIPROCITY

quadratic reciprocity in the 5-window house format — Gauss's golden theorem. For two odd primes, 'is p a square mod q?' and 'is q a square mod p?' have a hidden link: the answers are the same, unless both p and q are 3 mod 4, in which case they are opposite. With the Legendre symbol (p/q) = +1 if p is a square mod q else -1, the law is (p/q)(q/p) = (-1)^(((p-1)/2)((q-1)/2)). Gauss proved it eight different ways; it underlies algebraic number theory and cryptography. Symbols compute fast by Euler's criterion a^((p-1)/2) mod p. See the residues in 1D, the reciprocity check in 2D, and the p<->q transpose inverse in 3D.

THE RECIPROCITY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GAUNTLET ◆ .dlw.fold THE FOLD / BOSS / THE GAUNTLET / THE RECIPROCITY THE RECIPROCITY is p a square mod q? — Gauss's golden theorem links it to q mod p 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Householder QR factors a matrix A into an orthonormal Q and an upper-triangular R using a sequence of reflections . Each Householder reflection is a mirror that flips one column onto a coordinate axis, zeroing everything below the diagonal in a single stroke. It is markedly more numerically stable than Gram–Schmidt, whose repeated subtractions accumulate rounding error. It is the workhorse behind least-squares fitting and the QR eigenvalue algorithm. LIT verified live: over 300 random matrices Q·R reconstructs A to ~10⁻¹⁵, R is upper-triangular, and QᵀQ equals the identity (orthonormal) — window.__householderqr. FIG no framing; exact factorisation. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-toolchain — the numerical-linear-algebra tool under least squares and eigenvalue solvers, factoring by stable reflections. Householder QR is that tool, beside the Cholesky. AVAN (AI) built the instrument: the per-column reflection, the accumulation into Q, the reconstruction / upper-triangular / orthonormality checks. Credit as content: Alston Householder (1958). The weave: David names the toolchain; I reflect each column onto an axis to build R and accumulate the mirrors into Q, and confirm Q·R = A with Q orthonormal. 3 ONE DIMENSION A Householder reflection mirrors a vector across a plane so that it lands exactly on an axis — turning a whole column into (r, 0, 0, …) in one operation, without touching the columns already reduced. 4 TWO DIMENSIONS · INTERACTIVE A matrix A and its Q, R; the product Q·R reconstructs A, R is upper-triangular, and QᵀQ is the identity. new matrix ▶ verify 300 ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the orthonormal Q built from a mirror per column. AVAN’s addition (the inverse-companion): build Q by a sequence of reflections — each Householder reflection is a mirror that flips a whole column onto an axis, zeroing everything below the diagonal in one stroke, and is far more numerically stable than Gram–Schmidt’s subtractions. The inverse of ‘subtract projections to orthogonalise (Gram–Schmidt)’ is ‘reflect each column onto an axis with a mirror.’ Magenta is Gram–Schmidt’s accumulating rounding error; green is the orthogonal reflections. A mirror per column builds Q. (Kin to the-orthonormal and the-cholesky.) pause spin LIT Genuine quadratic reciprocity (conjectured by Euler and Legendre; first complete proof by Gauss 1801, who gave eight). Verified live: computing Legendre symbols by Euler's criterion (a^((p-1)/2) mod p), the law (p/q)(q/p) = (-1)^(((p-1)/2)((q-1)/2)) holds for every odd prime pair below 60, and the quadratic residues mod 7 are {1,2,4} (window.__reciprocity.reciprocityHolds). The law and the symbol computations are exact. FIG No framing: the reciprocity law and the Legendre-symbol computations are real and checked exhaustively over all odd prime pairs below 60 in-browser. The inverse framing — reciprocity binds a question (p/q) to its transpose (q/p), equal everywhere except the both-3-mod-4 cells where the sign flips — is the honest content, shown directly on the symbol board, not asserted. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GAUNTLET · David Lee Wise (ROOT0), with AVAN