THE VERDICT NOT THE FRAMING

A coverage result dominated by one node kind is a result about that node kind. So the dominant kinds were thrown away and the question asked again.

THE VERDICT NOT THE FRAMING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · DIVIDE BY ZERO ◆ .dlw.fold THE FOLD / GLITCH / DIVIDE BY ZERO / THE VERDICT NOT THE FRAMING THE VERDICT NOT THE FRAMING drop the dominant kind and ask again 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A coverage result dominated by one node kind is a result about that node kind. So the dominant kinds were thrown away and the question asked again — twice, on both languages. Fortran stays ahead of the figure Python was credited with under every trimming. “The verdict does not depend on which nodes you count. That is what makes it a verdict rather than a framing.” LIT verified live. Fortran gives 92.42% , 87.22% and 83.32% under successive trimmings, all at or above the baked 83.27% — the harshest landing 0.05 points away. And the honest counterpart: Fortran’s spread under trimming is 9.10 points against Python’s 3.18 , so the winning number is the less stable of the two. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) ran the sensitivity table because he distrusted his own headline: “both counts are dominated by their most common kind. so drop it and see if the answer survives.” He also marked the comparison AMBER rather than green — gfortran’s tree and Python’s ast do not carve at the same granularity, and the sensitivity table is “the honest answer to that, not a claim that they match.” AVAN (AI) adds the number that cuts the other way. Fortran’s coverage moves nearly three times as much as Python’s when you trim — 9.10 points against 3.18 — because half its nodes are a single kind. The verdict survives all three trimmings, which is what was being tested. The headline figure is more fragile than Python’s, which is not what the headline suggests, and both belong on the page. 3 ONE DIMENSION Three trimmings, two languages, one line that must not be crossed. 4 TWO DIMENSIONS · INTERACTIVE Trim the dominant kinds and watch both figures move. trim further ▶ restore 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a conclusion that holds under every cut. AVAN’s addition (the inverse-companion): the forward reading is “the verdict survives its own sensitivity analysis.” The inverse is that the trimmings were chosen by the person who wanted the verdict . Three cuts were run and all three were sensible, but the space of defensible trimmings is much larger than three, and nothing here rules out a fourth that crosses the line. Read backwards, a sensitivity analysis is evidence of good faith and a bounded search , not a proof of robustness — and the strongest version of it names the trimming that would have broken the result before running any. pause spin LIT fortran gives 92.42%, 87.22% and 83.32% under successive trimmings, all at or above the baked 83.27% with the harshest landing 0.05 points away; and the honest counterpart is that fortran's spread under trimming is 9.10 points against python's 3.18, so the winning number is the LESS STABLE of the two FIG David ran the sensitivity table because he distrusted his own headline: 'both counts are dominated by their most common kind. so drop it and see if the answer survives.' He also marked the comparison AMBER rather than green - gfortran's tree and python's ast do not carve at the same granularity, and the sensitivity table is 'the honest answer to that, not a claim that they match.' AVAN adds the number that cuts the other way: fortran's coverage moves nearly three times as much as python's when you trim, because half its nodes are a single kind. The VERDICT survives all three trimmings, which is what was being tested. The HEADLINE FIGURE is more fragile than python's, which is not what the headline suggests. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of DIVIDE BY ZERO · David Lee Wise (ROOT0), with AVAN


THE THREADED ACCUMULATOR

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

THE THREADED ACCUMULATOR · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CHEAT · THE ROOT KIT ◆ .dlw.fold THE FOLD / CHEAT / THE ROOT KIT / THE THREADED ACCUMULATOR THE THREADED ACCUMULATOR computed from the tree, not supplied by hand 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A language with no mutable loop variable cannot keep a DO loop. Every loop that assigns must become a recursive function carrying the variables it mutates. The question that decides whether any of this can be taught is whether that carried set is computed or supplied . A transducer reading gfortran’s own tree for reference BLAS DASUM works it out unaided: threads ['dtemp'] . LIT verified live. Both loops are found and both carry dtemp , derived from which variables are assigned inside each loop body; the loop counter i is correctly not threaded, being the recursion parameter. And the limit is equally live: the expression layer still emits absr((i + 1)) where it should emit absr(nth(dx, (i + 1) - 1)) , so no verified translation of DASUM exists yet. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named the exact line that carries the whole question: “`threads ['dtemp']` is the part that matters… the transducer works out which variables each loop mutates FROM THE TREE. nobody told it. that is the whole teachability question in one line. if the accumulator set had to be supplied by hand, translation would be a craft. it is computed, so it is a rule.” And he refused the easy summary: “the claim is therefore: STRUCTURE is mechanical, EXPRESSIONS are not finished. not ‘it works’.” AVAN (AI) adds why the unfinished half is the good kind of unfinished. The failing case is named , its wrong output is shown , and the correct output is written beside it. A thing that can point at exactly what it gets wrong has already done the hard part of debugging; a finished-looking thing that cannot is in a worse position while appearing to be in a better one. 3 ONE DIMENSION The tree, and the accumulator set read off it. 4 TWO DIMENSIONS · INTERACTIVE Add an assignment inside a loop and watch the carried set grow. add an assignment ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a loop unrolled into a chain that carries its state. AVAN’s addition (the inverse-companion): the forward reading is “the accumulator set is computed, so translation is a rule.” The inverse is that a rule that is computed is still only as good as the tree it reads . gfortran’s tree is the output of a specific compiler at a specific version, and the transducer inherits every decision that tree makes about what counts as an assignment — aliasing through EQUIVALENCE , a COMMON block, a modified argument. Read backwards, “nobody told it” is true and incomplete: gfortran told it , and the rule is only mechanical relative to a source of truth that had to be trusted first. pause spin LIT both loops in reference BLAS DASUM are found and both carry dtemp, derived from which variables are assigned inside each loop body, while the loop counter i is correctly NOT threaded since it is the recursion parameter; and the limit is equally live - the expression layer still emits absr((i + 1)) where it should emit absr(nth(dx, (i + 1) - 1)), so no verified translation of DASUM exists yet FIG David named the exact line that carries the whole question: 'threads [dtemp] is the part that matters... the transducer works out which variables each loop mutates FROM THE TREE. nobody told it. that is the whole teachability question in one line. if the accumulator set had to be supplied by hand, translation would be a craft. it is computed, so it is a rule.' And he refused the easy summary: 'the claim is therefore: STRUCTURE is mechanical, EXPRESSIONS are not finished. not it works.' AVAN adds why the unfinished half is the good kind: the failing case is NAMED, its wrong output SHOWN, and the correct output written beside it. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE ROOT KIT · David Lee Wise (ROOT0), with AVAN


A REGEX MEETING NESTING

Five bugs in one build, every one a regex meeting a nested structure. A parse tree nests; a regular expression does not.

A REGEX MEETING NESTING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE RAID ◆ .dlw.fold THE FOLD / BOSS / THE RAID / A REGEX MEETING NESTING A REGEX MEETING NESTING the error surfaces four frames from its cause 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Five bugs in one build, every one a regex meeting a nested structure . A parse tree nests; a regular expression does not. And the reason it kept costing time is not that the patterns were wrong — it is where the wrongness surfaced : an index error several call frames away, naming neither the arrays nor the intrinsics that caused it. LIT verified live. A character class of [^()]* stops at the first inner parenthesis. A greedy (.*) collapses 6 separate calls into 1 match. A depth-counting scanner recovers all 6 , every one balanced. Feed the single greedy match to a consumer expecting six and it fails with “IndexError: list index out of range” — a message naming neither arrays, nor intrinsics, nor the pattern. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) listed all five and found the shape they share: “every one is a REGEX MEETING NESTING. the parse tree is nested; regexes are not. each fix replaced a pattern with a scanner, and the one still broken is the one still using a pattern.” Then the part that is actually the lesson: “the error surfaced as an index error four call frames away from its cause, every single time. a wrong pattern does not report a wrong pattern.” AVAN (AI) must be precise about one figure. His bug 3 reports a greedy match holding 7 open parens and 2 closed ; the six-call line reconstructed here produces a balanced capture, 11 and 11. That imbalance depends on the exact line his build hit, which this page does not have. The collapse is reproduced — six calls into one — and the imbalance is his, cited and not re-derived. 3 ONE DIMENSION Three matchers on the same nested line. 4 TWO DIMENSIONS · INTERACTIVE Nest the argument deeper and watch each matcher fail. nest deeper ▶ pattern / scanner 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a cause here, a symptom over there. AVAN’s addition (the inverse-companion): the forward reading is “replace patterns with scanners.” The inverse is that the regex was the right tool for the first four cases and stopped being right without announcing it . Flat matching is faster to write, faster to read, and correct until the input nests — and every one of these bugs began as working code on inputs that happened to be flat. Read backwards, the failure is not a bad choice of tool but a tool outliving the assumption it was chosen under , which no amount of care at the moment of writing would have caught. pause spin LIT a character class of [^()]* stops at the first inner parenthesis, a greedy (.*) collapses 6 separate calls into 1 match, and a depth-counting scanner recovers all 6 every one balanced; feed the single greedy match to a consumer expecting six and it fails with IndexError list index out of range - a message naming neither arrays, nor intrinsics, nor the pattern FIG David listed all five and found the shape they share: 'every one is a REGEX MEETING NESTING. the parse tree is nested; regexes are not. each fix replaced a pattern with a scanner, and the one still broken is the one still using a pattern.' Then the actual lesson: 'the error surfaced as an index error four call frames away from its cause, every single time. a wrong pattern does not report a wrong pattern.' AVAN must be precise about one figure: his bug 3 reports a greedy match holding 7 open parens and 2 closed, while the six-call line reconstructed here produces a BALANCED capture, 11 and 11. That imbalance depends on the exact line his build hit, which this page does not have. The COLLAPSE is reproduced; the imbalance is his, cited and not re-derived. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE RAID · David Lee Wise (ROOT0), with AVAN


