THE TREAP

the treap in the 5-window house format — a binary search tree that stays balanced by chance. Each node holds a key (obeying BST order: smaller left, larger right) and a random priority (obeying heap order: parent beats children). For any keys, once priorities are fixed exactly one tree shape satisfies both, and because priorities are random it is balanced with high probability (expected height O(log n)) with far simpler code than a red-black tree — just rotations on insert. The shape is a function of the pairs alone, so the same keys and priorities build the identical tree regardless of insertion order. See the two orders in 1D, the rotating tree in 2D, and the order-independence inverse in 3D.

THE TREAP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · THE SANDBOX ◆ .dlw.fold THE FOLD / SPAWN / THE SANDBOX / THE TREAP THE TREAP a search tree balanced by random priorities — tree + heap 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A treap is a binary search tree that stays balanced by pure chance. Each node carries two numbers: a key , which obeys search-tree order (smaller keys left, larger right), and a random priority , which obeys heap order (every parent’s priority beats its children’s). Tree + heap = treap . The magic: for any set of keys, once the random priorities are fixed there is exactly one tree shape satisfying both constraints — and because the priorities are random, that shape is balanced with high probability , expected height O(log n), the same as a red-black tree but with far simpler code: just rotate to restore heap order on insert. Even better, the shape is a function of the pairs alone — the same keys and priorities build the identical tree no matter what order you insert them in, unlike a plain BST whose shape depends entirely on insertion order. Randomness alone tames the structure: no color bits, no rebalancing rules. LIT verified live: the built treap’s in-order traversal is sorted (BST holds), every parent’s priority exceeds its children’s (heap holds), the height is a small multiple of log n (balanced), and two different insertion orders of the same pairs yield the identical tree (window.__treap). FIG no framing; both invariants, the balance, and the order-independence are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SANDBOX — the spawn domain of a small self-contained system that behaves. A treap is a sandbox that balances itself: drop nodes in any order, hand each a random priority, and the structure settles into a shapely tree with no supervision. AVAN (AI) built the instrument: the rotating inserter, the two-invariant checker, the two-orders inverse. The weave: David names the seat (the self-ordering sandbox); I make keys hold left-right order and priorities hold top-down order at once, and show the shape ignore insertion order — the two orders in 1D, the tree in 2D, the order-independence inverse in 3D. The sphere is the seam. Credit: Cecilia R. Aragon & Raimund Seidel (1989). 3 ONE DIMENSION Two orders in one structure: the keys read left to right come out sorted (the BST axis), while the priorities read top to bottom always decrease (the heap axis). A node’s place is fixed by both at once. 4 TWO DIMENSIONS · INTERACTIVE Insert keys, each with a random priority, and watch the tree rotate to keep the heap order. In-order it stays sorted; top-down the priorities descend; the height hovers near log n. Insert the keys already sorted — a plain BST would degenerate into a line, but the treap stays balanced. insert ▶ insert sorted keys reset 5 THREE DIMENSIONS + AVAN’S INVERSE The tree turning, its green forward structure holding two orders at once: keys fixing left/right, priorities fixing depth — a single shape obeying both. AVAN’s addition (the inverse-companion): the magenta is the same tree built a different way . A plain binary search tree remembers its insertion order in its shape — feed it sorted keys and it collapses into a chain. A treap forgets the order entirely: the shape is a pure function of the (key, priority) pairs, so any insertion sequence of the same pairs produces the identical tree. That is the deep inverse — the map from ‘insertion order’ to ‘tree shape’, which for a BST is injective and adversary-exploitable, becomes constant for a treap: the inverse question ‘what order built this?’ has no answer , because every order builds it. The two orders that do matter — key and priority — are orthogonal, and their unique common solution (a Cartesian tree) is what randomness hands you, balanced. Green is the tree from one insertion order; magenta is the identical tree from another; the order that a BST would betray, the treap has thrown away. pause spin LIT Genuine treap / randomized BST (Cecilia R. Aragon & Raimund Seidel 1989). Verified live: the built treap's in-order traversal is sorted (BST invariant holds), every parent's priority exceeds its children's (heap invariant holds), the height is a small multiple of log2(n) (balanced, not the linear height of a degenerate BST), and two different insertion orders of the same (key,priority) pairs yield the identical tree, confirmed by comparing pre-order serializations (window.__treap.bstSorted && heapOk && balanced && orderIndependent). All are exact. FIG No framing: the dual BST+heap invariants, the O(log n) balance, and the insertion-order-independence are all real and verified in-browser (with deterministic hash priorities so the order-independence is checkable). The AVAN inverse is the genuine deep property — a treap's shape is a pure function of its pairs, so the 'what order built this?' inverse that a plain BST leaks (and an adversary exploits) is constant here: every order builds the same Cartesian tree. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SANDBOX · David Lee Wise (ROOT0), with AVAN


THE CONDORCET

the Condorcet paradox in the 5-window house format — even when every voter has consistent (transitive) preferences, the group's majority preference can cycle. Three voters ranking (A>B>C),(B>C>A),(C>A>B) give a majority for A over B, B over C, and C over A. There is no Condorcet winner (no candidate beating all others head-to-head), and the outcome depends entirely on the agenda: a chairman setting the order of pairwise votes picks the winner. Discovered by Condorcet in 1785, it is the seed of Arrow's impossibility theorem. See the ballots in 1D, the beats-cycle and agenda control in 2D, and the transitive-vs-cyclic inverse in 3D.

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

THE CONDORCET · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · RACE CONDITION ◆ .dlw.fold THE FOLD / GLITCH / RACE CONDITION / THE CONDORCET THE CONDORCET rational voters, an irrational majority — A>B>C>A 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Condorcet paradox. Even when every voter has perfectly consistent preferences, the group’s majority preference can cycle . Three voters ranking three candidates — (A>B>C), (B>C>A), (C>A>B) — produce a majority for A over B , a majority for B over C , and a majority for C over A . Round and round, with no bottom. So there is no Condorcet winner — no candidate who beats every other head-to-head. Worse, whoever wins depends entirely on the agenda : in sequential pairwise votes, a chairman who sets the order picks the winner. The individuals are rational; the collective is not. Discovered by the Marquis de Condorcet in 1785, it is the seed of Arrow’s impossibility theorem — the proof that no ranked voting method can be fair, decisive, and cycle-free all at once. LIT verified live: on this profile A beats B, B beats C, and C beats A (each 2–1), there is no Condorcet winner , and three different agenda orders elect three different candidates (window.__condorcet). FIG no framing; the majority cycle, the absent winner, and the agenda control are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in RACE CONDITION — the glitch domain of an outcome that depends on order and has no stable answer. The Condorcet cycle is a social race condition exactly: the winner is undefined until you fix the sequence, and any sequence can be forced to any result. AVAN (AI) built the instrument: the pairwise tally, the cyclic tournament, the transitive-vs-cyclic inverse. The weave: David names the seat (order decides, nothing is stable); I make three rational rankings breed an irrational cycle and let the agenda pick any winner — the ballots in 1D, the beats-cycle in 2D, the aggregation inverse in 3D. The sphere is the seam. Credit: Marquis de Condorcet (1785); the general impossibility by Kenneth Arrow (1951). 3 ONE DIMENSION The three ballots, each a clean top-to-bottom ranking, and beneath them the three head-to-head tallies. Every voter is consistent; every pairwise vote has a clear 2–1 winner — and yet the three winners chase each other in a ring. 4 TWO DIMENSIONS · INTERACTIVE The three candidates with directed “beats” arrows — A→B, B→C, C→A — a perfect cycle, no top and no bottom. Run a sequential agenda: pit two candidates, then the winner against the third. Change the order and the champion changes, though not one vote moved. run agenda ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The majority relation as a turning tournament — the magenta ring of “beats” arrows with no source and no sink, a cycle that cannot be laid out in a line. AVAN’s addition (the inverse-companion): the green is what each voter brings — a transitive ranking, a clean line from best to worst. Aggregating those lines by majority is supposed to invert them into a group line, a collective ordering. But the inverse fails : the sum of total orders need not be a total order at all. The forward step ‘each person ranks consistently’ has, as its majority inverse, a cycle — the group cannot be ranked, because A>B>C>A has no first place. That is the whole shock of collective choice: transitivity is not preserved under majority, so ‘who does the group prefer?’ can be a question with no answer, only an agenda. Green is the orderable individual; magenta is the un-orderable crowd; and the gap between them is the impossibility Arrow later proved no clever rule can close. To combine rational minds is not to get a rational mind. pause spin LIT Genuine Condorcet paradox (Marquis de Condorcet 1785; generalized by Arrow 1951). Verified live: on the profile (A>B>C),(B>C>A),(C>A>B), A beats B 2-1, B beats C 2-1, and C beats A 2-1 (a majority cycle), there is no Condorcet winner (0 candidates beat all others), and three agenda orders (ABC, BCA, CAB) in sequential pairwise voting elect three different winners (window.__condorcet.majorityCycle && condorcetWinners===0 && agendaControlled). The cycle, the absent winner, and the agenda control are exact. FIG No framing: the majority cycle, the absence of any Condorcet winner, and agenda control (different orders elect different candidates on identical votes) are all real and computed exactly in-browser. The AVAN inverse is the genuine mathematical content — majority aggregation does not preserve transitivity, so combining transitive individual orders can yield a non-orderable cyclic group relation, exactly the impossibility Arrow proved general. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of RACE CONDITION · David Lee Wise (ROOT0), with AVAN


THE SHAPLEY

the Shapley value in the 5-window house format — the unique fair way to divide a cooperating group's value: average each player's marginal contribution over every order of joining. It is the only allocation obeying efficiency (shares sum to the whole), symmetry (interchangeable players equal), dummy (a null player gets nothing), and additivity. In voting it becomes power: with weights 50/30/20 and a 51% quota the biggest party holds 2/3 of the power on half the seats, while the 30 and 20 parties are exactly equal. Underlies cost-sharing, credit attribution, and SHAP for explaining ML. See the marginal contributions in 1D, the pivot count in 2D, and the power-vs-weight inverse in 3D.

THE SHAPLEY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE SHAPLEY THE SHAPLEY the unique fair split — average marginal contribution 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Shapley value answers: when a group cooperates to make something worth v, how much does each member fairly deserve ? Lloyd Shapley’s answer (1953): average each player’s marginal contribution over every order of joining. Imagine the players arriving one at a time in a random sequence; each is credited with how much they add to the coalition already present; average over all n! orders. This single formula is the only one obeying four fairness axioms at once: efficiency (shares sum to the whole), symmetry (interchangeable players get equal shares), dummy (a player who adds nothing to any coalition gets nothing), and additivity . A jolt follows in voting: with weights 50/30/20 and a 51% quota, the biggest party holds two-thirds of the real power despite only half the seats, while the 30 and 20 parties are exactly equal . It underlies cost-sharing, credit attribution, and — as SHAP — explaining machine-learning predictions. LIT verified live: for [51; 50,30,20] the Shapley values are 2/3, 1/6, 1/6 — they sum to 1 (efficiency), the two smaller are equal (symmetry) — and a weight-0 player scores 0 (dummy) (window.__shapley). FIG no framing; the axioms and the power-≠-weight result are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE PUSH — the co-op domain of a shared effort and who deserves the credit. The Shapley value is the fair reckoning of a joint push: measure what each shoulder actually added, averaged over every way the work could have come together. AVAN (AI) built the instrument: the pivot counter, the power-vs-weight bars, the fair-share inverse. The weave: David names the seat (fair credit for pushing together); I make each player’s average marginal contribution the unique fair share and show power diverge from weight — the contributions in 1D, the pivots in 2D, the power/weight inverse in 3D. The sphere is the seam. Credit: Lloyd Shapley (1953, Nobel 2012); the voting index by Shapley & Shubik (1954); SHAP by Lundberg & Lee (2017). 3 ONE DIMENSION One player’s marginal contribution in each arrival order: sometimes they tip the coalition over the line (a pivot, worth 1), sometimes they add nothing. The Shapley value is simply the average of that row — the fraction of orders in which they were pivotal. 4 TWO DIMENSIONS · INTERACTIVE A weighted-voting game. Every ordering of the players is laid out; the one whose arrival first crosses the quota is the pivot , highlighted. Count pivots and divide — those fractions are the Shapley values. Change the weights and watch power refuse to track the seats. game: [51;50,30,20] 5 THREE DIMENSIONS + AVAN’S INVERSE The players’ Shapley power as green bars — the forward result: the fair share each earns, summing to the whole. AVAN’s addition (the inverse-companion): the magenta bars are the naive expectation — each player’s weight share , what you would guess power should be. They do not match. Power is a non-linear function of weight: with 50/30/20 the big party’s green power (2/3) towers over its magenta weight (1/2), while the 30 and 20 parties collapse to equal power even though their weights differ. And the inverse runs deeper — you cannot read the weights back off the power, because different weightings give the same Shapley vector, and a tiny weight can be pivotal constantly (huge power) or never (a dummy, zero power). So ‘how much you deserve’ is not ‘how much you brought’ scaled down; it is how often your arrival was decisive , averaged over every order, and that decisiveness has no simple inverse in the raw weights. Green is earned power; magenta is the proportional guess it refuses to be; the gap is why voting power, credit, and cost-sharing all need Shapley and not a ruler. pause spin LIT Genuine Shapley value (Lloyd Shapley 1953, Nobel 2012; Shapley-Shubik voting index 1954; SHAP by Lundberg & Lee 2017). Verified live: for the weighted-voting game [51; 50,30,20] the Shapley values are 2/3, 1/6, 1/6 — they sum to 1 (efficiency), the two smaller players are equal (symmetry), the big player holds 2/3 despite 50% weight — and a weight-0 player scores exactly 0 (dummy) (window.__shapley.efficiency && symmetry && bigHas2of3 && dummyIsZero). The axioms and the power-not-weight result are exact. FIG No framing: the Shapley values, the efficiency/symmetry/dummy axioms, and the power-does-not-equal-weight result are all computed exactly in-browser over every coalition/ordering. The AVAN inverse is genuine — power is a non-linear function of weight (equal-power despite unequal weight, a small weight can be pivotal-always or a dummy), and the weights cannot be read back from the Shapley vector. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE ALABAMA

the Alabama apportionment paradox in the 5-window house format — under Hamilton's largest-remainder method, adding a seat to the legislature can make a state lose one. Each state gets quota = pop/total x house-size, rounded down, and leftover seats go to the largest fractional remainders; growing the house rescales every quota at once, so a state can have its leftover seat snatched away. Named for the 1880 census, where Alabama would get 8 seats in a 299-member House but only 7 in a 300-member House. Balinski & Young proved no method escapes all such paradoxes. See the seat drop in 1D, the live apportionment in 2D, and the monotonicity-impossibility inverse in 3D.

