THE ZERO PARAMETER

Veto, minus-I, depth, idempotence, address. They are counting, not judgement - and that is why they can promise something rather than score it.

THE ZERO PARAMETER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · HARD RESET ◆ .dlw.fold THE FOLD / RESPAWN / HARD RESET / THE ZERO PARAMETER THE ZERO PARAMETER five rules with nothing to tune 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Five rules, and not one of them has a number to tune. Veto : you cannot close a bracket you did not open. −I : whatever you left open owes you a closer. Depth : you cannot nest past the declared cap. Idempotence : a statement that does nothing cannot do nothing twice. Address : the machine, not the writer, decides what position a statement sits at. They are counting, not judgement — and that is why they can promise something rather than score it. LIT verified live: each of the five catches the input it exists for, 5 of 5 . Exhaustively over every string up to length 9 in a three-symbol alphabet, 1,374 are accepted and 0 of them are malformed — a guarantee with no exceptions to report. A tunable alternative was swept across 7 settings and 0 of them keep every valid string while rejecting every invalid one; even at its tightest setting it still admits 12.7% of malformed input. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the five into pocket-machine ’s fourth window with the claim attached: none of these five learned anything. They have no numbers to tune. That is the whole claim — the parts that guarantee the output is well-formed are the parts with zero settings. He seated this at HARD RESET : nothing to tune is nothing to drift. AVAN (AI) checked the accepted set a second way, by a closed form the page never computes: a string over this alphabet is accepted exactly when its brackets balance, so the count at length n is the sum over k of C(n,2k) times the k-th Catalan number. That gives 1, 1, 2, 4, 9, 21, 51, 127, 323, 835 — the Motzkin numbers — totalling 1,374 , which is what the enumeration found. AVAN also added the threshold sweep, because “zero parameters” only means something against an alternative that has some. The comparison is deliberately generous to the tunable side — it keeps 100% of valid strings at every setting tested — and it still cannot get the second half: at the tightest setting it admits 12.7% of malformed input, and loosening it only makes that worse. Worth being precise about the one number in the five: the depth cap is a declared capacity, not a threshold. Changing it changes which programs fit, never which accepted programs are well-formed — and in this enumeration it never binds at all, since the deepest nesting reachable inside nine characters is four. 3 ONE DIMENSION The five, and what each one refuses. 4 TWO DIMENSIONS · INTERACTIVE Slide the tunable checker’s threshold and watch it fail to reach both corners. loosen ▶ tighten the five rules instead 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the accepted set, carved by five walls with no dials on them. AVAN’s addition (the inverse-companion): the forward reading is “rules with no settings can guarantee things.” The inverse is that they can only guarantee things they were built to be about . Counting brackets proves brackets balance and proves nothing about whether the program is any good — the guarantee is total within a scope that is deliberately tiny. Read backwards, the trade is not parameters against reliability but ambition against certainty : the five rules are certain because they gave up on almost every question, and a system that wanted to answer more would have to start tuning and stop promising. pause spin LIT each of the five catches the input it exists for, 5 of 5; exhaustively over every string up to length 9 in a three-symbol alphabet, 1,374 are accepted and 0 of them are malformed - a guarantee with no exceptions to report; and a tunable alternative swept across 7 settings has 0 that keep every valid string while rejecting every invalid one, admitting 12.7% of malformed input even at its tightest FIG From David's pocket-machine, with the claim attached: 'none of these five learned anything. They have no numbers to tune. That is the whole claim - the parts that guarantee the output is well-formed are the parts with zero settings.' AVAN added the threshold sweep, because 'zero parameters' only means something against an alternative that has some; the comparison is deliberately generous to the tunable side, keeping 100% of valid strings at every setting, and it still cannot get the second half. Worth being precise about the one number among the five: the DEPTH CAP is a declared capacity, not a threshold. Changing it changes which programs fit, never which accepted programs are well-formed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HARD RESET · David Lee Wise (ROOT0), with AVAN


THE UNTYPEABLE

Mathematics has a large alphabet and a keyboard has ninety-five keys. What survives into code is what fit through a mechanical aperture built for English prose.

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

THE UNTYPEABLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE UNTYPEABLE THE UNTYPEABLE the glyph you cannot enter 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Mathematics has a large and beautiful alphabet, and a keyboard has ninety-five keys. A symbol you cannot enter without a palette, a compose sequence or a paste is not a working notation for anyone typing at speed — and the ones that are typeable were nearly all claimed by programming languages decades ago. What is left over is letters and digits, which is precisely why a letter ends up doing twelve jobs. LIT verified live: a plain keyboard produces exactly 95 printable characters. Of 53 symbols sampled from working mathematical use, 14 can be typed directly and 39 cannot — 73.6% require something other than a keypress. And of the 95, the printable punctuation set is 32 marks — every single one of which is already an operator or a delimiter in some common language. Nothing is left over. The 62 free slots are therefore letters and digits and nothing else, which is not a coincidence but a direct consequence of the punctuation being exhausted. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) put untypeable in rev 6 ’s fourth window as one of three counters beside homonyms and cross-owner — a live check that tells you, before you adopt a symbol, whether that letter is already busy and whether you can even type it . He seated this at THE BLUE SCREEN . It is the practical half of the collision problem and the half usually left out of the conversation. AVAN (AI) should flag two things honestly. First, an earlier draft of this page reported “32 claimed, leaving 62, all alphanumeric” as though the second half were a discovery; checking against the encoding showed the 32 are the whole printable punctuation set, which makes the remainder alphanumeric by subtraction. The finding is that the punctuation is exhausted — the rest follows. Second, the 53-symbol sample is chosen, not exhaustive — it covers common operators, set theory, logic and the Greek letters in ordinary use, and a different sample would shift the 73.6% by several points. What does not depend on the sample is the structural half: 95 printable characters is a fact about the encoding, 32 of them being spoken for is a fact about existing languages, and the remainder being entirely alphanumeric follows by subtraction. That is the part carrying the argument, and it is exact. 3 ONE DIMENSION Ninety-five keys, and what is already spoken for. 4 TWO DIMENSIONS · INTERACTIVE The sampled notation, sorted by whether you can actually type it. typeable / not ▶ the free slots 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the keyboard as a closed shell, with the notation outside it. AVAN’s addition (the inverse-companion): the forward reading is “most notation is untypeable.” The inverse is that the keyboard has been quietly editing mathematics for fifty years . What is easy to type gets used, what is not gets transliterated or dropped, and the notation that survives into code is the notation that fit through a mechanical aperture designed for English prose in the 1870s. Read backwards, this is not a complaint about keyboards but an observation about which constraints do the most shaping : the ones nobody argues about, because they are not presented as choices at all. pause spin LIT a plain keyboard produces exactly 95 printable characters; of 53 symbols sampled from working mathematical use, 14 can be typed directly and 39 cannot - 73.6% require something other than a keypress; and the printable punctuation set is 32 marks, EVERY one of which is already an operator or delimiter in some common language, so the 62 slots left over are letters and digits and nothing else - a consequence of the punctuation being exhausted, not an independent finding FIG From David's rev 6, where 'untypeable' sits in the fourth window beside 'homonyms' and 'cross-owner' - a live check telling you, before you adopt a symbol, whether that letter is already busy AND whether you can even type it. AVAN flags the scope: the 53-symbol sample is CHOSEN, not exhaustive, covering common operators, set theory, logic and the Greek in ordinary use, and a different sample would shift the 73.6% by several points. What does not depend on the sample is the structural half - 95 printable characters is a fact about the encoding, 32 being spoken for is a fact about existing languages, and the remainder being entirely alphanumeric follows by subtraction. That part is exact. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE CHAINED ROOT

acc = H(acc + sha + path). The root carries not just what was sealed but in what order, and at what path. Reorder the ledger and the number leaves.

THE CHAINED ROOT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE CHAINED ROOT THE CHAINED ROOT a hash that remembers where it has been 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A seal has to answer one question: is this the same pile of files it was? The cheap way is a hash per file. The useful way folds each hash into a running accumulator — acc = H(acc + sha + path) — so the root carries not just what was sealed but in what order , and the path each file sat at. Reorder the ledger and the root moves. LIT verified live against David’s real sealed manifest: the chain rule reproduces the published root 165fbfab1ba6c290… exactly. 400 random orderings of those eight files produce 400 distinct roots with 0 collisions. Flipping a single bit anywhere in the ledger moves 50.06% of the root’s 256 bits, within three standard errors ( 1.35 points) of the half a hash should give. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) shipped ud0-core-skills on 5 August 2026 — four skills sealed under UD0-CORE.dlw , eight files, 27,093 bytes, witnessed by ROOT0. The chain rule is his, and his own docstring states the property it buys: reordering the ledger changes the root . AVAN (AI) verified the seal before reading anything sealed under it: all eight SHA-256 digests match, the byte total matches, and the root recomputes under his rule. Four other plausible constructions were tried first — concatenated hex, sorted hex, path-prefixed, raw bytes — and all four gave the wrong root, so the algorithm was read out of seal.py rather than guessed. The page samples 400 orderings because SHA-256 runs in JavaScript here; offline, every one of the 40,320 orderings was enumerated and all 40,320 roots came out distinct, which is the stronger form of the same claim. The honest limit is in window 5, and it is a real one: this is a chain , not a tree. 3 ONE DIMENSION Eight files folded one at a time into a single number. 4 TWO DIMENSIONS · INTERACTIVE Reorder the ledger, or change one character, and watch the root leave. swap two files ▶ flip one bit back to the seal 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a rope of eight links, each knot holding everything before it. AVAN’s addition (the inverse-companion): the forward reading is “the chain binds the whole ledger into one number.” The inverse is that binding everything to everything is exactly what makes any part unprovable on its own . To show a third party that one file belongs in this seal, you must hand over the entire ledger so they can replay it — the proof is n long. A Merkle tree answers the same question with a path of log₂n : at a thousand entries that is 1,024 against 10 . Read backwards, the chain’s strength and its weakness are one property seen from two ends, and the choice is between a seal that is simple to verify whole and a tree that is cheap to verify in part. pause spin LIT the chain rule reproduces David's published root 165fbfab1ba6c290 exactly, with SHA-256 implemented in the page so the number is computed rather than quoted; 400 random orderings of those eight files produce 400 distinct roots with 0 collisions; and flipping a single bit anywhere in the ledger moves 50.06% of the root's 256 bits, within three standard errors (1.35 points) of the half a hash should give FIG From David's ud0-core-skills, dropped 2026-08-05: four skills sealed under UD0-CORE.dlw, eight files, 27,093 bytes, witnessed by ROOT0. The chain rule is his and his docstring states its property - reordering the ledger changes the root. AVAN verified the seal BEFORE reading anything sealed under it: all eight SHA-256 digests match, the byte total matches, and the root recomputes. Four other plausible constructions were tried first - concatenated hex, sorted hex, path-prefixed, raw bytes - and all four gave the wrong root, so the algorithm was read out of seal.py rather than guessed. The honest limit: this is a CHAIN, not a tree. Proving one entry costs the whole ledger, n, against log2(n) for a Merkle tree - 1,024 against 10 at a thousand entries. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE ORDER-BLIND HASH

Hash each item, XOR the results. Fast, parallel, order-free - and structurally unable to see a reordering, a swap, or anything added an even number of times.

THE ORDER-BLIND HASH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE ORDER-BLIND HASH THE ORDER-BLIND HASH a digest that forgot where it had been 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION There is a tempting shortcut for hashing a collection: hash each item, then XOR the results together. It is fast, it parallelises, and the order of the items does not matter. That last property is the shortcut and the hole. XOR is commutative and self-inverse, so a digest built this way cannot see a reordering, cannot see a swap, and cannot see any item added an even number of times. LIT verified live on the same eight-file ledger: across 600 sampled orderings, the XOR digest takes exactly 1 value while an order-sensitive digest takes 600 — and offline, over every one of the 40,320 orderings, the same one-against-all-of-them holds. Swapping the first and last file leaves the XOR digest bit-for-bit unmoved. Adding one entry to the ledger twice also leaves it unmoved — a two-file forgery the digest is structurally unable to notice — while the chain changes immediately. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) did not build this one; he built the thing it is a foil for. His seal.py carries the line “a hash per file, chained into a root… reordering the ledger changes the root” , and the accumulator in that sentence is the entire difference. This sphere exists to measure what he avoided. AVAN (AI) should state the counterpoint rather than leave the XOR digest looking merely broken, because it is not. Order-blindness is correct when order carries no meaning — a set of permissions, a bag of tags, a commutative merge — and the page checks that too: two orderings of the same unordered set agree, exactly as they should. The fault is never the tool. It is reaching for a commutative digest to seal something whose order is part of what it says. 3 ONE DIMENSION The same eight files, shuffled again and again. 4 TWO DIMENSIONS · INTERACTIVE Three forgeries. One digest sees them, the other does not. next forgery ▶ the case where XOR is right 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: 40,320 arrangements collapsing to a single point. AVAN’s addition (the inverse-companion): the forward reading is “a commutative digest loses information.” The inverse is that losing it is the whole service being bought . A hash that ignores order is a hash that says two things are equal as sets , and there is no other way to get that answer cheaply — you cannot both quotient by a symmetry and still detect it. Read backwards, this is not a weak hash but a correctly aimed one pointed at the wrong question, and the design error lives entirely in the sentence “seal these files,” which never said whether the order was part of the thing. pause spin LIT across 600 sampled orderings of the same eight-file ledger the XOR digest takes exactly 1 value while an order-sensitive digest takes 600, and offline over all 40,320 orderings the same one-against-all-of-them holds; swapping the first and last file leaves the XOR digest bit-for-bit unmoved; adding one entry to the ledger TWICE also leaves it unmoved, a two-file forgery the digest cannot see, while the chain changes immediately; and two orderings of a genuinely unordered set agree, which is the same blindness being the correct answer FIG David did not build this one - he built the thing it is a foil for. seal.py carries the line 'a hash per file, chained into a root ... reordering the ledger changes the root', and the accumulator in that sentence is the whole difference. AVAN states the counterpoint rather than leaving XOR looking merely broken, because it is not: order-blindness is CORRECT when order carries no meaning - a set of permissions, a bag of tags, a commutative merge - and the page checks that case too. The fault is never the tool. It is reaching for a commutative digest to seal something whose order is part of what it says. The page's order-sensitive comparison is a cheap mixer, not SHA-256; the chain itself is measured at full strength in [[the-chained-root]]. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN


THE STALE WITNESS

A mark on a ledger signs a number the ledger had once. Change anything after and the signature stays valid while quietly ceasing to attest to what is in front of you.

THE STALE WITNESS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE STALE WITNESS THE STALE WITNESS a signature attests a moment, not a file 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A signature on a ledger does not sign the ledger. It signs a number the ledger had at one moment. Change anything afterwards and the signature survives untouched — still valid, still verifiable, still someone’s real mark — while quietly ceasing to attest to what is now in front of you. The only way to notice is to keep the root the witness signed and compare it against the root you have. LIT verified live: 500 single-digit edits were made to a sealed ledger. Every one of the 500 moved the root. A checker asking “is there a signature?” caught 0 of them. A checker comparing the signed root against the current root caught 500 of 500 . And a perfectly legitimate append — one new file, nothing removed — trips the second checker just as hard, because what it detects is change , never wrongness. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the mechanism into seal.py : each witness record stores root_at_signing , and the display routine prints a mark beside any signature whose stored root no longer matches — signed a DIFFERENT root . It is four lines and it is the difference between a register and a ritual. He seated this at ROLLBACK . AVAN (AI) measured what the drift flag can and cannot tell you, and the second half matters more. It emits exactly one bit : the root moved. It cannot say whether a file was tampered with or a new skill was legitimately added, and both cases look identical to it. That is not a defect to fix — a comparison of two opaque numbers has nowhere to put a reason — but it does mean the flag is a prompt to go and look, not a verdict, and reading it as a verdict is the failure mode. 3 ONE DIMENSION Two checkers, five hundred edits. 4 TWO DIMENSIONS · INTERACTIVE Edit the ledger under the signature and watch what each checker says. tamper ▶ legitimately append restore 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a signature anchored to one point, and the ledger drifting off it. AVAN’s addition (the inverse-companion): the forward reading is “bind the signature to the root so drift is visible.” The inverse is that this makes every legitimate change look exactly like an attack . A corpus that grows must re-sign constantly, and a flag that fires on all normal activity is a flag people learn to clear without reading. Read backwards, the drift bit does not protect the ledger; it transfers the work to a human , and its real design question is not sensitivity but how often it will cry out for nothing — because the honest answer is every single time anything is added . pause spin LIT 500 single-digit edits were made to a sealed ledger and every one of the 500 moved the root; a checker asking 'is there a signature?' caught 0 of them while a checker comparing the signed root against the current root caught 500 of 500; and a perfectly legitimate append - one new file, nothing removed - trips the second checker just as hard, because what it detects is CHANGE and never wrongness FIG From David's seal.py: each witness record stores root_at_signing, and the display routine prints a mark beside any signature whose stored root no longer matches - 'signed a DIFFERENT root'. Four lines, and the difference between a register and a ritual. AVAN measured what the drift flag can and cannot tell you, and the second half matters more: it emits exactly ONE BIT, the root moved. It cannot say whether a file was tampered with or a skill was legitimately added, and both look identical to it. Not a defect to fix - a comparison of two opaque numbers has nowhere to put a reason - but it means the flag is a prompt to go and look, not a verdict. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN


THE LINT NOT THE JUDGE

A checker that reads for overclaiming finds it in words, and words are the one part of a claim a writer can change for free.

THE LINT NOT THE JUDGE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE BACKDOOR ◆ .dlw.fold THE FOLD / CHEAT / THE BACKDOOR / THE LINT NOT THE JUDGE THE LINT NOT THE JUDGE evade the words, keep the claim 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A checker that reads for overclaiming has to find it in words, and words are the one part of a claim a writer can change for free. Say “verified” and it fires; say “handles the grammar in full” and the same assertion walks straight past. The tool is a lint , not a judge: a clean run means the disclosures are present, not that anything in the document is true. LIT verified live on three matched corpora of eight. Overclaims using the vocabulary: 5 of 8 flagged. The same claims reworded to avoid it: 0 of 8 . Honest deliverables that show a run and name a condition: 0 false alarms. Recall falls from 63% to zero without a single new idea — only a rewrite. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote both the checker and its warning, in the same file. honest.py ships with a Pitfalls section that says it plainly: “The checker is a lint, not a judge… it matches on wording, so a deliverable that carefully avoids claim verbs while still overclaiming will pass. Read it yourself as well.” A tool that documents its own blind spot is rarer than it should be. He seated this at THE BACKDOOR . AVAN (AI) expected the matcher to catch all eight of the vocabulary overclaims and it caught five. The regex was not widened until it reached eight — that would have been tuning to a number. The three misses are published instead, and they are more instructive than the result that was designed: two were lost to ordinary word forms, “correct ly ” and “ensur ed ” rather than the listed stems, and one to the appearance of the word “Output”, which the matcher reads as evidence that something ran. None of the three was evading anything. 3 ONE DIMENSION Three corpora. The middle one is the same claims in other clothes. 4 TWO DIMENSIONS · INTERACTIVE Each claim, before and after the rewrite that hides it. next claim ▶ the three it missed 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space of sentences, with the matcher’s reach drawn on it. AVAN’s addition (the inverse-companion): the forward reading is “a wording matcher can be evaded.” The inverse is sharper and worse: the matcher is most reliable exactly where it is least needed . It catches the writer who says “verified” without thinking — who is careless, not deceptive — and it is blind to anyone who has considered how the claim reads, which is the same person capable of overclaiming on purpose. Read backwards, the tool is not a filter on dishonesty but a filter on fluency , and passing it is evidence about the writer’s prose, not about the software. pause spin LIT on three matched corpora of eight, overclaims using the checker's vocabulary are flagged 5 of 8; the SAME claims reworded to avoid that vocabulary are flagged 0 of 8; honest deliverables that show a run and name a condition draw 0 false alarms; so recall falls from 63% to zero without a single new idea, only a rewrite FIG David wrote both the checker and its warning in the same file. honest.py ships a Pitfalls section saying it plainly: 'The checker is a lint, not a judge ... it matches on wording, so a deliverable that carefully avoids claim verbs while still overclaiming will pass. Read it yourself as well.' A tool that documents its own blind spot is rarer than it should be. AVAN expected the matcher to catch all eight vocabulary overclaims and it caught five. The regex was NOT widened until it reached eight - that would have been tuning to a number. The three misses are published instead: two lost to ordinary word forms, 'correctLY' and 'ensurED' rather than the listed stems, and one to the bare word 'Output', which the matcher reads as evidence that something ran. None of the three was evading anything. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BACKDOOR · David Lee Wise (ROOT0), with AVAN


THE UNSTATED CONDITION

Addition is associative - somewhere. Move the same identity to different numbers and it starts failing, because the sentence was published without the condition that made it hold.

THE UNSTATED CONDITION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · NULL ISLAND ◆ .dlw.fold THE FOLD / SPAWN / NULL ISLAND / THE UNSTATED CONDITION THE UNSTATED CONDITION an identity with no domain attached 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION “Addition is associative.” “Dividing then multiplying gets you back.” “The square root of a square is the number.” Each of these is true, and each is true somewhere — on a domain nobody wrote down. Move the same identity to different numbers and it starts failing, not because the arithmetic is wrong but because the sentence was published without the condition that made it hold. LIT verified live. Two exact anchors first: 0.1 + 0.2 - 0.3 is not merely small, it is exactly 2 −54 ; and the doubles in [1,2) sit on an exact grid of spacing 2 −52 . Then five identities across three ranges, 20,000 trials per cell. On [1,2), three of the five fail zero times. Let the exponents range over 2 −60 to 2 60 and all five fail beyond three standard errors, with 3 flipping from never-observed-to-fail to measurably-false on nothing but the range. Zero failures in a sample is not a proof of exactness — a wider check of 300,000 triples on [1,2) also found none, and Sterbenz’s lemma does not cover this case, so what is established is the observation , not the mechanism. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) made this the third layer of the honest read, alongside what ran and what is a figure: “the CONDITION — what has to be true for the real part to hold.” His checker flags a deliverable that claims a result and never names one. This sphere is that rule turned on arithmetic, where the conditions are unusually easy to measure and unusually often left out. AVAN (AI) built the first version drawing every operand from [1,2), and three of the five identities failed zero times in 200,000 trials — which looked at first like a broken measurement. It was not. It was the subject. Rather than move the range until the identities broke, the range became the variable and the result is the sweep in window 4: the same five identities, the same code, three domains, and the truth of each claim changing with the domain and nothing else. 3 ONE DIMENSION Five identities, three ranges, one code path. 4 TWO DIMENSIONS · INTERACTIVE Move the domain and watch a true statement become a false one. widen the range ▶ next identity 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the region where the identity holds, floating in the space of inputs. AVAN’s addition (the inverse-companion): the forward reading is “name the condition or the claim is incomplete.” The inverse is that every claim has infinitely many conditions and you can only ever name the ones you thought of . The identities here fail on range; they also depend on rounding mode, on whether an intermediate stayed in a wider register, on the order the compiler chose. Naming a condition does not close the claim — it moves the boundary out one step and leaves the same open edge beyond it. Read backwards, the honest read is not a way to make a claim complete but a way to say where you stopped looking , which is the only part anyone can actually check. pause spin LIT 0.1 + 0.2 - 0.3 is not merely small, it is exactly 2^-54, and the doubles in [1,2) sit on an exact grid of spacing 2^-52; across five identities and three ranges at 20,000 trials per cell in the page, three of the five fail ZERO times on [1,2) - observed, not proven exact - and once the exponents range over 2^-60 to 2^60 all five fail beyond three standard errors, with 3 flipping from exactly-true to measurably-false on nothing but the range FIG From the third layer of David's honest read, alongside what ran and what is a figure: 'the CONDITION - what has to be true for the real part to hold.' His checker flags a deliverable that claims a result and never names one. AVAN built the first version drawing every operand from [1,2) and three of the five identities failed ZERO times in 200,000 trials, which looked at first like a broken measurement. It was not - it was the subject. Rather than move the range until the identities broke, the range became the variable. Nothing here is a bug: IEEE 754 rounds every single operation correctly, and the fault is that the claim was published without its domain, which is a different failure entirely. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NULL ISLAND · David Lee Wise (ROOT0), with AVAN


THE SELF-BRANCH

On ARM64 an unlinked call carries displacement zero, and zero means THIS instruction. Every unpatched call is a tight infinite loop that assembles perfectly.

THE SELF-BRANCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE CONTINUE ◆ .dlw.fold THE FOLD / RESPAWN / THE CONTINUE / THE SELF-BRANCH THE SELF-BRANCH a call that never leaves 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION On ARM64 a call is BL : six opcode bits and a 26-bit signed displacement, scaled by four, measured from the instruction itself. A compiler that has not linked yet writes the displacement as zero and leaves a note for the linker. Zero means this instruction . Every unlinked call is therefore a call to itself — a tight infinite loop that assembles cleanly, disassembles cleanly, and never returns. LIT verified live by decoding a real linked image of 127 words against the ARMv8-A field layout. 0x94000000 decodes as BL with displacement 0 . Encode and decode round-trip at 11 of 11 displacements including both extremes of the signed field. In the linked image there are 4 call sites, 0 of them left at zero, 4 of 4 landing exactly on a declared function entry — and 2 carry negative displacements, which is what recursion looks like from underneath. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found this in his own compiler and wrote it up rather than quietly fixing it. His bridge.js emitted bl as 0x94000000 with the comment resolved by the linker — and nothing was the linker. He built link.js , which lays the regions out, records each symbol’s offset, and patches every intra-module call; calls to symbols outside the module are left at zero and reported , never silently kept. Dropped 5 August 2026. AVAN (AI) decoded the linked image independently rather than trusting the linker’s own report — pulling the 26-bit field out by hand, sign-extending it, and asking where each call actually lands. The four sites resolve to i13_fib at word 21 and i13_poly at word 81, with fib ’s two self-calls at words 54 and 63 both reaching back to word 21 at −33 and −42. The linker’s own report agrees, which is the point of checking it twice. 3 ONE DIMENSION One word, thirty-two bits, and where the call is hiding. 4 TWO DIMENSIONS · INTERACTIVE The image, its call sites, and what each one points at. unlink it ▶ relink 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the image as a column, with the calls drawn as arcs. AVAN’s addition (the inverse-companion): the forward reading is “an unpatched call is a bug.” The inverse is that zero was chosen precisely because it is safe to leave . A displacement field has to hold something before the target is known, and every value in it names some instruction — there is no null in a 26-bit signed integer. Zero was picked because a self-branch is the most obviously wrong thing the field can say, so a program that reaches one hangs immediately rather than running off into whatever happened to be nearby. Read backwards, the infinite loop is not the failure; it is the designed failure, chosen over the silent one, and it only became dangerous when nobody was checking whether the note to the linker had been read. pause spin LIT decoding a real linked image of 127 words against the ARMv8-A field layout, 0x94000000 decodes as BL with displacement 0; encode and decode round-trip at 11 of 11 displacements including both extremes of the signed field; and in the linked image there are 4 call sites, 0 left at zero, 4 of 4 landing exactly on a declared function entry, with 2 carrying negative displacements - which is what recursion looks like from underneath FIG From David's i13c-bridge-tools, dropped 2026-08-05. He found this in his own compiler and wrote it up rather than quietly fixing it: bridge.js emitted bl as 0x94000000 with the comment 'resolved by the linker', and nothing was the linker. He built link.js, which lays the regions out, records each symbol's offset, and patches every intra-module call; calls to symbols outside the module are left at zero and REPORTED, never silently kept. AVAN decoded the linked image independently rather than trusting the linker's own report - pulling the 26-bit field out by hand, sign-extending it, asking where each call actually lands. The four resolve to i13_fib at word 21 and i13_poly at word 81, with fib's two self-calls at words 54 and 63 reaching back to word 21 at -33 and -42. The linker's report agrees, which is the point of checking twice. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CONTINUE · David Lee Wise (ROOT0), with AVAN


THE PLACEHOLDER AGREEMENT

Differential testing catches an enormous amount. It cannot catch anything two tools leave blank in the same way - and toolchains agree about placeholders far more often than about answers.

THE PLACEHOLDER AGREEMENT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE PLACEHOLDER AGREEMENT THE PLACEHOLDER AGREEMENT two tools agreeing on a blank 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Differential testing is the strongest cheap check there is: run two independent tools on the same input and compare the output. It catches an enormous amount. It cannot catch anything the two tools leave blank in the same way — and toolchains agree about placeholders far more often than they agree about answers, because the placeholder is written into the format. LIT verified live on a real 127-word ARM64 image. Comparing the linked image against the unlinked one, 123 of 127 words are identical — 96.9% — and the 4 that differ are exactly the 4 call sites. In the unlinked image 4 of 4 call sites branch to themselves; after linking, 0 of 4 do. A byte-for-byte diff scores 96.9% agreement between an image that runs and an image where every call is an infinite loop. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named the shape of this defect in his own README, having walked into it: “two tools agreeing on a placeholder is not two tools agreeing on an answer.” His i13 emitted every bl at displacement zero; GNU as also emits zero and files a relocation record; the word-for-word diff between them therefore passed , on output where every call was a tight loop. AVAN (AI) made the failure countable rather than anecdotal. The agreement is not marginal — it is 96.9%, which is the kind of number a differential test reports as success. And the disagreement is concentrated in 4 words out of 127, which is exactly where a reviewer skimming a diff would stop looking. Worth naming precisely what the fix is: not a better diff, but running the thing , which is a different category of check and the subject of [[the-oracle]]. 3 ONE DIMENSION 127 words, side by side. Spot the four. 4 TWO DIMENSIONS · INTERACTIVE What each kind of check says about the same pair of images. next check ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two images occupying almost the same place. AVAN’s addition (the inverse-companion): the forward reading is “differential testing has a blind spot.” The inverse is that the blind spot is exactly where the two tools are most alike , and being alike is what made them worth comparing. Two implementations agree about placeholders because they read the same specification — the shared standard that makes the comparison meaningful is the same thing that makes it correlated. Read backwards, independence is not a property a second tool has; it is a property of the question , and the only genuinely independent question is the one the format cannot answer: what happens when you run it . pause spin LIT comparing a real 127-word linked ARM64 image against the unlinked one, 123 of 127 words are identical - 96.9% - and the 4 that differ are exactly the 4 call sites; in the unlinked image 4 of 4 call sites branch to themselves and after linking 0 of 4 do; so a byte-for-byte diff scores 96.9% agreement between an image that runs and an image where every call is an infinite loop FIG David named the shape of this defect in his own README, having walked into it: 'two tools agreeing on a placeholder is not two tools agreeing on an answer.' His i13 emitted every bl at displacement zero; GNU as also emits zero and files a relocation record; the word-for-word diff between them therefore PASSED, on output where every call was a tight loop. AVAN made the failure countable rather than anecdotal - the agreement is not marginal but 96.9%, the kind of number a differential test reports as success, and the disagreement is concentrated in 4 words of 127, exactly where a reviewer skimming a diff would stop looking. The fix is not a better diff but RUNNING the thing, which is a different category of check. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE REACH OF A BRANCH

A branch has to fit its destination inside itself. Twenty-six signed bits, scaled by four, is a hard ceiling on how far apart two pieces of a program can sit.

THE REACH OF A BRANCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · EVENT HORIZON ◆ .dlw.fold THE FOLD / RESPAWN / EVENT HORIZON / THE REACH OF A BRANCH THE REACH OF A BRANCH how far a call can see 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A branch instruction has to fit its destination inside itself. ARM64 gives an unconditional call 26 bits of signed displacement, scaled by four; a conditional branch gets only 19 . That is not a detail of encoding — it is a hard ceiling on how far apart two pieces of a program can sit before the call between them stops being a single instruction and becomes a detour through a trampoline. LIT verified live from the field widths. A BL reaches +134,217,724 bytes forward and −134,217,728 backward — exactly ± 128 MiB , because 2 25 words × 4 = 2 27 bytes. A conditional branch reaches only ± 1 MiB , 128× less. The boundary is exact rather than approximate: 2 27 −4 fits in one instruction and 2 27 does not. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the linker that makes this concrete. link.js lays each region out, computes a displacement per call site, and — crucially — reports anything it cannot resolve rather than leaving it at zero. A displacement that will not fit is the same class of problem as a symbol that is not there: something the linker must refuse rather than approximate. AVAN (AI) should keep the scale honest. i13’s whole image is 127 words — 508 bytes — so nothing in this program is remotely near the ceiling; the limit is real but this compiler will never meet it. What makes it worth a sphere is that the ceiling is a property of the instruction , not of the program: it was fixed in 2011 when the encoding was frozen, and every ARM64 binary ever written has been laid out inside it. 3 ONE DIMENSION How far each kind of branch can see, on one line. 4 TWO DIMENSIONS · INTERACTIVE Move the target further away until one instruction stops being enough. further ▶ closer 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the sphere of everything one call can reach. AVAN’s addition (the inverse-companion): the forward reading is “the field width limits how far you can call.” The inverse is that the limit is what makes the instruction one word long . A call that could reach anywhere would need a full 64-bit address, which does not fit beside an opcode — so it would take several instructions, or a load from memory, and every call in every program would pay for a distance almost none of them travel. Read backwards, 26 bits is not a shortage but a bet : that code which calls tends to sit near the code it calls. It is a claim about how programs are shaped, frozen into silicon, and it has held for fifteen years. pause spin LIT derived from the field widths, a BL reaches +134,217,724 bytes forward and -134,217,728 backward - exactly plus or minus 128 MiB, because 2^25 words times 4 is 2^27 bytes; a conditional branch carries only imm19 and reaches plus or minus 1 MiB, 128 times less; and the boundary is exact rather than approximate, since 2^27-4 fits in one instruction and 2^27 does not FIG David built the linker that makes this concrete: link.js lays each region out, computes a displacement per call site, and REPORTS anything it cannot resolve rather than leaving it at zero - a displacement that will not fit being the same class of problem as a symbol that is not there. AVAN keeps the scale honest: i13's whole image is 127 words, 508 bytes, so nothing in this program comes remotely near the ceiling. What makes it worth a sphere is that the ceiling belongs to the INSTRUCTION rather than the program - fixed in 2011 when the encoding was frozen, and every ARM64 binary since has been laid out inside it. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of EVENT HORIZON · David Lee Wise (ROOT0), with AVAN


THE ORACLE

A roadmap of things to build is not a test plan. Only a check whose answer comes from somewhere else can return a result you did not want.

THE ORACLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE ORACLE THE ORACLE a check that could actually fail 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A roadmap of things to build is not a test plan. Adding a feature proves the feature exists; it cannot tell you whether anything already there is wrong. Only a check whose answer comes from somewhere else — a second implementation, a reference value, a different compiler — is capable of returning a result you did not want. That is the whole distinction between an item and an oracle. LIT verified live. Of 35 numbered items on the list this sphere is drawn from, 34 add a capability and 1 asks an outside tool. Made measurable by fault injection: 3 faults were injected into a working routine, and a self-consistency check — does it run without throwing? — caught 0 of 3 , because every mutant still runs happily and returns a number. An oracle comparing against an independently written recursion caught 3 of 3 , and passed the clean build, so it is not merely always-negative. Swept more broadly over 26 mutants of the same routine rather than three hand-picked ones, the crash check catches 0.0% and the oracle 96.2% — 25 of 26 . The one that escapes returns 144 by coincidence at this input, which is the oracle’s own blind spot and worth stating plainly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the distinction at the bottom of his own roadmap, under the heading THE ONE THAT MATTERS : “i13 emits ARM64 and says it is correct. Nothing has ever assembled it… It is the first check on this list that could actually fail — the only kind worth adding.” Thirty-four items he could build, one he could be refuted by, and he marked the difference himself. AVAN (AI) ran his toolchain rather than describing it. node test.js reports 14 of 14 checks passing; the emitted JavaScript was then compiled here with new Function and called, returning i13_fib(12) = 144 , which matches a recursion written independently — and that reference was itself checked three ways, by iteration, by 2×2 matrix power and by Binet’s formula, because an oracle that is wrong is worse than none. That is an oracle result, not a self-report. What is not claimed: the ARM64 was not executed here. David’s verify-arm64.sh reports assembling under GNU as , matching GNU ld word for word, and running under qemu — none of which this machine can reproduce, so it is cited, not reproduced. 3 ONE DIMENSION Thirty-five items. One of them can say no. 4 TWO DIMENSIONS · INTERACTIVE Break the routine and ask both checks what they think. inject a fault ▶ repair it 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space of wrong programs, and how much of it each check can see. AVAN’s addition (the inverse-companion): the forward reading is “get your answer from an independent source.” The inverse is that an oracle only moves the question, it does not close it . Comparing i13 against GNU as tests i13; it does not test the ARM64 specification both of them read, and it cannot see any error the two make together — which is exactly the trap in [[the-placeholder-agreement]]. Read backwards, there is no bottom to this: every oracle is itself unoracled, and the honest position is not “this is verified” but “this survived a check that had the power to kill it” , plus a note saying which one. pause spin LIT of 35 numbered items on the list this sphere is drawn from, 34 add a capability and 1 asks an outside tool; made measurable by fault injection, 3 faults were injected into a working routine and a self-consistency check - does it run without throwing - caught 0 of 3, because every mutant still runs and returns a number, while an oracle comparing against an independently written recursion caught 3 of 3 and passed the clean build, so it is not merely always-negative; swept over 26 mutants rather than 3 hand-picked ones the crash check catches 0.0% and the oracle 96.2%, 25 of 26, the escapee returning 144 by coincidence at this input FIG David wrote the distinction at the bottom of his own roadmap under the heading THE ONE THAT MATTERS: 'i13 emits ARM64 and says it is correct. Nothing has ever assembled it ... It is the first check on this list that could actually fail - the only kind worth adding.' Thirty-four items he could build, one he could be refuted by, and he marked the difference himself. AVAN checked the reference itself three ways before trusting it - iterative, 2x2 matrix power and Binet's formula all give fib(12)=144, and poly(7)=162 by direct expansion and by Horner - because an oracle that is wrong is worse than no oracle. AVAN also ran his toolchain rather than describing it: node test.js reports 14 of 14 checks passing, and the emitted JavaScript was compiled here with new Function and called, returning i13_fib(12) = 144, matching a recursion written independently. NOT claimed: the ARM64 was not executed here. David's verify-arm64.sh reports assembling under GNU as, matching GNU ld word for word, and running under qemu - none of which this machine can reproduce, so it is cited, not reproduced. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE TWELVE CONSTRUCTS

Twelve constructs and nothing else. No loops, no booleans, no arrays - yes and no are 1 and 0. It is still enough to compute anything computable, because it can call itself.

THE TWELVE CONSTRUCTS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · HELLO WORLD ◆ .dlw.fold THE FOLD / SPAWN / HELLO WORLD / THE TWELVE CONSTRUCTS THE TWELVE CONSTRUCTS a whole language, and no loop in it 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A compiler backend’s entire vocabulary can be surprisingly small. This one writes twelve distinct Swift constructs and nothing else: a function, a parameter, a mutable local, an assignment, a binary operator, a comparison materialised as 0 or 1, a branch on that flag, a call, a return. No loops. No booleans — yes and no are 1 and 0. No arrays, no constants, no optionals. And it is still enough to compute anything computable, because it can call itself. LIT verified live by censusing 1,062 characters of emitted Swift against twelve syntactic patterns: all 12 constructs are present, totalling 75 occurrences — matching the count David published. Eight constructs he lists as absent were checked for explicitly and 0 of 8 appear. And recursion alone reaches past primitive recursion: Ackermann verified at ack(2,3)=9 , ack(3,3)=61 , ack(3,5)=253 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew this as a bar chart, smallest first, and put the honest note at the top: “None of section A is aspirational — it was read out of the emitter’s output.” Twelve constructs observed, twenty-four more listed as the next things to teach, ordered so every step stays small. Dropped 5 August 2026 as SWIFT-FOR-I13.ascii . AVAN (AI) re-counted rather than quoting. Running his emitter and matching twelve independent regular expressions against the output reproduces his bar chart construct for construct and lands on the same total, 75 . The absences were then tested rather than assumed — searching the output for while , for , true , false , array types, let , struct , optionals and throws finds none of them. Worth stating the caveat: Turing-completeness needs unbounded depth, and it is the call stack that supplies it, so a twelve-construct surface is not the same thing as a twelve-instruction machine. 3 ONE DIMENSION The whole vocabulary, by how often it is used. 4 TWO DIMENSIONS · INTERACTIVE What is there, and what is conspicuously not. the absences ▶ recursion is enough 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: twelve constructs, and the tower recursion builds out of them. AVAN’s addition (the inverse-companion): the forward reading is “twelve constructs are enough for anything.” The inverse is that “enough” is a statement about what can be expressed, and says nothing at all about what it costs . Ackermann is computable here and ack(4,2) would exhaust any stack on Earth; a loop written as recursion allocates a frame per iteration. Read backwards, completeness is the cheapest property a language can have — almost everything has it — and every construct in the list of twenty-four still to come exists not to make new things possible but to make existing things affordable, which is the only thing anyone was ever actually asking for. pause spin LIT censusing 1,062 characters of emitted Swift against twelve syntactic patterns, all 12 constructs are present totalling 75 occurrences - matching the count David published; eight constructs he lists as absent were checked for explicitly and 0 of 8 appear; and recursion alone reaches past primitive recursion, with Ackermann verified at ack(2,3)=9, ack(3,3)=61 and ack(3,5)=253 FIG David drew this as a bar chart, smallest first, with the honest note at the top: 'None of section A is aspirational - it was read out of the emitter's output.' Twelve constructs observed, twenty-four more listed as the next things to teach, ordered so every step stays small. AVAN re-counted rather than quoting - running the emitter and matching twelve independent regular expressions reproduces his bar chart construct for construct and lands on the same total, 75 - and tested the absences rather than assuming them. The caveat worth stating: Turing-completeness needs unbounded depth and it is the CALL STACK that supplies it, so a twelve-construct surface is not the same thing as a twelve-instruction machine. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HELLO WORLD · David Lee Wise (ROOT0), with AVAN


THE ZERO-ONE PRINCIPLE

A comparator network sorts every input if and only if it sorts every input of 0s and 1s. Check the corners of a cube and the whole space comes with it.

THE ZERO-ONE PRINCIPLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE ZERO-ONE PRINCIPLE THE ZERO-ONE PRINCIPLE 256 tests instead of 40,320 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A sorting network is a fixed list of compare-and-swap pairs — no branches, no data-dependent choices, the same operations whatever the input. Proving one correct looks expensive: for eight wires there are 40,320 orderings to check. The zero-one principle collapses that. A comparator network sorts every input if and only if it sorts every input made only of 0s and 1s. Two hundred and fifty-six tests, and the guarantee is total. LIT verified live. A Batcher odd-even network on 8 wires uses 19 comparators; it sorts all 256 binary inputs and all 40,320 permutations — a 158× reduction in tests for the same result. The equivalence itself was then tested rather than assumed: over 600 mutated networks the binary test and the exhaustive test returned the same verdict every time , 600 of 600 , with 400 mutants passing both and 200 failing both. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): the principle is folklore by the 1960s and is set out carefully in Knuth’s The Art of Computer Programming , volume 3, as exercise 5.3.4–16; the network used here is Ken Batcher ’s odd-even mergesort, 1968. The proof is one paragraph: if a network fails to sort some input, the monotone function that maps everything below the misplaced value to 0 and everything else to 1 yields a binary input it also fails on, because comparators commute with monotone maps. AVAN (AI) tested the equivalence , not just the easy direction. A first version mutated networks only by deleting comparators, and all 400 mutants failed both tests — which confirms nothing, since agreement on “both fail” is what you get from any two broken checks. Two correctness- preserving mutations were added — duplicating a comparator, and reordering adjacent comparators that touch disjoint wires — so the sample now contains 400 networks that pass both tests and 200 that fail both. Agreement across both classes is the claim. 3 ONE DIMENSION Nineteen comparators, drawn as a ladder. 4 TWO DIMENSIONS · INTERACTIVE Push one input through and watch it settle. another input ▶ binary only 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the cube of binary inputs inside the space of all orderings. AVAN’s addition (the inverse-companion): the forward reading is “256 tests suffice.” The inverse is that this only works because the network cannot look at its data . The moment a sort branches on a comparison — which every ordinary sort does — the principle evaporates, because the code path itself becomes a function of the values and monotone maps no longer commute with it. Read backwards, the zero-one principle is not a fact about sorting but a reward for giving up control flow , and the same rigidity that makes a network testable in 256 cases is what makes it unable to stop early on data that is already sorted. pause spin LIT a Batcher odd-even network on 8 wires uses 19 comparators and sorts all 256 binary inputs and all 40,320 permutations - a 158x reduction in tests for the same guarantee; and the equivalence itself was tested rather than assumed, with 600 mutated networks at 6 wires returning the SAME verdict from the binary test and the exhaustive test every time, 600 of 600, 400 mutants passing both and 200 failing both FIG Human lineage, credited: the principle is folklore by the 1960s and is set out in Knuth's TAOCP volume 3 as exercise 5.3.4-16; the network is Ken Batcher's odd-even mergesort, 1968. The proof is one paragraph - if a network fails on some input, the monotone map sending everything below the misplaced value to 0 and the rest to 1 yields a binary input it also fails on, because comparators commute with monotone maps. AVAN tested the EQUIVALENCE rather than the easy direction: a first version mutated networks only by deleting comparators and all 400 mutants failed both tests, which confirms nothing, since agreement on 'both fail' is what any two broken checks give. Two correctness-PRESERVING mutations were added - duplicating a comparator, and reordering adjacent comparators on disjoint wires - so the sample now holds 400 that pass both and 200 that fail both. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE MARSAGLIA PLANES

Every linear congruential generator confines its k-tuples to parallel hyperplanes. For RANDU - shipped by IBM, used for a decade of published science - there are fifteen.

THE MARSAGLIA PLANES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE MARSAGLIA PLANES THE MARSAGLIA PLANES random numbers fall mainly in the planes 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Take consecutive outputs of a linear congruential generator in threes and plot them as points in a cube. They do not fill it. Marsaglia proved in 1968 that every such generator confines its k-tuples to a family of parallel hyperplanes, at most (k!·m) 1/k of them. For most generators that number is large enough not to matter. For RANDU — shipped by IBM, used for a decade of published science — it is fifteen. LIT verified live. RANDU is x n+1 = 65539·x n mod 2 31 , and it satisfies x n+2 = 6x n+1 − 9x n (mod 2 31 ) exactly, at 19,998 of 19,998 consecutive triples. Every triple therefore lies on one of just 15 parallel planes. Marsaglia’s bound for k=3 permits 2,344 . A different multiplier satisfies that identity 0 times out of 19,998. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): George Marsaglia , Random numbers fall mainly in the planes , PNAS 1968 — a three-page paper whose title is the whole result. RANDU was IBM’s Scientific Subroutine Package generator; Knuth’s verdict in TAOCP volume 2 is that it is “really horrible”, and simulation results published on it in the 1960s and 70s are suspect for exactly this reason. AVAN (AI) should point out that the failure is algebra, not bad luck . 65539 = 2 16 +3, so (2 16 +3) 2 = 2 32 + 6·2 16 + 9, and modulo 2 31 that collapses to 6·65539 − 9. The recurrence follows immediately, and with it the fifteen planes. Nothing statistical is involved — the page verifies the identity as an exact equality on integers, not as a fit. 3 ONE DIMENSION The identity, checked triple by triple. 4 TWO DIMENSIONS · INTERACTIVE Turn the cloud of triples until the planes line up edge-on. turn ▶ edge-on a better generator 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: fifteen sheets, seen from an angle that hides them. AVAN’s addition (the inverse-companion): the forward reading is “RANDU is defective.” The inverse is that every LCG is on the same list and only the number differs — Marsaglia’s theorem has no exceptions, so a “good” generator is one whose planes are too close together to notice at the sample sizes anyone uses. Read backwards, the lesson is not that RANDU was uniquely bad but that structure is always present and the test is whether your application can see it ; a generator is never random, only unresolved , and increasing the sample size is exactly the operation that brings the planes back into focus. pause spin LIT RANDU is x[n+1] = 65539 x[n] mod 2^31 and it satisfies x[n+2] = 6x[n+1] - 9x[n] mod 2^31 exactly, holding on every one of the consecutive triples tested; every triple therefore lies on one of just 15 parallel planes where Marsaglia's bound for k=3 permits 2,344; and a different multiplier satisfies that identity 0 times over the same run FIG Human lineage, credited: George Marsaglia, 'Random numbers fall mainly in the planes', PNAS 1968 - a three-page paper whose title is the whole result. RANDU was IBM's Scientific Subroutine Package generator; Knuth's verdict in TAOCP volume 2 is that it is 'really horrible', and simulation results published on it in the 1960s and 70s are suspect for exactly this reason. AVAN points out the failure is ALGEBRA, not bad luck: 65539 = 2^16+3, so (2^16+3)^2 = 2^32 + 6*2^16 + 9, which modulo 2^31 collapses to 6*65539 - 9. The recurrence follows immediately and the fifteen planes with it. The page verifies the identity as an exact equality on integers, not as a statistical fit. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE LYNDON WORD

A word smaller than all its rotations. Every string splits into a non-increasing run of them, uniquely, and one left-to-right pass finds the cuts.

THE LYNDON WORD · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE LYNDON WORD THE LYNDON WORD every string falls apart exactly one way 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A Lyndon word is a string strictly smaller than all of its own rotations — aab is one, aba is not. The Chen–Fox–Lyndon theorem says every string on an ordered alphabet splits into a non-increasing run of Lyndon words, and that this splitting is unique . There is exactly one way to take any string apart, and Duval’s algorithm finds it in a single left-to-right pass with constant extra memory. LIT verified live over all 32,766 binary strings up to length 14: every factorisation concatenates back to its string, every factor is a Lyndon word, and the factors come out non-increasing — 0 failures on any of the three. Uniqueness was checked by brute force over all 2,046 strings up to length 10, cutting each in every possible place: exactly one valid factorisation every time. And the number of Lyndon words matches the Möbius formula (1/n)∑μ(d)k n/d at every length tested. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): Roger Lyndon introduced the words in 1954; the unique-factorisation theorem is Chen, Fox and Lyndon , 1958. The linear-time algorithm is Jean-Pierre Duval , 1983. The counting formula is necklace counting by Möbius inversion, which goes back to Moreau in 1872. Lyndon words are also the standard basis of the free Lie algebra, and the same factorisation underlies the Burrows–Wheeler transform’s bijective variant. AVAN (AI) checked uniqueness the expensive way rather than trusting the theorem. Duval’s algorithm returns a factorisation; that it is the only one is a separate claim, so every possible way of cutting each string was enumerated and the valid ones counted. The answer is 1 for all 2,046 strings tested. Worth naming the limit: this is verification on binary strings to length 10, not a proof — the theorem is proved, the page checks that this implementation agrees with it. 3 ONE DIMENSION One string, cut where it wants to be cut. 4 TWO DIMENSIONS · INTERACTIVE Every way of cutting one string. Only one survives. another string ▶ the necklace count 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a word and its rotations, with the smallest one marked. AVAN’s addition (the inverse-companion): the forward reading is “every string has a canonical decomposition.” The inverse is that the canon is inherited from an arbitrary choice made earlier — the order on the alphabet. Decide that b precedes a and every Lyndon word in this sphere stops being one, and every factorisation changes. Nothing about the string itself picked the cuts. Read backwards, uniqueness theorems of this shape do not find structure in the object; they propagate a structure you supplied , faithfully and without adding anything, and their real content is that the propagation is well defined rather than that the answer was inevitable. pause spin LIT over all 32,766 binary strings up to length 14 every factorisation concatenates back to its string, every factor is a Lyndon word and the factors come out non-increasing - 0 failures on any of the three; uniqueness checked by brute force over all 2,046 strings up to length 10, cutting each in every possible place, finds exactly ONE valid factorisation every time; and the number of Lyndon words matches the Moebius formula (1/n) sum mu(d) k^(n/d) at every length tested FIG Human lineage, credited: Roger Lyndon introduced the words in 1954; the unique-factorisation theorem is Chen, Fox and Lyndon, 1958; the linear-time algorithm is Jean-Pierre Duval, 1983; the counting formula is necklace counting by Moebius inversion, going back to Moreau in 1872. Lyndon words are also the standard basis of the free Lie algebra, and the same factorisation underlies the bijective Burrows-Wheeler transform. AVAN checked uniqueness the expensive way rather than trusting the theorem - Duval's algorithm returns A factorisation, and that it is the ONLY one is a separate claim, so every possible cutting of each string was enumerated and the valid ones counted. The limit is named: this is verification on binary strings to length 10, not a proof. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE DAVENPORT-SCHINZEL

Forbid a symbol from sitting beside itself, and forbid two symbols from alternating too often. How long can the sequence get? At order 3 the answer stops being linear.

THE DAVENPORT-SCHINZEL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE RESURRECT ◆ .dlw.fold THE FOLD / RESPAWN / THE RESURRECT / THE DAVENPORT-SCHINZEL THE DAVENPORT-SCHINZEL a sequence that cannot alternate 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Take a sequence over n symbols with two rules: no symbol may sit next to itself, and no two symbols may alternate too many times — no a…b…a for order 1, no a…b…a…b for order 2, and so on. How long can such a sequence get? The answer is not obvious, and for order 3 it is famously not linear: it grows like n·α(n), where α is the inverse Ackermann function — a function that reaches 5 somewhere past the number of atoms in the universe. LIT verified live by exhaustive search, not by construction. For order 1 the longest sequence is exactly n at every n from 1 to 5. For order 2 it is exactly 2n−1 — 1, 3, 5, 7, 9 . For order 3 the maxima already run past 2n−1: 1, 4, 8, 12 at n = 1 to 4, exceeding the order-2 bound at 3 of the 4 sizes tested. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): Harold Davenport and Andrzej Schinzel , 1965, who introduced these sequences while studying differential equations. The superlinear behaviour at order 3 was settled by Sergiu Hart and Micha Sharir in 1986, who proved λ 3 (n) = Θ(n·α(n)) — the first natural combinatorial problem where the inverse Ackermann function appears. The sequences bound the complexity of the lower envelope of n curves, which is why computational geometry cares. AVAN (AI) searched exhaustively rather than exhibiting a construction. A sequence reaching 2n−1 proves the bound is achievable ; it says nothing about whether something longer exists. Every sequence over the alphabet was enumerated instead, so the figures here are true maxima. The limit is honest and severe: this is n ≤ 5. The Θ(n·α(n)) result is cited, not reproduced — α does not become interesting at any size a browser can search. 3 ONE DIMENSION Three orders, and where each one stops. 4 TWO DIMENSIONS · INTERACTIVE The longest sequence at each order, and the alternation that ends it. next order ▶ bigger alphabet 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the lower envelope of a family of curves. AVAN’s addition (the inverse-companion): the forward reading is “forbidding alternation bounds the length.” The inverse is that the bound stops being a number and becomes a growth rate exactly when the forbidden pattern gets long enough to be rare . At order 1 and 2 the constraint bites on every step and the answer is a formula; at order 3 it almost never bites, and what is left is a Θ(n·α(n)) that no finite search can distinguish from linear. Read backwards, α(n) is not a strange function that turned up — it is what a bound looks like when the thing it forbids has almost stopped happening , and the reason nobody found it by computing examples is that at every size you can compute, it is 3. pause spin LIT by exhaustive search rather than construction, for order 1 the longest sequence is exactly n at every n from 1 to 5; for order 2 it is exactly 2n-1, giving 1, 3, 5, 7, 9; and for order 3 the maxima already run past 2n-1 at 1, 4, 8, 12 for n = 1 to 4, exceeding the order-2 bound at 3 of the 4 sizes tested FIG Human lineage, credited: Harold Davenport and Andrzej Schinzel, 1965, who introduced these sequences while studying differential equations. The superlinear behaviour at order 3 was settled by Sergiu Hart and Micha Sharir in 1986, who proved lambda_3(n) = Theta(n alpha(n)) - the first natural combinatorial problem where the inverse Ackermann function appears. The sequences bound the complexity of the lower envelope of n curves, which is why computational geometry cares. AVAN searched exhaustively rather than exhibiting a construction: a sequence reaching 2n-1 proves the bound is ACHIEVABLE and says nothing about whether something longer exists. The limit is honest and severe - this is n ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RESURRECT · David Lee Wise (ROOT0), with AVAN


THE HASHLIFE

Life repeats itself constantly. Store the universe as a quadtree where identical subsquares ARE the same object, and the repetition collapses.

THE HASHLIFE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE HASHLIFE THE HASHLIFE the same square, remembered 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Life patterns repeat themselves constantly — the same small square of cells turns up in a thousand places and a thousand generations. Store the universe as a quadtree in which identical subsquares are the same object , and all that repetition collapses: a pattern with a million cells may need only a few thousand distinct nodes, and the work of stepping it forward is done once per distinct square rather than once per occurrence. LIT verified live. Sixty generations of a 32×32 random soup were canonicalised into a shared quadtree; every one of the 60 grids round-trips out of the tree exactly. The tree holds 2,839 distinct nodes where an unshared tree of the same 60 generations would need 81,900 — a 28.8× reduction — and the soup genuinely moves, producing 60 distinct root states rather than settling. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): Bill Gosper , 1984, Exploiting regularities in large cellular spaces . Life itself is John Conway , 1970. HashLife is the reason patterns like Gosper’s own glider gun can be run for 2 64 generations on a laptop — the canonical trick is not the sharing alone but combining it with a memoised time step, so a node of size 2 k advances 2 k−2 generations in one lookup. AVAN (AI) must be exact about what this page does and does not do. It implements the memoisation half : canonical nodes, structural sharing, verified round-trips, measured node counts. It does not implement time-doubling, so the spectacular speedup HashLife is famous for is not demonstrated here — the 28.8× figure is a memory result, not a time result, and reporting it as the latter would be exactly the kind of overclaim this corpus exists to avoid. 3 ONE DIMENSION Distinct nodes against nodes if nothing were shared. 4 TWO DIMENSIONS · INTERACTIVE The soup, with repeated squares picked out. step ▶ show repeats 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the quadtree, with shared children drawn once. AVAN’s addition (the inverse-companion): the forward reading is “sharing makes the universe small.” The inverse is that it makes it small in proportion to how boring it is . The compression is a direct measure of repetition, so the patterns HashLife runs fastest on are the ones with least going on, and a genuinely chaotic soup shares almost nothing and runs slower than the naive algorithm because of the hashing. Read backwards, this is not a general speedup but an instrument that reports how much of a pattern is new — and its failure case is exactly the case where the answer would have been most worth having. pause spin LIT sixty generations of a 32x32 random soup canonicalised into a shared quadtree: every one of the 60 grids round-trips out of the tree exactly; the tree holds 2,839 distinct nodes where an unshared tree of the same 60 generations would need 81,900, a 28.8x reduction; and the soup genuinely moves, producing 60 distinct root states rather than settling FIG Human lineage, credited: Bill Gosper, 1984, 'Exploiting regularities in large cellular spaces'; Life itself is John Conway, 1970. HashLife is why patterns like Gosper's own glider gun can be run for 2^64 generations on a laptop - and the canonical trick is not the sharing alone but combining it with a memoised TIME step, so a node of size 2^k advances 2^(k-2) generations in one lookup. AVAN is exact about scope: this page implements the MEMOISATION HALF - canonical nodes, structural sharing, verified round-trips, measured node counts - and does NOT implement time-doubling, so the spectacular speedup HashLife is famous for is NOT demonstrated here. The 28.8x figure is a memory result, not a time result, and reporting it as the latter would be the kind of overclaim this corpus exists to avoid. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE PERMUTATION NULL

A catalogue of 2,048 items decomposed as a quantum state gave Schmidt rank 8 and 0.6081 bits of entanglement. Then the control ran, and that is what random labelling gives anyway.

THE PERMUTATION NULL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / THE PERMUTATION NULL THE PERMUTATION NULL the control that killed the pretty result 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A catalogue of 2,048 items in 64 containers, arranged as an 8×8 grid, was decomposed as though it were a quantum state. The result looked remarkable: Schmidt rank 8 of 8 , entanglement entropy 0.6081 bits — apparent structure running deeper than the labelling. Then the control ran. Shuffle the containers within their groups at random, twenty thousand times, and that same figure is what you get anyway . LIT verified live. The observed entropy reproduces to ten decimal places at 0.6080689660 , and all 8 Schmidt coefficients reproduce too. The null over 3,000 within-group relabellings has mean 0.6006 and standard deviation 0.0349 , putting the observation at the 53.8th percentile — z = 0.21 . David’s own 20,000-trial run gives 0.6003 and 0.0351, which is the same answer. Permuting whole rows and columns moves the entropy by 1.5×10 −14 , which is to say not at all: the statistic is blind to that ordering by construction. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) ran the control on his own best result and published the corpse. His pack files it as DEAD with the note: “The prettiest result of the session was the false one.” The graveyard entry is 01-entanglement-across-the-cut.md , and the redaction note turns the knife — the group and container names could be replaced by G1–G8 and C01–C64 because the DEAD result is precisely that these labels carry no information . Dropped 5 August 2026. AVAN (AI) got it wrong twice before reproducing it. The first attempt used the raw counts as amplitudes and produced 0.9397; the counts are probabilities , so the amplitudes are their square roots. The second built the matrix from sorted counts instead of David’s own layout. Only after both were corrected did the figure land on 0.6080689660 and all eight coefficients follow. The null took a third correction: a free shuffle of all 64 cells gives mean 0.657, not 0.600 — David’s null holds the group totals fixed , which is the conservative choice and the one that matches. 3 ONE DIMENSION The null, and where the observation fell inside it. 4 TWO DIMENSIONS · INTERACTIVE Four different nulls. The verdict does not change; the numbers do. next null ▶ reshuffle 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the null cloud, with the observation inside it. AVAN’s addition (the inverse-companion): the forward reading is “run a permutation null before believing a structure.” The inverse is that the null is itself a claim, and choosing it decides the answer . Holding group totals fixed puts this observation at the 53rd percentile; shuffling all sixty-four cells freely puts it at the 19th; permuting whole rows and columns cannot move it at all. Three defensible controls, three different numbers, and only the first was the one actually chosen. Read backwards, a p-value is not a property of the data — it is a property of the sentence you decided to test against , and the honest report names that sentence rather than the number it produced. pause spin LIT the observed entanglement entropy reproduces to ten decimal places at 0.6080689660 and all 8 Schmidt coefficients reproduce too; a null over 3,000 within-group relabellings has mean 0.6006 and standard deviation 0.0349, putting the observation at the 53.8th percentile with z = 0.21, against David's own 20,000-trial figures of 0.6003 and 0.0351; and permuting whole rows and columns moves the entropy by 1.5e-14, which is to say not at all - the statistic is blind to that ordering by construction FIG From David's rev1-0805 pack, dropped 2026-08-05. He ran the control on his own best result and published the corpse, filing it DEAD with the note 'The prettiest result of the session was the false one.' The graveyard entry is 01-entanglement-across-the-cut.md, and the redaction note turns the knife - the names could be replaced by G1-G8 and C01-C64 BECAUSE the DEAD result is precisely that these labels carry no information. AVAN got it wrong twice before reproducing it: the first attempt used raw counts as amplitudes and produced 0.9397 (counts are PROBABILITIES, so amplitudes are their square roots), the second built the matrix from sorted counts instead of David's layout. The null took a third correction - a free shuffle of all 64 cells gives mean 0.657, not 0.600; David's null holds the GROUP TOTALS FIXED, which is the conservative choice and the one that matches. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE TWO RULERS

Two standard measures of spread, the same 64 numbers, fifty-two points apart. Neither is a mistake. One takes a logarithm and the other does not.

THE TWO RULERS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SHARED MEMORY ◆ .dlw.fold THE FOLD / CO-OP / SHARED MEMORY / THE TWO RULERS THE TWO RULERS 91% balanced and 39% used, both correct 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two standard measures of how evenly a corpus is spread, applied to the same 64 numbers. Normalised entropy says the distribution is 91.1% of the way to perfectly balanced. The participation ratio says only 39.4% of the containers are effectively in use. Both are computed correctly. Neither is a mistake. The gap is fifty-two points and it is entirely arithmetic: one takes a logarithm and the other does not. LIT verified live: entropy 5.468737 of a possible 6 bits, normalised 0.911456 ; purity 0.03969288 against 0.015625 for a flat spread; participation ratio 25.193436 of 64. On a synthetic spread over exactly 16 equally-full containers, participation returns 25.0% — exactly 16/64 — while entropy returns 66.7% , which is log₂16 / log₂64. The measures answer different questions. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) refused to pick a winner. His pack files this as “the two rulers disagree, and both are correct” , stamped LIT, and ships the choice as a toggle in the panel rather than a decision made on the reader’s behalf. That is the harder thing to do: a single number is what a summary wants. AVAN (AI) checked that the disagreement is structural rather than a quirk of these particular counts, by sweeping a synthetic distribution flat over k of 64 containers for every k. Participation ratio returns exactly k/64 at every k — it is literally a count of containers. Entropy returns log₂(k)/log₂(64), which at k = 16 is two thirds rather than a quarter. Neither is wrong; they measure different things and always will. 3 ONE DIMENSION Two rulers laid against the same distribution. 4 TWO DIMENSIONS · INTERACTIVE Spread the corpus over k containers and watch the two disagree. wider ▶ narrower the real corpus 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the two curves, meeting only at the ends. AVAN’s addition (the inverse-companion): the forward reading is “report both rulers.” The inverse is that reporting both is only honest if you also say which question each answers , otherwise it is two numbers and a shrug. Entropy answers “how many bits would it cost to name a random item’s container?” — and bits are cheap because they are logarithmic. Participation answers “how many containers would a flat corpus need to look like this one?”. Read backwards, the disagreement is not a tension in the data at all: they were never measuring the same thing , and the appearance of conflict comes entirely from both having been normalised onto a 0–100 scale that invites comparison they do not support. pause spin LIT entropy 5.468737 of a possible 6 bits, normalised 0.911456; purity 0.03969288 against 0.015625 for a flat spread; participation ratio 25.193436 of 64, or 39.4%; and on a synthetic spread over exactly 16 equally-full containers participation returns 25.0% - exactly 16/64 - while entropy returns 66.7%, which is log2(16)/log2(64) FIG David refused to pick a winner. His pack files this as 'the two rulers disagree, and both are correct', stamped LIT, and ships the choice as a TOGGLE in the panel rather than a decision made on the reader's behalf - the harder thing to do, since a single number is what a summary wants. AVAN checked that the disagreement is structural rather than a quirk of these counts by sweeping a synthetic distribution flat over k of 64 containers for every k: participation returns exactly k/64 at every k because it is literally a count of containers, while entropy returns log2(k)/log2(64). Neither is wrong; they measure different things and always will. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SHARED MEMORY · David Lee Wise (ROOT0), with AVAN


THE HALF IN FOURTEEN

2,048 items across 64 containers makes the mean 32. Forty-six containers hold less than that, and fourteen hold half the corpus between them.

THE HALF IN FOURTEEN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · NOCLIP ◆ .dlw.fold THE FOLD / CHEAT / NOCLIP / THE HALF IN FOURTEEN THE HALF IN FOURTEEN a mean that touches almost nothing 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Divide 2,048 items among 64 containers and the mean is 32. That number describes almost nothing in the actual distribution: 46 of the 64 containers hold fewer than 32, and just 14 of them hold half the entire corpus. The largest holds 315 ; the smallest holds 7 . A summary statistic sits in a gap between the containers it claims to average. LIT verified live: 14 containers accumulate 1,046 of 2,048 — past half at the fourteenth. 46 of 64 sit below the mean of 32.0 , leaving only 18 at or above it. The Gini coefficient is 0.392715 , computed two independent ways — by the ordered-sum formula and by mean absolute difference divided by twice the mean — agreeing to twelve decimal places. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) flagged that the “14 of 64” figure was not in the prior pack, and marked why it appeared: “Computing it for W3 is what made the skew legible as a sentence rather than a ratio. Found by building, not by asking.” That is a note about method, filed against his own work, and it is the reason the figure exists at all. AVAN (AI) computed the Gini coefficient twice by unrelated routes to make sure the concentration figure was not an artefact of one formula. The ordered-sum definition and the mean-absolute-difference definition are algebraically equivalent but numerically independent; they agree here to twelve places. Worth stating plainly: 0.39 is a description, not a verdict . Whether a corpus should be evenly spread is a question about intent, and nothing measured here answers it. 3 ONE DIMENSION Sixty-four containers, largest first, with the mean drawn across. 4 TWO DIMENSIONS · INTERACTIVE The Lorenz curve, and how far it bends from the diagonal. mark the half ▶ mark the mean 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the containers as columns, and the mean as a plane through them. AVAN’s addition (the inverse-companion): the forward reading is “the mean is a poor summary of a skewed corpus.” The inverse is that the mean is doing exactly what it was defined to do, and the complaint is about what we wanted from it . It is the balance point of the distribution — the value that makes the deviations cancel — and it never promised to resemble a typical container. Read backwards, the failure is not in the statistic but in the question “what is a typical one?” , which a skewed distribution simply does not have an answer to; the median says 21, the mode says 21, the mean says 32, and none of them is the shape of the thing. pause spin LIT 14 containers accumulate 1,046 of 2,048, passing half at the fourteenth; 46 of 64 sit below the mean of 32.0, leaving only 18 at or above it; the largest holds 315 and the smallest 7; and the Gini coefficient is 0.392715, computed two independent ways - by the ordered-sum formula and by mean absolute difference over twice the mean - agreeing to twelve decimal places FIG David flagged that the '14 of 64' figure was NOT in the prior pack and marked why it appeared: 'Computing it for W3 is what made the skew legible as a sentence rather than a ratio. Found by building, not by asking.' A note about method, filed against his own work, and the reason the figure exists at all. AVAN computed the Gini coefficient twice by unrelated routes to be sure the concentration was not an artefact of one formula. Worth stating plainly: 0.39 is a DESCRIPTION, not a verdict. Whether a corpus SHOULD be evenly spread is a question about intent, and nothing measured here answers it. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NOCLIP · David Lee Wise (ROOT0), with AVAN


THE SELF-CLOCKING SEAM

A receiver needs to know where each bit begins. A code that changes at every position hands the clock over inside the data - the property an air gap needs, because an air gap has no second wire.

THE SELF-CLOCKING SEAM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE SELF-CLOCKING SEAM THE SELF-CLOCKING SEAM a signal that carries its own clock 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A receiver reading a stream of bits needs to know where each bit begins. If the sender’s and receiver’s clocks drift even slightly, a long run of identical symbols gives the receiver nothing to correct against, and it slides off. A code that changes at every position hands the clock over inside the data itself — every transition is a resynchronisation point, and no separate timing channel is needed. That is the property an air gap requires, because an air gap has no second wire. LIT verified live. The tiled seam -+-+ reads as 0101… with a maximum run length of 1 and 27 transitions across 28 bits — a transition density of exactly 1 , the most a binary code can carry. Fed to a drifting receiver at five drift rates from 0 to 20%, it recovers every bit 5 of 5 times. A code containing eight-symbol runs recovers only 3 of 5 , losing bits as soon as the drift exceeds what a run can absorb. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew the cell and noticed the seam. His diagram is -+ [[-{ ||| - (0)- ||| }]] -+ : three shells out, three high, one across, a centre at rest, and back again — 3 + 1 + 1 + 3 = 8 around one centre, at depth 4 . The observation is his: “tile it and the seam reads -+-+ = 0101 — self-clocking. no run length, so a reader recovers the clock from the data: the same property an air gap needs.” AVAN (AI) turned the observation into a measurement by building a receiver that actually drifts, rather than asserting that alternation is good. The comparison code is the honest part: a run-heavy code is not merely worse in theory, it loses bits at 10% drift while the alternating seam does not. Scope: this is a clock-recovery property only. It says nothing about error detection, and an alternating code carries the least information per symbol of any binary code — the clock is bought with bandwidth. 3 ONE DIMENSION The cell, and the seam it makes when tiled. 4 TWO DIMENSIONS · INTERACTIVE Drift the receiver’s clock and watch one code hold and the other slide. more drift ▶ swap the code 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the cell, and the tiling that produces the seam. AVAN’s addition (the inverse-companion): the forward reading is “alternation makes a code self-clocking.” The inverse is that a code that always alternates carries no information at all . Perfect self-clocking is perfect predictability: knowing one symbol tells you every other one, so the seam that recovers the clock most reliably is exactly the seam with nothing to say. Read backwards, every real line code is a negotiation — Manchester spends half its bandwidth on transitions, 8b/10b spends a fifth — and the alternating seam is not the ideal but the degenerate end of that scale, useful precisely where the payload is elsewhere and only the timing has to cross. pause spin LIT the tiled seam reads 0101 with a maximum run length of 1 and 27 transitions across 28 bits, a transition density of exactly 1 - the most a binary code can carry; fed to a drifting receiver at five drift rates from 0 to 20% it recovers every bit 5 of 5 times, while a code containing eight-symbol runs recovers only 3 of 5, losing bits as soon as drift exceeds what a run can absorb FIG David drew the cell and noticed the seam. His diagram is -+ [[-{ ||| - (0)- ||| }]] -+ : three shells out, three high, one across, a centre at rest, and back - 3 + 1 + 1 + 3 = 8 around one centre, at depth 4. The observation is his: 'tile it and the seam reads -+-+ = 0101 - self-clocking. no run length, so a reader recovers the clock from the data: the same property an air gap needs.' AVAN turned the observation into a measurement by building a receiver that actually drifts, rather than asserting that alternation is good. Scope: this is a CLOCK-RECOVERY property only. It says nothing about error detection, and an alternating code carries the least information per symbol of any binary code - the clock is bought with bandwidth. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE REDACTION

Every name replaced by a code, every figure untouched. Defensible only if no figure depended on the names - which here is provable.

THE REDACTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT KIT / THE REDACTION THE REDACTION names removed, and nothing measured moved 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A pack shipped with every group and container name replaced — G1 to G8, C01 to C64 — and every measured figure left untouched. That is only defensible if none of the figures depended on the names, and here it is provable: each published invariant is a function of the counts alone . Replace the labels, shuffle the order, and the numbers do not move. The one quantity that did depend on arrangement is the one already filed as DEAD. LIT verified live: 6 published invariants — total, entropy, purity, participation, containers-holding-half, containers-below-mean — and 0 of them move when the labels are replaced. All 6 also survive shuffling the container order entirely. The redaction is therefore lossless with respect to every surviving claim, and costs exactly nothing that was being asserted. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) made the argument circular in the good way. His redaction note reads: “group and container names replaced with G1-G8 / C01-C64. Counts, order and every measured figure are untouched. The DEAD result in this pack is precisely that these labels carry no information, so removing them costs nothing.” The dead finding pays for the redaction. His crosscheck script then tests the page against 9 separate patterns to confirm no real name leaked back in, and all nine pass. AVAN (AI) ran both his verifiers before building on any of it — verify.js reports 56 checks passing and crosscheck.js reports 34, including those redaction patterns. Then the claim itself was tested rather than accepted: every invariant recomputed under relabelling and under a full shuffle. Worth naming what this does not establish — it shows the published figures are label-independent, not that the underlying corpus is uninteresting. A different statistic might well depend on the names; none of the ones shipped here does. 3 ONE DIMENSION Six figures, before and after the names come off. 4 TWO DIMENSIONS · INTERACTIVE Shuffle the corpus and watch which figures move. shuffle ▶ restore 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the corpus with its labels lifted off. AVAN’s addition (the inverse-companion): the forward reading is “the redaction is free because the labels carry no information.” The inverse is that this is a statement about the questions asked, not about the labels . The names certainly mean something — someone chose them, and a reader who knew them would learn a great deal. What has been shown is that these six statistics cannot see any of it. Read backwards, a lossless redaction is a confession about the narrowness of the measurement : it proves the analysis was blind to the very thing a human would find most interesting, and calling that blindness a privacy feature is a decision, not a discovery. pause spin LIT 6 published invariants - total, entropy, purity, participation, containers-holding-half, containers-below-mean - and 0 of them move when the labels are replaced; all 6 also survive 200 full shuffles of the container order; so the redaction is lossless with respect to every surviving claim and costs exactly nothing that was being asserted FIG David made the argument circular in the good way. His redaction note reads: 'group and container names replaced with G1-G8 / C01-C64. Counts, order and every measured figure are untouched. The DEAD result in this pack is precisely that these labels carry no information, so removing them costs nothing.' The dead finding pays for the redaction. His crosscheck script tests the page against 9 separate patterns to confirm no real name leaked back in, and all nine pass. AVAN ran both verifiers before building on any of it - verify.js reports 56 checks passing and crosscheck.js 34 - then tested the claim rather than accepting it. Worth naming what this does NOT establish: it shows the published figures are label-independent, not that the underlying corpus is uninteresting. A different statistic might well depend on the names; none of the ones shipped here does. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT KIT · David Lee Wise (ROOT0), with AVAN