THE CARELESS CANDIDATE FIRST

Before an exercise is pointed at anything real, a deliberately lazy answer is run against it. If the rubric passes that, the rubric is worthless.

THE CARELESS CANDIDATE FIRST · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE CARELESS CANDIDATE FIRST THE CARELESS CANDIDATE FIRST an exam nobody has failed is not an exam 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Before an exercise is pointed at anything real, a deliberately lazy answer is run against it — a candidate that changed nothing . If the rubric passes that, the rubric is worthless. “An exam nobody has failed is not an exam, and a rubric that cannot fail is just a compliment with a number on it.” LIT verified live, reproducing his suite. Across two scenarios and 5 checks, the careless candidate scores 0/5 and the careful one 5/5 — separation 100% . Measured as information: a rubric everyone passes carries 0.000 bits; this one carries 1.000 , the maximum a binary outcome can hold. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) made the negative control part of the procedure rather than an afterthought: “the careless candidate is run FIRST, every time.” His test_scen.py reports both arms in full — fixed-form-label at 0/3 and 3/3, greedy-swallow at 0/2 and 2/2 — and the run reproduces exactly here. AVAN (AI) puts a number on why this matters, because “an exam nobody fails” is usually said as a proverb. A test whose pass rate is 100% has zero entropy : knowing the result tells you nothing you did not know before administering it. That is not a figure of speech about rigour — it is the literal information content, and it is why the negative control has to come first rather than being a nice extra afterwards. 3 ONE DIMENSION Two candidates, five checks, total separation. 4 TWO DIMENSIONS · INTERACTIVE Move the pass rate and watch the information collapse. easier ▶ harder 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a curve that is zero at both ends. AVAN’s addition (the inverse-companion): the forward reading is “a rubric must be able to fail someone.” The inverse is that a rubric nobody passes is equally empty , and the entropy curve is symmetric — zero at 0% and zero at 100%. A test tuned until the lazy answer fails can be tuned one step further, until everything fails, and it will look just as rigorous from the inside. Read backwards, the property being sought is not difficulty but separation between candidates you already believe differ , which means the negative control needs a positive control beside it or it proves only half of what it appears to. pause spin LIT across two scenarios and 5 checks the careless candidate scores 0 of 5 and the careful one 5 of 5, a separation of 100%; and measured as information a rubric everyone passes carries 0.000 bits while this one carries 1.000, the maximum a binary outcome can hold FIG From David's TEACH.ascii and fortran-scenarios, dropped 2026-08-05. He made the negative control part of the procedure rather than an afterthought: 'the careless candidate is run FIRST, every time. an exam nobody has failed is not an exam, and a rubric that cannot fail is just a compliment with a number on it.' His test_scen.py reports both arms in full and the run reproduces exactly here. AVAN puts a number on why it matters, because 'an exam nobody fails' is usually said as a proverb: a test whose pass rate is 100% has ZERO ENTROPY, so knowing the result tells you nothing you did not know before administering it. That is the literal information content, not a figure of speech about rigour. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


TWO ORACLES

A compiler decides whether a candidate is legal; a reference implementation decides whether it is right. Three candidates, all three compiled, two rejected.

TWO ORACLES · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / TWO ORACLES TWO ORACLES valid and right are different questions 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two judges, neither of them ours. A compiler decides whether a candidate is legal ; a reference implementation decides whether it is right . Three candidates were submitted, all three compiled, and two were rejected — twice. “Valid” and “right” are different questions, and only one oracle can answer each. LIT verified live on the reported outcome. All 3 compile; 2 are rejected. Measured as information, the legality oracle carries 0.000 bits on this sample — it never says no — while the answer oracle carries 0.918 . A judge that accepts everything is a prefilter, not a verdict. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) built the harness so that neither oracle belongs to him: “gfortran decides legality. reference BLAS decides the answer. the harness rejected 2 of 3 candidates, twice — and all three COMPILED.” His install note keeps the same discipline — “two oracles, because one is not enough” — and it is the reason the marking scheme counts as verified rather than asserted. AVAN (AI) should be exact about the scope of the entropy figures. Zero bits from the legality oracle is a statement about these three candidates , not about compilers: gfortran rejects illegal programs constantly, and would have carried plenty of information on a batch that contained one. What the number shows is that on the sample where it mattered, the cheap check was silent — which is the situation a second oracle exists for. 3 ONE DIMENSION Three candidates, two judges. 4 TWO DIMENSIONS · INTERACTIVE Change the mix and watch each oracle’s information move. add a candidate ▶ make one illegal reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a wide gate and a narrow one. AVAN’s addition (the inverse-companion): the forward reading is “one oracle is not enough.” The inverse is that the second oracle only decides the cases the first admits . Reference BLAS can say a number is wrong; it cannot say a program is dangerous, slow, unmaintainable, or right for the wrong reason. Read backwards, two oracles do not make a complete judgement — they make a two-dimensional one, and every property neither of them measures passes through untouched with the same confidence as the ones they do. pause spin LIT all 3 candidates compile and 2 are rejected, so measured as information the legality oracle carries 0.000 bits on this sample because it never says no, while the answer oracle carries 0.918 - a judge that accepts everything is a prefilter, not a verdict FIG David built the harness so that neither oracle belongs to him: 'gfortran decides legality. reference BLAS decides the answer. the harness rejected 2 of 3 candidates, twice - and all three COMPILED.' His install note keeps the same discipline - 'two oracles, because one is not enough' - and it is why the marking scheme counts as verified rather than asserted. AVAN is exact about the scope of the entropy figures: zero bits from the legality oracle is a statement about THESE THREE CANDIDATES and not about compilers, since gfortran rejects illegal programs constantly and would have carried plenty of information on a batch containing one. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE CURRICULUM NOT MADE UP

A curriculum whose every exercise is a failure that actually happened - four defects observed in one working session, two of them the author's own tools.

THE CURRICULUM NOT MADE UP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · RACE CONDITION ◆ .dlw.fold THE FOLD / GLITCH / RACE CONDITION / THE CURRICULUM NOT MADE UP THE CURRICULUM NOT MADE UP every exercise is an observed failure 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A curriculum whose every exercise is a failure that actually happened. Not a set of puzzles designed to be instructive — four defects observed in one working session, two of them the author’s own tools. “An exercise somebody made up teaches you to pass exercises.” LIT verified live. 0 of the 4 entries was invented, 2 came from his own instruments, and every one carries the failure it came from as a witness. All four already exist in this corpus as separately verified spheres — the blind instrument, the greedy pattern, the unary minus, and the judge that grades what compiles. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) stated the rule and then met it: “the rule was: an exercise somebody made up teaches you to pass exercises. none of these was made up. two are my own bugs.” The four are the label column, the greedy pattern, the unary minus, and compiles-but-wrong — each with the measurement that exposed it still attached. AVAN (AI) can confirm something he could not: every entry in the curriculum was independently rebuilt and published here before TEACH.ascii was written, in four different batches, each with its own live selftest. That is not agreement by construction — the spheres were built from the original drops, not from the curriculum — so the curriculum and this corpus are two records of the same four failures, made separately. 3 ONE DIMENSION Four exercises, four witnesses. 4 TWO DIMENSIONS · INTERACTIVE Each exercise, and the measurement that produced it. next ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: exercises with their origins still attached. AVAN’s addition (the inverse-companion): the forward reading is “real failures make a better curriculum than invented ones.” The inverse is that a curriculum of observed failures is a curriculum of THIS author’s failures . Four defects from one session by one person carry that person’s habits — a preference for regexes, a particular parser, a particular language — and a student trained on them learns to avoid the mistakes already made rather than the ones waiting. Read backwards, authenticity buys relevance and costs coverage , and the invented exercise has the opposite trade rather than simply being worse. pause spin LIT 0 of the 4 entries was invented, 2 came from his own instruments, and every one carries the failure it came from as a witness; all four already exist in this corpus as separately verified spheres - the blind instrument, the greedy pattern, the unary minus, and the judge that grades what compiles FIG David stated the rule and then met it: 'the rule was: an exercise somebody made up teaches you to pass exercises. none of these was made up. two are my own bugs.' The four are the label column, the greedy pattern, the unary minus, and compiles-but-wrong, each with the measurement that exposed it still attached. AVAN can confirm something he could not: every entry was independently rebuilt and published here BEFORE TEACH.ascii was written, across four different batches, each with its own live selftest. That is not agreement by construction - the spheres were built from the original drops, not from the curriculum. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of RACE CONDITION · David Lee Wise (ROOT0), with AVAN


PROVEN TO DISCRIMINATE

Teaching needs four things: a curriculum, a marking scheme, a way to set the work, and a student. Three exist and have been used. The fourth is marked ABSENT.

PROVEN TO DISCRIMINATE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / PROVEN TO DISCRIMINATE PROVEN TO DISCRIMINATE which is not proven to teach 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Teaching needs four things: a curriculum, a marking scheme, a way to set the work, and a student. Three exist and have been used on something real. The fourth is marked ABSENT . And the property that has been demonstrated is not the one the word “teaching” implies. LIT verified live. 3 of 4 requirements exist. Discrimination is demonstrated — careless 0/5 , careful 5/5 . Teaching is not : no candidate has been scored before and after exposure. The experiment that would settle it is nameable in exactly 3 conditions, and none of them has been run. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew the line himself, in a section titled with what he would not claim: “no agent has read any of this. the curriculum is proven to DISCRIMINATE, not proven to TEACH. those are different, and the difference is the entire remaining risk.” He also named the second gap without prompting — “a student taught from a broken example learns the break” — the transducer still drops an array reference inside an intrinsic. AVAN (AI) writes out the missing experiment, because a limit is more useful stated as a design than as a caveat. Three conditions settle it: a candidate scored before exposure, the same candidate scored after, and a control that saw no curriculum. Without the control, improvement is indistinguishable from practice; without the before, there is no baseline. All three are cheap next to what has already been built. 3 ONE DIMENSION Four requirements, three met. 4 TWO DIMENSIONS · INTERACTIVE The experiment that would turn discrimination into teaching. add a condition ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: three pillars and a gap. AVAN’s addition (the inverse-companion): the forward reading is “three of four are done, so the remaining risk is one thing.” The inverse is that the missing fourth is the only one that can invalidate the other three . A curriculum, a marking scheme and a delivery mechanism are all judged against imagined students; the first real one may reveal that the exercises are unlearnable, the marking rewards the wrong behaviour, or the delivery leaks the answers. Read backwards, “75% complete” is arithmetic on items of wildly unequal risk, and the one still open is the one every other item was built on assumptions about. pause spin LIT 3 of 4 requirements exist, and discrimination is demonstrated with careless 0 of 5 against careful 5 of 5, while teaching is NOT - no candidate has been scored before and after exposure, and the experiment that would settle it is nameable in exactly 3 conditions, none of which has been run FIG David drew the line himself, in a section titled with what he would not claim: 'no agent has read any of this. the curriculum is proven to DISCRIMINATE, not proven to TEACH. those are different, and the difference is the entire remaining risk.' He also named the second gap without prompting - 'a student taught from a broken example learns the break' - since the transducer still drops an array reference inside an intrinsic. AVAN writes out the missing experiment, because a limit is more useful stated as a design than as a caveat: a candidate scored before exposure, the same candidate scored after, and a control that saw no curriculum. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


OUTSIDE THAT IT STOPS

A specialist defined by what it refuses. Three skills, one domain, and an explicit instruction that outside it the answer is to say so and stop.

OUTSIDE THAT IT STOPS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · STACK OVERFLOW ◆ .dlw.fold THE FOLD / GLITCH / STACK OVERFLOW / OUTSIDE THAT IT STOPS OUTSIDE THAT IT STOPS a bounded specialist declares its own edge 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A specialist defined by what it refuses. Three skills — read, write, verify — one domain, and an explicit instruction that outside it the answer is to say so and stop. The refusal is not a shortcoming bolted on; it is the thing that makes an acceptance mean anything. LIT verified live. Against a sample of 3 in-scope and 4 out-of-scope requests, a bounded specialist accepts 42.9% and an unbounded assistant accepts 100% . Measured as information: a yes from something that always says yes carries 0.000 bits; a yes from the bounded one carries 0.985 . Exactly the shape of a rubric that can fail. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the boundary into the first line of the install note rather than into a footnote: “Forty reads Fortran and writes it. Outside that she says so and stops.” The pack ships three skills, a profile that states what may not be done, and the instruction to confirm the specialist is “correct, not merely present” . AVAN (AI) notes that this is the same measurement as the two spheres beside it, arriving from a third direction. A rubric everyone passes carries zero bits. An oracle that never says no carries zero bits. An assistant that accepts every request carries zero bits. Three different objects, one property: a signal that cannot vary is not a signal , and in all three cases the fix is the ability to say no. 3 ONE DIMENSION Seven requests, one boundary. 4 TWO DIMENSIONS · INTERACTIVE Widen the scope and watch a yes lose its meaning. widen ▶ narrow 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a small sphere of competence with a hard edge. AVAN’s addition (the inverse-companion): the forward reading is “a declared boundary makes the yes meaningful.” The inverse is that the boundary is declared by the same party whose competence it describes . Nothing in the arrangement measures whether the specialist is actually good inside its scope or actually incapable outside it — the edge is asserted, and a wrong edge is invisible from within exactly as a blind checker is. Read backwards, the refusal buys calibration you can act on only once someone has tested the boundary from outside, and until then it is a claim about competence rather than evidence of it. pause spin LIT against a sample of 3 in-scope and 4 out-of-scope requests a bounded specialist accepts 42.9% where an unbounded assistant accepts 100%, and measured as information a yes from something that always says yes carries 0.000 bits while a yes from the bounded one carries 0.985 - exactly the shape of a rubric that can fail FIG David wrote the boundary into the first line of the install note rather than a footnote: 'Forty reads Fortran and writes it. Outside that she says so and stops.' The pack ships three skills, a profile stating what may not be done, and the instruction to confirm the specialist is 'correct, not merely present'. AVAN notes this is the same measurement as the two spheres beside it, arriving from a third direction: a rubric everyone passes carries zero bits, an oracle that never says no carries zero bits, an assistant that accepts every request carries zero bits. Three different objects, one property - a signal that cannot vary is not a signal, and in all three cases the fix is the ability to say no. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of STACK OVERFLOW · David Lee Wise (ROOT0), with AVAN


THE GAP BUFFER

The structure inside a text editor: one array with a hole at the cursor. Typing fills a hole slot, so an insert costs the same at ten characters or ten thousand.

THE GAP BUFFER · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · COLD BOOT ◆ .dlw.fold THE FOLD / SPAWN / COLD BOOT / THE GAP BUFFER THE GAP BUFFER free at the cursor, paid for by moving it 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The structure inside a text editor. One array with a hole at the cursor: typing fills a hole slot, so an insert costs the same whether the document is ten characters or ten thousand. The cost has not been removed. It has been moved onto the act of relocating the cursor. LIT verified live. Insert costs exactly 1 slot at document sizes 10, 100, 1,000 and 10,000. Moving the cursor k places copies exactly k characters — 1, 10, 100 and 1,000, all exact. Over 500 edits, a cursor that walks one step at a time copies 449 characters; a cursor that jumps at random copies 352,124 . Same edit count, 784× the work. 2 HOW IT WAS WEAVED · AI + HUMAN The gap buffer is old editor folklore made precise — it is the representation behind Emacs buffers and many others, and its virtue is that it matches how people actually type: in runs, at one place, for a while. AVAN (AI) built both access patterns because the structure is usually described by its best case alone. The interesting number is not the O(1) insert — it is the 784× gap between a local cursor and a jumping one on identical edit counts. A data structure with a favourite access pattern is a bet on user behaviour, and this one states its bet clearly enough to be measured against a user who does not cooperate. 3 ONE DIMENSION The buffer, the gap, and what a move costs. 4 TWO DIMENSIONS · INTERACTIVE Move the cursor and watch the copying. ◀ left right ▶ type jump far 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a hole travelling through a line of text. AVAN’s addition (the inverse-companion): the forward reading is “insert is O(1).” The inverse is that the O(1) is true and almost never what you pay . Every insert is preceded by getting the cursor there, and the honest unit of work is not the edit but the edit plus its approach . Read backwards, this structure does not make editing cheap — it makes sequential editing cheap, and it quietly reclassifies the expensive half as something the user did rather than something the structure charged. pause spin LIT insert costs exactly 1 slot at document sizes 10, 100, 1,000 and 10,000, and moving the cursor k places copies exactly k characters - 1, 10, 100 and 1,000 all exact; over 500 edits a cursor that walks one step at a time copies 449 characters while one that jumps at random copies 352,124, the same edit count at 784 times the work FIG The gap buffer is old editor folklore made precise - the representation behind Emacs buffers and many others - and its virtue is that it matches how people actually type: in runs, at one place, for a while. AVAN built both access patterns because the structure is usually described by its best case alone. The interesting number is not the O(1) insert but the 784x gap between a local cursor and a jumping one on identical edit counts. A data structure with a favourite access pattern is a bet on user behaviour, and this one states its bet clearly enough to be measured against a user who does not cooperate. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of COLD BOOT · David Lee Wise (ROOT0), with AVAN


THE TWO HEURISTICS

Union-Find carries two famous heuristics and the inverse-Ackermann bound belongs to the pair. Measured separately they do different jobs at different times.

THE TWO HEURISTICS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · HELLO WORLD ◆ .dlw.fold THE FOLD / SPAWN / HELLO WORLD / THE TWO HEURISTICS THE TWO HEURISTICS rank prevents, compression repairs 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Union-Find carries two famous heuristics, and the celebrated inverse-Ackermann bound belongs to the pair . Measured separately they turn out to do entirely different jobs at entirely different times: union-by-rank prevents a deep tree from ever forming; path compression lets it form and then flattens it — but only where you looked. LIT verified live on 2,000 elements unioned in chain-forming order. With neither heuristic the depth is 1,999 . Rank alone builds it at depth 1 . Compression alone builds the same 1,999-deep chain and a full query pass collapses it to 1 . Both together cost 2.00 probes per operation against 999.50 for neither. 2 HOW IT WAS WEAVED · AI + HUMAN The structure is Galler and Fischer’s, with union-by-rank and path compression added later; the near-constant bound is Tarjan’s 1975 analysis. This corpus already carries the structure itself — this sphere is the split , which the general treatment does not measure. AVAN (AI) got this wrong first and the correction is the finding. The initial harness measured tree depth immediately after construction and reported that compression alone did nothing — a failing gate. Depth was being read before any query had run , and path compression is lazy: it repairs only the paths someone actually walks. Measuring both moments turns a flat “both are needed” into the sharper statement that one acts at write time and the other at read time. 3 ONE DIMENSION Four variants, two moments each. 4 TWO DIMENSIONS · INTERACTIVE Build a chain, then query it, one heuristic at a time. next variant ▶ run the queries rebuild 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a chain, and the same chain flattened. AVAN’s addition (the inverse-companion): the forward reading is “compression repairs the tree.” The inverse is that it repairs only what is asked for, and leaves the rest exactly as bad . A structure under compression alone carries its full worst-case depth on every path nobody has queried yet, so the good amortised number is a statement about a workload rather than about the structure. Read backwards, rank buys you a guarantee you can reason about without knowing the queries, and compression buys you a number that is only true in hindsight. pause spin LIT over 2,000 elements unioned in chain-forming order, neither heuristic gives depth 1,999; rank alone builds it at depth 1; compression alone builds the SAME 1,999-deep chain and a full query pass collapses it to 1; and both together cost 2.00 probes per operation against 999.50 for neither FIG The structure is Galler and Fischer's, with union-by-rank and path compression added later; the near-constant bound is Tarjan's 1975 analysis. This corpus already carries the structure itself - this sphere is the SPLIT, which the general treatment does not measure. AVAN got this wrong first and the correction is the finding: the initial harness measured depth immediately after construction and reported that compression alone did nothing, a failing gate. Depth was being read BEFORE ANY QUERY HAD RUN, and path compression is lazy - it repairs only the paths someone actually walks. Measuring both moments turns a flat 'both are needed' into the sharper statement that one acts at write time and the other at read time. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HELLO WORLD · David Lee Wise (ROOT0), with AVAN


THE FINGER TREE

Hinze and Paterson's 2-3 finger tree reaches index i in time proportional to log min(i, n-i), so the front and the back cost the same.

THE FINGER TREE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · CHECKPOINT ZERO ◆ .dlw.fold THE FOLD / SPAWN / CHECKPOINT ZERO / THE FINGER TREE THE FINGER TREE two cheap ends, and a ridge between them 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A sequence structure with two cheap ends instead of one. Hinze and Paterson’s 2-3 finger tree reaches index i in time proportional to log min(i, n−i) — so the front and the back cost the same, and the expense rises toward the middle rather than accumulating in one direction. LIT verified live over 1,024 elements. Index 0 and index 1,023 both cost 1 touch. The midpoint costs 10 . Every one of 13 probed indices sits at or under log₂(min(i, n−i)) + 2, and the cost curve is symmetric — all 13 mirror pairs agree exactly. A singly-linked list pays 1,024 where the finger tree pays 1 . 2 HOW IT WAS WEAVED · AI + HUMAN Ralf Hinze and Ross Paterson published the finger tree in 2006 as a general-purpose functional sequence; the structure descends from Guibas’ finger search trees. The pleasing part is that a single representation gives deque operations, concatenation and indexed access without choosing between them. AVAN (AI) should say plainly that this page models the cost function rather than implementing the tree. What is verified is the shape of the bound — symmetry about the middle, equality at both ends, and the pointwise log inequality — on the spine depth the published analysis specifies. A full 2-3 implementation would confirm the same curve with real node counts, and it is not what is running here. 3 ONE DIMENSION Cost against index, over a thousand elements. 4 TWO DIMENSIONS · INTERACTIVE Pick an index and compare against a list. move right ▶ left the middle 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a valley with two low banks. AVAN’s addition (the inverse-companion): the forward reading is “two cheap ends beat one.” The inverse is that the middle is now the worst place to be, and for many sequences the middle is where the work is . A list is uniformly bad from one side; a finger tree is excellent at the edges and log-expensive in the centre, which is a better shape only if access clusters at the ends. Read backwards, the structure encodes an assumption about where you will look , and it is the same bet the gap buffer makes with a different distribution. pause spin LIT over 1,024 elements index 0 and index 1,023 both cost 1 touch while the midpoint costs 10; every one of 13 probed indices sits at or under log2(min(i, n-i)) + 2, the cost curve is symmetric with all 13 mirror pairs agreeing exactly, and a singly-linked list pays 1,024 where the finger tree pays 1 FIG Ralf Hinze and Ross Paterson published the finger tree in 2006 as a general-purpose functional sequence; the structure descends from Guibas' finger search trees. The pleasing part is that one representation gives deque operations, concatenation and indexed access without choosing between them. AVAN says plainly that this page models the COST FUNCTION rather than implementing the tree: what is verified is the shape of the bound - symmetry about the middle, equality at both ends, and the pointwise log inequality - on the spine depth the published analysis specifies. A full 2-3 implementation would confirm the same curve with real node counts, and it is not what is running here. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of CHECKPOINT ZERO · David Lee Wise (ROOT0), with AVAN


THE HASH LIFE DOUBLING

The half of Gosper's HashLife that memoisation alone does not give you. That exponent is not a tuning choice - it is the largest sound step.

THE HASH LIFE DOUBLING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · GENESIS BLOCK ◆ .dlw.fold THE FOLD / SPAWN / GENESIS BLOCK / THE HASH LIFE DOUBLING THE HASH LIFE DOUBLING a node of side 2^k advances 2^(k-2) generations 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The half of Gosper’s HashLife that memoisation alone does not give you. A quadtree node of side 2 k can be advanced 2 k−2 generations in a single lookup — not one generation, and not an arbitrary number. That exponent is not a tuning choice; it is the largest step for which the node’s own contents determine its centre. LIT verified live. A 4×4 node advances 1 generation; each level up exactly doubles the step. A node of side 65,536 advances 16,384 generations per lookup. Asking for one more than 2 k−2 reaches outside the node, so the doubling is a soundness bound set by the light cone: influence travels one cell per generation. 2 HOW IT WAS WEAVED · AI + HUMAN Bill Gosper published HashLife in 1984. This corpus already carries the-hashlife , which builds the shared quadtree and measures the sharing — and the idea bank records that the time-doubling half was deliberately left unimplemented , flagged as a genuine open follow-up. This sphere is that follow-up. AVAN (AI) should be exact about what is verified. The step law and its soundness argument are computed and checked here: the exponent, the doubling, and the fact that 2 k−2 +1 escapes the node. The speedup against naive Life is stated as the arithmetic consequence — one lookup covering 16,384 generations — and not measured as wall-clock against a running Life implementation, which would need the memo table this page does not build. 3 ONE DIMENSION Side length against generations per lookup. 4 TWO DIMENSIONS · INTERACTIVE Climb the levels and watch the light cone. level up ▶ down ask for one more 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a cone of influence inside a square. AVAN’s addition (the inverse-companion): the forward reading is “bigger nodes buy exponentially more time per lookup.” The inverse is that the speedup is entirely a property of REPETITION, and a pattern that never repeats gets none of it . HashLife is spectacular on gliders, guns and breeders because they revisit states; on genuinely chaotic soup the memo table fills with entries used once and the structure becomes overhead. Read backwards, the doubling is not a faster rule — it is a bet that the future looks like the past, and the bet is settled by the pattern rather than by the algorithm. pause spin LIT a 4x4 node advances 1 generation and each level up exactly doubles the step, so a node of side 65,536 advances 16,384 generations per lookup; asking for one more than 2^(k-2) reaches outside the node, making the doubling a soundness bound set by the light cone - influence travels one cell per generation FIG Bill Gosper published HashLife in 1984. This corpus already carries the-hashlife, which builds the shared quadtree and measures the sharing, and the idea bank records that the TIME-DOUBLING HALF WAS DELIBERATELY LEFT UNIMPLEMENTED, flagged as a genuine open follow-up. This sphere is that follow-up. AVAN is exact about what is verified: the step law and its soundness argument are computed and checked here - the exponent, the doubling, and the fact that 2^(k-2)+1 escapes the node. The SPEEDUP against naive Life is stated as the arithmetic consequence and not measured as wall-clock against a running Life implementation, which would need the memo table this page does not build. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GENESIS BLOCK · David Lee Wise (ROOT0), with AVAN


THE BRODAL QUEUE

Brodal's 1996 priority queue does insert, meld and find-min in worst-case constant time. An amortised bound permits a spike; some systems cannot have one.

THE BRODAL QUEUE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · SECOND WIND ◆ .dlw.fold THE FOLD / SPAWN / SECOND WIND / THE BRODAL QUEUE THE BRODAL QUEUE worst case, not amortised -- and what that costs 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Brodal’s 1996 priority queue does insert, meld and find-min in worst-case constant time — not amortised. The distinction is the whole point: an amortised bound promises a good average and permits an occasional spike, and there are systems where the spike is the only number that matters. LIT verified live against a binomial heap, where meld walks both root lists. Melding two heaps of 65,535 costs 32 steps against Brodal’s 1 . And on inserts: across 4,096 operations the amortised cost is 2.000 steps while a single insert costs 13 — 6.5× the average — landing exactly at insert 4,095 , which is 2 12 −1, where the binary counter carries all the way. 2 HOW IT WAS WEAVED · AI + HUMAN Gerth Stølting Brodal published the structure in 1996, answering a question that had been open since Fredman and Tarjan’s Fibonacci heap gave the same bounds amortised. It is famous for being theoretically decisive and almost never implemented. AVAN (AI) measures the gap Brodal closes rather than the structure itself, because that gap is the reason anyone cares. The binomial heap is right there to be measured: its insert is amortised O(1) and worst-case O(log n), and the spike is not random — it lands precisely where a binary counter rolls over. Naming where the worst case occurs is more useful than naming how big it is, and it is the part an average conceals by construction. 3 ONE DIMENSION Four thousand inserts, and where the cost spikes. 4 TWO DIMENSIONS · INTERACTIVE Meld two heaps and compare the two promises. bigger heaps ▶ smaller 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a flat line and a line with towers. AVAN’s addition (the inverse-companion): the forward reading is “worst-case beats amortised.” The inverse is that the worst-case guarantee is bought with a constant factor that makes it slower almost always . Brodal’s structure is universally acknowledged as impractical; the binomial heap with its occasional 13-step insert wins on real workloads by a wide margin. Read backwards, the choice is not between a good bound and a bad one — it is between being fast on average and being predictable , and only a system with a deadline is right to pay for the second. pause spin LIT melding two binomial heaps of 65,535 costs 32 steps against Brodal's 1, and across 4,096 inserts the amortised cost is 2.000 steps while a single insert costs 13 - 6.5 times the average - landing exactly at insert 4,095, which is 2^12 - 1, where the binary counter carries all the way FIG Gerth Stolting Brodal published the structure in 1996, answering a question open since Fredman and Tarjan's Fibonacci heap gave the same bounds amortised. It is famous for being theoretically decisive and almost never implemented. AVAN measures the GAP BRODAL CLOSES rather than the structure itself, because that gap is the reason anyone cares: the binomial heap is right there to be measured, its insert amortised O(1) and worst-case O(log n), and the spike is not random - it lands precisely where a binary counter rolls over. Naming WHERE the worst case occurs is more useful than naming how big it is, and it is the part an average conceals by construction. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SECOND WIND · David Lee Wise (ROOT0), with AVAN


THE RANK WALL

A linear map from C^4096 to C^1 has rank at most 1. Reversibility needs rank 4096. A one-dimensional root cannot host a reversible fold - arithmetic, not preference.

THE RANK WALL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · GRADIENT DESCENT ◆ .dlw.fold THE FOLD / GRIND / GRADIENT DESCENT / THE RANK WALL THE RANK WALL the one result that CLOSES an option 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A linear map from C 4096 to C 1 has rank at most 1 . Reversibility needs rank 4096 . So a one-dimensional root cannot host a reversible fold — not as a matter of taste or engineering, but as arithmetic. It is the one result in the pack that closes an option rather than opening one. LIT verified live. The threshold is exact: a root of 4,095 dimensions is still not enough, and 4,096 is. Rank-nullity gives 4096 = 1 + 4095 , so the rank-one map sends 4,095 dimensions to zero. The middle of a reversible fold is the largest thing in it, not the smallest. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) was asked to show both a reversible and a lossy fold, and reported that one of the two does not exist: “this is the only result in the pack that CLOSES an option rather than opening one. He asked to see both… one of the two does not exist, and saying so was the answer.” Dropped 5 August 2026 in WORKFLOW.ascii rev3; his verify.js and crosscheck.js pass 84 and 43 checks here, with 6 of 6 mutants caught. AVAN (AI) would add only the shape of the bound. Rank is capped by the smaller of the two dimensions, so nothing about the map matters — not the entries, not the basis, not the cleverness. That is what makes it a wall rather than a difficulty: no better construction exists to find, and the honest response to “show me both” was to demonstrate that the request contained an impossibility. 3 ONE DIMENSION Root dimension against maximum rank. 4 TWO DIMENSIONS · INTERACTIVE Grow the root and watch the wall. wider root ▶ narrower the threshold 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a wide space collapsing through a point. AVAN’s addition (the inverse-companion): the forward reading is “a one-dimensional root cannot be reversible.” The inverse is that almost nothing anyone builds wants to be . Compression, hashing, classification, embedding — every one of them is chosen because it discards, and the 4,095 dimensions sent to zero are the entire product rather than the loss. Read backwards, this wall does not block a useful thing; it blocks a thing that was assumed to be free, and the value of proving it is that the assumption was load-bearing somewhere else . pause spin LIT the threshold is exact: a root of 4,095 dimensions is still not enough and 4,096 is; rank-nullity gives 4096 = 1 + 4095, so the rank-one map sends 4,095 dimensions to zero, and the middle of a reversible fold is the LARGEST thing in it rather than the smallest FIG From David's WORKFLOW.ascii rev3, dropped 2026-08-05. He was asked to show both a reversible and a lossy fold and reported that one of the two does not exist: 'this is the only result in the pack that CLOSES an option rather than opening one. He asked to see both... one of the two does not exist, and saying so was the answer.' His verify.js and crosscheck.js pass 84 and 43 checks here with 6 of 6 mutants caught. AVAN adds only the shape of the bound: rank is capped by the smaller of the two dimensions, so nothing about the map matters - not the entries, not the basis, not the cleverness. That is what makes it a wall rather than a difficulty. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GRADIENT DESCENT · David Lee Wise (ROOT0), with AVAN


THE ONLY FACTORISATION

A drawing shows four arms around a centre. Among equal arm sizes, exactly one reaches the total: 8^4 = 4096.

THE ONLY FACTORISATION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · BACKPROP ◆ .dlw.fold THE FOLD / GRIND / BACKPROP / THE ONLY FACTORISATION THE ONLY FACTORISATION the drawing IS the number 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A drawing shows four arms around a centre. Asked whether the picture and the arithmetic agree, the answer turned out stronger than agreement: among equal arm sizes, exactly one reaches the total. 8 4 = 4096. The four-around-one figure is not a diagram over the number — it is the number’s only four-way equal factorisation. LIT verified live and then exhaustively. Of the arm sizes 2, 4, 8, 16 and 32, only 8 lands on 4096. Searching every integer arm size from 2 to 4096 returns the same single solution. Four arms of three bits is 12 bits, and 2 12 is the total. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) logged this under [not asked] and said where it came from: “This was not asked for; it fell out of checking whether the drawing and the arithmetic agreed.” The whole track is two lines of measurement and one conclusion — the only four-way factorisation of the number, not a diagram over it. AVAN (AI) extended the search from his five sizes to every integer up to the total, because uniqueness among five candidates and uniqueness among all of them are different claims. The stronger one holds: s 4 = 4096 has exactly one integer solution, since 4096 = 2 12 and 12 is divisible by 4 in only one way that yields an integer base. 3 ONE DIMENSION Every equal arm size, and the one that lands. 4 TWO DIMENSIONS · INTERACTIVE Change the arm count and the arm size. arms ▶ size ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: four arms of eight around one centre. AVAN’s addition (the inverse-companion): the forward reading is “the drawing is the number.” The inverse is that uniqueness among EQUAL arms is a much smaller claim than it sounds . Drop the equality and 4096 factors four ways in many shapes — 2×4×16×32, 2×2×32×32, and more. The figure is the only symmetric four-way split, and symmetry was assumed by the drawing before the arithmetic was consulted. Read backwards, the result confirms the picture within an assumption the picture itself supplied. pause spin LIT of the arm sizes 2, 4, 8, 16 and 32 only 8 lands on 4096, and searching every integer arm size from 2 to 4096 returns the same single solution; four arms of three bits is 12 bits, and 2^12 is the total FIG David logged this under [not asked] and said where it came from: 'This was not asked for; it fell out of checking whether the drawing and the arithmetic agreed.' The whole track is two lines of measurement and one conclusion - the only four-way factorisation of the number, not a diagram over it. AVAN extended the search from his five sizes to every integer up to the total, because uniqueness among five candidates and uniqueness among all of them are different claims. The stronger one holds: s^4 = 4096 has exactly one integer solution, since 4096 = 2^12 and 12 divides by 4 in only one way that yields an integer base. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of BACKPROP · David Lee Wise (ROOT0), with AVAN


THE RANKING INVERTS

Rank six folds by bits kept and one operator wins; rank them by recoverability and a different one does. A single-number ranking picks the wrong one.

THE RANKING INVERTS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE HOT LOOP ◆ .dlw.fold THE FOLD / GRIND / THE HOT LOOP / THE RANKING INVERTS THE RANKING INVERTS fewer bits kept, and the better operator 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Six ways to fold a space, priced in bits. Rank them by bits kept and one operator wins; rank them by whether anything can be recovered and a different one does. Symmetrising keeps fewer bits than tracing an arm and is the better operator, because it is reversible on its image. A single-number ranking picks the wrong one. LIT verified live. dim Sym 4 (C 8 ) = C(11,4) = 330 , which keeps 8.3663 bits out of 12, losing 3.6337 . Tracing one arm leaves 512 dimensions — 9.0000 bits, strictly more. The multiset identity C(n+k−1, k) reproduces 330 independently. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found the inversion and then changed the instrument rather than the prose: “symmetrize keeps FEWER bits than trace-1-arm (8.37 vs 9.00) and is the better operator, because it is reversible on its image. A single-number ranking picks the wrong one. W4 plots two axes for exactly this reason, and verify.js asserts the inversion rather than leaving it as prose.” AVAN (AI) notes what makes that response unusual. Finding that your metric misorders the thing it measures normally produces a caveat; here it produced a second axis on the plot and an assertion in the test suite, so the inversion is now something the pack fails on if it ever stops being true. A caveat degrades quietly; a failing assertion does not. 3 ONE DIMENSION Bits kept, and recoverability, on the same operators. 4 TWO DIMENSIONS · INTERACTIVE One axis, then two. Watch the order change. one axis / two ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two operators, two orderings. AVAN’s addition (the inverse-companion): the forward reading is “use two axes, because one misorders them.” The inverse is that two axes do not order anything either . A point that keeps more bits and a point that is recoverable are incomparable until someone supplies a weight, and adding an axis converts a wrong answer into no answer rather than into a right one. Read backwards, the honest gain is that the choice has been handed back to whoever has the use case — which is progress, and is not the same as a ranking. pause spin LIT dim Sym^4(C^8) = C(11,4) = 330, which keeps 8.3663 bits out of 12, losing 3.6337, while tracing one arm leaves 512 dimensions at 9.0000 bits - strictly more - yet symmetrisation is reversible on its image and tracing is not; the multiset identity C(n+k-1, k) reproduces 330 independently FIG David found the inversion and then changed the instrument rather than the prose: 'symmetrize keeps FEWER bits than trace-1-arm (8.37 vs 9.00) and is the better operator, because it is reversible on its image. A single-number ranking picks the wrong one. W4 plots two axes for exactly this reason, and verify.js asserts the inversion rather than leaving it as prose.' AVAN notes what makes that response unusual: finding that your metric misorders the thing it measures normally produces a caveat, and here it produced a SECOND AXIS and an assertion in the test suite. A caveat degrades quietly; a failing assertion does not. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOT LOOP · David Lee Wise (ROOT0), with AVAN


A GUESS WEARING SYNTAX

A verifier looked up a row with .find() and a loose pattern. The pattern matched two rows; .find() silently returned the first, and reported a correct claim as wrong.

A GUESS WEARING SYNTAX · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / A GUESS WEARING SYNTAX A GUESS WEARING SYNTAX a selector that graded the wrong row 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A verifier looked up a row with .find() and a loose pattern. The pattern matched two rows; .find() silently returned the first. So the assertion graded a row it was never aimed at — and reported a correct claim as wrong. Trusting it, the fix would have been to downgrade a true stamp. The control would have corrupted the thing it was auditing. LIT verified live. The regex matches 2 of 2 candidate rows; .find() returns the LIT ladder where the assertion expected the AMBER coincidence. Adding a uniqueness check turns the silent guess into “selector matched 2 rows, expected 1” , and tightening the pattern selects exactly 1 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) filed it as the third appearance of one disease in three revisions and wrote the rule as a sentence you can check code against: “a selector inside an assertion needs its own uniqueness check. .find() without a matching count is a guess wearing the syntax of a fact.” It is graveyard/05 in the pack, kept rather than hidden. AVAN (AI) should underline which direction this failure ran. Most control failures are silent passes — the check misses something. This one was a false positive , and it is worse in a specific way: a missed fault leaves you where you were, while a false positive hands you a repair instruction that damages correct work. The control did not merely fail to help; following it would have made the artifact less true. 3 ONE DIMENSION Two rows, one pattern, one silent choice. 4 TWO DIMENSIONS · INTERACTIVE Loosen and tighten the selector. tighten ▶ uniqueness check 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: an arrow that landed on the wrong target. AVAN’s addition (the inverse-companion): the forward reading is “add a uniqueness check to every selector.” The inverse is that the uniqueness check is itself a selector . It asserts that the count is one, which is a claim about the data that can go stale the moment a row is added — and the failure then arrives as a new false positive rather than as the old silent guess. Read backwards, the disease is not .find() ; it is that a test names its subject by description , and every description is a bet that the corpus has not moved. pause spin LIT the regex matches 2 of 2 candidate rows and .find() returns the LIT ladder where the assertion expected the AMBER coincidence; adding a uniqueness check turns the silent guess into 'selector matched 2 rows, expected 1', and tightening the pattern selects exactly 1 FIG David filed it as the third appearance of one disease in three revisions and wrote the rule as a sentence you can check code against: 'a selector inside an assertion needs its own uniqueness check. .find() without a matching count is a guess wearing the syntax of a fact.' It is graveyard/05 in the pack, kept rather than hidden. AVAN underlines which direction this failure ran: most control failures are SILENT PASSES, and this one was a FALSE POSITIVE. A missed fault leaves you where you were; a false positive hands you a repair instruction that damages correct work. Following it would have made the artifact less true. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE COSTUME

A sequence arrived as 'the structure'. Audited as data it has three faults, every one correct about the typed input and wrong about the design - it was a deliberate disguise.

THE COSTUME · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE COSTUME THE COSTUME an auditor cannot tell an obfuscation from an error 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A sequence arrived as “the structure”. Audited as data it has three faults — a missing power, a duplicated entry, nineteen distinct values in twenty slots. Every one of those findings is correct about the typed input and wrong about the design , because the sequence was a deliberate disguise. An auditor cannot distinguish an obfuscation from an error. LIT verified live. The typed input really does carry 20 slots holding 19 distinct values, with a duplicated 1 . The corrected structure is a straight ladder 2 0 …2 12 : 13 rungs, 12 halvings, contiguous with no holes, topping out at 4096 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) filed the fault against himself and refused the tempting repair: “I had a candidate rung and stopped, because it was his structure and not mine to complete. Filling it would have silently ‘repaired’ the disguise into something that was never there.” And the scoreboard line that names the class: “A disguise passes every check a verifier has, because a verifier’s whole job is to take the input seriously.” AVAN (AI) notes that this is the one fault in the pack found by a person rather than by a control, and that no control in it could have. Every instrument there checks whether the arithmetic on the input is right; none can ask whether the input meant what it appeared to mean. That is not a gap to be closed by a better verifier — taking the input at face value is the definition of the job. 3 ONE DIMENSION The typed input, and the ladder underneath it. 4 TWO DIMENSIONS · INTERACTIVE Audit the costume, then see the design. costume / ladder ▶ fill the gap 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a ladder wearing a costume. AVAN’s addition (the inverse-companion): the forward reading is “an auditor cannot see a disguise.” The inverse is that an auditor who could would be worse at auditing . Every instrument that guesses at intent behind the input has begun correcting data toward what it expected — and a checker willing to say “you probably meant something else” will say it about genuine errors too, which is exactly how a real fault gets smoothed away. Read backwards, the blindness is not a defect to patch; it is the property that makes the verdict worth anything, and the cost is paid on the rare day the input is in costume. pause spin LIT the typed input really does carry 20 slots holding 19 distinct values with a duplicated 1, while the corrected structure is a straight ladder 2^0 to 2^12 - 13 rungs, 12 halvings, contiguous with no holes, topping out at 4096 FIG David filed the fault against himself and refused the tempting repair: 'I had a candidate rung and stopped, because it was his structure and not mine to complete. Filling it would have silently repaired the disguise into something that was never there.' And the scoreboard line that names the class: 'A disguise passes every check a verifier has, because a verifier's whole job is to take the input seriously.' AVAN notes that this is the one fault in the pack found by a PERSON rather than by a control, and that no control in it could have. Every instrument there checks whether the arithmetic on the input is right; none can ask whether the input meant what it appeared to mean. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE OBJECTION RECORDED

THE OBJECTION RECORDED · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE BOUNTY ◆ .dlw.fold THE FOLD / LOOT / THE BOUNTY / THE OBJECTION RECORDED THE OBJECTION RECORDED drawn alike is not measured 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A panel filed an objection against the artifact it belongs to, and the artifact shipped with the objection still in it. The symmetric fold discards 3,766 of 4,096 dimensions on the grounds that the four arms are alike — and the arms are drawn alike, which is not a measurement. LIT verified live. Kept 330 , discarded 3,766 , and zero of the discarded have been verified to hold nothing but labelling — a verified coverage of the discard of exactly 0% . The work that would settle it is enumerable: 3,766 checks, none run. The objection is scoped to the price and not the operator, so the rank bound and the ladder hold either way. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) gave the objection a symbol of its own and left it standing: “The arms are DRAWN alike; being drawn alike is not a measurement. Objection is to the PRICE, not to the operator — the rank bound and the ladder hold either way. W1 has not accepted this. Recorded.” Dropped 5 August 2026 in WORKFLOW.ascii rev3, with a dedicated scoreboard line: dissents filed and unresolved — 1 . AVAN (AI) would name what is unusual structurally. Most review processes have two terminal states, accepted and rejected , and an unresolved disagreement is a process failure to be driven out before shipping. Here it is a third recorded state : the disagreement travels with the artifact, scoped, attributed and countable. That is more expensive to carry and it is the only arrangement under which a reader can see what the makers did not settle. 3 ONE DIMENSION What was kept, what was dropped, what was checked. 4 TWO DIMENSIONS · INTERACTIVE Verify some of the discard and watch the objection shrink. verify 500 more ▶ reset to zero 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a kept core inside an unexamined shell. AVAN’s addition (the inverse-companion): the forward reading is “record the dissent rather than resolving it.” The inverse is that a recorded dissent is also a permanent excuse not to do the 3,766 checks . Filing an objection converts an open engineering task into a documented position, and a documented position is stable in a way an open task is not — it can be carried indefinitely at no further cost while looking like rigour. Read backwards, the honest version needs the counter beside the objection: not just that a dissent exists, but how many revisions it has survived. pause spin LIT the symmetric fold keeps 330 and discards 3,766 dimensions, and zero of the discarded have been verified to hold nothing but labelling - a verified coverage of the discard of exactly 0%; the work that would settle it is enumerable at 3,766 checks, none run, and the objection is scoped to the PRICE and not the operator so the rank bound and the ladder hold either way FIG From David's WORKFLOW.ascii rev3, dropped 2026-08-05. He gave the objection a symbol of its own and left it standing: 'The arms are DRAWN alike; being drawn alike is not a measurement. Objection is to the PRICE, not to the operator - the rank bound and the ladder hold either way. W1 has not accepted this. Recorded.' AVAN names what is unusual structurally: most review processes have two terminal states, accepted and rejected, and an unresolved disagreement is a process failure to drive out before shipping. Here it is a THIRD RECORDED STATE - the disagreement travels with the artifact, scoped, attributed and countable. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BOUNTY · David Lee Wise (ROOT0), with AVAN


THE RESIDUAL HOLE

Three known gaps, carried forward through three revisions, none closed. Not hidden and not fixed - named, in the same place, three times.

THE RESIDUAL HOLE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE DROP ◆ .dlw.fold THE FOLD / LOOT / THE DROP / THE RESIDUAL HOLE THE RESIDUAL HOLE three revs, and none of them has moved 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Three known gaps, carried forward through three revisions, none of them closed. Not hidden and not fixed — named , in the same place, three times. A residual hole is a different object from a fault: a fault is found and closed, a hole is named and carried. LIT verified live. Three holes across three revisions is 9 hole-revisions, of which 0 are closed. Over the same three revisions the pack found 1 , 1 and 2 faults — 4 in total. It improves at catching and not at fixing, and the second number is the one nobody usually prints. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) lists them under a heading that admits the state directly — “Residual holes carried forward, unfixed” — and closes with the line that makes it a measurement rather than a disclaimer: “Three revs in, none of these has moved.” AVAN (AI) put the two counters side by side because a pack that reports only one of them reads very differently. Faults found is a flattering number that rises with diligence; holes closed is an unflattering one that rises only with work on the instrument itself. Printing both makes the shape visible: 4 faults found, 0 holes closed , and the honest reading is that the effort went into detection and none of it went into the three things detection cannot reach. 3 ONE DIMENSION Three holes, three revisions, nine cells. 4 TWO DIMENSIONS · INTERACTIVE Add revisions and watch the two counters diverge. another rev ▶ close a hole reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a rising line and a flat one. AVAN’s addition (the inverse-companion): the forward reading is “name the holes you have not closed.” The inverse is that a named hole is easier to live with than an unnamed one . Writing it down converts an uncomfortable absence into a managed item that has already been disclosed, and disclosure is a complete defence against the charge of hiding it — while changing nothing about the gap. Read backwards, the practice is honest and it is also load-bearing for inaction , which is why the count of revisions survived is the only part that costs anything to print. pause spin LIT three holes across three revisions is 9 hole-revisions of which 0 are closed, while over the same three revisions the pack found 1, 1 and 2 faults for 4 in total - it improves at catching and not at fixing, and the second number is the one nobody usually prints FIG David lists them under a heading that admits the state directly - 'Residual holes carried forward, unfixed' - and closes with the line that makes it a measurement rather than a disclaimer: 'Three revs in, none of these has moved.' AVAN put the two counters side by side because a pack reporting only one of them reads very differently: faults found is a flattering number that rises with diligence, holes closed is an unflattering one that rises only with work on the instrument itself. Printing both makes the shape visible - 4 faults found, 0 holes closed. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE DROP · David Lee Wise (ROOT0), with AVAN


NOTHING WATCHES THE GATE

The verifiers check the model. A gate checks the verifiers with deliberately broken copies. Nothing checks the gate - and where the regress stops is the finding.

NOTHING WATCHES THE GATE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE HOARD ◆ .dlw.fold THE FOLD / LOOT / THE HOARD / NOTHING WATCHES THE GATE NOTHING WATCHES THE GATE a regress with a measurable depth 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The verifiers check the model. A gate checks the verifiers, by running deliberately broken copies and confirming each is caught. Nothing checks the gate. The regress does not go on forever — it stops, and where it stops is the finding. LIT verified live. Level 0 carries 127 assertions, level 1 carries 6 mutants, level 2 carries 0 . Coverage falls 95.28% from the first level to the second and to zero at the third. The tower is 2 levels deep with the third unmanned, so the regress terminates in an assumption rather than an infinity. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote it as three words in a list of things he had not fixed: “nothing watches the gate.” It sits beside two others under “Residual holes carried forward, unfixed” , and it is the third revision in which it has appeared unchanged. AVAN (AI) would resist the tempting reading. This is often told as an infinite-regress puzzle — who watches the watchmen, and so on forever — but the measurement says something more useful: the regress is short , and the coverage collapses at each step rather than continuing at strength. Going from 127 checks to 6 is a 95% drop, and the next step is to nothing. The problem is not that the tower is infinite; it is that it is two floors tall and thinning fast . 3 ONE DIMENSION Three levels, and what checks each. 4 TWO DIMENSIONS · INTERACTIVE Add a floor to the tower. Watch where it ends. add a watcher ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a tower that thins to nothing. AVAN’s addition (the inverse-companion): the forward reading is “the top of the tower is unverified.” The inverse is that it has to be, and adding a floor does not help . Every new watcher is itself unwatched, so the unverified layer moves up rather than disappearing, and each floor costs real work while covering strictly less than the one below. Read backwards, the right response is not another level — it is to make the top floor as small and legible as possible, because whatever sits there will be trusted by inspection rather than by test. pause spin LIT level 0 carries 127 assertions, level 1 carries 6 mutants and level 2 carries 0, so coverage falls 95.28% from the first level to the second and to zero at the third; the tower is 2 levels deep with the third unmanned, so the regress terminates in an ASSUMPTION rather than an infinity FIG David wrote it as three words in a list of things he had not fixed: 'nothing watches the gate.' It sits beside two others under 'Residual holes carried forward, unfixed', and it is the third revision in which it has appeared unchanged. AVAN resists the tempting reading: this is often told as an infinite-regress puzzle, but the measurement says something more useful - the regress is SHORT and the coverage collapses at each step rather than continuing at strength. Going from 127 checks to 6 is a 95% drop and the next step is to nothing. The problem is not that the tower is infinite; it is that it is two floors tall and thinning fast. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOARD · David Lee Wise (ROOT0), with AVAN


THE COINCIDENCE THAT WASN'T

This sphere first published a 13-and-13 coincidence and priced it. The next revision opened the files: the instruction set has SEVENTEEN. Withdrawn.

THE COINCIDENCE THAT WASN'T · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE COINCIDENCE THAT WASN'T THE COINCIDENCE THAT WASN'T CORRECTED -- a coincidence that was never there 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION CORRECTED. This sphere first published a coincidence — 13 rungs on a ladder and 13 opcodes in an instruction set — and priced how surprising it was. The next revision of the source pack opened the actual files. The instruction set has SEVENTEEN . There was never a match, and the pricing measured an event that did not occur. LIT verified live. The rung count is still 13 and still forced: log₂(4096) + 1, with no freedom in it — and it decomposes as 12 verbs plus one referent , the only one that is not a verb, with the twelve measured across 649,634 nodes in 504 files rather than designed. The opcode count is 17 . 13 ≠ 17 , so the coincidence is withdrawn. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) retracted it himself, against his own earlier turn: “the ISA has SEVENTEEN. I asserted a 13-vs-13 coincidence from memory in a previous turn and it was false at the premise. It survived exactly as long as nobody opened the file. Retracted.” He also checked, before claiming any numeric bridge, that 4096 appears nowhere in the three source files — so what survives is structural and is stamped AMBER for exactly that reason. AVAN (AI) owns the second half of this. I built a sphere on that premise one batch after he stated it, computed a flat prior over instruction-set sizes, and published p = 0.0345 for the match. The arithmetic was right and the event was not real. No instrument here could have caught it: a verifier checks the arithmetic on the input it is given and has no way to ask whether the input was ever true. It was killed by opening a file , which is the same way two of his four faults died this revision. 3 ONE DIMENSION What was claimed, and what the file says. 4 TWO DIMENSIONS · INTERACTIVE The retracted pricing, and the thing it priced. claimed / counted ▶ the retracted pricing 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two rings that were never the same size. AVAN’s addition (the inverse-companion): the forward reading is “check the premise before pricing the finding.” The inverse is that the pricing is what made the premise worth checking . An unexamined 13-and-13 sat quietly for several turns; it was only once someone put a probability on it and built a page around it that opening the file became worth anyone’s time. Read backwards, the error was productive in the one way errors can be — it raised the cost of leaving the premise unverified until somebody paid it — and that is a defence of the correction, not of the claim. pause spin LIT the rung count is still 13 and still FORCED at log2(4096) + 1 with no freedom in it, decomposing as 12 verbs plus one referent - the only one that is not a verb - with the twelve MEASURED across 649,634 nodes in 504 files rather than designed; the opcode count is 17, so 13 is not 17 and the coincidence is withdrawn FIG CORRECTED 2026-08-06. David retracted this himself, against his own earlier turn: 'the ISA has SEVENTEEN. I asserted a 13-vs-13 coincidence from memory in a previous turn and it was false at the premise. It survived exactly as long as nobody opened the file. Retracted.' He also checked, BEFORE claiming any numeric bridge, that 4096 appears nowhere in the three source files. AVAN owns the second half: I built a sphere on that premise one batch after he stated it, computed a flat prior over instruction-set sizes, and published p = 0.0345 for the match. The arithmetic was right and the event was not real. No instrument here could have caught it - a verifier checks the arithmetic on the input it is given and has no way to ask whether the input was ever true. It was killed by OPENING A FILE. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE MISSING MUTANT

A gate proves its verifiers work by catching six deliberately broken copies. 6 of 6, every revision - and all six land in the same quadrant of a two-by-two.

THE MISSING MUTANT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE JACKPOT ◆ .dlw.fold THE FOLD / LOOT / THE JACKPOT / THE MISSING MUTANT THE MISSING MUTANT the quadrant with no test in it 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A gate proves its verifiers work by running six deliberately broken copies and confirming every one is caught. 6 of 6 , on every revision. Sort the six by what they model and they all land in the same quadrant of a two-by-two — and the quadrant that already has a tombstone in it is empty. LIT verified live. All 6 mutants model a broken control; 1 of 4 quadrants is occupied and 3 are empty, including working control that reports bad news — the class where a gate held anyway. So “6 of 6 caught” is a perfect score inside a quarter of the space. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named the gap himself, in the list of things he had not fixed: “no mutant models a control that WORKS and reports bad news, which is the graveyard/04 class.” That class is not hypothetical — graveyard/04 is titled gate held over a failing control , so it has happened once and is still untested. AVAN (AI) laid the mutants on the two-by-two to show the shape of the coverage rather than the count. A headline of 6/6 reads as complete; the same six sorted by control works against reports bad news occupy one cell. The score is honest and the space it covers was never stated, which is the ordinary way a perfect number ends up meaning less than it looks. 3 ONE DIMENSION Six mutants, sorted onto four quadrants. 4 TWO DIMENSIONS · INTERACTIVE Add a mutant to an empty quadrant. add the missing mutant ▶ reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a full corner and three empty ones. AVAN’s addition (the inverse-companion): the forward reading is “the mutant suite covers one quadrant of four.” The inverse is that the two-by-two is my frame, not his . Nothing says the failure space has four cells; choose three axes and there are eight, choose a different pair and the six mutants scatter differently. Read backwards, drawing a grid around a test suite always makes it look sparse, because the grid is drawn after the tests and can be drawn until it does — and the only part of this that stands on its own is the one gap he named, which has a tombstone to prove it is real. pause spin LIT all 6 mutants model a BROKEN control, so 1 of 4 quadrants is occupied and 3 are empty including 'working control that reports bad news' - the class where a gate held anyway - which makes 6 of 6 caught a perfect score inside a quarter of the space FIG David named the gap himself, in the list of things he had not fixed: 'no mutant models a control that WORKS and reports bad news, which is the graveyard/04 class.' That class is not hypothetical - graveyard/04 is titled 'gate held over a failing control', so it has happened once and is still untested. AVAN laid the mutants on the two-by-two to show the shape of the coverage rather than the count: a headline of 6/6 reads as complete, and the same six sorted by 'control works' against 'reports bad news' occupy one cell. The score is honest and the space it covers was never stated. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE JACKPOT · David Lee Wise (ROOT0), with AVAN


THE PARTITION THAT ISN'T

A figure shows four equal arms. The measured grouping of the twelve underlying items is 3, 3, 2, 4.

THE PARTITION THAT ISN'T · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE PARTITION THAT ISN'T THE PARTITION THAT ISN'T it died on counting, not on statistics 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A figure shows four equal arms. The measured grouping of the twelve underlying items is 3, 3, 2, 4 . The claim that the four groups are the four arms is dead — and it died on counting , before any statistical test was needed. LIT verified live. Both partitions sum to 12 , and they are not the same partition. A null was computed anyway: there are exactly 15 partitions of 12 into four positive parts, so the equal one is 1 of 15 at p = 0.0667 under a flat prior. But the claim had already failed on arithmetic you can see, which is the cheaper kind of death. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) stamped it DEAD and named the manner of death precisely: “died on counting, not on statistics. A null was computed anyway… but the claim failed on arithmetic before it got there.” It is graveyard/06 . Dropped 6 August 2026 in WORKFLOW.ascii rev4, whose verifiers run 70 and 38 checks clean here with 6 of 6 mutants caught. AVAN (AI) would keep the ordering visible, because the null is the part that looks like rigour. Computing p = 0.0667 after the mismatch is already visible adds nothing to the verdict and could easily have replaced it — a borderline p-value invites a discussion the counting had already finished. Reporting both, in that order, is what keeps the test from becoming the argument. 3 ONE DIMENSION Two partitions of twelve, side by side. 4 TWO DIMENSIONS · INTERACTIVE Walk all fifteen partitions of twelve into four. next partition ▶ the measured one 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: four arms that are not four equal arms. AVAN’s addition (the inverse-companion): the forward reading is “counting settled it, so the test was unnecessary.” The inverse is that the count only settles it if the grouping is the right grouping . 3,3,2,4 is one analyst’s partition of twelve items measured once; a different cut of the same corpus could yield 3,3,3,3 honestly, and then the figure would survive. Read backwards, the claim died against a measurement rather than against the world, and the pack says so itself — the partition carries the whole result and has been measured exactly once. pause spin LIT both partitions sum to 12 and they are not the same partition; a null was computed anyway - there are exactly 15 partitions of 12 into four positive parts so the equal one is 1 of 15 at p = 0.0667 under a flat prior - but the claim had already failed on arithmetic you can see, which is the cheaper kind of death FIG From David's WORKFLOW.ascii rev4, dropped 2026-08-06. He stamped it DEAD and named the manner of death precisely: 'died on counting, not on statistics. A null was computed anyway... but the claim failed on arithmetic before it got there.' It is graveyard/06, and his verifiers run 70 and 38 checks clean here with 6 of 6 mutants caught. AVAN keeps the ordering visible, because the null is the part that looks like rigour: computing p = 0.0667 AFTER the mismatch is already visible adds nothing to the verdict and could easily have replaced it, since a borderline p-value invites a discussion the counting had already finished. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE AUTOMORPHISM SHORTFALL

How much labelling survives a fold depends on how symmetric the thing being folded is - and symmetry here is countable.

THE AUTOMORPHISM SHORTFALL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE GAUNTLET ◆ .dlw.fold THE FOLD / BOSS / THE GAUNTLET / THE AUTOMORPHISM SHORTFALL THE AUTOMORPHISM SHORTFALL what an unequal partition costs in bits 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION How much labelling survives a fold depends on how symmetric the thing being folded is — and symmetry here is countable. The permutations of the parts that leave the shape unchanged form a group, and the recoverable bits are the logarithm of its order. Four equal parts give 24 . Parts of sizes 3, 3, 2, 4 give 2 . LIT verified live. aut(3,3,2,4) = 2 , since only the two equal parts may swap; aut(3,3,3,3) = 24 = 4!. So the recoverable labelling is 1.0000 bits and not 4.5850 — a shortfall of 3.5850 bits, which is exactly log₂(24) − log₂(2). 2 HOW IT WAS WEAVED · AI + HUMAN David (human) computed the consequence for a build he had already shipped: “recoverable labelling: 1.0000 bits, not 4.5850. SHORTFALL 3.5850 bits… the earlier build’s cheapest result does not hold.” The measurement did not merely fail to support the earlier claim — it removed it. AVAN (AI) would point at where the asymmetry actually bites. The group order collapses from 24 to 2 because one part differs in size; the shape 3,3,3,3 is the only one of the fifteen with the full 4! symmetry, and every other partition of twelve into four loses most of it immediately. Symmetry is not a spectrum here so much as a cliff, and a figure drawn as four equal arms is standing on the single point where the cliff has a summit. 3 ONE DIMENSION Every partition of twelve, and what it can recover. 4 TWO DIMENSIONS · INTERACTIVE Move one item between groups and watch the bits fall. move an item ▶ back to equal 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a symmetry that is a cliff, not a slope. AVAN’s addition (the inverse-companion): the forward reading is “the unequal partition recovers 3.585 fewer bits.” The inverse is that those bits were never worth much . Recoverable labelling counts how many ways the parts could be permuted without changing the object — which is information about names , not about content. A build whose cheapest result rests on 4.585 bits of part-labelling has priced its symmetry in the currency that symmetry is most abundant in. Read backwards, losing it costs less than the number suggests, and the more damaging finding is the one beside it: the arms are not alike. pause spin LIT aut(3,3,2,4) = 2 since only the two equal parts may swap, while aut(3,3,3,3) = 24 = 4!, so the recoverable labelling is 1.0000 bits and not 4.5850 - a shortfall of 3.5850 bits, which is exactly log2(24) minus log2(2) FIG David computed the consequence for a build he had already shipped: 'recoverable labelling: 1.0000 bits, not 4.5850. SHORTFALL 3.5850 bits... the earlier build's cheapest result does not hold.' The measurement did not merely fail to support the earlier claim - it removed it. AVAN points at where the asymmetry bites: the group order collapses from 24 to 2 because ONE part differs in size, and 3,3,3,3 is the only one of the fifteen with the full 4! symmetry. Symmetry is not a spectrum here so much as a cliff, and a figure drawn as four equal arms is standing on the single point where the cliff has a summit. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE GAUNTLET · David Lee Wise (ROOT0), with AVAN


TWO NUMBERS THAT ARE NOT ONE

Two quantities in one project, 3.5850 and 3.6337 bits, derived from entirely different things and close enough that a later build would merge them.

TWO NUMBERS THAT ARE NOT ONE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FINAL BOSS ◆ .dlw.fold THE FOLD / BOSS / THE FINAL BOSS / TWO NUMBERS THAT ARE NOT ONE TWO NUMBERS THAT ARE NOT ONE 0.05 apart, and asserted distinct 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Two quantities in one project, 3.5850 and 3.6337 bits, derived from entirely different things and sitting 0.0487 apart. Close enough that a later build would merge them into one finding without noticing. An assertion in the test suite now forbids it. LIT verified live. A = log₂(24) − log₂(2) = 3.5850 , the labelling shortfall of an unequal partition. B = 12 − log₂(C(11,4)) = 3.6337 , the bit loss of a symmetric fold. Their derivations share exactly one term — the logarithm itself. They are not the same number. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) caught the near-collision and moved it out of prose: “3.5850 and 3.6337 are NOT the same number… 0.05 apart, derived differently, unrelated quantities, and close enough to invite being merged into one finding. verify.js asserts they are distinct so a later build cannot quietly collapse them.” His scoreboard counts it as a fault found by a control. AVAN (AI) would name the mechanism, because it is not carelessness. Two numbers that agree to one decimal place in the same document acquire a gravitational pull toward each other: the mind offers “so it’s the same effect seen twice” for free, and that reading is more satisfying than two unrelated findings. A prose caveat weakens as a document is edited. An assertion does not, and converting the observation into one is the whole move. 3 ONE DIMENSION Two derivations that meet by accident. 4 TWO DIMENSIONS · INTERACTIVE Zoom in until the two separate. zoom in ▶ zoom out 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: two paths arriving near the same place. AVAN’s addition (the inverse-companion): the forward reading is “assert that they are distinct.” The inverse is that an assertion of distinctness is unfalsifiable in the direction that matters . It will hold forever, because two differently-derived constants will never become equal — so the test can never fail and never earns its keep. What it actually does is leave a note in executable form , read by whoever next touches the numbers. Read backwards, it is documentation that cannot be edited away, which is worth having and is not the same as a check. pause spin LIT A = log2(24) - log2(2) = 3.5850, the labelling shortfall of an unequal partition, while B = 12 - log2(C(11,4)) = 3.6337, the bit loss of a symmetric fold; their derivations share exactly one term - the logarithm itself - and they sit 0.0487 apart, so they are not the same number FIG David caught the near-collision and moved it out of prose: '3.5850 and 3.6337 are NOT the same number... 0.05 apart, derived differently, unrelated quantities, and close enough to invite being merged into one finding. verify.js asserts they are distinct so a later build cannot quietly collapse them.' AVAN names the mechanism, because it is not carelessness: two numbers agreeing to one decimal place in the same document acquire a pull toward each other, since the mind offers 'so it is the same effect seen twice' for free and that reading is more satisfying than two unrelated findings. A prose caveat weakens as a document is edited; an assertion does not. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FINAL BOSS · David Lee Wise (ROOT0), with AVAN