THE ALABAMA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE ALABAMA THE ALABAMA add a seat to the house — a state loses one 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Alabama paradox. Under a natural method for dividing seats among states in proportion to population, adding a seat to the legislature can make a state lose one. It is not a rounding slip — it is a real flaw in Hamilton’s method (largest-remainder apportionment). Each state gets a fair-share quota = population/total × house size, rounded down; the leftover seats go to the states with the biggest fractional remainders . The trap: growing the house rescales every quota and remainder at once, and a state can have its leftover seat snatched by two faster-rising rivals. It is named for the 1880 U.S. census, where Alabama would have received 8 seats in a 299-member House but only 7 in a 300-member House. The discovery, and its cousins, eventually drove Congress to abandon the method — and Balinski & Young later proved no apportionment method can be free of every such paradox. LIT verified live: for populations 6, 6, 2, Hamilton’s method gives seats (4,4,2) in a 10-seat house but (5,5,1) in an 11 -seat house — state C drops from 2 to 1 while the house grew (window.__alabama). FIG no framing; the paradox is exact arithmetic under the stated method. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in OFF BY ONE — the glitch domain of the count that moves the wrong way. The Alabama paradox is the purest off-by-one in politics: add exactly one seat and a state loses exactly one, the total up while a part goes down. AVAN (AI) built the instrument: the quota/remainder apportioner, the house-size slider, the monotonicity-impossibility inverse. The weave: David names the seat (add one, lose one); I make growing the house strip a seat from a state and show why no method escapes it — the seat drop in 1D, the live apportionment in 2D, the fairness-vs-monotonicity inverse in 3D. The sphere is the seam. Credit: noticed after the 1880 census (C. W. Seaton); Alexander Hamilton’s method; the impossibility theorem by Michel Balinski & H. Peyton Young (1982). 3 ONE DIMENSION The seat counts at house size 10 and 11, side by side. Two states climb from 4 to 5; the third falls from 2 to 1 — even though there is now one more seat to hand out. The total rose; a part sank. 4 TWO DIMENSIONS · INTERACTIVE Populations and their apportionment. Slide the house size and watch the seats update by quota-then-remainder. Cross the threshold and a state visibly loses a seat as the house grows — the quotas and remainders shown so you can see the leftover seat change hands. house + 1 house − 1 5 THREE DIMENSIONS + AVAN’S INVERSE The seat allocation turning — the green forward result: Hamilton’s method, fair by quota, handing every state close to its exact share. AVAN’s addition (the inverse-companion): the magenta is the property everyone assumes and the method quietly breaks — monotonicity : more total seats should mean no state ever loses one. Reverse the reasoning and the fault appears — the inverse expectation, ‘growing the whole weakly grows each part,’ is false here, because the leftover seats are handed out by a ranking that the very act of adding a seat reshuffles. And the deep inverse is Balinski & Young’s theorem: the method you actually want — one that stays within each state’s quota and never suffers the Alabama or population paradoxes — does not exist . You may have fairness-to-quota or monotonicity, never both. So the magenta ideal is provably unreachable: every apportionment rule betrays some intuition somewhere. Green is Hamilton’s fair-but-fickle split; magenta is the paradox-free method that cannot be built; and the gap between them is a small, exact, permanent flaw in the arithmetic of representation. pause spin LIT Genuine Alabama paradox (noticed after the 1880 US census by C. W. Seaton; Hamilton's method; impossibility theorem by Balinski & Young 1982). Verified live: for populations 6, 6, 2 Hamilton's method gives seats (4,4,2) in a 10-seat house but (5,5,1) in an 11-seat house — state C drops from 2 seats to 1 while the house grew, with correct totals (window.__alabama.alabamaParadox && sumsCorrect). The paradox is exact arithmetic under the stated apportionment method. FIG No framing: the seat allocation and the non-monotone drop (house grows, a state loses a seat) are exact and computed in-browser by Hamilton's method. The AVAN inverse is the genuine impossibility content — Balinski & Young proved no apportionment method can both stay within quota and avoid the Alabama/population paradoxes, so the monotone-and-fair ideal is provably unreachable, stated as the established theorem. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE BORDA

the rule-dependence of elections in the 5-window house format — who wins depends entirely on the counting rule. For 10 voters (4: A>B>C, 3: B>C>A, 3: C>B>A), plurality elects A with 4 first-place votes, but a majority prefers B to A (6-4) and C to A (6-4), so A is the Condorcet loser who loses to everyone, yet plurality crowns them. The Borda count (points by rank) instead elects B, which is exactly the Condorcet winner. First-past-the-post hands victory to the universally-rejected candidate while a full-ballot rule reverses it (Borda 1770). See the tallies in 1D, the three rules and head-to-head grid in 2D, and the discarded-preference inverse in 3D.

THE BORDA · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE BORDA THE BORDA same ballots, different rule — plurality crowns the loser 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Who wins an election? It depends entirely on the rule — and the rules can disagree violently on the very same ballots. Take 10 voters: 4 rank A>B>C, 3 rank B>C>A, 3 rank C>B>A. Under plurality (most first-place votes), A wins with 4. But look head-to-head: a majority prefers B to A (6–4) and a majority prefers C to A (6–4) — A is the Condorcet loser , the candidate who loses to everyone, yet plurality crowns them. The Borda count (award points by rank position) instead elects B — which is exactly the Condorcet winner (B beats both A and C). So first-past-the-post hands victory to the universally-rejected candidate, while a rule that reads the whole ballot reverses it. Jean-Charles de Borda argued precisely this in 1770: plurality can systematically elect the wrong candidate when the vote splits. LIT verified live: on this profile the plurality winner is A (the Condorcet loser, beaten head-to-head by all), while the Borda winner equals the Condorcet winner, B (window.__borda). FIG no framing; the tallies, the head-to-head majorities, and the rule disagreement are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE CHOKE POINT — the boss domain where one narrow decision governs everything downstream. The counting rule is the choke point of an election: the same votes flow in, and the rule alone decides who emerges. AVAN (AI) built the instrument: the three tallies, the head-to-head grid, the discarded-preference inverse. The weave: David names the seat (the rule is the gate); I make plurality crown the loser everyone beats while Borda restores the pairwise winner — the tallies in 1D, the rule comparison in 2D, the full-ballot inverse in 3D. The sphere is the seam. Credit: Jean-Charles de Borda (1770); the debate with Condorcet; modern geometry by Donald Saari. 3 ONE DIMENSION The plurality tally (first-place votes only) beside the head-to-head majorities. A leads the first bar — and loses both duels. First place and majority preference are pulling in opposite directions. 4 TWO DIMENSIONS · INTERACTIVE The 10 ballots and three verdicts. Flip between plurality , Borda , and Condorcet : the same votes, a different champion. The head-to-head grid exposes it — the plurality winner loses every column, the universal loser the counting rule mistook for a winner. rule: plurality 5 THREE DIMENSIONS + AVAN’S INVERSE The ballots turning — the green forward view of plurality: keep only each voter’s first choice, stack the tops, crown the tallest. AVAN’s addition (the inverse-companion): the magenta is everything plurality threw away — the rest of each ballot. Plurality is a lossy projection : it keeps the top of every ranking and discards the order beneath, and that discarded order is exactly where A’s universal defeat is written. Read the whole ballot back — Borda’s points, or the full grid of pairwise majorities — and the winner reverses : the candidate ranked first most often is the candidate a majority ranks last against each rival. So the inverse of ‘who leads the first-choice count?’ is ‘who beats everyone in a duel?’, and on a split vote they can be opposite people. The magenta lower preferences are not noise; they are the majority’s real verdict, invisible to a rule that only looks at the top. Green crowns the plurality leader; magenta, restored, crowns the pairwise winner and unmasks the leader as the loser — the whole quarrel of voting theory in one profile. pause spin LIT Genuine voting-rule disagreement (Jean-Charles de Borda 1770; the Borda-Condorcet debate; geometry by Donald Saari). Verified live: on the profile (4: A>B>C, 3: B>C>A, 3: C>B>A) the plurality winner is A (with 4 first-place votes) yet A is the Condorcet loser, beaten 4-6 by both B and C, while the Borda winner (tally A=8,B=13,C=9) is B, equal to the Condorcet winner (window.__borda.pluralityCrownsLoser && bordaEqualsCondorcet && rulesDisagree). The tallies, head-to-head majorities, and rule disagreement are exact. FIG No framing: the plurality/Borda/Condorcet tallies and the fact that plurality elects the Condorcet loser while Borda matches the Condorcet winner are all computed exactly in-browser on a concrete profile. The AVAN inverse is genuine — plurality is a lossy projection keeping only first choices, and restoring the discarded lower preferences (Borda points / pairwise majorities) reverses the winner, exposing the top-count leader as the pairwise loser. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE BANZHAF

the Banzhaf power index in the 5-window house format — measure a voter's real power in a weighted body by counting swing votes: winning coalitions where the voter is critical (leaving flips pass to fail). Power is each voter's share of total swings. It is almost never proportional to weight: with weights 50,49,1 and a majority quota of 50, the weight-49 and weight-1 parties have exactly equal power, and a large weight can be a dummy with zero power. Banzhaf devised it in 1965 for a lawsuit over a malapportioned county board. See the swing counts in 1D, the critical-coalition scan in 2D, and the Banzhaf-vs-Shapley inverse in 3D.

THE BANZHAF · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE BROADCAST ◆ .dlw.fold THE FOLD / CO-OP / THE BROADCAST / THE BANZHAF THE BANZHAF voting power by swing votes — weight 49 can equal weight 1 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Banzhaf power index measures a voter’s real clout in a weighted body by counting swing votes: the winning coalitions in which that voter is critical — where their leaving would flip the result from pass to fail. Divide each voter’s swings by the total across everyone, and you get their share of power. The startling lesson: power is almost never proportional to weight. In a body with weights 50, 49, 1 and a majority quota of 50, the weight-49 party and the weight-1 party have exactly equal power — because in every coalition they play the identical decisive role. Forty-nine times the votes buys no extra sway. A large enough weight can even be a dummy , with zero swings and zero power. Banzhaf devised the index in 1965 for a lawsuit against a New York county board whose weighted voting handed some towns literally no power; courts have since used it to strike down malapportioned schemes. LIT verified live: for [50; 50,49,1] the Banzhaf powers are 3/5, 1/5, 1/5 — the weight-49 and weight-1 parties tie — and in [50; 26,26,26,2] the weight-2 party is a genuine dummy with zero power (window.__banzhaf). FIG no framing; the swing counts, the equal-power tie, and the dummy are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE BROADCAST — the co-op domain of whose voice actually carries. The Banzhaf index is a broadcast meter: it counts not how loud a voter is on paper but how often their vote is the one that decides, the signal that actually reaches the outcome. AVAN (AI) built the instrument: the swing counter, the power-vs-weight bars, the two-indices inverse. The weave: David names the seat (whose vote truly carries); I make critical-coalition counts the measure of power and show weight 49 equal to weight 1 — the swings in 1D, the coalition scan in 2D, the Banzhaf-vs-Shapley inverse in 3D. The sphere is the seam. Credit: John F. Banzhaf III (1965); the earlier form by Lionel Penrose (1946), hence “Penrose–Banzhaf.” See [[the-shapley]]. 3 ONE DIMENSION The swing count for each party — how many winning coalitions they alone hold together. Two parties with wildly different weights can post the same number of swings, and their power bars come out identical. 4 TWO DIMENSIONS · INTERACTIVE A weighted game with every coalition listed. Pick a party and its critical coalitions light up — the ones that win with it and lose without it. Count them, divide, and read the power. Flip to the [26,26,26,2] game and watch the weight-2 party register zero swings: a dummy. game: [50;50,49,1] party ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The parties’ Banzhaf power as green bars — the forward measure: clout counted as swings, not seats. AVAN’s addition (the inverse-companion): the magenta bars are the weight shares — and they refuse to match, because power is a step-function of weight: crossing the quota threshold turns a party from decisive to irrelevant in an instant, so weight 49 and weight 1 can land on the same swing count while a heavier party crashes to a dummy’s zero. Trying to run the inverse — recover weights from power — fails: the map is many-to-one and discontinuous. And there is a second inverse hiding here: Banzhaf is not the only fair power index. Count coalitions equally and you get Banzhaf; count orderings instead and you get the Shapley–Shubik value — two principled measures that can hand the same body different power vectors. So ‘how much power does this voter have?’ has no single inverse: it depends on whether you weigh unordered coalitions or ordered arrivals, and reasonable people pick different answers. Green is Banzhaf’s swing-power; magenta is the weight it defies (and the rival index it need not agree with); the very notion of ‘voting power’ has more than one honest inverse. pause spin LIT Genuine Banzhaf (Penrose-Banzhaf) power index (John F. Banzhaf III 1965; earlier Lionel Penrose 1946). Verified live: for the game [50; 50,49,1] the Banzhaf powers are 3/5, 1/5, 1/5 — the weight-49 and weight-1 parties tie exactly despite the 49x weight difference, and the shares sum to 1 — while in [50; 26,26,26,2] the weight-2 party has zero swings and zero power, a genuine dummy (window.__banzhaf.weight49equalsWeight1 && sumsToOne && weight2IsDummy). The swing counts, the equal-power tie, and the dummy are exact. FIG No framing: the swing-count powers, the equal-power tie (weight 49 == weight 1), and the dummy (weight 2, zero power) are all computed exactly over every coalition in-browser. The AVAN inverse is genuine and honest — power is a discontinuous step-function of weight (no inverse from power to weights), and Banzhaf (counting coalitions) can differ from the Shapley-Shubik index (counting orderings), so 'voting power' itself has more than one legitimate definition. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BROADCAST · David Lee Wise (ROOT0), with AVAN


THE BELL

Bell's theorem via the CHSH game in the 5-window house format — two entangled particles go to distant labs; each picks one of two measurement settings and records +-1, with no signal between them. If the particles carried predetermined answers (local hidden variables), the CHSH combination S of their correlations can never exceed 2. Quantum mechanics reaches S = 2*sqrt(2) ~ 2.828, breaking the bound — correlations stronger than any classical mechanism, without hidden coordination or signalling. Bell proved it in 1964; the 2022 Nobel honored the experiments. See the CHSH wall in 1D, the angle dials in 2D, and the no-local-explanation inverse in 3D.

THE BELL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE BELL THE BELL entanglement beats every classical bound — CHSH 2√2 > 2 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Bell’s theorem , in the concrete form of the CHSH game. Two particles are prepared in an entangled Bell state and sent to distant labs, Alice and Bob. Each independently picks one of two measurement settings and records +1 or −1. No signal passes between them. Classically, if the particles carried predetermined answers (local hidden variables), a certain combination of their correlations — the CHSH quantity S — can never exceed 2 . But quantum mechanics predicts, and experiments confirm, that entangled particles reach S = 2√2 ≈ 2.828 , breaking the bound. This is not hidden coordination or faster-than-light signalling — it is that entangled particles share correlations stronger than any classical mechanism can produce . John Bell proved it in 1964, turning Einstein’s “spooky action at a distance” from a complaint into a testable — and refuted — prediction; the 2022 Nobel Prize honoured the experiments. LIT verified live: the quantum CHSH value is exactly 2√2, a brute force over every local deterministic strategy caps the classical value at 2, and 2√2 is the Tsirelson quantum maximum (window.__bell). FIG no framing; the quantum value, the classical bound, and their gap are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SYNC — the co-op domain of two things kept in step. Entanglement is synchronisation past the classical limit: two distant measurements agree more tightly than any shared plan or signal could arrange. AVAN (AI) built the instrument: the correlation calculator, the CHSH climb, the no-local-explanation inverse. The weave: David names the seat (in step beyond what a channel allows); I make the correlations sum past 2 to 2√2 and cap the best classical strategy at 2 — the CHSH bar in 1D, the angle dials in 2D, the impossible-hidden-variable inverse in 3D. The sphere is the seam. Credit: John Stewart Bell (1964); the CHSH form (Clauser, Horne, Shimony & Holt 1969); the quantum ceiling by Boris Tsirelson (1980); Nobel 2022. 3 ONE DIMENSION The CHSH value on a line. Every classical strategy lives at or below 2 — the wall Bell drew. Quantum entanglement reaches 2√2 ≈ 2.83 , past the wall but stopping at Tsirelson’s ceiling: more than classical, less than anything. 4 TWO DIMENSIONS · INTERACTIVE Alice’s two settings and Bob’s two, as angles. The four correlations E(a,b) = cos(a−b) combine into S. Dial to the optimal angles and S climbs to 2√2; switch to the best classical strategy and it is pinned at 2, never more. optimal angles ▶ classical strategy 5 THREE DIMENSIONS + AVAN’S INVERSE The two measurement directions turning on a shared sphere — the green forward law: the correlation depends only on the angle between the settings, E = cos(a−b), a clean rotational symmetry. AVAN’s addition (the inverse-companion): the magenta is the inverse that cannot exist — a local hidden-variable model, a shared list of predetermined answers, that reproduces cos(a−b) at all angles. Run the correlations backward, asking ‘what common cause produced them?’, and Bell’s theorem answers: no such cause . There is no assignment of definite +1/−1 outcomes, fixed before measurement and independent across the labs, that can match the quantum curve everywhere — the very attempt caps out at S = 2, and the quantum world sits at 2√2, provably out of reach. So the inverse of ‘entangled correlation’ is not a hidden mechanism; it is the demonstrated absence of one. Green is the correlation any experiment measures; magenta is the local explanation that would tame it — and Bell’s achievement was to prove that magenta is empty, not merely unknown. The spookiness is real because its classical inverse has been ruled out, not left open. pause spin LIT Genuine Bell theorem / CHSH inequality (John Stewart Bell 1964; CHSH form by Clauser, Horne, Shimony & Holt 1969; Tsirelson bound 1980; Nobel 2022). Verified live: the quantum CHSH value with E(a,b)=cos(a-b) at the optimal angles (0, pi/2, pi/4, 3pi/4) is exactly 2*sqrt(2) ~ 2.828, a brute force over every local deterministic strategy caps the classical value at exactly 2, and 2*sqrt(2) is the Tsirelson quantum maximum (window.__bell.quantumBeatsClassical && classicalMax===2 && isTsirelson). The quantum value, the classical bound, and their gap are exact. FIG No framing: the quantum CHSH value (2*sqrt(2)), the classical bound (2, brute-forced over all local strategies), and the Tsirelson ceiling are all computed exactly in-browser. The AVAN inverse is the genuine content of Bell's theorem — no local hidden-variable model can reproduce cos(a-b) at all angles (the classical value provably caps at 2), so the 'local explanation' inverse is proven absent, not merely unknown. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE DEUTSCH

Deutsch's algorithm in the 5-window house format — the first proof a quantum computer beats a classical one. Given a black box computing an unknown function f from one bit to one bit, decide if it is constant (same output both inputs) or balanced (different). Classically you must query it twice; quantumly, once. A Hadamard puts the input in superposition, the box runs f once, and a second Hadamard makes the two paths interfere — constructively if constant, destructively if balanced — so measuring the input qubit reads 0 for constant, 1 for balanced. Quantum speedup from interference, the seed of Shor and Grover. See the four verdicts in 1D, the running circuit in 2D, and the relation-vs-values inverse in 3D.

THE DEUTSCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SPEEDRUN ◆ .dlw.fold THE FOLD / CHEAT / THE SPEEDRUN / THE DEUTSCH THE DEUTSCH one quantum query where classical needs two 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Deutsch’s algorithm (1985) was the first proof a quantum computer can beat a classical one. The puzzle: a black box computes an unknown function f from one bit to one bit. Is it constant (same output for both inputs) or balanced (different outputs)? Classically you must query it twice — check f(0), then f(1). Quantumly you need just one . Put the input qubit into a superposition of 0 and 1 with a Hadamard gate, run the box once so it evaluates f on both inputs, then a second Hadamard makes the two paths interfere — constructively if f is constant, destructively if balanced. A single measurement of the input qubit then reads out the answer: 0 for constant, 1 for balanced . It is a toy problem, but it is the seed of Shor’s and Grover’s algorithms — quantum speedup from interference , not brute parallelism. LIT verified live: simulating the two-qubit circuit for all four functions, one query’s measurement is 0 for both constant functions and 1 for both balanced ones — always correct (window.__deutsch). FIG no framing; the circuit and its one-query verdict are exact quantum linear algebra. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SPEEDRUN — the cheat domain of finishing in fewer moves than should be possible. Deutsch is the original quantum speedrun: one oracle call where classical logic demands two, the whole point of quantum computing in miniature. AVAN (AI) built the instrument: the circuit simulator, the interference view, the relation-not-values inverse. The weave: David names the seat (win in one move); I make superposition and interference read the function’s nature in a single query — the four verdicts in 1D, the running circuit in 2D, the relation-vs-values inverse in 3D. The sphere is the seam. Credit: David Deutsch (1985); the n-bit generalization by Deutsch & Jozsa (1992). 3 ONE DIMENSION The four possible functions and the single qubit the algorithm measures: 0 for the two constant functions, 1 for the two balanced ones. One number, read in one query, tells constant from balanced with certainty. 4 TWO DIMENSIONS · INTERACTIVE Pick a function and step the circuit: Hadamards spread the input into superposition, the oracle runs f once, a final Hadamard makes the paths interfere. Watch the amplitudes at each stage; the input qubit collapses to 0 (constant) or 1 (balanced) — a single oracle call. f: constant-0 step ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The two computational paths — f(0) and f(1) — turning and meeting; the green forward step: they interfere into a single answer bit. AVAN’s addition (the inverse-companion): the magenta is what the quantum query refuses to give you — the individual values. Classically, two queries recover f(0) and f(1) separately. Deutsch spends one query to learn only the relation f(0) ⊕ f(1) — whether they are equal — and never reveals either value on its own. So the inverse of ‘the two answers’ is ‘a single bit about how they relate,’ and quantum buys that relational bit at half the cost precisely by giving up the values. It is a lossy query: one bit of global structure extracted, the local data left forever inside the box. That is the true shape of quantum advantage here — not learning more for less, but learning exactly the right one bit for less, by asking a question about the whole rather than the parts. Green is the relation the interference hands you in one shot; magenta is the pair of values it will not, and does not need to, expose. pause spin LIT Genuine Deutsch's algorithm (David Deutsch 1985; n-bit Deutsch-Jozsa 1992). Verified live: simulating the two-qubit circuit (H tensor H, oracle U_f mapping |x,y> to |x, y XOR f(x)>, H on qubit 0) for all four functions, one query's measurement of qubit 0 is 0 for both constant functions and 1 for both balanced ones — always correct (window.__deutsch.oneQueryCorrect true, measuredBits 0,0,1,1). The circuit and its one-query verdict are exact quantum linear algebra. FIG No framing: the circuit is simulated exactly (real amplitudes) and the one-query answer is correct for all four functions in-browser. The AVAN inverse is honest and genuine — the algorithm learns only the relation f(0) XOR f(1) (constant vs balanced), never the individual values, a lossy query that buys a single global bit for less by declining to reveal the local data. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SPEEDRUN · David Lee Wise (ROOT0), with AVAN


THE GROVER

Grover's algorithm in the 5-window house format — search an unsorted database of N items for a marked one in about sqrt(N) steps, a quadratic speedup over the N/2 a classical scan averages. Start with all items in equal superposition (amplitude 1/sqrt(N)) and repeat two moves: an oracle that flips the marked amplitude's sign, and a diffusion that reflects every amplitude about the average. Each round rotates the state toward the marked item, its probability growing as sin^2((2k+1)theta) with sin(theta)=1/sqrt(N), peaking near (pi/4)sqrt(N) rounds. Overshoot and it comes back down. See the amplitudes in 1D, the amplification and overshoot in 2D, and the rotation inverse in 3D.

THE GROVER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE SHORTCUT ◆ .dlw.fold THE FOLD / CHEAT / THE SHORTCUT / THE GROVER THE GROVER search N items in √N — the quantum shortcut 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Grover’s algorithm searches an unsorted database of N items for a marked one in about √N steps — a quadratic speedup over the N/2 a classical scan needs on average. It works by amplitude amplification . Start with all N items in equal superposition, each amplitude 1/√N. Repeat two moves: an oracle that flips the sign of the marked item’s amplitude, and a diffusion that reflects every amplitude about their average. Each round rotates the state a little closer to the marked item; its probability grows as sin²((2k+1)θ) with sinθ = 1/√N, reaching nearly 1 after about (π/4)√N rounds. The catch: don’t overshoot — keep going and the probability comes back down. For 16 items the peak is at 3 rounds; for a million, about 785. Grover found it in 1996; it is the general-purpose quantum speedup for brute-force search. LIT verified live: simulating the oracle-plus-diffusion rounds, the marked probability follows sin²((2k+1)θ) exactly and peaks near 0.96 at 3 rounds for N=16 — where a classical search averages 8 (window.__grover). FIG no framing; the amplitude curve, the √N peak, and the overshoot are exact. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE SHORTCUT — the cheat domain of reaching the end by a hidden path. Grover is the archetypal shortcut: the whole haystack searched in the square root of the time, by turning the amplitudes rather than checking the items. AVAN (AI) built the instrument: the amplitude bars, the rotation view, the overshoot inverse. The weave: David names the seat (the square-root path); I make oracle-and-diffusion rounds amplify the marked amplitude to near-certainty in √N steps — the amplitudes in 1D, the amplification in 2D, the stop-at-the-peak inverse in 3D. The sphere is the seam. Credit: Lov K. Grover (1996). 3 ONE DIMENSION The N amplitudes as a row of bars. The oracle drives the marked bar negative ; the diffusion — reflect about the average — then pumps it tall and shrinks the rest. Two moves, and the needle stands a little higher than the hay. 4 TWO DIMENSIONS · INTERACTIVE Step the rounds and watch the marked amplitude grow toward certainty, its probability tracing sin²((2k+1)θ). Reach the peak near √N — then keep going and watch it fall . In Grover, more work past the optimum makes things worse. round ▶ N: 16 reset 5 THREE DIMENSIONS + AVAN’S INVERSE The state as a vector in the plane of ‘marked’ and ‘everything else’ — the green forward step: each round rotates it by a fixed angle 2θ toward the marked axis. AVAN’s addition (the inverse-companion): the magenta is the same rotation carried too far . Grover is not an accumulation that only ever helps — it is a rotation , and a rotation can turn past its target. Up to the peak near (π/4)√N, each round swings the state closer to the marked axis; one round beyond, and it swings away , the probability falling exactly as it rose. So the inverse of ‘search more’ here is ‘search worse’ — unlike a classical scan, where extra checks never cost you, extra Grover rounds undo your progress. You must stop at the right moment, because the algorithm has no notion of ‘good enough and holding’; it simply keeps turning. The magenta over-rotation is the honest price of amplitude amplification: the quadratic shortcut is a pendulum, not a ramp, and knowing when to measure is as essential as the amplification itself. Green rotates toward the answer; magenta rotates past it; the peak is a knife-edge you aim for, not a plateau you climb onto. pause spin LIT Genuine Grover's algorithm (Lov K. Grover 1996). Verified live: simulating oracle (flip marked sign) plus diffusion (invert about mean), the marked probability follows sin^2((2k+1)theta) exactly and peaks at ~0.96 at 3 rounds for N=16 = round((pi/4)sqrt(16)), then falls if continued, while a classical search averages N/2=8 (window.__grover.closedFormMatches && peakIter near optimalIters && overshoots). The amplitude curve, the sqrt(N) peak, and the overshoot are exact. FIG No framing: the amplitude amplification, the sin^2((2k+1)theta) curve, the sqrt(N) peak, and the overshoot (probability falls past the optimum) are all simulated exactly in-browser. The AVAN inverse is genuine — Grover is a rotation by 2theta per round in the marked/unmarked plane, so continuing past the peak rotates away and reduces the probability; unlike classical search, more rounds can make it worse, and knowing when to stop is essential. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SHORTCUT · David Lee Wise (ROOT0), with AVAN


THE GHZ

the GHZ paradox in the 5-window house format — three particles entangled in the GHZ state (|000>+|111>)/sqrt2, sent to distant labs, refute local realism with certainty in one measurement round (no statistics, unlike Bell). Quantum predicts XXX = +1 while XYY = YXY = YYX = -1. If the particles had predetermined values, XXX = x1x2x3 would equal the product (XYY)(YXY)(YYX) = x1x2x3(y1y2y3)^2 = x1x2x3 — the same. But quantum gives +1 vs -1, so no assignment of definite values fits all four predictions. The sharpest form of Bell's theorem: all or nothing. See the observables in 1D, the impossible assignment in 2D, and the no-hidden-reality inverse in 3D.

THE GHZ · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / THE GHZ THE GHZ three qubits refute local realism with certainty 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The GHZ paradox (Greenberger–Horne–Zeilinger, sharpened by Mermin) refutes Einstein’s local realism with certainty , in a single measurement round — no statistics needed, unlike Bell’s inequality. Three particles are entangled in the GHZ state (|000⟩ + |111⟩)/√2 and sent to three distant labs. Each measures X or Y. Quantum mechanics predicts, with probability 1 : XXX = +1 , while XYY = YXY = YYX = −1 . Now suppose the particles carried predetermined values xᵢ, yᵢ = ±1 fixed before measurement. Then XXX = x₁x₂x₃, and the product (XYY)(YXY)(YYX) = x₁x₂x₃·(y₁y₂y₃)² = x₁x₂x₃ as well — so local realism demands XXX = (XYY)(YXY)(YYX) . But quantum gives +1 versus −1 . No assignment of definite values can satisfy all four predictions; one run exposes the clash. It is the sharpest form of Bell’s theorem — quantum mechanics against hidden variables, all or nothing. LIT verified live: computing the GHZ state’s eigenvalues, XXX = +1 while XYY, YXY, YYX = −1, so their product (−1) contradicts XXX (+1) — a value local realism forces to be equal (window.__ghz). FIG no framing; the eigenvalues and the exact contradiction are computed from the Pauli operators. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE RAID — the boss domain of a coordinated strike three fronts at once. GHZ is a three-party quantum raid: three distant measurements whose joint pattern classical reality cannot possibly defend, and it falls in one blow, not a war of attrition. AVAN (AI) built the instrument: the eigenvalue table, the try-to-satisfy-classically failure, the no-hidden-reality inverse. The weave: David names the seat (the three-front strike that lands at once); I make the four quantum predictions consistent and the single classical assignment self-contradict — the observables in 1D, the impossible assignment in 2D, the pre-existing-values inverse in 3D. The sphere is the seam. Credit: Greenberger, Horne & Zeilinger (1989); Mermin’s sharpening (1990); Zeilinger, Nobel 2022. 3 ONE DIMENSION The four measurement patterns and the definite value quantum mechanics assigns each on the GHZ state: XXX = +1, and the three mixed ones −1. Multiply the three mixed values and you should recover XXX — but you get the opposite sign. 4 TWO DIMENSIONS · INTERACTIVE Try to be a local realist: assign each particle a definite X and Y value (±1) in advance. The panel checks all four quantum predictions at once — and no assignment satisfies them. Flip the values however you like; the contradiction never closes. try assignment ▶ show quantum 5 THREE DIMENSIONS + AVAN’S INVERSE The three entangled particles turning together — the green forward truth: quantum mechanics’ four predictions, all mutually consistent, all confirmed in the lab. AVAN’s addition (the inverse-companion): local realism is the belief that measurement merely reveals a value that was already there. The GHZ argument runs that belief in reverse — assume the pre-existing values exist, and derive that XXX must equal the product of the mixed measurements, forcing +1 = −1 . So the inverse, ‘recover the hidden values behind the outcomes,’ is not merely hard, it is algebraically impossible : a single sign kills it. The magenta is that collapsing assumption, the pre-existing reality that cannot be consistently written down. Where Bell needed many runs to build a statistical case against hidden variables, GHZ needs one — the contradiction is certain, not probable. Green is the quantum world, self-consistent and observed; magenta is the classical story of definite-values-waiting-to-be-found, and here it does not merely fail to fit the data, it fails to exist . The inverse of ‘the outcome’ is not ‘the hidden cause’; it is a proof that no such cause is there. pause spin LIT Genuine GHZ / Mermin all-versus-nothing argument (Greenberger, Horne & Zeilinger 1989; Mermin 1990; Zeilinger Nobel 2022). Verified live: computing the GHZ state's expectation values from the Pauli operators, XXX = +1 while XYY = YXY = YYX = -1, so the product of the three mixed observables is -1, contradicting XXX = +1 — a value local hidden variables force to be equal (window.__ghz.quantumContradicts true). The eigenvalues and the exact +1-vs--1 contradiction are computed from the operators, not asserted. FIG No framing: the four GHZ eigenvalues and the +1-vs--1 contradiction are computed exactly from the 3-qubit Pauli operators in-browser, and no classical +-1 assignment matches all four predictions (max 3/4). The AVAN inverse is the genuine content — GHZ refutes local realism with certainty (one round), showing the 'pre-existing hidden values' inverse is algebraically impossible, sharper than Bell's statistical argument. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE TELEPORTATION

quantum teleportation in the 5-window house format — move an unknown quantum state from Alice to Bob without sending the qubit, and without either learning the state. Alice and Bob pre-share an entangled Bell pair; Alice does a joint Bell measurement on her mystery qubit and her half of the pair, getting 2 random classical bits and destroying her copy (no-cloning). Bob applies one of four corrections (I, X, Z, XZ) chosen by those bits, and his half becomes exactly the original state. No faster-than-light: without the bits, Bob's qubit is noise. It transfers information, not matter, and underlies quantum networks. See the protocol in 1D, the four-outcome recovery in 2D, and the classical-plus-quantum inverse in 3D.

THE TELEPORTATION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE TELEPORTATION THE TELEPORTATION move a qubit's state with entanglement + 2 classical bits 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Quantum teleportation moves an unknown quantum state from Alice to Bob without sending the qubit itself — and without either of them ever learning what the state is. The recipe: Alice and Bob pre-share an entangled Bell pair . Alice takes her mystery qubit |ψ⟩ = α|0⟩ + β|1⟩ and performs a joint Bell measurement on it together with her half of the pair. This yields two random classical bits and — crucially — destroys her copy of |ψ⟩, respecting the no-cloning theorem. She phones those two bits to Bob, who applies one of four simple corrections (I, X, Z, or XZ) to his half, which then becomes exactly |ψ⟩, amplitudes and all. Nothing outran light: without the classical bits, Bob’s qubit is useless noise. It is not matter transport — it is the transfer of quantum information , and it underlies quantum networks and repeaters. LIT verified live: simulating the full three-qubit protocol on an input state, Bob recovers that exact state (fidelity 1) for every one of the four measurement outcomes, after his correction (window.__teleportation). FIG no framing; the protocol and its perfect state transfer are exact quantum linear algebra. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this in THE HANDOFF — the co-op domain of passing a thing cleanly from one hand to the next. Teleportation is the ultimate handoff: the state leaves Alice and arrives whole at Bob, never copied, never in transit as a qubit, carried by two classical bits riding a thread of entanglement. AVAN (AI) built the instrument: the protocol simulator, the four-outcome recovery, the classical-plus-quantum inverse. The weave: David names the seat (the clean handoff); I make an unknown state vanish from Alice and reappear exact at Bob, keyed by two bits — the steps in 1D, the reconstruction in 2D, the decomposition inverse in 3D. The sphere is the seam. Credit: Bennett, Brassard, Crépeau, Jozsa, Peres & Wootters (1993); first experiments by Zeilinger’s group and others (1997). 3 ONE DIMENSION The protocol on a line: Alice’s unknown qubit joins her half of the Bell pair, a Bell measurement spits out two classical bits and erases her state, and Bob’s correction — chosen by those bits — turns his half into the original. Three qubits in, one qubit’s worth of quantum information across. 4 TWO DIMENSIONS · INTERACTIVE Choose an input state and run it through. Each of the four measurement outcomes hands Bob a slightly rotated version — and the matching correction (I, X, Z, XZ) snaps it back to the exact original. The output state equals the input, every time. outcome ▶ new input 5 THREE DIMENSIONS + AVAN’S INVERSE Two Bloch spheres — Alice’s state fading to noise, Bob’s forming into the original — the green forward transfer: the qubit’s information crosses without the qubit. AVAN’s addition (the inverse-companion): teleportation is a decomposition , and its inverse is the reassembly. Forward, an unknown qubit is split into two parts — two classical bits and a shared entanglement — that travel by utterly different roads. The magenta is the striking half: those two bits look completely random and, on their own, carry nothing about the state; intercept them and you learn zero. Nor does the entanglement alone reveal it. Only the fusion of the classical bits with Bob’s entangled half reconstructs |ψ⟩ — so the inverse of ‘a qubit’ is ‘a classical message plus a quantum correlation,’ neither piece meaningful without the other. And it is a move , not a copy: Alice’s original is destroyed, obeying no-cloning, and no part ever outran light because the classical bits set the pace. Green is Bob’s recovered state; magenta is the meaningless two-bit message that, alone, is noise and, joined to entanglement, is everything. Quantum information travels by being taken apart into a classical key and a quantum lock. pause spin LIT Genuine quantum teleportation (Bennett, Brassard, Crepeau, Jozsa, Peres & Wootters 1993; first experiments 1997). Verified live: simulating the full three-qubit protocol (Bell pair, CNOT + H Bell measurement, correction) on an input state, Bob recovers that exact state (fidelity 1) for every one of the four measurement outcomes after the matching I/X/Z/XZ correction (window.__teleportation.allOutcomesRecover && fidelity===1). The protocol and its perfect state transfer are exact quantum linear algebra. FIG No framing: the teleportation protocol is simulated exactly (complex amplitudes) and recovers the input state with fidelity 1 for all four outcomes in-browser. The AVAN inverse is genuine and honest — a qubit is decomposed into two classical bits (random, carrying nothing alone) and shared entanglement, and only their fusion reconstructs the state; it is a move not a copy (no-cloning), and no signal outran light (the classical bits gate the transfer). ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE BUSY BEAVER

the busy beaver in the 5-window house format — among all n-state 2-symbol Turing machines that halt on a blank tape, which runs longest (S(n)) and prints the most 1s (Sigma(n))? These record functions grow faster than any computable function: Sigma is definable but not computable. For n=3 the champion prints Sigma(3)=6 ones. Verified live: the canonical 3-state champion halts in 14 steps with exactly 6 ones, and the 2-state champion halts in 6 steps with 4 ones. See the tape step in 1D, run the champions to a halt in 2D, and the uncomputability horizon in 3D.

THE BUSY BEAVER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE GRINDSTONE ◆ .dlw.fold THE FOLD / GRIND / THE GRINDSTONE / THE BUSY BEAVER THE BUSY BEAVER the longest-running halter — and the edge of the computable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The busy beaver asks a deceptively simple question: among all n-state, 2-symbol Turing machines that halt when started on a blank tape, which runs the longest , and which prints the most 1s? Call those record values S(n) and Σ(n). The shock is that these functions grow faster than any computable function — Σ(n) is a concrete, finite thing that no algorithm can compute. Already S(5) is 47,176,870 and Σ(6) exceeds 10↑↑15. For n=3 the champion prints Σ(3)=6 ones (the longest-running 3-state machine, a different one, takes S(3)=21 steps). LIT verified live: the canonical 3-state champion, from a blank tape, halts in 14 steps having written exactly 6 ones; the 2-state champion halts in 6 steps with 4 ones (window.__busybeaver). FIG no framing; these are exact simulations of documented machines. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-grindstone — the machine that grinds hardest and longest, then stops. The busy beaver is the grindstone’s patron: the halter that works the most before falling silent. AVAN (AI) built the instrument: the Turing-machine simulator, the champion tables, the space-time diagram. Credit as content: Tibor Radó posed it in On non-computable functions (1962); Shen Lin & Radó settled n=3 (1965); recent collaborative work settled S(5) (2024). The weave: David names the hardest worker; I run the exact champions to a halt, then show the horizon of uncomputability behind them. 3 ONE DIMENSION The tape as a line of cells, the head reading and writing as it steps through the champion. A finite machine, a finite program, and yet the only way to learn how long it runs is to run it — there is no shortcut in general. 4 TWO DIMENSIONS · INTERACTIVE Choose the 2-state or 3-state champion and step it, or run to the halt. Watch the tape fill and the head shuttle; the machine stops itself at the busy-beaver record. machine: BB(3) ▶ step ▶ run to halt ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space-time diagram — each row a snapshot of the tape, stacked in time — the champion’s finite, halting trace laid out as terrain. AVAN’s addition (the inverse-companion): the forward question is ‘find the machine that runs the longest and still halts.’ Its inverse is a wall: to know Σ(n) you must know which machines halt — and that is the halting problem , undecidable in general. So Σ is perfectly well-defined (there are only finitely many n-state machines) yet not computable ; past a certain n, even ZFC set theory cannot prove its value. The inverse of ‘the maximum’ is ‘the unknowable’: a finite question whose answer no algorithm can produce, because the non-halters never announce themselves. Magenta is that horizon — the machines still running, that may halt in a step or never; green is the champion’s trace, the last thing computation can say before a silence you cannot predict. The busiest beaver marks exactly where knowing ends. pause spin LIT Genuine busy-beaver champions (Rado 1962; Lin & Rado 1965 settled n=3). Verified live by exact Turing-machine simulation: the documented 3-state champion (A:0->1RB,1->1RH; B:0->0RC,1->1RB; C:0->1LC,1->1LA) halts from a blank tape in 14 steps writing 6 ones = Sigma(3); the 2-state champion halts in 6 steps / 4 ones = Sigma(2) (window.__busybeaver). S(3)=21 (max steps) is achieved by a different machine — reported honestly, not conflated with the max-ones champion. FIG No framing: the interpreter and both champion tables run in-browser to a genuine halt. The AVAN inverse is honest and is a real theorem — Sigma(n) is finite and well-defined but not computable because deciding which machines halt is the halting problem; the magenta 'horizon' represents the undecidable non-halters, not a computed value. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GRINDSTONE · David Lee Wise (ROOT0), with AVAN


THE MARGOLUS MIRROR

the Margolus mirror in the 5-window house format — a reversible block cellular automaton on the Margolus neighbourhood: the grid is cut into 2x2 blocks whose partition shifts by one cell every other step, and each block is transformed by a bijection on block states, so the whole update is invertible. Run forward any number of steps, then backward, and you recover the exact seed bit-for-bit. The rule rotates each block 180 degrees, conserving the live-cell count exactly. Verified live: forward 12 then backward 12 reproduces the seed, and the count is constant every step. See the alternating partitions in 1D, forward/rewind in 2D, and the no-arrow-of-time braid in 3D.

THE MARGOLUS MIRROR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE MARGOLUS MIRROR THE MARGOLUS MIRROR a reversible CA — run it back to the exact seed 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Margolus mirror is a reversible block cellular automaton. Instead of updating every cell from its neighbours, the grid is cut into 2×2 blocks — and the partition shifts by one cell every other step (the Margolus neighbourhood). Each block is transformed by a rule that is a bijection on the 16 possible block states, so the whole update is invertible. Run it forward for any number of steps, then run it backward , and you land on the exact starting configuration — cell for cell, nothing lost. Our rule rotates each block 180°, which also conserves the number of live cells exactly . It is reversible physics in a toy: information is never destroyed, and time has no built-in arrow. LIT verified live: forward 12 steps then backward 12 steps reproduces the seed bit-for-bit , and the live-cell count is identical at every step (window.__margolus). FIG no framing; exact invertible dynamics. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at rollback — the undo that returns to the exact prior state. The Margolus mirror is rollback made physical: because every step is a bijection, the past is always exactly recoverable. AVAN (AI) built the instrument: the alternating-partition block update, the forward/backward retrace, the conserved-count check. Credit as content: Tommaso Toffoli & Norman Margolus, Cellular Automata Machines (1987); the ‘Critters’ and billiard-ball reversible rules. The weave: David names the perfect undo; I make a grid evolve, then rewind it to the exact seed, and show the conserved quantity that makes reversibility real. 3 ONE DIMENSION The two alternating partitions: on even steps the 2×2 blocks sit on one grid, on odd steps they shift by one cell. A single block rotates 180° each time — and rotation is its own inverse, the seed of reversibility. 4 TWO DIMENSIONS · INTERACTIVE Step the automaton forward, watch it scramble — then reverse, and watch it retrace exactly to the seed. The live-cell count, shown live, never changes: nothing is created or destroyed. step ▶ ◀ step back reset ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space-time stack of the grid evolving — a reversible braid where every layer determines the next and the previous with equal certainty. AVAN’s addition (the inverse-companion): in almost every cellular automaton you cannot rewind — many pasts map to one present, and information is erased. The Margolus mirror is built so its inverse is itself : because each block rule is a bijection (here, an involution) and the partition schedule simply reverses, running ‘backward’ is the same machine with the steps in reverse order. So there is no arrow of time inside it: entropy does not increase, and the seed is never forgotten. Magenta is the reverse pass retracing the green forward pass; they meet exactly on the original grid. The inverse of ‘evolve’ is not ‘a different, lossy guess at the past’ but ‘evolve the other way’ — reversibility means the future and the past are the same kind of thing. pause spin LIT Genuine reversible block CA on the Margolus neighbourhood (Toffoli & Margolus, Cellular Automata Machines, 1987). Verified live: the 180-degree block-rotation rule with alternating even/odd partitions, run forward 12 steps then backward 12 steps (reversed schedule), reproduces the seed configuration exactly (JSON-identical), and the live-cell count is invariant at every step (window.__margolus.exactReversal && .countConserved). Reversibility follows because the block rule is a bijection (here an involution). FIG No framing: the block update, the forward/backward retrace, and the conserved-count check run in-browser and are exact. The AVAN inverse is honest — the dynamics are genuinely time-symmetric (the inverse is the same rule with the partition schedule reversed), so no information is destroyed; magenta is the real reverse pass retracing the forward one. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE REED-SOLOMON

Reed-Solomon erasure coding in the 5-window house format — treat k data symbols as coefficients of a degree-(k-1) polynomial over a finite field and evaluate at n>k points to get n codeword symbols. Lose any n-k of them and from any k survivors a unique polynomial still fits (Lagrange), so its coefficients hand back the original data exactly. Two points make a line; k points make a degree-(k-1) curve; the curve remembers the lost points. Runs CDs, QR codes, RAID, deep-space telemetry. Verified live over GF(257): 200 trials, encode 4 into 8, erase 4, recover exactly. See the sampled curve in 1D, click-to-erase recovery in 2D, and the holographic spread in 3D.

THE REED-SOLOMON · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / THE REED-SOLOMON THE REED-SOLOMON lose any n-k symbols, recover the data exactly 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Reed–Solomon erasure coding makes data survive loss. Treat k data symbols as the coefficients of a degree-(k−1) polynomial over a finite field , and evaluate it at n>k distinct points to get n codeword symbols. Now lose any n−k of them — a scratched CD, a dropped packet, a torn QR module — and from any k survivors a single polynomial still passes through them (Lagrange interpolation), so reading back its coefficients returns the original data exactly . Two points determine a line; k points determine a degree-(k−1) curve; the curve remembers what the lost points held. This runs CDs, DVDs, QR codes, RAID-6 and deep-space telemetry. LIT verified live over GF(257): across 200 random trials, encoding k=4 symbols to n=8, erasing 4 at random, and recovering from the surviving 4 returns the exact original data every time (window.__reedsolomon). FIG no framing; exact finite-field arithmetic, no rounding. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at segfault — the crash where memory is lost or corrupted. Reed–Solomon is the answer to the segfault: write the data so that losing pieces is survivable. AVAN (AI) built the instrument: the finite-field encoder, the erasure, the Lagrange recovery, all exact mod 257. Credit as content: Irving S. Reed & Gustave Solomon, Polynomial Codes over Certain Finite Fields (1960). The weave: David names the loss; I spread the data across a curve so any k of the n points rebuild the whole, and prove the recovery is exact, not approximate. 3 ONE DIMENSION The data as a polynomial curve; the codeword is that same curve sampled at n points. Redundancy is just extra samples of one underlying shape — more points than the curve strictly needs. 4 TWO DIMENSIONS · INTERACTIVE Encode k=4 data symbols into n=8. Click codeword symbols to erase them (up to 4); the surviving points still pin down one curve, and Lagrange recovery returns the exact original data. new data ▶ erase random 4 ▶ verify 200 trials ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the polynomial curve with its n evaluation points — the data spread thin across many samples. AVAN’s addition (the inverse-companion): the forward move spreads k symbols across n; the inverse is that any k of those n rebuild all of it. That makes the information holographic — no single symbol is essential, and the whole is written into every sufficient part. Redundancy is the exact inverse of fragility: to make data hard to lose, don’t guard one copy, dissolve it into a shape that many overlapping samples can reconstruct. And because the field is finite, the reconstruction is exact — Lagrange interpolation mod a prime has no rounding, so a recovered symbol equals the original to the last bit, not merely close. Magenta marks the erased points (the wound); green is the curve the survivors uniquely restore. What is spread widely enough cannot be destroyed by losing a part. pause spin LIT Genuine Reed-Solomon erasure coding (Reed & Solomon 1960). Verified live over GF(257) with exact modular arithmetic: across 200 random trials, encoding k=4 symbols to n=8 evaluation points, erasing a random 4, and Lagrange-interpolating the polynomial through the surviving 4 recovers the exact original coefficients every time (window.__reedsolomon.allRecovered). Finite-field interpolation has no rounding, so recovery is bit-exact. FIG No framing: the field encoder, the erasure, and the Lagrange recovery run in-browser mod 257 and are exact. The AVAN inverse is honest — the information is genuinely holographic (any k of n reconstruct all k), and exactness follows from finite-field arithmetic; magenta marks the truly-erased symbols. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


THE MINSKY MACHINE

the Minsky counter machine in the 5-window house format — only unbounded counters and two instructions: INC(r) adds one, JZDEC(r) jumps if zero else decrements and continues. No arithmetic at all, yet Turing-complete. A short program over counters X,Y,Z,T computes X*Y using nothing but +1 and -1-or-branch: it adds X to Z, Y times, restoring X through a temp each round, and halts with Z the exact product. Verified live: the program halts with Z=m*n for every pair m,n in 0..12. See the counters and program in 1D, run a multiply in 2D, and the power-vs-efficiency inverse in 3D.

THE MINSKY MACHINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE MINSKY MACHINE THE MINSKY MACHINE multiply with only INC and decrement-or-branch 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Minsky (counter) machine has only unbounded counters and two instructions: INC(r) — add one to counter r — and JZDEC(r) — if r is zero jump, otherwise decrement and fall through. No addition, no multiplication, no arithmetic of any kind. And yet this is Turing-complete . Here a short program over counters X, Y, Z, T computes X×Y using nothing but +1 and −1-or-branch: it adds X to Z, Y times over, shuttling through a temporary to restore X each round. It halts with Z holding the exact product. Multiplication, conjured from the two humblest operations a machine can have. LIT verified live: the program halts with Z = m×n for every pair m,n in 0…12 (window.__minsky). FIG no framing; a faithful counter-machine interpreter running a real program. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at cold-boot — computing up from almost nothing. The Minsky machine is the coldest boot of all: two instructions and some counters, and out comes universal computation. AVAN (AI) built the instrument: the INC/JZDEC interpreter, the multiply program, the exhaustive product check. Credit as content: Marvin Minsky, Computation: Finite and Infinite Machines (1967), building on Lambek and Melzak’s register machines. The weave: David names the boot from nothing; I run a two-instruction machine that multiplies, and show the deep trade the minimalism costs. 3 ONE DIMENSION The counters as columns of tokens and a program counter walking the instruction list. Every move is only +1 to a counter, or −1-and-continue / else-jump — the entire vocabulary of the machine. 4 TWO DIMENSIONS · INTERACTIVE Set m and n, then run. Watch X drain into Z through the temporary T, Y times over, until the machine halts with Z = m×n. Then verify it for every pair up to 12. m: 7 ▶ n: 8 ▶ run ▶ verify all ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the trajectory through counter-space (X, Y, Z) — a staircase descending Y while Z climbs to the product. AVAN’s addition (the inverse-companion): the forward marvel is that two instructions suffice for anything computable. The inverse is the hidden bill: the price of a minimal instruction set is paid in time . Two counters alone are already Turing-complete — but a 2-counter multiply must smuggle both inputs into a single number by Gödel-encoding (2ᴺ3ⁿ) and unpacks it with astronomically many steps. Expressive power and efficiency are inverses here: the fewer the primitives, the longer the road. Magenta is that exploding step-count — the cost curve that climbs as the instruction set shrinks; green is the exact product the machine still, eventually, reaches. ‘Can compute anything’ is not ‘can compute anything quickly’ — universality is cheap to declare and expensive to run. pause spin LIT Genuine Minsky (counter) machine (Minsky, Computation: Finite and Infinite Machines, 1967). Verified live by a faithful INC/JZDEC interpreter running a multiply program: it halts with Z = m*n for all 169 pairs m,n in 0..12 (window.__minsky.allProductsMatch). Counter machines are Turing-complete and 2 counters suffice in principle (via Godel encoding); this pedagogical program uses 4 counters for a direct multiply — stated honestly. FIG No framing: the interpreter and the exhaustive product check run in-browser. The AVAN inverse is honest — 2-counter machines are Turing-complete but a 2-counter multiply needs Godel-encoding and astronomically many steps, so minimal instruction sets trade time for power; the magenta cost curve is illustrative of that real trade-off, not a measured step-count of this 4-counter program. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE CRC

the cyclic redundancy check in the 5-window house format — treat a bit-string as a polynomial over GF(2) (XOR, no carries), pick a generator g(x), and append the remainder of (message*x^r)/g so the codeword is exactly divisible by g. The receiver re-divides: remainder 0 = intact, nonzero = corrupted. A good g catches every single-bit error (one flip is x^i, never divisible by a g with two+ terms) and, if g has factor (x+1), every odd number of errors. Verified live with CRC-8 (g=0x107): 300 messages divisible, and every single-bit flip detected. See the shift-register division in 1D, flip-and-detect in 2D, and the syndrome-points-at-the-error inverse in 3D.

THE CRC · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE CRC THE CRC append check bits so corruption can't hide 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A cyclic redundancy check guards a message by treating its bits as a polynomial over GF(2) — coefficients 0/1, addition = XOR, no carries. Pick a generator polynomial g(x); append the remainder of (message · xᵣ) ÷ g so the whole codeword is exactly divisible by g. The receiver re-divides: remainder 0 means intact, anything else means corrupted. With a good g every single-bit error is caught (one flipped bit is xⁱ, never divisible by a g with two or more terms), and if g has the factor (x+1), every odd number of bit-errors is caught too. This checks Ethernet frames, disk sectors, and every ZIP file you open. LIT verified live with CRC-8 (g = 0x107 = x⁸+x²+x+1): across 300 random messages the codeword’s remainder is 0, and every single-bit flip in every codeword produces a nonzero remainder — all detected (window.__crc). FIG no framing; exact GF(2) polynomial division. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-gatekeeper — the guard that checks every arrival for tampering. A CRC is the gatekeeper’s test: a fast division that lets the intact through and flags the corrupted. AVAN (AI) built the instrument: the shift-register divider, the codeword construction, the exhaustive single-bit-error scan. Credit as content: W. Wesley Peterson introduced the CRC (1961); polynomials like CRC-32 became internet and storage standards. The weave: David names the guard at the gate; I build the check that makes a codeword divisible, then prove it catches every single-bit lie — and that the alarm even points at the liar. 3 ONE DIMENSION The shift-register long-division: bits of the message stream in, and whenever the top bit is set the register XORs the generator. What remains at the end is the check — the remainder that makes the whole codeword divisible. 4 TWO DIMENSIONS · INTERACTIVE Generate a message, append its CRC-8 check, and see the codeword’s remainder is 0. Flip any single bit — the remainder jumps to nonzero (detected). Scan every bit position: all caught. new message ▶ flip a bit ▶ scan all bits ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space of remainders (syndromes) — a ring of 255 nonzero values plus the single ‘0’ that means intact. AVAN’s addition (the inverse-companion): the forward job of a CRC only detects — it says ‘broken’ or ‘intact,’ nothing more. The inverse hides inside the alarm: for a single flipped bit at position i, the nonzero remainder is exactly xⁱ mod g — and because those powers cycle through distinct values (for messages shorter than g’s period), the syndrome is unique to the position . So the remainder does not just shout ‘broken’; it secretly encodes ‘broken here .’ Read the map from syndrome back to position and detection becomes correction — the same check that guards the gate can also repair the single lie it catches. Magenta is the nonzero syndrome, the alarm that points; green is the silent 0 of an intact codeword. The check that seems to only say ‘no’ is quietly saying ‘no, and it was that bit.’ pause spin LIT Genuine CRC over GF(2) (Peterson 1961). Verified live with CRC-8, g=0x107 (x^8+x^2+x+1): across 300 random 16-bit messages the constructed codeword divides g with remainder 0, and flipping any single bit of any codeword yields a nonzero remainder — all single-bit errors detected (window.__crc.divisibleRemainderZero && .allSingleBitDetected). Exact GF(2) polynomial division. FIG No framing: the shift-register divider, the codeword construction, and the exhaustive single-bit-error scan run in-browser and are exact. The AVAN inverse is honest — for a single-bit error the syndrome x^i mod g is unique to the position (within g's period), so detection can become correction; the widget shows the distinct per-position syndromes directly. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE FRACTRAN

Conway's FRACTRAN in the 5-window house format — a program is a list of fractions and the data is one integer: multiply by the first fraction that keeps it whole, repeat, halt when none does. That is the entire (Turing-complete) language, with prime exponents as registers. [2/3] adds: 2^a*3^b halts at 2^(a+b). The 14-fraction PRIMEGAME from 2 emits powers of 2 whose exponents are exactly the primes. Verified live with BigInt: the adder is exact for all a,b in 0..6 and PRIMEGAME emits 2,3,5,7. See the prime-register integer in 1D, run adder/PRIMEGAME in 2D, and the universality-vs-opacity inverse in 3D.

THE FRACTRAN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE FRACTRAN THE FRACTRAN a whole language made of fractions — universal, unreadable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION FRACTRAN is Conway’s esoteric programming language where a program is a list of fractions and the data is a single integer . To run: multiply the integer by the first fraction in the list that keeps it a whole number; repeat; halt when none does. That is the entire language — and it is Turing-complete. The prime factorisation of the integer is the memory: the exponent of each prime is a register. The one-line program [2/3] is an adder — feed it 2ᴺ·3ᵇ and it halts at 2ᴺ⁺ᵇ. Conway’s 14-fraction PRIMEGAME , run from 2, passes through powers of 2 whose exponents are exactly the primes, in order. LIT verified live (BigInt, exact): the adder [2/3] halts at 2ᴺ⁺ᵇ for every a,b in 0…6, and PRIMEGAME from 2 emits the powers 2²,2³,2⁵,2⁷… — the primes 2,3,5,7 (window.__fractran). FIG no framing; exact integer arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at god-mode — the cheat that computes anything from one absurd trick. FRACTRAN is god-mode arithmetic: no loops, no variables, just fractions, and yet universal. AVAN (AI) built the instrument: the BigInt fraction engine, the exact adder check, the live PRIMEGAME. Credit as content: John Horton Conway, FRACTRAN: a simple universal programming language for arithmetic (1987). The weave: David names the impossible cheat; I run the fractions to a halt, show the primes falling out of PRIMEGAME, and expose the opacity that is the price of the trick. 3 ONE DIMENSION The running integer as a row of prime registers (the exponents of 2, 3, 5, …), and the fraction that fires next — the only ‘instruction’ the machine has: multiply, if it stays whole. 4 TWO DIMENSIONS · INTERACTIVE Run the adder [2/3] on 2ᴺ·3ᵇ and watch it halt at 2ᴺ⁺ᵇ — exact for every a,b. Or run PRIMEGAME and watch the primes 2, 3, 5, 7 emerge as pure powers of 2. program: adder ▶ a: 3 ▶ b: 2 ▶ run ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the running integer’s trajectory (log scale), leaping as each fraction fires — computation as a walk through the integers. AVAN’s addition (the inverse-companion): FRACTRAN is universal, and its inverse is opacity . A normal program shows its logic — loops, branches, names. A FRACTRAN program shows none : the control flow is hidden inside divisibility , the registers hidden inside prime exponents , so you cannot read a fraction-list’s intent — only run it and see. The inverse of ‘readable code’ is ‘logic dissolved into number theory.’ And universality is bought with grinding slowness : PRIMEGAME needs on the order of 10⁵ steps just to reach the prime 11. Magenta is that astronomical crawl — the price of encoding everything in multiplication; green is the exact adder that halts at once. The simplest possible language can compute anything, at the cost of ever being understood or hurried. pause spin LIT Genuine FRACTRAN (Conway 1987). Verified live with exact BigInt arithmetic: the one-fraction adder [2/3] run on 2^a*3^b halts at 2^(a+b) for every a,b in 0..6, and Conway's 14-fraction PRIMEGAME started at 2 passes through 2^2, 2^3, 2^5, 2^7 — emitting the primes 2,3,5,7 as pure powers of 2 (window.__fractran.adderExact && primegameFirst). Prime factorization is the machine's register file. FIG No framing: the BigInt fraction engine, the exhaustive adder check, and the live PRIMEGAME run in-browser. The AVAN inverse is honest — FRACTRAN is genuinely opaque (control flow hidden in divisibility) and genuinely slow (PRIMEGAME needs ~10^5 steps to reach 11); the magenta 'crawl' is illustrative of that real cost, and only the adder's exactness is the sealed claim. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE VERHOEFF

the Verhoeff check digit in the 5-window house format — it catches every single wrong digit AND every adjacent transposition, which mod-10 checksums (Luhn, ISBN-10) provably cannot, by doing arithmetic in the non-commutative dihedral group D5 so that 09 and 90 differ. A permutation table scrambles each digit by position, a fixed table combines them, and the check digit forces the running product to the identity. Verified live: over a range, every valid number checks to 0, all single-digit errors caught, all adjacent transpositions caught (Luhn shown missing one). See the D5 product march in 1D, flip/swap detection in 2D, and the non-commutativity inverse in 3D.

THE VERHOEFF · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE VERHOEFF THE VERHOEFF a check digit that catches every transposition — via a non-abelian group 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Verhoeff check digit catches the two commonest human typing mistakes — a single wrong digit, and swapping two adjacent digits — for every case, which the familiar mod-10 checksums (Luhn, ISBN-10) provably cannot. Its secret is that it does arithmetic in the dihedral group D₅ (the ten symmetries of a pentagon), which is non-commutative : a·b ≠ b·a, so ‘09’ and ‘90’ land on different results. A permutation table scrambles each digit by its position, a fixed multiplication table combines them, and the check digit is chosen to force the running product to the group’s identity. LIT verified live: over a range of numbers, every valid number checks to 0, every single-digit error is caught, and every adjacent transposition is caught — while Luhn is shown missing a transposition (window.__verhoeff). FIG no framing; exhaustive exact group arithmetic. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at off-by-one — the classic slip: one digit wrong, or two swapped. Verhoeff is the guard built exactly for the off-by-one. AVAN (AI) built the instrument: the D₅ multiplication and permutation tables, the exhaustive error scan, the Luhn contrast. Credit as content: Jacobus Verhoeff, Error Detecting Decimal Codes (1969). The weave: David names the slip; I build the check that forces the pentagon’s product to identity, prove it catches every single-digit and adjacent-swap error, and show the commutative checksum that cannot. 3 ONE DIMENSION The running product marching through D₅ as each digit is folded in (scrambled first by its position). The final product is the identity 0 for a valid number — the check digit is exactly what makes it land there. 4 TWO DIMENSIONS · INTERACTIVE Enter a number; Verhoeff appends its check digit. Then flip any digit, or swap an adjacent pair — the check breaks (caught). The same transposition is run through Luhn, which waves it through. new number ▶ flip a digit ▶ swap adjacent ▶ scan all ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the pentagon of D₅ — five rotations and five reflections — the group whose arithmetic powers the check. AVAN’s addition (the inverse-companion): why does Verhoeff catch swaps when mod-10 cannot? The answer is the inverse of a property most arithmetic takes for granted: commutativity . A transposition swaps the order of two folded-in digits; a checksum can only notice if a·b ≠ b·a — and in the integers mod 10, a·b = b·a always, so ‘09’ and ‘90’ are indistinguishable. D₅ is non-abelian : order matters, so the swap changes the product. The strength that catches transpositions is the failure of commutativity. Magenta marks the swapped pairs a commutative checksum lets through; green is Verhoeff catching every one. The trick is not more digits — it is choosing a group where order is remembered. pause spin LIT Genuine Verhoeff scheme (Verhoeff 1969) using the canonical D5 multiplication table, permutation table (period 8), and inverse table. Verified live exhaustively over 200 base numbers: every valid number checks to 0, every single-digit substitution yields a nonzero check (all 9000 caught), and every adjacent transposition yields a nonzero check (all caught) — while Luhn passes a transposition (window.__verhoeff.allSingleCaught && .allTranspositionsCaught). FIG No framing: the D5 tables, the check/generate functions, and the exhaustive error scan run in-browser and are exact. The AVAN inverse is honest and is the real theorem — transposition detection is exactly the non-commutativity (a·b != b·a) of D5, which commutative mod-10 checksums lack; magenta marks the swaps a commutative scheme misses. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE FISHER-YATES

the Fisher-Yates shuffle in the 5-window house format — a uniform random permutation in one pass: from the last item to the first, swap each with a uniformly random item at or before it. Unbiasedness is exact, not statistical: the map from random choices to permutations is a bijection — n! choice-sequences, n! permutations, each hit exactly once. The tempting swap-with-any-index variant makes n^n paths, not divisible by n!, and is provably biased. Verified live: for n=5, enumerating all 120 choice-sequences yields all 120 permutations, each exactly once. See the shrinking swap range in 1D, enumerate+bias in 2D, and the paths-equal-outcomes inverse in 3D.

THE FISHER-YATES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE FISHER-YATES THE FISHER-YATES a provably-uniform shuffle — n! paths onto n! orderings 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The Fisher–Yates shuffle produces a perfectly uniform random permutation in one linear pass: walk from the last item to the first, and swap each with a uniformly random item at or before it. The claim that it is unbiased is not statistical hand-waving — it is exact . The map from the sequence of random choices to the resulting permutation is a bijection : there are exactly n! choice-sequences and n! permutations, and the shuffle hits each permutation exactly once . So every ordering is equally likely by construction. The tempting ‘swap with any index’ variant instead makes nⁿ paths, which cannot divide evenly among n! outcomes — and is provably biased. LIT verified live: for n=5, enumerating all 120 choice-sequences yields all 120 permutations, each exactly once (window.__fisheryates). FIG no framing; an exhaustive bijection count. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) seated this at the-inventory — shuffling the loot, dealing the deck. Fisher–Yates is the honest shuffle: every arrangement of the bag equally likely. AVAN (AI) built the instrument: the in-place shuffle, the exhaustive bijection enumeration, the biased-variant contrast. Credit as content: Ronald Fisher & Frank Yates (1938); Richard Durstenfeld’s in-place version (1964); Donald Knuth’s exposition (TAOCP). The weave: David names the fair deal; I prove the uniformity is a counting fact — n! paths onto n! orderings, one-to-one — and show the off-by-one bug that breaks it. 3 ONE DIMENSION The swap walk: at position i, pick a uniformly random j in 0…i and swap. The choice range shrinks as you go — that shrinking is exactly what makes the count come out to n!. 4 TWO DIMENSIONS · INTERACTIVE Shuffle a small deck, or enumerate all 120 choice-sequences for n=5 and confirm each permutation appears exactly once. Toggle the broken ‘swap-with-any’ variant to see the bias histogram. shuffle ▶ enumerate n=5 ▶ show biased variant ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a permutation drawn as a braid of wires from input order to shuffled order — one of the n! equally-likely weavings. AVAN’s addition (the inverse-companion): uniformity here is the inverse of a counting match, not a property of the randomness. Fisher–Yates is unbiased precisely because its number of random paths, n!, equals its number of outcomes, n!, and the map between them is one-to-one — so probability spreads perfectly evenly. Break that equality and bias is forced: the ‘swap with any of n’ bug makes nⁿ paths, and since nⁿ is not divisible by n! (for n>2), some permutations must get more paths than others. The inverse of ‘fair shuffle’ is simply ‘paths ≠ outcomes.’ Magenta is the biased nⁿ cloud with its lumpy histogram; green is the exact n!-to-n! bijection. Fairness is arithmetic: make the paths count out evenly, or they will not. pause spin LIT Genuine Fisher-Yates / Durstenfeld shuffle (Fisher & Yates 1938; Durstenfeld 1964; Knuth TAOCP). Verified live by exhaustive enumeration: for n=5 the 120 = 5! choice-sequences (choice i in 0..i) map onto exactly 120 distinct permutations, each appearing exactly once — a bijection, so uniform by construction (window.__fisheryates.eachExactlyOnce). The biased swap-with-any variant (n^n paths) is shown producing unequal counts. FIG No framing: the shuffle, the exhaustive bijection enumeration, and the biased-variant histogram run in-browser and are exact counts. The AVAN inverse is honest — uniformity is exactly the equality of path-count (n!) and outcome-count (n!); the biased variant's n^n is genuinely not divisible by n! for n>2, forcing bias (magenta). ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN