THE DECLARABLE ONLY

One name for two things is detectable. One thing with many names is declarable only. Nothing in the text says bench, Bench, wb_ and thing-bench are the same object.

THE DECLARABLE ONLY · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE KONAMI CODE ◆ .dlw.fold THE FOLD / CHEAT / THE KONAMI CODE / THE DECLARABLE ONLY THE DECLARABLE ONLY a synonym cannot be found by looking 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Three ways a symbol registry can go wrong, and they are not equally findable. One name, two things — a homonym — is detectable : group the corpus by symbol and count the meanings. One thing, many names — a synonym — is declarable only : nothing in the text says that bench , Bench , wb_ and thing-bench are the same object. And no name filed at all is the real gap, which a registry cannot even list. LIT verified live. Strip every meaning from the corpus and repeated symbols are still visible — i, w, x, y — because a repeat is a property of the text. Strip the same labels and the four names for one bench become four unrelated strings: nothing groups them. One category survives the loss of semantics and the other does not. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) set the three headings in rev 7 and marked each with its own reachability: ONE NAME, TWO THINGS — detectable ; ONE THING, MANY NAMES — declarable only ; NO NAME FILED AT ALL — the real gap . The middle label is the finding: not hard to detect, not expensive , but not detectable at all from the artefact. AVAN (AI) tested the asymmetry rather than restating it, by deleting the meaning column and re-running both searches. Homonym detection survives intact because it never used the meanings — it counts repeats. Synonym detection collapses completely, because identity between two different strings is not a fact the text contains. That is a statement about where the information lives , and it is why one of these can be automated and the other requires somebody to say so. 3 ONE DIMENSION Three categories, and what survives losing the meanings. 4 TWO DIMENSIONS · INTERACTIVE Delete the meaning column and re-run both searches. strip the meanings ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: symbols and meanings as two layers, with the links between them. AVAN’s addition (the inverse-companion): the forward reading is “synonyms can only be declared.” The inverse is that a declaration is itself just another name for the thing . Writing “ bench and wb_ are the same” creates a fifth artefact that can drift, contradict a sixth, and go stale the moment either name changes meaning — and nothing detects that either, for exactly the same reason. Read backwards, declarations do not escape the problem; they move it up one level , where it is rarer and no more findable, and the registry ends up needing a registry. pause spin LIT strip every meaning from the corpus and the repeated symbols are STILL visible - i, w, x, y - because a repeat is a property of the text; strip the same labels and the four names for one bench become four unrelated strings with nothing to group them; so one category survives the loss of semantics and the other does not FIG From David's rev 7, dropped 2026-08-05. He set the three headings and marked each with its own reachability: ONE NAME TWO THINGS - detectable; ONE THING MANY NAMES - declarable only; NO NAME FILED AT ALL - the real gap. The middle label is the finding: not HARD to detect, not expensive, but NOT DETECTABLE AT ALL from the artefact. AVAN tested the asymmetry rather than restating it, by deleting the meaning column and re-running both searches. Homonym detection survives intact because it never used the meanings - it counts repeats. Synonym detection collapses completely, because identity between two different strings is not a fact the text contains. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE KONAMI CODE · David Lee Wise (ROOT0), with AVAN


THE UNFILED

Two censuses of one corpus: what is used, and what is declared. The difference is the only category a registry cannot enumerate.

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

THE UNFILED · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · GARBAGE COLLECTION ◆ .dlw.fold THE FOLD / RESPAWN / GARBAGE COLLECTION / THE UNFILED THE UNFILED the symbols nobody wrote down 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two censuses of the same corpus: what is used , and what is declared . The difference is the third of rev 7’s categories — symbols in play with no meaning filed anywhere — and it is the only one a registry cannot enumerate. It can report no entry . It cannot report what the symbol means, because that is precisely what is missing. LIT verified live. 18 symbols in use, 7 declared in the canon, 11 used but never filed. The canon covers 38.9% of what is actually in play, and a lookup of every used symbol returns no entry 11 times. The registry knows the exact size of its gap and nothing whatever about its contents. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) lists this third category in rev 7 as “NO NAME FILED AT ALL — the real gap” , with p and k beneath it. Naming it as the real gap, rather than as an error, is the choice that matters: the other two categories are collisions between things that were written down, and this one is a hole where nothing was. AVAN (AI) should be precise about what coverage measures here, because the number invites the wrong reading. 38.9% is a measurement of the canon against the corpus — it is not a defect rate in the code. A symbol used without being declared is not an error; it is a piece of the system whose meaning lives only in somebody’s head. The gap is a finding about the documentation , and calling it a code-quality figure would be a category error of exactly the kind rev 7 is about. 3 ONE DIMENSION Used, declared, and the gap between them. 4 TWO DIMENSIONS · INTERACTIVE Look a symbol up and see what the registry can say. next symbol ▶ file it 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two sets, and the region only one of them covers. AVAN’s addition (the inverse-companion): the forward reading is “close the gap by filing the missing symbols.” The inverse is that a canon covering everything would be a second copy of the program . Every symbol declared is a fact stated twice, and two statements of the same fact drift — so complete coverage does not remove the problem, it converts a documentation gap into a synchronisation one, which is the harder of the two and, per this batch’s companion sphere, undetectable . Read backwards, the right size for a canon is not all of it ; it is exactly the symbols whose meaning a reader cannot recover from context, and nobody has measured which those are. pause spin LIT 18 symbols in use against 7 declared in the canon leaves 11 used but never filed; the canon covers 38.9% of what is actually in play; and a lookup of every used symbol returns 'no entry' 11 times, so the registry knows the exact SIZE of its gap and nothing whatever about its contents FIG David lists this third category in rev 7 as 'NO NAME FILED AT ALL - the real gap', with p and k beneath it. Naming it as the REAL gap rather than as an error is the choice that matters: the other two categories are collisions between things that were written down, and this one is a hole where nothing was. AVAN is precise about what coverage measures, because the number invites the wrong reading: 38.9% is a measurement OF THE CANON against the corpus, not a defect rate in the code. A symbol used without being declared is not an error; it is a piece of the system whose meaning lives only in somebody's head, and calling that a code-quality figure would be a category error of exactly the kind rev 7 is about. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GARBAGE COLLECTION · David Lee Wise (ROOT0), with AVAN


THE JOINT

One unmatched closer at the front, one unmatched opener at the back. Not a broken container - a joint, which closes what came before and opens what comes after.

THE JOINT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE JOINT THE JOINT bookends that balance only in a chain 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A fragment with one unmatched closer at the front and one unmatched opener at the back. Read alone it is broken. It is not broken — it is a joint : it closes what came before and opens what comes after, so it only ever lives between two cells. Alone it reads incomplete because alone it is incomplete. LIT verified live with a pushdown veto. The joint on its own reports 1 illegal closer and 1 unclosed frame. Placed between two cells it reports 0 bad, 0 unclosed . Chained at 1, 2, 3 and 5 joints it stays clean every time, with opens equalling closes at every length — 7, 13, 19, 31 of each. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew the joint and named the misreading before anyone could make it: “that is not a broken container. it is a JOINT… the same trick as -+ … -+ on the cube: the bookends are only balanced once the thing is in a chain.” He also recorded the version that really was broken — an early draft where the while chamber never closed, giving 3 illegal closers and 4 unclosed, and one missing bracket away from the joint signature. Dropped 5 August 2026 as SUIT.ascii ; his suite passes 15/15 , twice. AVAN (AI) should be exact about what the veto proves here. A balanced chain does not show the joint is correct — it shows it is composable . Any fragment with one spare closer and one spare opener chains cleanly, including nonsense; the bracket count cannot tell a joint from a coincidence with the same shape. What the measurement establishes is that the shape is legal in context, which is exactly the claim being made and no more. 3 ONE DIMENSION The joint alone, and the joint in a chain. 4 TWO DIMENSIONS · INTERACTIVE Add cells and watch the verdict flip. add a joint ▶ just the joint 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: cells on a chain, with the joints between them. AVAN’s addition (the inverse-companion): the forward reading is “a joint is only balanced in a chain.” The inverse is that this makes every fragment unverifiable on its own . A checker handed one piece cannot say whether it is a legal joint or a genuine error, because both look identical in isolation — and the file, the diff and the code review all work on pieces. Read backwards, the design buys composability by moving correctness into the assembly , and the cost is that nothing can be checked until everything is present, which is the opposite of what a veto is for. pause spin LIT under a pushdown veto the joint on its own reports 1 illegal closer and 1 unclosed frame; placed between two cells it reports 0 bad and 0 unclosed; and chained at 1, 2, 3 and 5 joints it stays clean every time with opens equalling closes at every length - 7, 13, 19 and 31 of each FIG From David's SUIT.ascii, dropped 2026-08-05; his suite passes 15/15, twice. He drew the joint and named the misreading before anyone could make it: 'that is not a broken container. it is a JOINT ... the same trick as -+ ... -+ on the cube: the bookends are only balanced once the thing is in a chain.' He also recorded the version that really WAS broken - an early draft where the while chamber never closed, giving 3 illegal closers and 4 unclosed. AVAN is exact about what the veto proves: a balanced chain does not show the joint is CORRECT, it shows it is COMPOSABLE. Any fragment with one spare closer and one spare opener chains cleanly, including nonsense, and the bracket count cannot tell a joint from a coincidence with the same shape. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE NO ELSE

can asks whether the action is available; do runs it. There is no else. Absence of capability is a refusal, and the refusal goes into the record.

THE NO ELSE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · HELLO WORLD ◆ .dlw.fold THE FOLD / SPAWN / HELLO WORLD / THE NO ELSE THE NO ELSE a refusal is written down, not branched around 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two chambers, can and do . The first asks whether the action is available; the second runs it. There is no else. When the capability is absent nothing branches — the refusal is written into the record and the machine moves on. A path not taken leaves a trace instead of a silence. LIT verified live over 300 invocations, 100 of them not capable. The suit records all 300 events, with the 100 refusals counted exactly. The equivalent if/else construction records 200 — the else path leaves nothing behind — so 100 events are invisible to it. And a chamber with no else has one path to prove rather than two. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) put the rule in capitals because it is the whole design: “`can` asks whether the action is available at this |i|. `do` runs it. THERE IS NO ELSE. absence of capability is not a branch — it is a refusal, and the refusal is written down.” His plain-English version is the same claim without the jargon: “Nothing silently takes a different path.” AVAN (AI) should say what this does and does not remove. It does not remove conditionality — something still decides whether the action runs, and that decision is still a fork in the machine. What it removes is the unrecorded half: an else branch is a place where behaviour happens with no entry in the log, and the suit makes that shape unavailable. The gain is auditability, not simplicity, and the two are often confused. 3 ONE DIMENSION Three hundred invocations, and what each form remembers. 4 TWO DIMENSIONS · INTERACTIVE Run the same inputs through both and compare the records. suit / if-else ▶ change the capability 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: one path with a record beside it. AVAN’s addition (the inverse-companion): the forward reading is “remove the else and nothing happens unrecorded.” The inverse is that a refusal that is always recorded is a log that grows with every non-event . The if/else version is silent about the hundred refusals; the suit writes all hundred down, and on a system where capability is usually absent the record becomes mostly the story of things that did not happen. Read backwards, this is not free auditability but a decision about what deserves storage , and the suit has decided that absence does — which is right for a machine being debugged and expensive for one being run. pause spin LIT over 300 invocations with 100 of them not capable, the suit records all 300 events with the 100 refusals counted exactly, while the equivalent if/else construction records 200 because the else path leaves nothing behind - so 100 events are invisible to it; and a chamber with no else has one path to prove rather than two FIG David put the rule in capitals because it is the whole design: 'can asks whether the action is available at this |i|. do runs it. THERE IS NO ELSE. absence of capability is not a branch - it is a refusal, and the refusal is written down.' His plain-English version is the same claim without the jargon: 'Nothing silently takes a different path.' AVAN says what this does and does not remove: it does NOT remove conditionality, since something still decides whether the action runs. What it removes is the UNRECORDED half - an else branch is a place where behaviour happens with no entry in the log. The gain is auditability, not simplicity, and the two are often confused. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HELLO WORLD · David Lee Wise (ROOT0), with AVAN


THE SHARED TERMINATOR

FORTRAN 77 lets two DO loops end on the same labelled statement. Two openers, one closer, entirely legal - and a pushdown check sees nothing wrong.

THE SHARED TERMINATOR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE RESURRECT ◆ .dlw.fold THE FOLD / RESPAWN / THE RESURRECT / THE SHARED TERMINATOR THE SHARED TERMINATOR two loops, one CONTINUE 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION FORTRAN 77 permits two DO loops to end on the same labelled statement. Two openers, one closer, and it is entirely legal. A pushdown check pops once, finds nothing illegal, and leaves a phantom frame on the stack — then a discharge step tidies the leftover away and reports clean. The check is not wrong at any single step; it simply cannot see the shape. LIT verified live. The nested shared terminator gives 2 opens, 1 close, 0 illegal closers and 1 unclosed frame — a clean report over a wrong state. Two nested chambers in the suit give 3 opens, 3 closes and a depth of 0 at the end, because every chamber carries its own closer and there is no label to share. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found the case that broke his veto and wrote both halves down: the FORTRAN shape with its one-frame drift, and the conclusion — “the fix for a parser that cannot see an ambiguity is not always a smarter parser. sometimes it is a grammar that cannot express the ambiguity.” The suit is that grammar; his suite passes 15/15 , twice. AVAN (AI) should record one difference honestly. David reports max nesting 1 for two nested chambers; the bracket model here measures a max nesting of 3 , because it counts literal delimiters rather than chamber frames. The figures that carry the claim — 3 opens, 3 closes, depth back to 0 — agree exactly. The nesting number depends on which representation you count, and this page counts brackets, so it reports its own. 3 ONE DIMENSION The stack, walking a shared terminator. 4 TWO DIMENSIONS · INTERACTIVE Nest more loops on one label and watch the drift grow. nest deeper ▶ the suit version 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: frames opened, and the one that never closes. AVAN’s addition (the inverse-companion): the forward reading is “the shared terminator is a defect the veto cannot see.” The inverse is that FORTRAN’s designers were not being careless — sharing a terminator saved a line on a punched card , and on hardware where a program was a physical stack of cards that was a real economy. Read backwards, the ambiguity is a fossil of a constraint that no longer exists , and the reason it survives is that the language kept its promise of compatibility; every parser since has had to see a shape that was rational in 1977 and is merely dangerous now. pause spin LIT the nested shared terminator gives 2 opens, 1 close, 0 illegal closers and 1 unclosed frame - a clean report over a wrong state; while two nested chambers in the suit give 3 opens, 3 closes and a depth of 0 at the end, because every chamber carries its own closer and there is no label to share FIG David found the case that broke his veto and wrote both halves down: the FORTRAN shape with its one-frame drift, and the conclusion - 'the fix for a parser that cannot see an ambiguity is not always a smarter parser. sometimes it is a grammar that cannot express the ambiguity.' AVAN records one difference honestly: David reports MAX NESTING 1 for two nested chambers, while the bracket model here measures 3, because it counts literal delimiters rather than chamber frames. The figures that carry the claim - 3 opens, 3 closes, depth back to 0 - agree exactly. The nesting number depends on which representation you count, and this page counts brackets, so it reports its own. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RESURRECT · David Lee Wise (ROOT0), with AVAN


THE READ-ONLY INPUT

Both chambers read |i|. Neither may write it - an attempt throws. If a body can edit its own input, running it twice is running it on two different things.

THE READ-ONLY INPUT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE READ-ONLY INPUT THE READ-ONLY INPUT a chamber cannot edit what it is given 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Both chambers read |i| , the magnitude they are given. Neither may write it — an attempt throws. That single restriction is what makes a chamber testable: if a body can edit its own input, then running it twice is running it on two different things, and no re-run means what it appears to mean. LIT verified live. A reading body runs unguarded and leaves i at 5 . A writing body throws under the guard, and i is still 5 afterwards. Without the guard the same body silently moves i from 5 to 6 . Re-run five times, the guarded chamber sees 5, 5, 5, 5, 5 and the unguarded one sees 6, 7, 8, 9, 10 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) stated the rule and its purpose in the same breath: “|i| — the magnitude of I. both chambers READ it. neither may WRITE it — writing throws. that is what makes a chamber testable: its inputs cannot be edited by its own body.” It is one of the fifteen checks his suite runs twice. AVAN (AI) should connect it to something this corpus already measured. Two batches ago a sensitivity probe re-ran an impure thunk and turned eleven calls into ninety-nine, breaking three later assertions. The read-only input is the same problem solved at the other end : rather than restricting who may probe, restrict what a body may touch. The guard is cheaper and stronger — it applies to every caller rather than to the careful ones — and it is only available if you control the language. 3 ONE DIMENSION The same body, five re-runs, two regimes. 4 TWO DIMENSIONS · INTERACTIVE Run a body that writes its own input, with and without the guard. guard on / off ▶ run it again reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a fixed input with a body orbiting it. AVAN’s addition (the inverse-companion): the forward reading is “a body must not edit its own input.” The inverse is that the restriction only reaches as far as the guard can see . A proxy stops assignment to |i| ; it does not stop the body writing to a file, a global, a clock or a socket, and any of those makes the second run different in exactly the way the rule was written to prevent. Read backwards, read-only inputs do not buy reproducibility — they buy one specific kind of it , and the value of the guarantee is set entirely by how much of the outside world the chamber can still reach. pause spin LIT a reading body runs unguarded and leaves i at 5; a writing body THROWS under the guard with i still 5 afterwards; without the guard the same body silently moves i from 5 to 6; and re-run five times the guarded chamber sees 5, 5, 5, 5, 5 while the unguarded one sees 6, 7, 8, 9, 10 FIG David stated the rule and its purpose together: '|i| - the magnitude of I. both chambers READ it. neither may WRITE it - writing throws. that is what makes a chamber testable: its inputs cannot be edited by its own body.' AVAN connects it to something this corpus already measured: two batches ago a sensitivity probe re-ran an impure thunk and turned eleven calls into ninety-nine, breaking three later assertions. The read-only input is the SAME PROBLEM SOLVED AT THE OTHER END - rather than restricting who may probe, restrict what a body may touch. The guard is cheaper and stronger, applying to every caller rather than the careful ones, and it is only available if you control the language. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE GRAMMAR THAT CANNOT

A parser could not see an ambiguity, so the grammar was narrowed until it could not be written. Not a smarter checker - a smaller language.

THE GRAMMAR THAT CANNOT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE GRAMMAR THAT CANNOT THE GRAMMAR THAT CANNOT make the ambiguity unwriteable 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A parser could not see an ambiguity, so the grammar was changed until the ambiguity could not be written. Not a smarter checker — a narrower language . The shape that broke the veto is not detected in the suit; it is simply not expressible, because there is no shared label for two constructs to end on. LIT verified live by enumerating every short program in both grammars. Of 1,364 labelled programs up to length 5, 664 can share a terminator — 48.7% . Of 62 suit programs of the same lengths, 0 can. And the cost is exact and unflattering: the suit expresses 4.55% as many programs, because you cannot remove a shape without removing everything that used it. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the conclusion as a general rule rather than a local fix: “the fix for a parser that cannot see an ambiguity is not always a smarter parser. sometimes it is a grammar that cannot express the ambiguity.” The specific target was F2 in his tower — a veto with no braces, for a language whose loops end on labels. AVAN (AI) enumerated both grammars to put a number on the trade, because the rule is stated as a win and it is really an exchange. Removing the ambiguity removed 95% of the expressible programs at these lengths. Most of those programs were nonsense, and the ratio is sensitive to how each grammar is encoded — but the direction is not in doubt, and a restriction that costs nothing is usually a restriction that removes nothing. 3 ONE DIMENSION Two grammars, every short program, counted. 4 TWO DIMENSIONS · INTERACTIVE Grow the program length and watch both counts move. longer ▶ shorter 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the expressible space, with the ambiguous region cut out. AVAN’s addition (the inverse-companion): the forward reading is “make the bad shape unwriteable.” The inverse is that a grammar cannot tell a bad shape from an unforeseen one . The restriction removes the shared terminator and everything isomorphic to it, including uses nobody has thought of yet, and the language has no way to distinguish the ambiguity it was aimed at from a legitimate construction with the same skeleton. Read backwards, this is prohibition rather than detection — it is more reliable precisely because it is less discriminating , and every future need that happens to have that shape is now a language change rather than a bug report. pause spin LIT enumerating every short program in both grammars, of 1,364 labelled programs up to length 5 some 664 can share a terminator - 48.7% - while of 62 suit programs of the same lengths 0 can; and the cost is exact and unflattering, the suit expressing 4.55% as many programs, because you cannot remove a shape without removing everything that used it FIG David wrote the conclusion as a general rule rather than a local fix: 'the fix for a parser that cannot see an ambiguity is not always a smarter parser. sometimes it is a grammar that cannot express the ambiguity.' The specific target was F2 in his tower - a veto with no braces, for a language whose loops end on labels. AVAN enumerated both grammars to put a number on the trade, because the rule is stated as a win and is really an exchange: removing the ambiguity removed 95% of the expressible programs at these lengths. Most of those were nonsense and the ratio is sensitive to how each grammar is encoded, but the direction is not in doubt - a restriction that costs nothing is usually a restriction that removes nothing. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE BLIND INSTRUMENT

A FORTRAN veto sliced each line to column 7, discarding the label that lives in columns 1-5, and let any closer pop whatever was on top. Two repairs, and the numbers moved in both directions.

THE BLIND INSTRUMENT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GATEKEEPER ◆ .dlw.fold THE FOLD / BOSS / THE GATEKEEPER / THE BLIND INSTRUMENT THE BLIND INSTRUMENT a checker that cannot see is silent, not noisy 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A checker was written to find unbalanced blocks in FORTRAN. Its first version sliced each line to column 7 — discarding the statement label, which in fixed form lives in columns 1–5 — and let any closer pop whatever was on top of the stack. Two repairs: read the label, and match the closer’s kind. The interesting part is which way the numbers moved . LIT verified live on twelve programs, every one accepted by gfortran 13.3.0. The repaired veto mis-parses 3 of 12 — cases 01, 03 and 12, reproducing David’s published result exactly. The first version mis-parses 4 — more cases, not fewer. But its count of illegal closers across all twelve programs is 0 , and type-matching turns that silence into 3 . The blindness was silent, not noisy. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the twelve cases, compiled every one first so that no failure could be a strawman, and wrote the rule the experiment produced: “a veto that cannot see labels reports FEWER problems, not more. an instrument that is blind in the same place as the thing it measures agrees with it perfectly.” Dropped 5 August 2026 as FORTRAN-TRAPS.ascii . AVAN (AI) re-ran both versions over the full twelve and must report a split result. On illegal closers his rule holds and holds hard: 0 against 3, because a closer that pops anything can never mismatch. On case count it inverts — the blind version flags 4 rather than 3, since cases 05 and 11 are false alarms that the repair removed. Both directions are real. The case count is simply the wrong instrument for the question, and that is the sharper version of his finding rather than a contradiction of it. 3 ONE DIMENSION Twelve legal programs, two versions of the same checker. 4 TWO DIMENSIONS · INTERACTIVE Toggle each repair and watch which cases move. see the label ▶ type-match closers 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the instrument and its subject, sharing a blind spot. AVAN’s addition (the inverse-companion): the forward reading is “a blind instrument under-reports.” The inverse is that the blindness was discovered only because someone already knew the answer . Twelve cases were hand-built by a person who knew where FORTRAN hides its traps, and the checker was judged against that knowledge. Without it, the first version’s zero illegal closers reads exactly like a clean bill of health. Read backwards, this measures nothing about instruments in general — it measures what happens when you have an oracle , and the situations where you most need a checker are precisely the ones where you do not. pause spin LIT across twelve programs all accepted by gfortran 13.3.0, the repaired veto mis-parses 3 of 12 - cases 01, 03 and 12, reproducing David's published result exactly - while the first version mis-parses 4, MORE cases and not fewer; but its count of illegal closers across all twelve is 0, and type-matching turns that silence into 3 FIG From David's FORTRAN-TRAPS.ascii, dropped 2026-08-05. He built the twelve cases and compiled every one first, so that no failure could be a strawman, and wrote the rule the experiment produced: 'a veto that cannot see labels reports FEWER problems, not more. an instrument that is blind in the same place as the thing it measures agrees with it perfectly.' AVAN re-ran both versions over the full twelve and must report a SPLIT result. On illegal closers his rule holds hard - 0 against 3, because a closer that pops anything can never mismatch. On case count it INVERTS: the blind version flags 4 rather than 3, since cases 05 and 11 are false alarms the repair removed. Both directions are real. The case count is the wrong instrument for the question, which is the sharper version of his finding rather than a contradiction of it. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GATEKEEPER · David Lee Wise (ROOT0), with AVAN


THE TWO ERRORS THAT CANCEL

DO 10 I = 1.10 is an assignment to a variable named DO10I - a period, not a comma, and spaces are not significant. Two programs contain it. One is called clean.

THE TWO ERRORS THAT CANCEL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE WALL ◆ .dlw.fold THE FOLD / BOSS / THE WALL / THE TWO ERRORS THAT CANCEL THE TWO ERRORS THAT CANCEL clean for exactly the wrong reason 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two FORTRAN programs contain the identical statement DO 10 I = 1.10 . A period, not a comma — and since spaces are not significant in fixed form, this is an assignment to a variable named DO10I . No loop is opened. One program is followed by 10 CONTINUE ; the other is not. The checker calls the first clean and the second broken . LIT verified live. Case 11 reports 0 unclosed, 0 bad . Case 12 reports 2 unclosed, 1 bad . The statement is byte-identical in both. Case 11 passes because a frame the language never opened is closed by a terminator that terminates nothing — two errors cancelling exactly, and a clean verdict over a model that has understood none of it. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the pair and compiled both, which is what makes them evidence: “this is an ASSIGNMENT to a variable named DO10I. spaces are not significant in fixed form. the veto sees DO + label and opens a frame that the language never opened. the famous one. it is not folklore: gfortran compiles it.” He separated the myth from the mechanism — the story usually attached to this syntax is disputed, and the syntax is not. AVAN (AI) noticed the pair rather than the case. David’s table lists case 11 as clean and case 12 as mis-parsed without remarking on it; the two files differ by one line. That makes 11 the more alarming of the two, because a checker that is wrong and says so is far less dangerous than one that is wrong and reports success. This page publishes the cancellation, and the credit for the pair existing at all belongs to whoever wrote both files. 3 ONE DIMENSION The same statement, two verdicts. 4 TWO DIMENSIONS · INTERACTIVE Add or remove the terminator and watch the verdict flip. terminator on / off ▶ period / comma 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a phantom open meeting a phantom close. AVAN’s addition (the inverse-companion): the forward reading is “a passing test can be evidence of nothing.” The inverse is that cancellation is the normal case, not the exception . Any checker that reports a single aggregate — a balance, a total, a difference from zero — is a function that maps many states onto one number, and every such function has a kernel: a whole space of wrong models that produce the right output. Read backwards, case 11 is not a freak. It is one visible member of the set of errors the measurement was designed to be unable to distinguish from correctness. pause spin LIT case 11 reports 0 unclosed and 0 bad while case 12 reports 2 unclosed and 1 bad, from a byte-identical statement; case 11 passes because a frame the language never opened is closed by a terminator that terminates nothing - two errors cancelling exactly, and a clean verdict over a model that has understood none of it FIG David built the pair and compiled both, which is what makes them evidence: 'this is an ASSIGNMENT to a variable named DO10I. spaces are not significant in fixed form. the veto sees DO + label and opens a frame that the language never opened. the famous one. it is not folklore: gfortran compiles it.' He separated the myth from the mechanism - the story usually attached to this syntax is disputed, and the syntax is not. AVAN noticed the PAIR rather than the case: David's table lists 11 as clean and 12 as mis-parsed without remarking on it, and the two files differ by one line. That makes 11 the more alarming, because a checker that is wrong and SAYS SO is far less dangerous than one that is wrong and reports success. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE WALL · David Lee Wise (ROOT0), with AVAN


THE STACK THAT CANNOT JUMP

A pushdown automaton reads one symbol and makes one move. That discipline is what makes it decidable, and it is exactly what a jump violates.

THE STACK THAT CANNOT JUMP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FIREWALL ◆ .dlw.fold THE FOLD / BOSS / THE FIREWALL / THE STACK THAT CANNOT JUMP THE STACK THAT CANNOT JUMP a pushdown model has no move for GO TO 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A pushdown automaton reads one symbol and makes one move: push, pop, or neither. That discipline is what makes it decidable, and it is exactly what a GO TO violates. FORTRAN’s arithmetic IF — IF (X) 10, 20, 30 — branches three ways from a single statement, with no block and no closer, into labels that need not share a nesting depth. LIT verified live. In a program where a jump leaves a loop, label 10 sits at stack depth 2 and label 20 at depth 1 — the jump crosses 1 frame, and the automaton has no move that both pops and lands. The arithmetic IF names 3 targets from one statement. Of the twelve compiled cases, exactly 1 uses a jump, and it is the one no stack repair reaches. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) ranked his three fixes by cost and was blunt about the third: “a stack cannot model GO TO. the arithmetic IF and every labelled jump leave the pushdown model entirely. this is not a bug to patch — it is the limit of the automaton.” And on the scoring: “the veto’s zero-parameter 100.00% is a property of a bracketed language. fortran is not one.” AVAN (AI) adds the formal name for what he found, because it is older than the veto. A language whose control flow includes unrestricted jumps to labels is not context-free in the sense a stack can track, and this is why structured-programming arguments of the 1960s were about expressive discipline rather than taste. The measurement here is not a discovery of that fact; it is a demonstration that his particular instrument hits it, on a case a compiler accepts. 3 ONE DIMENSION Stack depth at each label, and the jump that crosses it. 4 TWO DIMENSIONS · INTERACTIVE Move the jump target and watch the frames it crosses. next target ▶ the arithmetic IF 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: nested frames, with an arrow that ignores them. AVAN’s addition (the inverse-companion): the forward reading is “a stack cannot model a jump.” The inverse is that the stack was never trying to . A pushdown automaton is a model chosen for what it makes cheap — linear time, no backtracking, a decidable emptiness test — and every one of those properties is bought by the restriction that control returns where it left. Read backwards, this is not a failure of the instrument but a correctly priced trade , and calling it a limitation obscures that the alternative is a model with none of the guarantees that made the first one worth building. pause spin LIT in a program where a jump leaves a loop, label 10 sits at stack depth 2 and label 20 at depth 1, so the jump crosses 1 frame and the automaton has no move that both pops and lands; the arithmetic IF names 3 targets from a single statement; and of the twelve compiled cases exactly 1 uses a jump, which is the one no stack repair reaches FIG David ranked his three fixes by cost and was blunt about the third: 'a stack cannot model GO TO. the arithmetic IF and every labelled jump leave the pushdown model entirely. this is not a bug to patch - it is the limit of the automaton.' And on the scoring: 'the veto's zero-parameter 100.00% is a property of a bracketed language. fortran is not one.' AVAN adds the formal name for what he found, because it is older than the veto: a language whose control flow includes unrestricted jumps to labels is not context-free in the sense a stack can track, which is why the structured-programming arguments of the 1960s were about expressive discipline rather than taste. The measurement here is not a discovery of that fact - it is a demonstration that his particular instrument hits it, on a case a compiler accepts. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FIREWALL · David Lee Wise (ROOT0), with AVAN


THE CAP THAT WAS LUCK

A recursion cap shipped at 1000, chosen by taste. The real ceiling was then bisected: 1734 completes, 1750 overflows. It had sat under the ceiling by luck.

THE CAP THAT WAS LUCK · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GAUNTLET ◆ .dlw.fold THE FOLD / BOSS / THE GAUNTLET / THE CAP THAT WAS LUCK THE CAP THAT WAS LUCK a number about this machine, written as a number about the language 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A recursion cap was shipped at 1000 , chosen by taste. The real ceiling was then bisected on the machine that would run it: 1734 completes, 1750 overflows. The cap had sat under the ceiling by 734 iterations — not by design, but by luck. Replacing a guess with a measurement is the improvement. The measurement is still a fact about one machine. LIT verified live, and the page bisects this browser by the same method while you read it. It finds a different ceiling — the number is a property of the host, not of the language, and it gets written into source as if it were the latter. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found the ceiling and then immediately turned on his own result: “3 is the one that will bite. 1734 is measured, which is better than chosen, but it is measured HERE. it is a fact about this machine, and it is written into the code as if it were a fact about the language.” He also caught why the cap existed at all — the VM has no loop instruction, so iteration is recursion, and a cap above the ceiling would overflow while wearing a loop’s clothes. AVAN (AI) can only strengthen this by running the same bisection somewhere else, which the page does. Two caveats belong on the record: a browser’s limit varies with what is already on the stack, so the number here is a snapshot rather than a constant, and a JavaScript engine’s frame budget is not the same quantity as his VM’s. The claim being demonstrated is only that the ceiling moves with the host , and for that any second host suffices. 3 ONE DIMENSION The cap, the ceiling, and the margin nobody chose. 4 TWO DIMENSIONS · INTERACTIVE Re-run the bisection on this host. The answer moves. bisect again ▶ try a cap 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a ceiling that is a different height on every floor. AVAN’s addition (the inverse-companion): the forward reading is “measure the ceiling instead of guessing the cap.” The inverse is that a measured constant is more dangerous than a guessed one, precisely because it is trusted . 1000 was visibly arbitrary and invited scrutiny; 1734 carries the authority of an experiment and will be copied forward without one. Read backwards, the improvement is not the number — it is the bisection procedure , and shipping the output while discarding the method converts a measurement back into a guess with better credentials. pause spin LIT the shipped cap of 1000 sat 734 iterations below a ceiling bisected at 1734 completes and 1750 overflows, a bracket 16 wide; and the page re-runs the same bisection on whatever browser is reading it and finds a DIFFERENT ceiling - the number is a property of the host, not of the language, and it gets written into source as if it were the latter FIG David found the ceiling and then immediately turned on his own result: '3 is the one that will bite. 1734 is measured, which is better than chosen, but it is measured HERE. it is a fact about this machine, and it is written into the code as if it were a fact about the language.' He also caught why the cap existed at all - the VM has no loop instruction, so iteration is recursion, and a cap above the ceiling would overflow while wearing a loop's clothes. AVAN can only strengthen this by running the same bisection somewhere else, which the page does. Two caveats belong on the record: a browser's limit varies with what is already on the stack, so the number here is a snapshot rather than a constant, and a JavaScript engine's frame budget is not the same quantity as his VM's. The claim being demonstrated is only that the ceiling MOVES WITH THE HOST, and for that any second host suffices. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GAUNTLET · David Lee Wise (ROOT0), with AVAN


THE BRANCH STILL IN THE MACHINE

A language with no if/then was lowered onto a VM and the opcodes counted. No new instruction was needed, and JMPF appears three times.

THE BRANCH STILL IN THE MACHINE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · SUDDEN DEATH ◆ .dlw.fold THE FOLD / BOSS / SUDDEN DEATH / THE BRANCH STILL IN THE MACHINE THE BRANCH STILL IN THE MACHINE the grammar lost if/then; the ISA never did 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A language with no if/then was lowered onto a virtual machine, and the opcodes it produced were counted. The result: no new instruction was needed, and JMPF — jump-if-false — appears three times. Removing the branch from the grammar did not remove it from the machine, and was never meant to. LIT verified live on the published census. 29 instructions across 11 distinct opcodes: ASK 6, CONST 5, RET 5, JMPF 3, ARG 2, FUNC 2, CALL 2, BIN 1, CMP 1, ANSWER 1, HALT 1. Branch-carrying instructions — JMPF plus CMP — are 4 of 29, or 13.8% . The conditional survives the translation intact and is a small minority of it. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) ran the census as an integration gate and read it correctly the first time: “JMPF present. the branch still exists IN THE MACHINE. the suit removes if/then from the GRAMMAR, not from the ISA — and that is correct, because the ambiguity lives in the source form, so that is where it must be unwritable.” AVAN (AI) flags what the census cannot settle. Twenty-nine instructions is one lowering of one gate; the proportions are a property of that fragment and would move on any other program, so 13.8% is a reading rather than a rate. What the census does establish, and establishes firmly, is the presence of JMPF — and presence is what the claim needs. A single occurrence would have been enough. 3 ONE DIMENSION The census, and the branch inside it. 4 TWO DIMENSIONS · INTERACTIVE Two layers: what the source can say, and what the machine runs. source / ISA ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a narrowed surface over an unchanged core. AVAN’s addition (the inverse-companion): the forward reading is “restrict the source, keep the machine.” The inverse is that the guarantee now lives entirely in the compiler . Nothing at the instruction level prevents a JMPF pattern the grammar forbids — the ISA will execute it happily — so the property is enforced at exactly one point, and anything that emits bytecode directly bypasses it completely. Read backwards, a grammar restriction is a promise about who writes the code , not about what the machine can do, and it holds for as long as there is only one way in. pause spin LIT the published census totals 29 instructions across 11 distinct opcodes - ASK 6, CONST 5, RET 5, JMPF 3, ARG 2, FUNC 2, CALL 2, BIN 1, CMP 1, ANSWER 1, HALT 1 - so the branch-carrying instructions JMPF and CMP are 4 of 29 or 13.8%, and the conditional survives the translation intact as a small minority of it FIG From David's INTEGRATE.ascii. He ran the census as an integration gate and read it correctly the first time: 'JMPF present. the branch still exists IN THE MACHINE. the suit removes if/then from the GRAMMAR, not from the ISA - and that is correct, because the ambiguity lives in the source form, so that is where it must be unwritable.' AVAN flags what the census cannot settle: twenty-nine instructions is ONE lowering of ONE gate, so the proportions are a property of that fragment and would move on any other program - 13.8% is a reading rather than a rate. What the census does establish firmly is the PRESENCE of JMPF, and presence is what the claim needs. A single occurrence would have been enough. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SUDDEN DEATH · David Lee Wise (ROOT0), with AVAN


THE ZERO THAT WAS THE POINT

Two constructs were feared enough to scope a whole piece of work around them. Counted against 938,154 lines of BLAS and LAPACK, both occur zero times.

THE ZERO THAT WAS THE POINT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · GOD MODE ◆ .dlw.fold THE FOLD / CHEAT / GOD MODE / THE ZERO THAT WAS THE POINT THE ZERO THAT WAS THE POINT two zeros that look identical in the output 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two constructs were feared enough to scope a whole piece of work around them. Counted against reference BLAS 3.12.0 and LAPACK 3.11.0 — 2,387 files, 938,154 lines — both occur zero times. And the counter shipped alongside that result, run here without the corpus present, also prints zero for everything. The two zeros are identical in the output. LIT verified live. A zero in 938,154 lines gives a 95% upper bound of 3.20 occurrences per million lines by the rule of three. Were the true rate 1 in 10,000 lines, the expected count is 93.8 and the probability of seeing none is 1.8 × 10 -41 . The corpus counts are David’s , cited not re-derived — his zip ships the counter, not the libraries. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) counted before building, which is the entire point of the drop: “arithmetic IF — 0 occurrences. 0 files. verified twice, once by the classifier, once by a raw grep over every line of both libraries.” And the consequence, stated against his own plan: “that work would have been aimed at nothing.” Dropped 5 August 2026 as COUNT.ascii . AVAN (AI) ran his count.py without BLAS or LAPACK on disk and got a table of zeros — the same zeros his real run reports for the two traps. That is not a criticism of his counter; it is the reason the denominator has to travel with the numerator. His table carries 2,387 files and 938,154 lines beside the zeros, so it is a measurement. The same zeros with a line count of 0 would be an empty read wearing a result’s clothes, and nothing in the number itself distinguishes them. 3 ONE DIMENSION What a zero rules out, and what it does not. 4 TWO DIMENSIONS · INTERACTIVE Slide the true rate and watch the chance of seeing zero collapse. rarer ▶ commoner the empty run 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a zero with a denominator, and a zero without one. AVAN’s addition (the inverse-companion): the forward reading is “count before you build.” The inverse is that the count is only as good as the corpus standing in for the world . Reference BLAS and LAPACK are two specific libraries maintained to a modern standard; the arithmetic IF is absent from them and is not absent from FORTRAN as it was written and still runs in places these libraries do not reach. Read backwards, this zero licenses a claim about a target , not about a language, and the honest version of “it does not occur” is always “it does not occur here ” — which is exactly what makes it actionable and exactly what makes it portable to nowhere else. pause spin LIT a zero in 938,154 lines across 2,387 files gives a 95% upper bound of 3.20 occurrences per million lines by the rule of three; were the true rate 1 in 10,000 lines the expected count is 93.8 and the probability of seeing none is 1.8e-41; and the same counter run with no corpus present also prints zero for everything, the two zeros being told apart only by the denominator FIG From David's COUNT.ascii, dropped 2026-08-05. He counted before building, which is the entire point: 'arithmetic IF - 0 occurrences. 0 files. verified twice, once by the classifier, once by a raw grep over every line of both libraries.' And the consequence, stated against his own plan: 'that work would have been aimed at nothing.' The corpus counts are HIS, cited and not re-derived here - the zip ships the counter, not the libraries. AVAN ran that count.py without BLAS or LAPACK on disk and got a table of zeros, the same zeros his real run reports for the two traps. That is not a criticism of his counter; it is the reason the DENOMINATOR has to travel with the numerator. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GOD MODE · David Lee Wise (ROOT0), with AVAN


THE HUNDRED AND THIRTY-TWO

A first count found 132 shared loop terminators. The test was 'a DO label appears more than once in a file' - which also matches two sequential loops reusing label 10.

THE HUNDRED AND THIRTY-TWO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE EXPLOIT ◆ .dlw.fold THE FOLD / CHEAT / THE EXPLOIT / THE HUNDRED AND THIRTY-TWO THE HUNDRED AND THIRTY-TWO label reuse counted as nesting 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A first count found 132 shared loop terminators in BLAS. The test was “a DO label appears more than once in a file” — which also matches two sequential loops reusing label 10, legal and harmless and not the trap. Counting the ones where the same label is open twice at once gives 0 . The error was not small. It was large, and it ran in the direction that made the argument look good. LIT verified live by building both tests. On sequential reuse the loose test fires 1 and the strict test fires 0 ; on true nesting both fire 1 . Scaled to 310 files with three harmless reuses each, the loose test reports 310 and the strict test reports 0 — and the loose test is a strict superset, so it can never under-count. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) published the retraction with the number attached and named the asymmetry himself: “MY FIRST COUNT SAID 132 SHARED TERMINATORS IN BLAS. it was wrong… the number was not small and wrong. it was large and wrong, in the direction that made my earlier argument look good.” AVAN (AI) built both predicates to show the failure is structural rather than accidental. “Appears twice in a file” and “open twice at once” are not two attempts at the same question — the first is a property of the text and the second a property of the execution nesting , and one contains the other. Any test that measures the containing set will over-report by exactly the cases that separate them, every time, in the same direction. That is a fact about the predicates, and no amount of care in applying the loose one would have helped. 3 ONE DIMENSION Two predicates, and the cases that separate them. 4 TWO DIMENSIONS · INTERACTIVE Switch between sequential reuse and true nesting. sequential / nested ▶ scale it up 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: one set properly containing another. AVAN’s addition (the inverse-companion): the forward reading is “the loose predicate over-counted.” The inverse is that a superset test is the correct first move and is supposed to over-count . Cheap over-inclusive filters exist precisely so that nothing is missed, and the discipline they require is that their output is treated as a candidate list rather than a result. Read backwards, the failure was not in choosing the loose predicate — it was in reporting its output as the answer , and the same 132 would have been entirely respectable one line earlier, labelled as the set still to be checked. pause spin LIT on sequential reuse the loose test fires 1 and the strict test fires 0, while on true nesting both fire 1; scaled to 310 files with three harmless reuses each the loose test reports 310 and the strict test reports 0; and the loose test is a strict superset, so it can never under-count and its error has a fixed direction FIG David published the retraction with the number attached and named the asymmetry himself: 'MY FIRST COUNT SAID 132 SHARED TERMINATORS IN BLAS. it was wrong... the number was not small and wrong. it was large and wrong, in the direction that made my earlier argument look good.' AVAN built both predicates to show the failure is structural rather than accidental: 'appears twice in a file' and 'open twice at once' are not two attempts at the same question - the first is a property of the TEXT and the second a property of the EXECUTION NESTING, and one contains the other. Any test that measures the containing set over-reports by exactly the cases that separate them, every time, in the same direction. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE EXPLOIT · David Lee Wise (ROOT0), with AVAN


THE JUMP THAT IS EVERYWHERE

The exotic FORTRAN relics are gone - ENTRY nowhere, assigned GO TO nowhere, EQUIVALENCE six times. What is everywhere is the plain jump.

THE JUMP THAT IS EVERYWHERE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · NOCLIP ◆ .dlw.fold THE FOLD / CHEAT / NOCLIP / THE JUMP THAT IS EVERYWHERE THE JUMP THAT IS EVERYWHERE the real obstacle, and not the one raised 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The exotic FORTRAN relics are gone. ENTRY appears nowhere, assigned GO TO nowhere, EQUIVALENCE six times across two libraries. What is everywhere is the plain jump: GO TO in 739 of LAPACK’s 2,077 files and 12 of BLAS’s 310. A stack cannot model a jump — and the thing it cannot model is not a museum piece, it is the ordinary construct. LIT verified live on the published table. LAPACK 35.58% , BLAS 3.87% — a ratio of 9.19× , at z = 11.21 against the hypothesis that the two libraries share a rate. Plain GO TO totals 3,593 against 6 exotic relics: 599 times as many. The corpus counts are David’s , cited not re-derived. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named the reversal precisely: “this is the real obstacle, and it is not the one I raised. a pushdown automaton cannot model a jump. one third of LAPACK contains one. the veto’s stack discipline does not fail on exotic F77 relics — it fails on plain GO TO, everywhere.” And the consequence for the plan: the port “must be re-scoped around GO TO, which is a harder problem because it is not a bracket problem at all.” AVAN (AI) ran a two-proportion test on the BLAS/LAPACK gap because a nine-fold difference invites a question his table does not answer: whether it reflects age or purpose . BLAS is small kernels with short bodies; LAPACK is drivers with error paths and early exits, which is precisely what a jump expresses in a language with no break . The gap is real at z = 11.21, and the interesting reading is that jump density tracks what the code does , not when it was written. 3 ONE DIMENSION What is there, and what turned out not to be. 4 TWO DIMENSIONS · INTERACTIVE Two libraries, file by file. BLAS / LAPACK ▶ the relics 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a third of the files with an arrow through them. AVAN’s addition (the inverse-companion): the forward reading is “GO TO is the real obstacle.” The inverse is that the obstacle is only an obstacle to this instrument . A third of LAPACK contains a jump and LAPACK works — it is among the most heavily exercised numerical code in existence, and its jumps are overwhelmingly early exits and error returns, which is what a language without break or exceptions gives you. Read backwards, this measures a mismatch between a checker and a corpus , and calling the corpus the problem gets the direction wrong: the code was there first and it computes correct answers. pause spin LIT GO TO appears in 739 of LAPACK's 2,077 files and 12 of BLAS's 310 - 35.58% against 3.87%, a ratio of 9.19x at z = 11.21 against the hypothesis that the two libraries share a rate; and plain GO TO totals 3,593 against 6 exotic relics, 599 times as many FIG David named the reversal precisely: 'this is the real obstacle, and it is not the one I raised. a pushdown automaton cannot model a jump. one third of LAPACK contains one. the veto's stack discipline does not fail on exotic F77 relics - it fails on plain GO TO, everywhere.' The corpus counts are HIS, cited not re-derived. AVAN ran a two-proportion test on the BLAS/LAPACK gap because a nine-fold difference invites a question his table does not answer - whether it reflects AGE or PURPOSE. BLAS is small kernels with short bodies; LAPACK is drivers with error paths and early exits, which is what a jump expresses in a language with no break. The gap is real at z = 11.21, and the reading is that jump density tracks what the code DOES. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NOCLIP · David Lee Wise (ROOT0), with AVAN


UNJUSTIFIED IS NOT DISPROVEN

A design was argued for on the grounds that it makes a bad shape unwritable. The shape was counted and found zero times. That does not make the design wrong.

UNJUSTIFIED IS NOT DISPROVEN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE BACKDOOR ◆ .dlw.fold THE FOLD / CHEAT / THE BACKDOOR / UNJUSTIFIED IS NOT DISPROVEN UNJUSTIFIED IS NOT DISPROVEN a likelihood ratio of one leaves the prior alone 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A design was argued for on the grounds that it makes a particular bad shape unwritable. The shape was then counted in the target corpus and found zero times. That does not make the design wrong. It makes the argument inert — and the difference has an exact form. LIT verified live. Evidence with a likelihood ratio of 4 moves a prior of 0.5 to a posterior of 0.80 ; a ratio of 0.25 moves it to 0.20 ; and a ratio of exactly 1 leaves it at 0.5000 . Checked across seven priors from 0.01 to 0.99, LR = 1 is the identity map on belief every time. Losing your evidence returns the question to where it stood before you made the argument — it does not answer it the other way. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew the distinction himself and got it exactly right, against his own project: “the suit is not disproven. it is UNJUSTIFIED BY THIS EVIDENCE, which is a different thing and a smaller claim than I made.” He also stated the plain consequence without softening it: the suit’s argument is “true, and worth nothing here: nothing writes that shape.” AVAN (AI) gives the distinction its arithmetic, because it is the kind of claim that sounds like generosity and is in fact a theorem. In odds form the update is one multiplication, so evidence that is equally likely under both hypotheses multiplies by one and changes nothing at all. The reason this deserves saying out loud is that the two outcomes feel the same from inside — an argument collapsing and a claim being refuted are both bad days — and only one of them tells you anything about the world. 3 ONE DIMENSION Three kinds of evidence, one prior. 4 TWO DIMENSIONS · INTERACTIVE Move the prior. The inert case never moves. shift the prior ▶ change the evidence 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a belief line with a fixed point. AVAN’s addition (the inverse-companion): the forward reading is “unjustified is not disproven.” The inverse is that this is exactly the shape a claim uses to survive indefinitely . Every time the supporting evidence fails, the claim returns to its prior rather than dying, and a design defended this way can absorb an unlimited number of collapsed arguments without ever being wrong. Read backwards, the honest use of the distinction requires the second half that rarely follows it: naming, in advance, the observation that would carry a likelihood ratio below one — and here that is measurable, since the suit’s real test is whether can/do/does can express what a third of LAPACK does with a jump. pause spin LIT evidence with a likelihood ratio of 4 moves a prior of 0.5 to a posterior of 0.80, a ratio of 0.25 moves it to 0.20, and a ratio of exactly 1 leaves it at 0.5000; checked across seven priors from 0.01 to 0.99, LR = 1 is the IDENTITY MAP on belief every time - losing your evidence returns the question to where it stood before the argument, it does not answer it the other way FIG David drew the distinction himself and got it exactly right, against his own project: 'the suit is not disproven. it is UNJUSTIFIED BY THIS EVIDENCE, which is a different thing and a smaller claim than I made.' He also stated the plain consequence without softening it - the suit's argument is 'true, and worth nothing here: nothing writes that shape.' AVAN gives the distinction its arithmetic, because it is the kind of claim that sounds like generosity and is in fact a theorem: in odds form the update is one multiplication, so evidence equally likely under both hypotheses multiplies by one and changes nothing. It deserves saying aloud because the two outcomes FEEL the same from inside, and only one of them tells you anything about the world. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BACKDOOR · David Lee Wise (ROOT0), with AVAN


THE FLATTERING DIRECTION

Three numbers came out wrong in one session, each in the direction that made the argument look better, each corrected by measuring again rather than by thinking harder.

THE FLATTERING DIRECTION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / THE FLATTERING DIRECTION THE FLATTERING DIRECTION three errors, all the same way 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Three numbers came out wrong in one working session. A ratio that compared two different quantities under one name. A veto that reported 2 of 10 because it was blind to the labels it needed to read. And 132 shared terminators that were label reuse counted as nesting. All three were wrong in the direction that made the argument look better. All three were corrected by measuring again with a sharper question — none by thinking harder about the first answer. LIT verified live, including the part that undercuts the pattern. Under a fair coin, three errors all running one way has a one-tailed probability of 0.125 and two-tailed 0.25 . That is not significant at any conventional level. It would take 6 consecutive same-direction errors to reach p < 0.05. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) kept the tally against himself and wrote the method note that matters more than the tally: “each was corrected only by measuring the thing again with a sharper question. none was corrected by thinking harder about the first answer.” The three are listed with their causes on his own page, in a document whose headline result also retracts one of them. AVAN (AI) has to be the one that says three is not enough. As a statistic the pattern is worth nothing — p = 0.25, and any run of three coin flips comes up all-heads a quarter of the time. As a mechanism it is worth a great deal, and the mechanism is visible in a single case: each wrong number came from a predicate that was easier to compute than the one actually wanted, and easier predicates tend to be more inclusive, which is a bias with a direction rather than noise. That reading needs one example, not six. 3 ONE DIMENSION Three errors, their causes, and what three points can carry. 4 TWO DIMENSIONS · INTERACTIVE Add same-direction errors and watch the p-value fall. one more ▶ one fewer 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: errors scattered, and errors leaning. AVAN’s addition (the inverse-companion): the forward reading is “my errors lean toward flattering me.” The inverse is that the tally is drawn from the errors that were caught . An error that flatters an argument survives until someone checks the argument; an error that undercuts it gets found immediately, because the person holding it has every reason to look. Read backwards, a list of one’s own corrected mistakes is filtered by the same bias it is being used to measure , and the flattering ones are over-represented in the record precisely because they were harder to notice — which makes the count uninformative and the mechanism no less real. pause spin LIT under a fair coin, three errors all running one way has a one-tailed probability of 0.125 and two-tailed 0.25, which is NOT significant at any conventional level; it would take 6 consecutive same-direction errors to reach p below 0.05 FIG David kept the tally against himself and wrote the method note that matters more than the tally: 'each was corrected only by measuring the thing again with a sharper question. none was corrected by thinking harder about the first answer.' The three are listed with their causes on his own page, in a document whose headline result also retracts one of them. AVAN has to be the one that says three is not enough. As a STATISTIC the pattern is worth nothing - p = 0.25, and any run of three coin flips comes up all one way a quarter of the time. As a MECHANISM it is worth a great deal, and it is visible in a single case: each wrong number came from a predicate easier to compute than the one actually wanted, and easier predicates tend to be more inclusive, which is a bias with a direction rather than noise. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN


THE UNARY MINUS THAT ISN'T

A 13-symbol language has a binary minus and no unary one. Negative numbers are not handled badly - they are inexpressible as literals and must be constructed.

THE UNARY MINUS THAT ISN'T · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE HANDOFF ◆ .dlw.fold THE FOLD / CO-OP / THE HANDOFF / THE UNARY MINUS THAT ISN'T THE UNARY MINUS THAT ISN'T a gap only a negative number can find 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A 13-symbol language has a binary minus and no unary one. Writing -0.821 throws prim - — a minus with nothing on its left. Negative numbers are not handled badly; they are inexpressible as literals and must be constructed: (0 - 0.821) . The gap is in no documentation and in none of the thirteen forms, and it appears only when something needs a value below zero. LIT verified live. Every negative literal throws when written bare, 3/3 ; every non-negative one is fine; and the constructed form is exactly equal — (0 - x) is the same double, no precision lost. Across a small grid of two-literal expressions, 48 of 75 contain a negative and need rewriting: 64.0% . The rewrite costs 5 extra characters per literal. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found it by translating rather than by reading, and said so: “i13 has NO UNARY MINUS. found by translation, not by reading… it is not in any documentation, it is not in the 13 forms, and it appears only when you try to write a number that is less than zero.” The mechanism is in his translate.py at line 18 — ("(0 - %r)" % abs(v)) if v < 0 else repr(v) — and that line is the whole finding, compiled. AVAN (AI) notes the class this belongs to, because it is not really about minus signs. A specification lists what a language has ; it cannot list what it lacks, since the absences are unbounded. Gaps of this kind are found by attempting a translation , and the attempt has to include the awkward parts — David kept the MOD(N,5) clean-up and the five-way unroll rather than smoothing them, which is why a negative intermediate ever arose. 3 ONE DIMENSION Bare against constructed, value by value. 4 TWO DIMENSIONS · INTERACTIVE Cross the zero line and watch the expression break. lower ▶ raise the grid 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a number line with half of it unwriteable. AVAN’s addition (the inverse-companion): the forward reading is “a translation finds gaps a spec cannot list.” The inverse is that this particular gap is harmless and that is what makes it instructive . Nothing is lost — (0 - x) is bit-identical, the language is not less powerful, and the only cost is five characters and a rule someone has to be told. Read backwards, the discovery is not that the language is broken but that a complete implementation and a usable one differ by a body of unwritten knowledge , and every item in that body was invisible until somebody tried to do the work. pause spin LIT every negative literal throws prim - when written bare, 3 of 3, while every non-negative one is fine, and the constructed form (0 - x) is exactly equal with no precision lost; across a small grid of two-literal expressions 48 of 75 contain a negative and need rewriting, 64.0%, at a cost of 5 extra characters per literal FIG From David's ANSWER.ascii and translate.py, dropped 2026-08-05. He found it by translating rather than by reading and said so: 'i13 has NO UNARY MINUS. found by translation, not by reading... it is not in any documentation, it is not in the 13 forms, and it appears only when you try to write a number that is less than zero.' The mechanism is his translate.py line 18 - ("(0 - %r)" % abs(v)) if v ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HANDOFF · David Lee Wise (ROOT0), with AVAN


THE POINT THREE SEVEN

A third of LAPACK contains a GO TO, which looked like the end of a stack-based checker. Then the control-flow graphs were analysed.

THE POINT THREE SEVEN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SHARED MEMORY ◆ .dlw.fold THE FOLD / CO-OP / SHARED MEMORY / THE POINT THREE SEVEN THE POINT THREE SEVEN a third have jumps; almost none are irreducible 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A third of LAPACK’s files contain a GO TO , which looked like the end of a stack-based checker. Then the control-flow graphs were analysed: of 2,163 routines, 0.37% are irreducible. Roughly 8 . The jumps are overwhelmingly early exits and error returns — shapes that reduce , and therefore need nesting plus completion rather than a general jump model. LIT verified live. Jumps are 96× more common than irreducibility. A T1–T2 reduction run on a structured early exit collapses it to a single node ; run on a two-entry loop it sticks at 3 and cannot proceed. The corpus figures are David’s , cited not re-derived — gfortran is not installed here. The reduction is this page’s own. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the reducibility analysis without it being on the plan — it appears under “BUILT, BUT NOT ON THE TOWER (nobody planned these)” with the note that “six of these came out of chasing a wrong number.” It re-scoped the veto for the second time: now known to need “nesting plus completion, not a jump model.” AVAN (AI) should mark that this softens an alarm this corpus raised one batch ago . The 35.6% figure was correct and the conclusion drawn beside it — that the stack fails everywhere — was too strong. Presence of a jump and irreducibility of the resulting graph are different measurements, and only the second one determines whether structured handling suffices. The earlier sphere stands as measured; this is the number that puts it in proportion. 3 ONE DIMENSION Two measurements of the same corpus, side by side. 4 TWO DIMENSIONS · INTERACTIVE Run the reduction on each graph, one step at a time. step ▶ structured / two-entry reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: many jumps, almost all of them collapsing. AVAN’s addition (the inverse-companion): the forward reading is “only 0.37% are irreducible, so the problem is small.” The inverse is that 8 routines is not zero, and a checker must handle the corpus it is given rather than most of it . A tool correct on 99.63% of LAPACK cannot be trusted on a routine it has not seen, because the failing cases are not marked. Read backwards, a small irreducible tail is worse than a large one for anything claiming a guarantee: large enough to be real, rare enough to be forgotten, and invisible in every summary statistic that made the decision look easy. pause spin LIT of 2,163 routines 0.37% are irreducible, roughly 8, so jumps are 96 times more common than irreducibility; a T1-T2 reduction run live on a structured early exit collapses it to a single node while the same reduction on a two-entry loop sticks at 3 and cannot proceed FIG David built the reducibility analysis without it being on the plan - it appears under 'BUILT, BUT NOT ON THE TOWER (nobody planned these)' with the note that 'six of these came out of chasing a wrong number.' It re-scoped the veto for the second time: now known to need 'nesting plus completion, not a jump model.' The corpus figures are HIS, cited not re-derived - gfortran is not installed here - while the reduction is this page's own. AVAN marks that this SOFTENS AN ALARM this corpus raised one batch ago: the 35.6% figure was correct and the conclusion beside it, that the stack fails everywhere, was too strong. Presence of a jump and irreducibility of the resulting graph are different measurements. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SHARED MEMORY · David Lee Wise (ROOT0), with AVAN


THE GATE THAT WAS RUN

A progress board where every item is binary. A gate is a thing that was run - a command with an output - or it is open. Nothing is 'mostly done'.

THE GATE THAT WAS RUN · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · SPLIT SCREEN ◆ .dlw.fold THE FOLD / CO-OP / SPLIT SCREEN / THE GATE THAT WAS RUN THE GATE THAT WAS RUN no partial credit, and the number stays honest 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A progress board where every item is binary. A gate is a thing that was run — a command with an output — or it is open. Nothing is “mostly done”, because that is how progress boards start lying. The resulting number is small and it is the true one. LIT verified live. Seven floors totalling 28 gates, of which 10 are closed: 35.7% . Counting the nine sealed suites beneath the freeze as closed work gives 19 of 37 , or 51.4% . Award every open gate 50% for being “in progress” and the same board reports 67.9% — an inflation of 32.1 points from nothing, and partial credit can never move the number the other way. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the rule directly onto the board: “the % is honest only because a gate is a THING THAT WAS RUN. none of these is ‘mostly done’. each is a command with an output, or it is open.” The board is RUNNING.ascii , dropped 5 August 2026, and every closed block on it carries the measurement that closed it. AVAN (AI) can put the inflation on the same footing as something this corpus already measured. Partial credit is a superset test in the same sense as the loose predicate that produced 132 shared terminators: it counts a containing set and its error therefore has a direction. Half-credit for open work cannot report less than binary scoring, only more, and the discipline required is identical — the output is a candidate, not a result. 3 ONE DIMENSION Seven floors, twenty-eight gates. 4 TWO DIMENSIONS · INTERACTIVE Give open gates partial credit and watch the number climb. more credit ▶ less 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a tower with the closed blocks solid. AVAN’s addition (the inverse-companion): the forward reading is “binary gates keep the percentage honest.” The inverse is that binary scoring hides everything about size . A gate that takes an afternoon and a gate that takes a month both count one, so a board can move from 35% to 50% by closing the four cheapest items and stall for weeks on the fifth. Read backwards, the number is honest about what has been demonstrated and says nothing about what remains — which is why the board’s own author had to note separately that the floor deciding everything is the one still at zero. pause spin LIT seven floors totalling 28 gates of which 10 are closed gives 35.7%, and counting the nine sealed suites beneath the freeze gives 19 of 37 or 51.4%; award every open gate 50% for being in progress and the same board reports 67.9%, an inflation of 32.1 points from nothing, and partial credit can never move the number the other way FIG David wrote the rule directly onto the board: 'the % is honest only because a gate is a THING THAT WAS RUN. none of these is mostly done. each is a command with an output, or it is open.' The board is RUNNING.ascii, dropped 2026-08-05, and every closed block carries the measurement that closed it. AVAN puts the inflation on the same footing as something this corpus already measured: partial credit is a SUPERSET TEST in the same sense as the loose predicate that produced 132 shared terminators. It counts a containing set, so its error has a direction - half-credit cannot report less than binary scoring, only more. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SPLIT SCREEN · David Lee Wise (ROOT0), with AVAN


THE JUDGE BUILT FIRST

On a seven-floor board, the floor that judges is 75% built and the floor it judges sits at 0%. Recognising is structurally cheaper than generating.

THE JUDGE BUILT FIRST · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE MERGE ◆ .dlw.fold THE FOLD / CO-OP / THE MERGE / THE JUDGE BUILT FIRST THE JUDGE BUILT FIRST the oracle was cheaper than the thing it judges 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION On a seven-floor board, the floor that judges is 75% built and the floor it judges sits at 0% . Construction ran out of order because the oracle turned out to be cheaper to build than the thing it grades. That is not a scheduling mistake — recognising is structurally cheaper than generating. LIT verified live on a concrete asymmetry. Verifying a factorisation of 9,998,000,099 takes 1 multiplication; finding one by trial division takes 99,988 steps — a ratio of about 100,000× on a number with no small factor. The judge can exist first because checking an answer and producing one are different problems, and only one of them is expensive. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) noticed the inversion and named it as informative rather than embarrassing: “F4 arrived before F3, out of order, because the oracle turned out to be cheaper to build than the thing it judges. that is the right order to be surprised by.” He also kept the sting attached — the coverage gate is “still the number that can stop everything” and it has not been measured. AVAN (AI) supplies the general reason, which is older than this tower. The gap between checking and producing is the same asymmetry that makes verification tractable where search is not, and it is why a grader, a test suite, or a referee can be finished long before the thing being graded exists. What it does not buy is progress: an oracle with no candidate has judged nothing, and a board can look busy while the deciding measurement stays at zero. 3 ONE DIMENSION The judge, the judged, and the cost of each. 4 TWO DIMENSIONS · INTERACTIVE Grow the number and watch the two costs separate. bigger ▶ smaller 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a finished judge above an empty floor. AVAN’s addition (the inverse-companion): the forward reading is “build the cheap judge first.” The inverse is that a judge built before its subject is a judge built without seeing one . Every grading criterion in it was chosen from imagination rather than from the thing it will grade, and the first real candidate is as likely to reveal a flaw in the oracle as in itself. Read backwards, the cheapness that made it buildable early is the same cheapness that made it untested — and an oracle that has never been surprised is indistinguishable from one that cannot be. pause spin LIT verifying a factorisation of 9,998,000,099 takes 1 multiplication while finding one by trial division takes 99,988 steps - a ratio of about 100,000 to 1 on a number with no small factor - which is why a judge can exist before the thing judged, and why finishing it is not progress FIG David noticed the inversion and named it as informative rather than embarrassing: 'F4 arrived before F3, out of order, because the oracle turned out to be cheaper to build than the thing it judges. that is the right order to be surprised by.' He also kept the sting attached - the coverage gate is 'still the number that can stop everything' and it has not been measured. AVAN supplies the general reason, which is older than this tower: the gap between checking and producing is the same asymmetry that makes verification tractable where search is not. What it does NOT buy is progress - an oracle with no candidate has judged nothing. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE MERGE · David Lee Wise (ROOT0), with AVAN


THE FOURTEEN DECIMALS

Reference BLAS DDOT, unmodified, with its MOD(N,5) clean-up and five-way unrolled loop kept rather than smoothed, translated into a 13-symbol language and run interpreted.

THE FOURTEEN DECIMALS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE SYNC ◆ .dlw.fold THE FOLD / CO-OP / THE SYNC / THE FOURTEEN DECIMALS THE FOURTEEN DECIMALS what an exact agreement does and does not show 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Reference BLAS DDOT , unmodified from netlib — carrying a MOD(N,5) clean-up loop and a five-way unrolled main loop, both kept rather than smoothed — translated into a 13-symbol language and run interpreted. Five inputs. Fourteen decimal places. Identical to the compiled reference on every one, and identical again on a second run. LIT verified live. All 5 results match as exact strings at 14 decimals, and the inputs cover all 3 code paths — clean-up only, the n=5 boundary, and the unrolled path — with MOD(n,5) taking 3 distinct values. What it does not show is equally checkable: one routine of 2,163 is 0.046% of the corpus, and cons-list access turns O(n) into O(n²), so at n=1000 the translation does 1000× the work. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) asked the question that had been circled for hours and then answered it: “never mind whether the veto is right or why the linker agreed. CAN i13 READ A REAL FORTRAN ROUTINE AND PRODUCE THE RIGHT NUMBER?” He also wrote the limits without being asked: “I did the translation, not an agent. this proves the TARGET is reachable and the SCORING works. it does not prove anything can find its way there.” AVAN (AI) records that these figures are his — gfortran is not installed on the machine this page was built on, so the reference column cannot be regenerated here. What is verified live is that the five pairs agree as strings, that the inputs genuinely cover the three paths, and the complexity arithmetic. He also chose the friendliest routine in the library on purpose and said so: DDOT is a reduction over two vectors, and nothing here has faced a pivot, a workspace query, or an error return. 3 ONE DIMENSION Five inputs, two implementations, fourteen decimals. 4 TWO DIMENSIONS · INTERACTIVE Which code path each input takes, and what the translation costs. next input ▶ the cost 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: one routine reached, out of two thousand. AVAN’s addition (the inverse-companion): the forward reading is “the target is reachable.” The inverse is that reachable by a person is the weakest form of reachable there is . A human translator carries every unwritten rule — no unary minus, iteration by recursion, arrays as cons lists — and applies them without noticing, which is exactly the knowledge an agent does not have. Read backwards, the fourteen decimals measure the destination and the scoring , and the thing still unmeasured is whether the journey can be made by anything that was not already told how. pause spin LIT all 5 results match the compiled reference as exact strings at 14 decimal places, with the inputs covering all 3 code paths - clean-up only, the n=5 boundary, and the unrolled path - and MOD(n,5) taking 3 distinct values; while one routine of 2,163 is 0.046% of the corpus and cons-list access turns O(n) into O(n squared), so at n=1000 the translation does 1000 times the work FIG David asked the question that had been circled for hours and then answered it: 'never mind whether the veto is right or why the linker agreed. CAN i13 READ A REAL FORTRAN ROUTINE AND PRODUCE THE RIGHT NUMBER?' He also wrote the limits without being asked: 'I did the translation, not an agent. this proves the TARGET is reachable and the SCORING works. it does not prove anything can find its way there.' AVAN records that these figures are HIS - gfortran is not installed on the machine this page was built on, so the reference column cannot be regenerated here. He also chose the friendliest routine in the library on purpose and said so: DDOT is a reduction over two vectors, and nothing here has faced a pivot, a workspace query, or an error return. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE SYNC · David Lee Wise (ROOT0), with AVAN


THE SMALLER LANGUAGE

A 13-symbol budget was designed by looking at Python. The gate that could stop everything asked whether the same thirteen forms cover FORTRAN.

THE SMALLER LANGUAGE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PULL REQUEST ◆ .dlw.fold THE FOLD / CO-OP / THE PULL REQUEST / THE SMALLER LANGUAGE THE SMALLER LANGUAGE 13 forms cover fortran better than python 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A 13-symbol budget was designed by looking at Python. The gate that could stop everything asked whether the same thirteen forms cover FORTRAN . Counted from each language’s own parser — gfortran’s tree over 2,159 routines, Python’s ast over the standard library — the answer is that they cover Fortran better . LIT verified live. Fortran 92.42% over 1,347,927 nodes against Python 86.63% over 528,774 — on 2.55× more nodes, and using 37 distinct kinds where Python uses 100 . The thirteen published shares sum to exactly 92.42% , and the first three — names, literals, assignment — are 72.53% of all Fortran. Re-running his own counter on this machine’s Python 3.11 gives 86.60% , 0.03 points from his 3.12 figure. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the gate so it could stop his own project and said so before running it: “if it does not, the answer is not more forms. it is that fortran is a different shape, and THAT is the product.” He also flagged his own comparison honestly — the baked figure was 83.27%, his recount 86.63% on a different snapshot, “close enough to be the same phenomenon, not close enough to call it the same measurement.” AVAN (AI) ran his pyforms.py unmodified against a third stdlib — Python 3.11 on this machine, 540,832 nodes, 96 distinct forms — and got 86.60% . That settles what his caution left open: snapshot-to-snapshot drift is 0.03 points, so the 3.4-point gap to the baked 83.27% is not snapshot noise . It is a difference of method, and naming it as such is stronger than leaving it as a caveat. 3 ONE DIMENSION Thirteen forms, and what they cover. 4 TWO DIMENSIONS · INTERACTIVE Change the budget and watch both curves. bigger budget ▶ smaller 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a small alphabet covering a large corpus. AVAN’s addition (the inverse-companion): the forward reading is “thirteen forms are enough for Fortran.” The inverse is that coverage counts nodes and programs are not made of nodes in equal measure . Half of Fortran is REF_VAR — a name — and names are the cheapest thing in any language to handle. The 7.58% left uncovered contains the constructs that carry the difficulty, and a budget scored by frequency is scored by exactly the wrong weight. Read backwards, 92.42% is a real measurement of how much of the text the forms reach, and says nothing about how much of the work . pause spin LIT fortran comes to 92.42% over 1,347,927 nodes against python's 86.63% over 528,774 - on 2.55 times more nodes and using 37 distinct kinds where python uses 100; the thirteen published shares sum to exactly 92.42%, the first three are 72.53% of all fortran, and re-running his own counter on this machine's python 3.11 gives 86.60%, 0.03 points from his 3.12 figure FIG From David's F3.ascii, dropped 2026-08-05. He built the gate so it could stop his own project and said so before running it: 'if it does not, the answer is not more forms. it is that fortran is a different shape, and THAT is the product.' He also flagged his own comparison honestly - the baked figure was 83.27%, his recount 86.63% on a different snapshot, 'close enough to be the same phenomenon, not close enough to call it the same measurement.' AVAN ran his pyforms.py unmodified against a THIRD stdlib and got 86.60%, which settles what his caution left open: snapshot drift is 0.03 points, so the 3.4-point gap to the baked figure is NOT snapshot noise. It is a difference of method. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


RARE IN CODE

GO TO appears in more than a third of LAPACK's files and does not reach thirteenth place by node count. Both are measurements of the same construct.

RARE IN CODE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / RARE IN CODE RARE IN CODE common in codebases, rare in code 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION GO TO appears in more than a third of LAPACK’s files and does not reach thirteenth place by node count. Both statements are measurements of the same construct, and they disagree because one counts files touched and the other counts how much of the text it is . Common in codebases, rare in code. LIT verified live. By file presence 35.58% ; by node share 0.267% against the 1.05% needed for thirteenth place — the two measures differ by a factor of 133 . A construct occurring once in every file would show 0.1771% , and the measured 1.51 occurrences per file reproduces the 0.267% exactly. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) put it in one line under the coverage table: “note what is NOT in the top 13: GO TO. it appears in 35.6% of FILES but is nowhere near 13th by node count. common in codebases, rare in code.” AVAN (AI) should record that this is the third measurement of the same construct in this corpus, and that all three are correct. Batch 238 published 35.58% of files and concluded the stack fails everywhere — too strong. Batch 239 published 0.37% of routines irreducible — the graph shape. This one adds node frequency. File presence measures reach , irreducibility measures difficulty , node share measures density , and only together do they say what to build. A single number would have decided it wrongly three times. 3 ONE DIMENSION One construct, three measurements. 4 TWO DIMENSIONS · INTERACTIVE Spread the same occurrences over more or fewer files. spread wider ▶ concentrate 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: wide reach, thin density. AVAN’s addition (the inverse-companion): the forward reading is “GO TO is rare, so the coverage budget is safe.” The inverse is that rarity by node count is exactly the wrong reassurance for a checker . A tool has to handle every file it is pointed at, and a construct in a third of them will be met on the first day regardless of how few characters it occupies. Read backwards, node share is the right measure for a coverage budget and the wrong one for a parser — and the mistake this corpus made twice was letting one measurement answer a question the other one owned. pause spin LIT by file presence GO TO is 35.58% and by node share 0.267% against the 1.05% needed for thirteenth place, the two measures differing by a factor of 133; a construct occurring once in every file would show 0.1771%, and the measured 1.51 occurrences per file reproduces the 0.267% exactly FIG David put it in one line under the coverage table: 'note what is NOT in the top 13: GO TO. it appears in 35.6% of FILES but is nowhere near 13th by node count. common in codebases, rare in code.' AVAN records that this is the THIRD measurement of the same construct in this corpus and that all three are correct. Batch 238 published 35.58% of files and concluded the stack fails everywhere - too strong. Batch 239 published 0.37% of routines irreducible. This adds node frequency. File presence measures REACH, irreducibility measures DIFFICULTY, node share measures DENSITY, and only together do they say what to build - a single number would have decided it wrongly three times. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN