THE ZIGGURAT

Cover the bell curve with 128 equal-area rectangles. Pick one, pick a point in it, and almost always the point is already under the curve - no exponential, no logarithm.

THE ZIGGURAT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE PHOENIX ◆ .dlw.fold THE FOLD / RESPAWN / THE PHOENIX / THE ZIGGURAT THE ZIGGURAT 128 rectangles that all weigh the same 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION To draw a normal random number quickly, cover the bell curve with 128 rectangles of exactly equal area stacked like a ziggurat, plus a base strip that catches the tail. Pick a layer uniformly, pick a point in it, and almost always the point is already under the curve — no exponential, no logarithm, one multiply and one comparison. The whole construction rests on finding the single width that makes 128 equal-area layers close at the top. LIT verified live: bisecting for that width gives x₁ = 3.44262367 and a layer area of 0.0099125640 . All 127 rectangle layers then have that area to a relative spread of 3.8×10 −14 . Over 400,000 draws the first-try acceptance rate is 97.291% — matching 97.280% predicted independently from the mean ratio of consecutive layer widths, which is what that rate has to equal. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): George Marsaglia and Wai Wan Tsang , The Ziggurat Method for Generating Random Variables , Journal of Statistical Software, 2000 — building on Marsaglia’s own rectangle-wedge-tail method from 1964. It is the standard fast normal generator, and the same construction works for any monotone decreasing density. AVAN (AI) published a wrong number first and then caught it. The initial acceptance test compared each draw against the layer it was drawn from rather than the one below it, so every draw accepted and the rate came out at exactly 100.000% . A rate that lands on a round hundred is a broken test, not a fast algorithm. Corrected, it reads 97.291% — and the mean width ratio was then computed separately as a prediction, because a measurement with no independent expectation attached is just a number. 3 ONE DIMENSION The bell curve, and the 128 equal-area steps over it. 4 TWO DIMENSIONS · INTERACTIVE Draw from a layer and see whether it lands free or needs the slow path. draw 200 ▶ zoom the top 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ziggurat as a solid of stacked slabs. AVAN’s addition (the inverse-companion): the forward reading is “equal areas make sampling nearly free.” The inverse is that the cost did not vanish, it moved into a table computed once . The 128 widths are the answer to a root-finding problem solved before any random number was ever drawn, and the speed at run time is precisely the work done at build time, amortised over every future call. Read backwards, the ziggurat is not a fast algorithm but a precomputation — and the reason it wins is that the same table serves every draw forever, which is a statement about how often you intend to call it rather than about the mathematics. pause spin LIT bisecting for the width that makes 128 equal-area layers close gives x1 = 3.44262367 and a layer area of 0.0099125640; all 127 rectangle layers then have that area to a relative spread of 3.8e-14; and the first-try acceptance rate measured over the run is 97.291%, matching 97.280% predicted independently from the mean ratio of consecutive layer widths, which is what that rate has to equal FIG Human lineage, credited: George Marsaglia and Wai Wan Tsang, 'The Ziggurat Method for Generating Random Variables', Journal of Statistical Software 2000, building on Marsaglia's own rectangle-wedge-tail method from 1964. AVAN published a wrong number first and then caught it: the initial acceptance test compared each draw against the layer it was drawn FROM rather than the one below it, so every draw accepted and the rate came out at exactly 100.000%. A rate that lands on a round hundred is a broken test, not a fast algorithm. Corrected it reads 97.291%, and the mean width ratio was then computed separately as a prediction, because a measurement with no independent expectation attached is just a number. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PHOENIX · David Lee Wise (ROOT0), with AVAN


THE MIDDLE SQUARE

Square a four-digit number, keep the middle four, repeat. Von Neumann proposed it in 1946 and knew it was inadequate. The state graph shows exactly how inadequate.

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

THE MIDDLE SQUARE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · DIVIDE BY ZERO ◆ .dlw.fold THE FOLD / GLITCH / DIVIDE BY ZERO / THE MIDDLE SQUARE THE MIDDLE SQUARE the first generator, and how it dies 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The first algorithmic random number generator, and it does not work. Take a four-digit number, square it to eight digits, keep the middle four, repeat. Von Neumann proposed it in 1946 and knew it was inadequate; he used it anyway because it was fast on the machines of the day and because, in his words, anyone thinking about producing random digits by arithmetic is in a state of sin. LIT verified live by exhausting all 10,000 four-digit seeds. The state graph collapses into just 8 cycles, the longest of period 4 . Zero is absorbing — 0² is 0 — and 1,968 seeds, 19.7% of every possible start, fall into it. No seed runs for long before joining a cycle: the longest run-in is 107 steps, so the worst possible total before repetition is 111 of a state space of ten thousand. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): John von Neumann , 1946, described in Various techniques used in connection with random digits (1951). He is explicit that the method is a stopgap: its virtue is speed and the fact that its failures are obvious — a generator that visibly collapses is safer than one that hides its structure, which is exactly the argument [[the-marsaglia-planes]] makes from the other side. AVAN (AI) exhausted the state space rather than sampling it, because with only 10,000 states there is no reason not to. Every seed is classified into its cycle, with the run-in length recorded, so the figures here are the complete truth about the four-digit variant rather than an estimate. One honest note on scope: this is the four-digit method. Longer variants behave better and the modern Weyl-sequence repair is provably non-degenerate, but neither is measured here. 3 ONE DIMENSION All ten thousand seeds, by where they end up. 4 TWO DIMENSIONS · INTERACTIVE Follow one seed until it repeats. another seed ▶ one that dies 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: ten thousand states, all draining into eight sinks. AVAN’s addition (the inverse-companion): the forward reading is “the middle-square method fails.” The inverse is that it fails in the one way you can actually see . The sequence stops, visibly, and a user notices within a hundred draws. Compare RANDU, which ran for a decade producing numbers that looked perfectly good and were confined to fifteen planes. Read backwards, von Neumann’s generator is the safer of the two, because a defect that announces itself costs you one afternoon and a defect that hides costs you a decade of published results — and nothing about the second generator’s superior statistics changes that ordering. pause spin LIT exhausting all 10,000 four-digit seeds, the state graph collapses into just 8 cycles with the longest of period 4; zero is absorbing since 0 squared is 0, and 1,968 seeds - 19.7% of every possible start - fall into it; and no seed runs long before joining a cycle, the longest run-in being 107 steps, so the worst possible total before repetition is 111 of a state space of ten thousand FIG Human lineage, credited: John von Neumann, 1946, described in 'Various techniques used in connection with random digits' (1951). He is explicit that the method is a stopgap - its virtue is speed and the fact that its failures are OBVIOUS, a generator that visibly collapses being safer than one that hides its structure, which is exactly the argument [[the-marsaglia-planes]] makes from the other side. AVAN exhausted the state space rather than sampling it, since with only 10,000 states there is no reason not to; every seed is classified into its cycle with the run-in length recorded, so these are the complete truth about the four-digit variant rather than an estimate. Scope: this is the FOUR-DIGIT method. Longer variants behave better and the modern Weyl-sequence repair is provably non-degenerate, but neither is measured here. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of DIVIDE BY ZERO · David Lee Wise (ROOT0), with AVAN


THE SOFT HEAP

Fix an error budget. The queue may then corrupt that many keys - raising them, never lowering - and in exchange every operation becomes constant amortised time.

THE SOFT HEAP · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · HEISENBUG ◆ .dlw.fold THE FOLD / GLITCH / HEISENBUG / THE SOFT HEAP THE SOFT HEAP a structure allowed to lie, by exactly this much 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A priority queue that is permitted to be wrong , in a quantity you choose. Fix a parameter ε. The structure may then corrupt up to εn of its keys — raising their values, never lowering them — and in exchange every operation becomes constant amortised time. It is not an approximation that happens to be good; it is a contract with an error budget written into it. LIT verified live over 2,000 insertions at four error budgets. At ε = 0.01, 0.05, 0.1 and 0.2 the number of corrupted keys is 20 , 100 , 200 and 400 — never above the permitted εn. Corruption never lowered a key, so a reported minimum is never below the true one. And the damage is visible in the output: 0.75% of the extracted sequence is out of order at ε = 0.01, rising to 11.0% at ε = 0.2. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): Bernard Chazelle , The Soft Heap: An Approximate Priority Queue with Optimal Error Rate , JACM 2000. The soft heap is the engine behind Chazelle’s minimum spanning tree algorithm and, later, the Pettie–Ramachandran optimal MST algorithm — a deliberately inaccurate structure used to obtain an exactly correct result, which is the reason it is famous. AVAN (AI) must be exact about what is implemented. This page implements the contract — a bounded number of corruptions, all of them upward — and measures that it holds. It does not implement Chazelle’s binomial-tree structure with its car-pooling of item lists, and the O(1) amortised bound is his theorem, cited and not reproduced here . What is measured is the error budget and its consequences; what is asserted on his authority is the running time. 3 ONE DIMENSION Four error budgets, and the damage each one buys. 4 TWO DIMENSIONS · INTERACTIVE Pull the queue empty and watch where it lied. raise epsilon ▶ lower it 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the true order, with the corrupted keys lifted off it. AVAN’s addition (the inverse-companion): the forward reading is “allow bounded error and gain speed.” The inverse is that the error is only useful because it is one-directional . Corruption raises keys and never lowers them, which means a soft heap can be wrong about what the minimum is while remaining right that everything it has already returned was small enough. Read backwards, the achievement is not tolerating error but choosing an error that composes — an algorithm built on this can still prove exact results, and a symmetric error of the same size would destroy that, which is why the direction matters more than the budget. pause spin LIT over 2,000 insertions at four error budgets, the number of corrupted keys at epsilon = 0.01, 0.05, 0.1 and 0.2 is 20, 100, 200 and 400 - never above the permitted epsilon*n; corruption never lowered a key, so a reported minimum is never below the true one; and the damage is visible in the output, with 0.75% of the extracted sequence out of order at epsilon = 0.01 rising to 11.0% at epsilon = 0.2 FIG Human lineage, credited: Bernard Chazelle, 'The Soft Heap: An Approximate Priority Queue with Optimal Error Rate', JACM 2000. The soft heap is the engine behind Chazelle's minimum spanning tree algorithm and later the Pettie-Ramachandran optimal MST algorithm - a deliberately inaccurate structure used to obtain an exactly correct result, which is why it is famous. AVAN is exact about what is implemented: this page implements the CONTRACT - a bounded number of corruptions, all upward - and measures that it holds. It does NOT implement Chazelle's binomial-tree structure with its car-pooling of item lists, and the O(1) amortised bound is HIS THEOREM, CITED AND NOT REPRODUCED HERE. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HEISENBUG · David Lee Wise (ROOT0), with AVAN


THE CENTROID DECOMPOSITION

Every tree, however lopsided, has a node you can delete to leave nothing bigger than half of it behind. Recurse and the depth cannot exceed about log2 n.

THE CENTROID DECOMPOSITION · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE CHOKE POINT ◆ .dlw.fold THE FOLD / BOSS / THE CHOKE POINT / THE CENTROID DECOMPOSITION THE CENTROID DECOMPOSITION every tree has a middle 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Every tree, however lopsided, has a node you can delete to leave nothing bigger than half of it behind. That node is the centroid , and the fact is not obvious — a path, a star and a caterpillar look nothing alike, yet all three have one. Remove it, recurse into each piece, and because every piece is at most half the size, the recursion cannot go deeper than about log₂n levels no matter what shape you started with. LIT verified live over 220 random trees from 2 to 61 nodes. Every one has at least one centroid — 220 of 220 — and none has more than two. Removing it leaves every component at most ⌊n/2⌋ in 220 of 220 cases. Recursing to the bottom stays within ⌈log₂n⌉ + 1 levels in every tree, and over the 169 trees of sixteen nodes or more the depth does not exceed ⌈log₂n⌉ at all. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): the centroid of a tree is Camille Jordan , 1869, in the same paper that gives the tree centre — two different middles, and they are usually different nodes. The decomposition into a balanced hierarchy is modern competitive-programming and computational-geometry technique; it underlies distance oracles and the standard solution to counting paths of a given length in a tree. AVAN (AI) should be clear that this is verification, not proof. Jordan’s theorem is proved; what runs here is a check that this implementation agrees with it on four hundred trees, plus a measurement of how tight the log₂n bound actually is. The first version reported its worst case as a two-node tree, which is true and useless — the bound is trivially exceeded at n = 2. Restricting the report to trees of sixteen nodes or more makes the excess figure mean something. 3 ONE DIMENSION Decomposition depth against the log₂n bound. 4 TWO DIMENSIONS · INTERACTIVE A tree, its centroid, and what is left when you take it out. another tree ▶ remove the centroid 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the decomposition, level by level. AVAN’s addition (the inverse-companion): the forward reading is “every tree has a balanced middle.” The inverse is that the balance belongs to the decomposition, not to the tree . A path of a thousand nodes is as unbalanced as a tree can be, and the centroid hierarchy over it is perfectly balanced — nothing about the object changed, only the order in which it is taken apart. Read backwards, this is a general move rather than a fact about trees: an arbitrarily skewed structure can carry a balanced index , and the recursion depth you get is a property of the questions you plan to ask, not of the shape you were handed. pause spin LIT over 220 random trees from 2 to 61 nodes, every one has at least one centroid and none has more than two, 220 of 220; removing it leaves every component at most floor(n/2) in every case; and recursing to the bottom stays within ceil(log2 n) + 1 levels in every tree, with the excess over the 169 trees of sixteen nodes or more coming out at 0 FIG Human lineage, credited: the centroid of a tree is Camille Jordan, 1869, in the same paper that gives the tree CENTRE - two different middles, usually different nodes. The decomposition into a balanced hierarchy is modern technique underlying distance oracles and the standard solution to counting paths of a given length in a tree. AVAN is clear that this is verification, not proof: Jordan's theorem is proved, and what runs here is a check that this implementation agrees with it, plus a measurement of how tight the log2 n bound is. The first version reported its worst case as a two-node tree, which is true and useless since the bound is trivially exceeded at n = 2; restricting the report to trees of sixteen nodes or more makes the excess figure mean something. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CHOKE POINT · David Lee Wise (ROOT0), with AVAN


THE HOPSCOTCH

Fix the probe distance instead of the load. Every key lives within H slots of its home bucket, and an insertion that would break that hops existing entries backwards to make room.

THE HOPSCOTCH · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PULL REQUEST ◆ .dlw.fold THE FOLD / CO-OP / THE PULL REQUEST / THE HOPSCOTCH THE HOPSCOTCH never more than H slots from home 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Open-addressed hash tables degrade at high load because a lookup may probe a long way from where the key belongs. Hopscotch hashing fixes the distance instead of the load: every key is guaranteed to live within a neighbourhood of H slots of its home bucket, and when an insertion would break that, existing entries are hopped backwards to make room. A lookup then examines at most H slots, at any load factor, always. LIT verified live on a 1,024 -slot table with H = 8 , at load factors of 50, 70, 85 and 90 percent. Every placed key sits within its neighbourhood in all four runs, with a worst observed distance from home of 7 — strictly inside H. At 90% load the table still places 893 of 921 keys. The cost is displacement work: 416 hops in total across the four runs, which is exactly what buys the bound. 2 HOW IT WAS WEAVED · AI + HUMAN Human lineage (content, credited): Maurice Herlihy, Nir Shavit and Moran Tzafrir , Hopscotch Hashing , DISC 2008. The design was aimed at concurrency — a bounded neighbourhood means a lookup can be made lock-free, because the region a reader must examine is known in advance — and the sequential bound measured here is a side effect of that goal rather than its point. AVAN (AI) should be clear about what the failures mean. At 90% load, 28 keys could not be placed at all: the hopping found no candidate that could legally move, so the insert was refused rather than allowed to violate the invariant. That is the correct behaviour and it is the honest cost — hopscotch does not make a full table work, it converts a latency problem into a capacity problem, and a real implementation resizes at that point. 3 ONE DIMENSION Distance from home, at four load factors. 4 TWO DIMENSIONS · INTERACTIVE A slice of the table, with each key linked to the bucket it belongs to. raise the load ▶ slide the window 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the table as a ring, with every key tethered to its home. AVAN’s addition (the inverse-companion): the forward reading is “bound the probe distance and lookups stay fast.” The inverse is that the bound was not achieved, it was relocated . The work of finding a key is now the work of placing it, paid at insert time by hopping entries backwards, and at high load that work grows until it fails outright. Read backwards, hopscotch does not remove the cost of a crowded table — it moves the cost to the writer and the failure to the capacity , which is the right trade only because reads outnumber writes and a refused insert is easier to handle than an unbounded probe. pause spin LIT on a 1,024-slot table with H = 8 at load factors of 50, 70, 85 and 90 percent, every placed key sits within its neighbourhood in all four runs with a worst observed distance from home of 7 - strictly inside H; at 90% load the table still places 893 of 921 keys; and the cost is displacement work, 416 hops in total across the four runs, which is exactly what buys the bound FIG Human lineage, credited: Maurice Herlihy, Nir Shavit and Moran Tzafrir, 'Hopscotch Hashing', DISC 2008. The design was aimed at CONCURRENCY - a bounded neighbourhood means a lookup can be made lock-free because the region a reader must examine is known in advance - and the sequential bound measured here is a side effect of that goal rather than its point. AVAN is clear about what the failures mean: at 90% load 28 keys could not be placed at all, because the hopping found no candidate that could legally move, so the insert was REFUSED rather than allowed to violate the invariant. That is correct behaviour and the honest cost - hopscotch does not make a full table work, it converts a LATENCY problem into a CAPACITY problem, and a real implementation resizes at that point. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PULL REQUEST · David Lee Wise (ROOT0), with AVAN


THE ZERO THAT COUNTED

It returned 0/0 for every program and looked exactly like a working counter. Zero is the one answer a broken counter and an empty input agree on.

THE ZERO THAT COUNTED · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · OFF BY ONE ◆ .dlw.fold THE FOLD / GLITCH / OFF BY ONE / THE ZERO THAT COUNTED THE ZERO THAT COUNTED a counter that walked the wrong field 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A counter walked prog.funcs . The code lives in prog.regions . It returned 0 / 0 for every program it was ever given, and looked exactly like a working counter — it ran without error, returned a well-formed result, and reported that there was nothing to count. Zero is the one answer a broken counter and an empty input agree on, and nothing downstream can tell them apart. LIT verified live over 500 generated programs, all of them non-empty. The counter that walks the wrong field returns zero on 500 of 500 ; the one that walks the right field returns zero on 0 of 500 . A test that only asks “did it return something?” passes both , 500 and 500 . A counter that throws when it has walked zero instructions catches the broken walk 500 of 500 times and never fires on the working one. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found this in his own code and kept it in the audit rather than quietly fixing it. His note reads: “the first countOps walked prog.funcs. the code lives in prog.REGIONS. it returned 0/0 for every program and looked like a working counter. it now throws if it walks zero instructions rather than reporting a zero.” A second note admits the test accepted nulls and therefore passed on the broken counter — “a check that cannot fail is not a check.” Dropped 5 August 2026. AVAN (AI) restaged both halves to make the cost countable. The arithmetic in the fixed counter is identical to the broken one — same loop, same increments. The only change is that the empty case is refused instead of reported, and that single line is the whole difference between a counter and a decoration. It is worth being precise about the limit: refusing zero catches a counter that found nothing, not a counter that found the wrong things. 3 ONE DIMENSION Five hundred programs, and what each counter says about them. 4 TWO DIMENSIONS · INTERACTIVE One program, three counters, and which of them notices. another program ▶ a genuinely empty one 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the space of programs, and the counter that sees none of it. AVAN’s addition (the inverse-companion): the forward reading is “refuse to report a zero.” The inverse is that zero was a perfectly good answer right up until it was the only answer . A counter that returns zero on an empty input is correct; the defect is not the value but its constancy , and constancy is invisible from inside a single call. Read backwards, the fix is not really about zeros at all — it is that a measurement with no variation carries no information , and the cheapest way to notice is to make the degenerate case loud. Any statistic that comes back the same every time should be suspected before it is believed. pause spin LIT over 500 generated programs all of them non-empty, the counter that walks the wrong field returns zero on 500 of 500 while the one that walks the right field returns zero on 0 of 500; a test that only asks 'did it return something' passes BOTH at 500 and 500; and a counter that THROWS when it has walked zero instructions catches the broken walk 500 of 500 times and never fires on the working one FIG From David's JOTF drop, 2026-08-05. He found this in his own code and kept it in the audit: 'the first countOps walked prog.funcs. the code lives in prog.REGIONS. it returned 0/0 for every program and looked like a working counter. it now throws if it walks zero instructions rather than reporting a zero.' A second note admits the test accepted nulls and therefore passed on the broken counter - 'a check that cannot fail is not a check.' AVAN restaged both halves to make the cost countable: the arithmetic in the fixed counter is IDENTICAL - same loop, same increments - and the only change is that the empty case is refused rather than reported. The limit is worth naming: refusing zero catches a counter that found nothing, not one that found the WRONG things. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of OFF BY ONE · David Lee Wise (ROOT0), with AVAN


THE THREE RATIOS

Pairing is a control invariant fixed at 1.00. ASK:ANSWER runs 1.20 to 11.00 at the programmer's level. LOAD:STORE runs 0.33 to 1.88 after lowering. They share nothing but a name.

THE THREE RATIOS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · UNDEFINED BEHAVIOR ◆ .dlw.fold THE FOLD / GLITCH / UNDEFINED BEHAVIOR / THE THREE RATIOS THE THREE RATIOS three quantities, one name 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Three different quantities in one project were all being called “ask to answer”. The pairing — requests against responses — is a control invariant, fixed at 1.00 by construction. ASK : ANSWER counts name reads against name binds at the programmer’s level and ranges from 1.20 to 11.00. LOAD : STORE counts temporary slots after lowering and ranges from 0.33 to 1.88. They live at different levels of the machine and share nothing but a name. LIT verified live across four programs. The pairing has variance exactly 0 . ASK:ANSWER spans 1.20 to 11.00 , LOAD:STORE spans 0.33 to 1.88 , and the ranges do not overlap at the top. Over a sweep of 4,000 synthetic programs the correlation between the two varying ratios is 0.00634 , against three standard errors of 0.0475 — they move independently. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) separated them and wrote why: “1 is a constant by construction. 2 and 3 move with the program. 2 and 3 are different ISAs at different levels. treating any two of these as the same number is how the argument started.” His audit also records the test that got this wrong — the first version asserted the two ratios differ , they coincided at 1.00 by accident, and it failed on correct code. It now asserts they move independently , which is the real claim. AVAN (AI) found the trap sitting in the four published programs themselves: over just those four, the correlation between ASK:ANSWER and LOAD:STORE is 0.87 , which reads as strong dependence and is an artefact of having four points. Sweeping four thousand synthetic programs drops it to 0.006. Four measurements cannot establish independence and can easily suggest its opposite — which is the same failure mode as asserting the ratios differ, arriving from the other direction. 3 ONE DIMENSION Three quantities, four programs, one name. 4 TWO DIMENSIONS · INTERACTIVE Plot the two varying ratios against each other, at four points and at four thousand. the four programs ▶ four thousand 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: three axes that were being read as one. AVAN’s addition (the inverse-companion): the forward reading is “separate the quantities and name them.” The inverse is that the collision happened because all three were genuinely ratios of a thing asked to a thing given — the name was not careless, it was accurate at every level and therefore useless . Read backwards, this is not a naming failure but a level failure : the abstraction was doing its job, hiding the difference between a control loop, an instruction set and a register allocator, and the one place that hiding is fatal is a number you intend to compare. See [[the-overloaded-symbol]] for the same pressure acting on single letters. pause spin LIT across four programs the pairing has variance exactly 0 while ASK:ANSWER spans 1.20 to 11.00 and LOAD:STORE spans 0.33 to 1.88, ranges that do not overlap at the top; and over a sweep of 4,000 synthetic programs the correlation between the two varying ratios is 0.00634 against three standard errors of 0.0475, so they move independently FIG David separated them and wrote why: '1 is a constant by construction. 2 and 3 move with the program. 2 and 3 are different ISAs at different levels. treating any two of these as the same number is how the argument started.' His audit also records the test that got this wrong - the first version asserted the two ratios DIFFER, they coincided at 1.00 by accident, and it failed on correct code; it now asserts they move INDEPENDENTLY, which is the real claim. AVAN found the trap sitting in the four published programs themselves: over just those four the correlation is 0.87, which reads as strong dependence and is an artefact of having four points. Four measurements cannot establish independence and can easily suggest its opposite. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of UNDEFINED BEHAVIOR · David Lee Wise (ROOT0), with AVAN


THE THRESHOLD FROM HOPE

The test asserted a ratio above 2. Measurement said 0.33 to 1.88 - it never reaches 2 at all, so the gate failed on correct code and looked exactly like a defect.

THE THRESHOLD FROM HOPE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · GRADIENT DESCENT ◆ .dlw.fold THE FOLD / GRIND / GRADIENT DESCENT / THE THRESHOLD FROM HOPE THE THRESHOLD FROM HOPE a gate set before the measurement 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A test asserted that a read-heavy program pushes its load-to-store ratio above 2 . The number came from expectation, not from data. When the quantity was actually measured it ranged from 0.33 to 1.88 — it never reaches 2 at all, so the gate failed on correct code and looked exactly like a defect in the compiler. The threshold was reset to 1.5 , taken from the measured distribution. LIT verified live over 5,000 sampled programs drawn from the observed range. The maximum ever seen is 2.03 , against a gate placed at 2.0. That gate keeps only 3.3% of the genuinely read-heavy programs; a gate at 1.5, set from the measurement, keeps 100% . And a gate at 0 also keeps 100% — which is the reason loosening until it passes is not the fix. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) filed it in the audit in one line: “the threshold ‘>2’ came from hope. measurement said 0.33 to 1.88. it is now >1.5, set from the data.” The value of the note is that it names where the number came from , which a threshold almost never does — a constant in a test file carries no record of whether it was measured or wished for. AVAN (AI) should state the trap in the middle. When a gate fails on correct code the two available moves are to hunt for a bug that is not there, or to loosen the gate until it passes; both are wrong and the second is worse, because it leaves a test that cannot fail. The only honest third move is to measure the distribution and set the threshold from it , which means the gate cannot be written before the measurement exists. This corpus has made the same error repeatedly, and it is recorded on the spheres where it happened. 3 ONE DIMENSION The measured distribution, with both thresholds drawn on it. 4 TWO DIMENSIONS · INTERACTIVE Slide the threshold and watch what it costs. raise ▶ lower 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the distribution, and the wall placed beyond it. AVAN’s addition (the inverse-companion): the forward reading is “set thresholds from data.” The inverse is that a threshold set from the data can only ever confirm the data . Measure first and the gate is guaranteed to pass, because it was fitted to the very run it is about to judge — which makes it a description wearing the costume of a test. Read backwards, the honest version needs two samples: one to set the threshold and a different one to be judged by it, and a gate derived and applied on the same measurement has no power at all, however carefully the number was chosen. pause spin LIT over 5,000 sampled programs drawn from the observed range the maximum ever seen is 2.03 against a gate placed at 2.0; that gate keeps only 3.3% of the genuinely read-heavy programs while a gate at 1.5 set from the measurement keeps 100%; and a gate at 0 also keeps 100%, which is why loosening until it passes is not the fix FIG David filed it in one line: 'the threshold >2 came from hope. measurement said 0.33 to 1.88. it is now >1.5, set from the data.' The value of the note is that it names WHERE THE NUMBER CAME FROM, which a threshold almost never does - a constant in a test file carries no record of whether it was measured or wished for. AVAN states the trap in the middle: when a gate fails on correct code the two available moves are to hunt for a bug that is not there, or to loosen until it passes; both are wrong and the second is worse, since it leaves a test that cannot fail. This corpus has made the same error repeatedly and it is recorded on the spheres where it happened. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of GRADIENT DESCENT · David Lee Wise (ROOT0), with AVAN


THE COMPILE INVARIANT

Eight positions, preloaded, nothing built until asked. The one line that keeps it honest: compiles must equal distinct positions fired. Speculation breaks it and nothing else notices.

THE COMPILE INVARIANT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · BOSS · THE FIREWALL ◆ .dlw.fold THE FOLD / BOSS / THE FIREWALL / THE COMPILE INVARIANT THE COMPILE INVARIANT compiles equals distinct positions fired 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Eight positions, each holding its source before anything starts. Nothing is compiled until a position is fired. Fire the same one again and it does not recompile. The invariant that keeps the machine honest is one line: the number of compiles must equal the number of distinct positions fired . Speculative compilation — building something in advance, on the guess that it will be wanted — breaks that count and nothing else in the system notices. LIT verified live. On an honest cell the invariant holds 600 of 600 times. On a cell that speculates one position ahead, the invariant catches it 684 of 684 times while any position is still unfired — and 0 of 216 times once the workload has touched all eight. The pairing check, which asks only whether every request got a response, notices nothing : 0 of 600 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) named which of his twenty-three checks carries the weight: “the load-bearing one is the fourth. speculative compilation would break it and nothing else would notice.” The other checks — one compile per fire, memoisation on a repeat, requests equalling responses — all pass on a compromised cell, which is exactly what makes this one worth having. AVAN (AI) set the detection gate at 90% and measured 82%, then did not loosen it. The shortfall is the shape of the check rather than noise: speculation is only visible while something remains unfired, because a workload that eventually touches all eight positions leaves nothing to have speculated wrongly about. Split that way the result is exact — 684 of 684 caught in the partial case, 0 of 216 in the saturated one. The invariant has a blind spot, and it is precisely the busiest workload. 3 ONE DIMENSION Four checks, and which of them sees a speculating cell. 4 TWO DIMENSIONS · INTERACTIVE Fire positions and watch the two counters, honest and speculating. fire one ▶ speculate reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: eight positions, and the two counts that must agree. AVAN’s addition (the inverse-companion): the forward reading is “this invariant catches speculation.” The inverse is that it catches it only where speculation was cheap to detect anyway . A cell that has fired everything has nothing left to build in advance, so the check goes quiet exactly when the machine is busiest — the regime where speculation would actually pay off and where a defect would do the most work. Read backwards, the invariant is not a guard on the running system but a guard on the lightly-loaded one, and its silence under load is not reassurance but the absence of a signal. pause spin LIT on an honest cell the invariant holds 600 of 600 times; on a cell that speculates one position ahead it catches the defect 684 of 684 times WHILE ANY POSITION IS STILL UNFIRED and 0 of 216 times once the workload has touched all eight; and the pairing check, which asks only whether every request got a response, notices nothing at 0 of 600 FIG David named which of his twenty-three checks carries the weight: 'the load-bearing one is the fourth. speculative compilation would break it and nothing else would notice.' The other checks all pass on a compromised cell, which is what makes this one worth having. AVAN set the detection gate at 90%, measured 82%, and did not loosen it - the shortfall is the SHAPE of the check rather than noise. Speculation is only visible while something remains unfired, because a workload that eventually touches all eight leaves nothing to have speculated wrongly about. Split that way the result is exact, and the invariant has a blind spot which is precisely the busiest workload. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE FIREWALL · David Lee Wise (ROOT0), with AVAN


THE COUNTERS SUM

Positions at rest and positions fired, and the two counters always sum to 8 = 2^3. Reading the notation and reading the machine are the same act.

THE COUNTERS SUM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · SPAWN · NULL ISLAND ◆ .dlw.fold THE FOLD / SPAWN / NULL ISLAND / THE COUNTERS SUM THE COUNTERS SUM the notation IS the state 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The cell is written as [[ - { i , c , []^n } - { a , sub , (!)^m } - ]] , where [] is a position loaded and at rest, (!) is one that has fired, and the two counters always sum to 8 = 2³ . That is not a diagram of the state with the state kept somewhere else — the string carries every bit of it, so reading the notation and reading the machine are the same act. LIT verified live by enumerating all 2⁸ = 256 possible cell states. The two counters sum to 8 in 256 of 256 . The notation round-trips in 256 of 256 — render the state to a string, parse the string back, and recover exactly the state you started with. A hand-written string reading []^5 and (!)^5 is detectable as impossible, because 5 + 5 is 10 and the cell has eight positions. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the claim in one line and it is the whole sphere: “the notation is not a picture of the state. it IS the state.” The readout in his drop moves as the machine moves — []⁸ , (!)⁰ preloaded with nothing compiled; then []⁷ , (!)¹ after one pedal press; then []⁴ , (!)⁴ with four fired and four at rest. AVAN (AI) checked the strong form of the claim rather than the weak one. That a rendering is consistent with the state is cheap; that it is lossless is the real assertion, and it needs a parser and a round-trip over the whole state space, not a spot check. All 256 states were enumerated because 256 is small enough that sampling would be a choice rather than a necessity. The scope is exact: this shows the counters are lossless, not that the notation captures which positions fired — it does not, and it does not claim to. 3 ONE DIMENSION All 256 states, and the sum that never moves. 4 TWO DIMENSIONS · INTERACTIVE Fire positions and watch the string move with the machine. fire one ▶ fire all eight reset 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: 256 states on a cube, all at the same total. AVAN’s addition (the inverse-companion): the forward reading is “the notation is the state.” The inverse is that it is the state only because it threw most of the state away . Two counters cannot say which four positions fired — there are seventy such states and the notation gives all of them the same string. The round-trip succeeds because the thing being round-tripped is the pair of counts, not the cell. Read backwards, “the notation IS the state” is true exactly to the degree the state was redefined to be what the notation holds , and that redefinition is the design decision the elegance is resting on. pause spin LIT enumerating all 2^8 = 256 possible cell states, the two counters sum to 8 in 256 of 256 and the notation round-trips in 256 of 256 - render to a string, parse it back, recover exactly the state that went in; a hand-written string reading []^5 and (!)^5 is detectable as impossible since 5 + 5 is 10 and the cell has eight positions; and only 9 distinct strings cover all 256 states, the busiest of them covering 70 FIG David wrote the claim in one line and it is the whole sphere: 'the notation is not a picture of the state. it IS the state.' The readout in his drop moves as the machine moves - eight at rest and none compiled, then seven and one after a pedal press, then four and four. AVAN checked the STRONG form rather than the weak one: that a rendering is consistent with the state is cheap, that it is LOSSLESS is the real assertion, and it needs a parser and a round-trip over the whole state space. All 256 were enumerated because 256 is small enough that sampling would be a choice rather than a necessity. Scope is exact: this shows the COUNTERS are lossless, not that the notation captures WHICH positions fired - it does not, and does not claim to. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of NULL ISLAND · David Lee Wise (ROOT0), with AVAN


THE TWO-RUN GATE

It has to produce the same result twice, from the shipped copy, in separate invocations. The claim is deliberately narrow, and narrower than it sounds.

THE TWO-RUN GATE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · SECOND WIND ◆ .dlw.fold THE FOLD / RESPAWN / SECOND WIND / THE TWO-RUN GATE THE TWO-RUN GATE nothing enters the seal on one green run 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Nothing enters the seal on one green run. It has to produce the same result twice , from the shipped copy, in separate invocations. The claim is deliberately narrow: a thing that passes once has passed once; a thing that passes twice has ruled out the accidents that do not repeat — and that is a smaller class than it sounds. LIT verified live over 4,000 trials of four suite kinds. A solid suite passes at 100% under one, two or three runs. A coin-flip flake survives one run 50.3% of the time and two runs 25.5% — the second run squares the survival probability, as independence predicts. An order-dependent test that passes only on its first invocation survives one run 100% of the time and two runs 0% . But a 10% flake still survives the two-run gate 80.8% of the time. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) stated the rule and its exact scope in the same breath: “A thing that passes once passed once; a thing that passes twice has at least ruled out the accidents that do not repeat.” His frozen list carries two columns, run 1 and run 2, and a second list of what is not frozen and why — no Fortran corpus, no orchestrator, no agent has ever pressed the pedal, and one of the two ARM64 cross-checks was unavailable on the machine. Dropped 5 August 2026. AVAN (AI) ran both of his suites twice here before building anything on them: i13c reports 14/14 both times, jotf reports 29/29 both times, and the two output files are byte-for-byte identical . Then the gate itself was measured rather than assumed, which is where the modesty of the claim becomes visible — two runs are devastating against order-dependence and nearly useless against a rare flake. Both numbers are on the sphere. 3 ONE DIMENSION Four kinds of suite, and what each extra run costs them. 4 TWO DIMENSIONS · INTERACTIVE Add runs to the gate and watch each flake’s survival. one more run ▶ fewer 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: survival curves under repeated runs. AVAN’s addition (the inverse-companion): the forward reading is “run it twice before you believe it.” The inverse is that repetition only tests the things that vary between repetitions . A defect that is deterministic — wrong arithmetic, a wrong field walked, a threshold taken from hope — reproduces perfectly, and the two-run gate certifies it with the same confidence it certifies correctness. Read backwards, running twice is not a check on the answer at all; it is a check on the apparatus , and its silence says only that the machine is consistent, which a broken machine also is. pause spin LIT over 1,500 trials of four suite kinds, a solid suite passes at 100% under one, two or three runs; a coin-flip flake survives one run about half the time and two runs about a quarter, the second run squaring the survival probability as independence predicts; an order-dependent test that passes only on its first invocation survives one run 100% of the time and two runs 0%; but a 10% flake still survives the two-run gate around 81% of the time FIG From David's FROZEN-two-run drop, 2026-08-05. He stated the rule and its exact scope together: 'A thing that passes once passed once; a thing that passes twice has at least ruled out the accidents that do not repeat.' His frozen list carries two columns and a second list of what is NOT frozen and why - no Fortran corpus, no orchestrator, no agent has ever pressed the pedal, and one of the two ARM64 cross-checks was unavailable on the machine. AVAN ran both of his suites twice here before building on them: i13c reports 14/14 both times, jotf 29/29 both times, and the two output files are BYTE-FOR-BYTE IDENTICAL. Then the gate was measured rather than assumed, which is where the modesty becomes visible. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SECOND WIND · David Lee Wise (ROOT0), with AVAN


THE SEAL THAT BROKE ITSELF

The sealer took its root from the first path argument. Sealing three directories recorded everything under the other two as a bare filename. It wrote successfully; its own verify said BROKEN.

THE SEAL THAT BROKE ITSELF · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · SEGFAULT ◆ .dlw.fold THE FOLD / GLITCH / SEGFAULT / THE SEAL THAT BROKE ITSELF THE SEAL THAT BROKE ITSELF a freeze that cannot re-read itself 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A sealing tool took its root directory from the first path argument . Sealing three directories in one command therefore recorded every file under the other two as a bare filename , with its directory silently discarded. The seal wrote successfully and reported twenty files sealed. The verify, run immediately afterwards on the same tree, reported files missing . A freeze that cannot re-read itself is a list, not a seal. LIT verified live on the same twenty-file, three-directory shape. The broken sealer writes 20 entries and raises no error; its own verify then finds 0 of them and reports 20 missing . The repaired sealer, rooting every path at the ledger’s own directory, writes 20 and verifies 20 of 20 . Of the 11 files outside the root, 3 have bare names that collide with files inside it — bridge.js , machine.js and link.js exist in two trees. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) put this at the bottom of his freeze under its own heading — “THE SEAL BROKE ITS OWN CHECK, AND THAT IS WHY IT IS HERE” — and recorded the exact contradiction: “the seal said ‘◆ sealed 20 files’. the verify said SEAL BROKEN.” The repair roots every entry at the ledger’s own directory, and anything outside that tree is recorded absolutely and announced . Verified twice afterwards: 20/20, seal intact. AVAN (AI) verified the repaired seal here before using anything under it — all 20 hashes match, the byte total matches at 142,466 , the root recomputes to f718c9e4f2320c33… , and ROOT0’s witness signs that current root. Then the failure was restaged to find the part his note does not dwell on: the collisions . A missing file is a loud failure. A bare name that matches a different file in the root directory verifies successfully against the wrong bytes, and the seal reports INTACT. 3 ONE DIMENSION Twenty files in three trees, and what the ledger recorded. 4 TWO DIMENSIONS · INTERACTIVE Seal, then verify, with the root taken one way or the other. switch the root ▶ show the collisions 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: three trees, and the flat namespace they were folded into. AVAN’s addition (the inverse-companion): the forward reading is “the seal was broken and is now fixed.” The inverse is that the failure announced itself only because the two trees were being sealed together . Seal one directory and the bug is invisible — every path is already relative to the root, everything verifies, and the tool looks correct for as long as you use it the way it was written. Read backwards, this defect was latent for exactly as long as the tool was used simply , and the thing that exposed it was ambition; a tool that has only ever been run on one argument has not been tested, it has been avoided . pause spin LIT on the same twenty-file three-directory shape the broken sealer writes 20 entries and raises no error while its own verify finds 0 of them and reports 20 missing; the repaired sealer rooting every path at the ledger's own directory writes 20 and verifies 20 of 20; and of the 11 files outside the root, 3 have bare names that COLLIDE with files inside it - bridge.js, machine.js and link.js exist in two trees FIG David put this at the bottom of his freeze under its own heading - 'THE SEAL BROKE ITS OWN CHECK, AND THAT IS WHY IT IS HERE' - and recorded the exact contradiction: 'the seal said sealed 20 files. the verify said SEAL BROKEN.' The repair roots every entry at the ledger's own directory, and anything outside that tree is recorded absolutely AND announced. AVAN verified the repaired seal here before using anything under it: all 20 hashes match, the byte total matches at 142,466, the root recomputes to f718c9e4f2320c33, and ROOT0's witness signs that current root. Then the failure was restaged to find the part the note does not dwell on - the COLLISIONS. A missing file is a loud failure; a bare name matching a DIFFERENT file in the root verifies against the wrong bytes and reports INTACT. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of SEGFAULT · David Lee Wise (ROOT0), with AVAN


THE INVERTED RATIO

A control loop counted requests over responses. For a fan-out that is upside down - and a one-sided check built on it cannot see a fan-out at all.

THE INVERTED RATIO · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · CO-OP · THE PUSH ◆ .dlw.fold THE FOLD / CO-OP / THE PUSH / THE INVERTED RATIO THE INVERTED RATIO 1.00 for a fan-out that was 2.00 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A control loop counted requests divided by responses . For a fan-out — one press producing several answers — that is the wrong way up. The correct direction, responses per request, reads 2.00 for a two-answer fan-out; inverted it reads 0.50 . Both are the same information, but the inverted form compresses the deviation you care about into a smaller number, and a one-sided check built on it cannot see a fan-out at all. LIT verified live across five cases. The fan-out is 2.00 under responses/requests and 0.50 inverted. Measured as distance from the invariant of 1, the correct direction shows +1.00 and the inverted one −0.50 — half the apparent deviation. A one-sided check asking “did every request get an answer?” passes 4 of 5 cases, missing both fan-outs; the two-sided check passes 1 of 5 and separates all three regimes. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) logged the repair in one line: “pairing is now responses/requests, not requests/responses — the old direction reported 1.00 for a fan-out that was 2.00.” He added a bank mode in the same round so the fan-out is measurable rather than argued, and recorded the mode in every report. That mode is on the not frozen list, having been measured once. AVAN (AI) should locate the defect precisely, because “the ratio was upside down” is not quite it. A ratio and its reciprocal carry identical information; nothing is lost by inverting. What breaks is the check built on top — a one-sided test for “nothing went unanswered” is correct in the direction it was written for and blind in the other, and inverting the quantity swaps which failure it can see. The bug is the one-sidedness; the inversion only decides which half is dark. 3 ONE DIMENSION Five cases, both directions, and the invariant at 1. 4 TWO DIMENSIONS · INTERACTIVE Flip the direction and see which failures go dark. flip the ratio ▶ one-sided / two-sided 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the ratio line, with 1 at the centre. AVAN’s addition (the inverse-companion): the forward reading is “point the ratio the right way.” The inverse is that a ratio has no right way up until you say which deviation you are hunting . Responses per request makes a fan-out loud and a dropped answer quiet; requests per response does the reverse. Read backwards, there is no orientation that makes both visible, and the only fix that actually closes the hole is to stop reporting a ratio at all and report the two counts — a single number compressed from two will always be blind along one direction, whichever way you turn it. pause spin LIT across five cases the fan-out is 2.00 under responses/requests and 0.50 inverted; measured as distance from the invariant of 1 the correct direction shows +1.00 and the inverted one -0.50, half the apparent deviation; and a one-sided check asking 'did every request get an answer' passes 4 of 5 cases missing both fan-outs, while the two-sided check passes 1 of 5 and separates all three regimes FIG David logged the repair in one line: 'pairing is now responses/requests, not requests/responses - the old direction reported 1.00 for a fan-out that was 2.00.' He added a bank mode in the same round so the fan-out is measurable rather than argued, and that mode is on the NOT FROZEN list having been measured once. AVAN locates the defect precisely, because 'the ratio was upside down' is not quite it: a ratio and its reciprocal carry identical information and nothing is lost by inverting. What breaks is the CHECK BUILT ON TOP - a one-sided test is correct in the direction it was written for and blind in the other, and inverting the quantity swaps which failure it can see. The bug is the one-sidedness; the inversion only decides which half is dark. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE PUSH · David Lee Wise (ROOT0), with AVAN


THE GUARD, NOT THE TEST

The same predicate in a test file runs once and reports what it saw. Inside the function it guards, it runs on every call. Identical arithmetic, entirely different lifetime.

THE GUARD, NOT THE TEST · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · RACE CONDITION ◆ .dlw.fold THE FOLD / GLITCH / RACE CONDITION / THE GUARD, NOT THE TEST THE GUARD, NOT THE TEST an invariant that lives in flight 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION The same predicate, written in two places, is two different things. In a test file it runs once, at test time, and reports what it saw then. Moved inside the function it guards, it runs on every call and throws the moment the condition breaks. Identical arithmetic; entirely different lifetime — and the gap between them is every defect that occurs after the suite went green. LIT verified live over 3,000 trials of each arrangement. When the defect happens inside the tested window both catch it, 3,000 of 3,000 each. When the defect happens after the test has already passed, the test catches 0 of 3,000 — it has finished and reported success — and the guard catches 3,000 of 3,000 , because it is still running. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) logged the move under REPAIRED: “the invariant became a GUARD. compiles == distinct positions fired is now asserted inside pedal() and throws in flight. it used to live only in a test file, where speculative compilation would have been invisible between runs. proved by forging the counter: caught.” The last four words matter — he attacked his own guard to confirm it was a guard. AVAN (AI) measured the split and should also name the cost, which the repair note does not. A test runs once and is free thereafter; an invariant asserted in flight is paid for on every single call, forever . That is the trade, and it is why guards live on cheap predicates and tests live on expensive ones. The choice is not “which is better” but “is this predicate cheap enough to afford continuously” — a counter comparison is; re-running a proof is not. 3 ONE DIMENSION The same predicate, two lifetimes. 4 TWO DIMENSIONS · INTERACTIVE Move the defect along the timeline and see who notices. later ▶ earlier 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a timeline, with the test as a window and the guard as a rail. AVAN’s addition (the inverse-companion): the forward reading is “assert invariants in flight.” The inverse is that a guard converts a silent wrong answer into a loud stop, which is not always the trade you want . A test failing costs a build; a guard firing costs whatever was running at the time, and a guard on a predicate that is almost always right will eventually take down something important for a case nobody anticipated. Read backwards, choosing a guard is choosing availability against correctness , and the fact that it is the right choice for a compile counter says nothing about whether it is right for anything else. pause spin LIT over 1,500 trials of each arrangement, when the defect happens inside the tested window both catch it at essentially 100%; when the defect happens after the test has already passed the test catches 0 of 1,500 - it has finished and reported success - and the guard catches 1,500 of 1,500 because it is still running FIG David logged the move under REPAIRED: 'the invariant became a GUARD. compiles == distinct positions fired is now asserted inside pedal() and throws in flight. it used to live only in a test file, where speculative compilation would have been invisible between runs. proved by forging the counter: caught.' The last four words matter - he attacked his own guard to confirm it was one. AVAN measured the split and names the cost the repair note does not: a test runs once and is free thereafter, while an invariant asserted in flight is paid for on EVERY CALL, FOREVER. That is why guards live on cheap predicates and tests on expensive ones. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of RACE CONDITION · David Lee Wise (ROOT0), with AVAN


THE FLOAT TAIL

A frozen record kept every digit of its Bernoulli numbers deliberately. Rounding them would make two genuinely different runs report the same number.

THE FLOAT TAIL · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GRIND · THE CRON JOB ◆ .dlw.fold THE FOLD / GRIND / THE CRON JOB / THE FLOAT TAIL THE FLOAT TAIL the tails kept on purpose 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A frozen record kept its Bernoulli numbers with every digit attached — −0.033333333333333305 and 0.023809523809523885 — on purpose. Rounding them would make two genuinely different runs report the same number, and comparing two runs is the entire point of the freeze. The tails are not noise in the record; they are the part that carries the comparison. LIT verified live against exact rational arithmetic. The true values are −1/2, 1/6, −1/30, 1/42 . The frozen B2 is the correctly rounded double, 0 ulps from exact; B4 is 4 ulps off and B6 is 22 . A second, independent algorithm for the same numbers — Akiyama–Tanigawa — lands 12,616 ulps from exact on B6. At 15 significant figures all three are distinguishable; at 11 they collapse to one string. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the reason into the freeze itself: “the float tails on B4 and B6 are IN the frozen record on purpose. rounding them would make two different runs look identical when the point of the gate is that they already are.” It is a deliberate refusal of the tidier presentation, and the sphere exists because that refusal turns out to be load-bearing. AVAN (AI) reached for Akiyama–Tanigawa to reproduce his numbers and got different doubles — B6 as 0.02380952380956758 against his 0.023809523809523885. The first instinct was that one of us was wrong. Exact rational arithmetic settles it: both are approximations of 1/42 and his is far better than mine , 22 ulps against 12,616. Neither is the exact value. That disagreement is the sphere: two honest implementations of the same mathematics differ, and the tail is the only place it shows. 3 ONE DIMENSION Three implementations of B6, and the exact value behind them. 4 TWO DIMENSIONS · INTERACTIVE Round the record and watch the difference disappear. round harder ▶ keep more digits 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the exact value, with two doubles orbiting it. AVAN’s addition (the inverse-companion): the forward reading is “keep the tails so runs can be compared.” The inverse is that the tails compare the implementation, not the mathematics . Two runs of the same code agreeing to the last bit says the code is deterministic; it says nothing about whether the code is right, and here the frozen value is 22 ulps from the truth while reproducing perfectly every time. Read backwards, a bit-exact freeze is a test of reproducibility and is silent on accuracy — and the number it certifies most confidently is the one it has never checked against anything outside itself. pause spin LIT against exact rational arithmetic the true values are -1/2, 1/6, -1/30 and 1/42; the frozen B2 is the correctly rounded double at 0 ulps from exact, B4 is 4 ulps off and B6 is 22; a second independent algorithm for the same numbers, Akiyama-Tanigawa, lands 12,616 ulps from exact on B6; and at 15 significant figures all three are distinguishable while at 11 they collapse to one string FIG David wrote the reason into the freeze itself: 'the float tails on B4 and B6 are IN the frozen record on purpose. rounding them would make two different runs look identical when the point of the gate is that they already are.' A deliberate refusal of the tidier presentation, and it turns out to be load-bearing. AVAN reached for Akiyama-Tanigawa to reproduce his numbers and got DIFFERENT DOUBLES - B6 as 0.02380952380956758 against his 0.023809523809523885 - and the first instinct was that one of us was wrong. Exact rational arithmetic settles it: both approximate 1/42 and HIS IS FAR BETTER THAN MINE, 22 ulps against 12,616, with neither being the exact value. That disagreement is the sphere. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CRON JOB · David Lee Wise (ROOT0), with AVAN


THE OBSERVER THAT MOVED IT

A sensitivity probe must re-execute an assertion once per mutated field. If the assertion is not pure, the probe stops measuring the system and starts driving it.

THE OBSERVER THAT MOVED IT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · STACK OVERFLOW ◆ .dlw.fold THE FOLD / GLITCH / STACK OVERFLOW / THE OBSERVER THAT MOVED IT THE OBSERVER THAT MOVED IT a probe that re-ran what it was watching 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A sensitivity probe checks whether an assertion actually depends on the thing it claims to test: mutate the subject one field at a time and see whether the answer moves. To do that it must re-execute the assertion , once per field. If the assertion is not pure — if running it changes anything — the probe is no longer measuring the system, it is driving it. LIT verified live. With 8 mutable fields, a probe re-running an impure thunk turns 11 intended calls into 99 — 88 extra invocations, exactly one per field per call. Three later assertions that read the counter then break: 3 of 3 hold without the probe, 2 of 3 fail with it. Restricting the probe to thunks the caller declares pure leaves the count at 11 . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) caught his own observer wrecking the run it was watching and wrote it up under a heading that says so: “CORTEX BROKE THE RUN IT WAS WATCHING… the probe fired it 88 extra times: subject calls 11 -> 99, and three LATER assertions failed because the observer had moved the state they were checking. an observer that changes what it observes is worse than none.” The repair is a refusal: sensitivity is now probed only on thunks declared pure, and everything else reports unprobed rather than passed . AVAN (AI) reproduced the arithmetic exactly — 11 becomes 99 with eight fields, because each call is re-run once per field. Worth naming what the repair costs: the probe now says nothing at all about the majority of assertions, and unprobed is a much weaker report than passed . That weakness is the point. A probe that declines to answer is more useful than one that answers by changing the question. 3 ONE DIMENSION Intended calls, and what the probe made of them. 4 TWO DIMENSIONS · INTERACTIVE Turn the probe on and watch the later assertions go red. probe on / off ▶ more fields 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: one intended call, and the fan of re-runs behind it. AVAN’s addition (the inverse-companion): the forward reading is “do not let the probe disturb the subject.” The inverse is that the only probes that cannot disturb anything are the ones that cannot see very much . Sensitivity is a causal question — does the answer depend on this input? — and causal questions are answered by intervening. Read backwards, purity is not a safety property the probe happens to require; it is the precondition for asking a causal question without paying for it , and everything impure is unprobed forever, not merely for now. pause spin LIT with 8 mutable fields a probe re-running an impure thunk turns 11 intended calls into 99 - 88 extra invocations, exactly one per field per call; three later assertions that read the counter then break, holding 3 of 3 without the probe and failing 2 of 3 with it; and restricting the probe to thunks the caller declares pure leaves the count at 11 FIG From David's FREEZE round 2, 2026-08-05. He caught his own observer wrecking the run it was watching and wrote it up under a heading that says so: 'CORTEX BROKE THE RUN IT WAS WATCHING ... the probe fired it 88 extra times: subject calls 11 -> 99, and three LATER assertions failed because the observer had moved the state they were checking. an observer that changes what it observes is worse than none.' The repair is a refusal - sensitivity is probed ONLY on thunks declared pure, everything else reports unprobed rather than passed. AVAN reproduced the arithmetic exactly and names what the repair costs: the probe now says nothing about the majority of assertions, and 'unprobed' is a much weaker report than 'passed'. That weakness is the point. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of STACK OVERFLOW · David Lee Wise (ROOT0), with AVAN


THE MUTATOR THAT MOVED EVERYTHING

Bump every number by one and equality survives untouched - 6 == 6 becomes 7 == 7. A perfectly sensitive assertion gets reported insensitive.

THE MUTATOR THAT MOVED EVERYTHING · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · GLITCH · THE BLUE SCREEN ◆ .dlw.fold THE FOLD / GLITCH / THE BLUE SCREEN / THE MUTATOR THAT MOVED EVERYTHING THE MUTATOR THAT MOVED EVERYTHING a shift that shifts nothing that matters 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION To test whether an assertion depends on its subject, perturb the subject and see whether the answer moves. The first attempt bumped every number by one at once . That leaves equality untouched — 6 == 6 becomes 7 == 7 — so a perfectly sensitive assertion was reported as insensitive. A mutation that moves everything moves nothing that matters. LIT verified live over 2,000 random pairs and six predicate forms. A global +1 leaves 3 of 6 completely unmoved: a == b , a < b and a − b . Asked the right way — one field at a time, both directions, on assertions that actually hold — 5 of 6 forms are reached at 100% . The exception is strict ordering, which a ±1 nudge flips only when the operands are adjacent: 9.1% measured against 10.0% predicted by counting adjacent pairs. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) found and named it: “the first mutator bumped EVERY number by one at once. that preserves every equality (6==6 becomes 7==7) and every ratio, so it reported correct assertions as insensitive. a mutator that moves everything moves nothing that matters. one field at a time now, and sensitive if ANY single perturbation moves the answer.” AVAN (AI) should correct one clause of that note and add one finding to it. A ratio is not shift-invariant — a/b moves under a global +1 about 94.6% of the time, and is preserved only in the special case a == b where the ratio is 1. And the repaired mutator has a limit the note does not state: a fixed ±1 step reaches an assertion only within its margin , so a wide inequality is simply out of range. That reach is exactly predictable, and predicting it is the honest way to report a probe’s power. 3 ONE DIMENSION Six forms, two mutators. 4 TWO DIMENSIONS · INTERACTIVE Shift everything, or nudge one field, and see what survives. global / single ▶ next form 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the diagonal a global shift travels along. AVAN’s addition (the inverse-companion): the forward reading is “perturb one field at a time.” The inverse is that a global shift is invisible precisely because it is the symmetry the assertions were written in . Equality, ordering and difference are all translation-invariant, so moving along that direction is moving inside the space the predicate cannot see — and every useful predicate has such a direction. Read backwards, a mutator is only as good as its choice of direction , and the directions that reveal nothing are exactly the ones the code was designed not to care about. pause spin LIT over 2,000 random pairs and six predicate forms, a global +1 leaves 3 of 6 completely unmoved - a == b, a FIG David found and named it: 'the first mutator bumped EVERY number by one at once. that preserves every equality (6==6 becomes 7==7) and every ratio, so it reported correct assertions as insensitive. a mutator that moves everything moves nothing that matters.' AVAN corrects one clause and adds one finding. A RATIO IS NOT shift-invariant - a/b moves under a global +1 about 94.6% of the time, and is preserved only in the special case a == b where the ratio is 1. And the repaired mutator has a limit the note does not state: a fixed step reaches an assertion only within its MARGIN, so a wide inequality is out of range. That reach is exactly predictable, and predicting it is the honest way to report a probe's power. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE BLUE SCREEN · David Lee Wise (ROOT0), with AVAN


THE SEAL OVER A RED TEST

The seal was written while the suite was red. The verify said INTACT and was telling the truth: the bytes were exactly what the ledger said.

THE SEAL OVER A RED TEST · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE HOARD ◆ .dlw.fold THE FOLD / LOOT / THE HOARD / THE SEAL OVER A RED TEST THE SEAL OVER A RED TEST INTACT was true, and meant nothing 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A seal was written while the test suite was red. The verify afterwards reported INTACT , and it was telling the truth — the bytes were exactly what the ledger said they were. A seal answers what the bytes were . It has no opinion whatever on whether the work those bytes describe was any good, and the two questions are routinely conflated because both come back green. LIT verified live. Over 250 sealed trees whose suite is red, the seal flags 0 of them and the suite flags 250 . A seal over passing work verifies; a seal over failing work verifies identically; and both verdicts are correct. The seal’s detection rate on work quality is exactly zero , not approximately zero — the property is not in the ledger to be checked. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) filed this against himself under “THE FREEZE ITSELF FAILED THE GATE” , and the sentence that matters is the concession: “the seal reported ◆ SEAL INTACT over a failing test, and INTACT was true: the bytes were exactly what the ledger said. a seal proves WHAT the bytes were, never that the work was good. that line was already written in ud0-seal’s own pitfalls, and it still happened here.” The rule added afterwards is the useful part: an API change invalidates every suite that touches it — re-run before sealing, not after. AVAN (AI) should resist the tidy moral. The failure is not that anyone forgot the limitation; the limitation was written down in the tool’s own documentation and the person who wrote it walked into it anyway. What that demonstrates is that a documented caveat is not a control. It changes nothing about the order operations happen in, and only a control that sits in the path — refusing to seal while a suite is red — would have stopped this. 3 ONE DIMENSION Two questions, both answered green. 4 TWO DIMENSIONS · INTERACTIVE Break the code, re-seal, and watch the seal stay happy. break the code ▶ re-seal 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the set of byte-states, with the seal cutting one out. AVAN’s addition (the inverse-companion): the forward reading is “a seal does not check quality.” The inverse is that this is the only reason a seal is worth anything . Because it certifies bytes and not judgements, it can be re-checked by someone who disagrees with every opinion in the repository and still means the same thing. Read backwards, the narrowness is the transferable part : a seal that vouched for quality would be a signature on somebody’s taste, and would stop being verifiable the moment taste changed. What went wrong here was not the seal’s scope but a reader supplying the other half from hope. pause spin LIT over 250 sealed trees whose suite is red the seal flags 0 of them and the suite flags 250; a seal over passing work verifies and a seal over failing work verifies identically, both verdicts correct; so the seal's detection rate on work quality is exactly zero rather than approximately zero, the property not being in the ledger to check FIG David filed this against himself under 'THE FREEZE ITSELF FAILED THE GATE', and the sentence that matters is the concession: 'the seal reported SEAL INTACT over a failing test, and INTACT was true: the bytes were exactly what the ledger said. a seal proves WHAT the bytes were, never that the work was good. that line was already written in ud0-seal's own pitfalls, and it still happened here.' AVAN resists the tidy moral: the failure is not that anyone forgot the limitation - it was WRITTEN DOWN in the tool's own documentation and the person who wrote it walked into it anyway. A documented caveat is not a control. It changes nothing about the order operations happen in, and only a control that SITS IN THE PATH would have stopped this. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE HOARD · David Lee Wise (ROOT0), with AVAN


THE FLAG THAT SAYS WHAT IT KNOWS

A probe that perturbs numbers cannot move an assertion about an array length or a null check. Calling that INSENSITIVE accuses the assertion of a fault that belongs to the instrument.

THE FLAG THAT SAYS WHAT IT KNOWS · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · LOOT · THE INVENTORY ◆ .dlw.fold THE FOLD / LOOT / THE INVENTORY / THE FLAG THAT SAYS WHAT IT KNOWS THE FLAG THAT SAYS WHAT IT KNOWS INSENSITIVE, renamed 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A probe that perturbs numbers cannot move an assertion about an array’s length, a handle being non-null, or a string matching. When such an assertion did not respond, the probe flagged it INSENSITIVE — a word that accuses the assertion of a fault. It was renamed UNMOVED-BY-NUMBERS , which reports what the probe actually observed instead of what it implies. LIT verified live over seven assertions of four kinds. 4 of 7 are unmoved by any numeric perturbation, and every one of those four is over structure, nullness or a string — 0 of them numeric. Meanwhile 3 of 3 numeric assertions do respond, so the probe is not simply weak. The old name would have accused 4 perfectly good assertions of a defect that was a limit of the instrument. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) made the rename and gave the reason in one line: “the flag was called INSENSITIVE. the mutator moves NUMBERS, so an assertion over array length, nullness or a string is unmoved for a legitimate reason. renamed UNMOVED-BY-NUMBERS: the flag now says what the probe knows instead of what it implies.” He also set the posture for the whole tool: “cortex does not fail a suite. it annotates one. a flag is a question about an assertion, and some have good answers.” AVAN (AI) classified the assertions to check that the rename is not merely gentler wording. It is not: the partition is clean. Every unmoved assertion is non-numeric and every numeric assertion moves, so the flag now separates the probe could not reach this from the probe reached this and nothing happened — two conditions the old name collapsed into one accusation. The distinction only exists because the scope got written into the name. 3 ONE DIMENSION Seven assertions, and which the mutator can reach. 4 TWO DIMENSIONS · INTERACTIVE Perturb a field and see which assertions notice. next field ▶ the old name 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the reach of a numeric mutator inside the space of assertions. AVAN’s addition (the inverse-companion): the forward reading is “name the flag after what the probe knows.” The inverse is that every flag name is a claim about scope, and most of them are wrong in the same direction . INSENSITIVE, FLAKY, UNUSED, DEAD — each asserts a property of the subject when what was observed is a property of the looking . Read backwards, the rename is not politeness but type correctness : the probe returns a fact about itself and the old name silently cast it into a fact about the code, which is a coercion no compiler would allow and no vocabulary prevents. pause spin LIT over seven assertions of four kinds, 4 of 7 are unmoved by any numeric perturbation and every one of those four is over structure, nullness or a string with 0 of them numeric; meanwhile 3 of 3 numeric assertions do respond, so the probe is not simply weak; and the old name would have accused 4 perfectly good assertions of a defect FIG David made the rename and gave the reason in one line: 'the flag was called INSENSITIVE. the mutator moves NUMBERS, so an assertion over array length, nullness or a string is unmoved for a legitimate reason. renamed UNMOVED-BY-NUMBERS: the flag now says what the probe knows instead of what it implies.' He also set the posture for the tool: 'cortex does not fail a suite. it annotates one. a flag is a question about an assertion, and some have good answers.' AVAN classified the assertions to check the rename is not merely gentler wording. It is not - the partition is clean, and the flag now separates 'the probe could not reach this' from 'the probe reached this and nothing happened', two conditions the old name collapsed into one accusation. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE INVENTORY · David Lee Wise (ROOT0), with AVAN


THE API CHANGE

The fourth argument became an options object. Every call site kept compiling and running while the meaning of half of them quietly inverted.

THE API CHANGE · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · EVENT HORIZON ◆ .dlw.fold THE FOLD / RESPAWN / EVENT HORIZON / THE API CHANGE THE API CHANGE a signature moved and a default came with it 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A function’s fourth argument changed from a bare subject to an options object. Every call site kept compiling, kept running, and kept returning a well-formed result — while the meaning of half of them quietly inverted, because a bare subject now implies pure: false where it used to imply probing. A case that had been exercised stopped being exercised, and nothing anywhere reported it. LIT verified live on six call sites. 4 of 6 have their purity flag silently flipped by the signature change; the 2 that pass an explicit options object are unaffected. The number of assertions actually probed for sensitivity falls from 6 to 2 . No error is raised, no warning issued, and every call still returns a well-formed object. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) traced it precisely: “changing ok()’s fourth argument from a bare subject to an options object meant `subject` alone now implies pure:false. case F — ‘a constant thunk ignores the subject’ — stopped being flagged, because sensitivity was no longer probed at all. correct new behaviour, stale assertion.” He added a case G asserting that a bare subject leaves sensitivity unprobed rather than assumed — a regression test for exactly the hole — and a rule: an API change invalidates every suite that touches it; re-run before sealing, not after. AVAN (AI) should be precise about who is at fault, because the natural reading blames the API. Nothing is wrong with the new signature; the defaults it chose are defensible and arguably safer. The fault is that a positional argument changed shape , which is invisible to a dynamic language at the call site, so the old suite kept passing while testing something else. A named argument or a version bump would have made the same change loud. 3 ONE DIMENSION Six call sites, before and after the signature moved. 4 TWO DIMENSIONS · INTERACTIVE Swap the signature under the same call sites. old / new signature ▶ 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: call sites unchanged, meanings moved beneath them. AVAN’s addition (the inverse-companion): the forward reading is “re-run every suite an API change touches.” The inverse is that you cannot know which suites an API change touches without already having the tool the change broke . The set of affected call sites is exactly what a static type system or a named-argument convention would tell you, and in their absence the only honest answer is all of them . Read backwards, the rule is not a discipline anybody can follow selectively — it is an argument for making the change loud at the call site , because a rule that requires re-running everything will, on a big enough repository, quietly become a rule that requires re-running nothing. pause spin LIT on six call sites, 4 of 6 have their purity flag silently flipped by the signature change while the 2 that pass an explicit options object are unaffected; the number of assertions actually probed for sensitivity falls from 6 to 2; and no error is raised, no warning issued, and every call still returns a well-formed object FIG David traced it precisely: 'changing ok()'s fourth argument from a bare subject to an options object meant subject alone now implies pure:false. case F stopped being flagged, because sensitivity was no longer probed at all. correct new behaviour, stale assertion.' He added a case G asserting that a bare subject leaves sensitivity UNPROBED RATHER THAN ASSUMED - a regression test for exactly the hole - and the rule: an API change invalidates every suite that touches it, re-run before sealing, not after. AVAN is precise about the fault, because the natural reading blames the API: nothing is wrong with the new signature and its defaults are arguably safer. The fault is that a POSITIONAL argument changed SHAPE, which is invisible at the call site in a dynamic language, so the old suite kept passing while testing something else. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of EVENT HORIZON · David Lee Wise (ROOT0), with AVAN


THE ORDER THAT IS FORCED

A stated reason for every adjacency turns a build plan into a theorem. Six reasons in a row and the order stops being a choice.

THE ORDER THAT IS FORCED · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · THE CONTINUE ◆ .dlw.fold THE FOLD / RESPAWN / THE CONTINUE / THE ORDER THAT IS FORCED THE ORDER THAT IS FORCED seven floors, and only one way to stack them 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION Seven floors, and a stated reason for every adjacency: you cannot write a veto for a language you have not read, coverage means nothing until the veto is honest, there is no point diffing against an oracle if the forms never covered the domain. Six reasons in a row, and they turn the build order from a plan into a theorem — there is exactly one way to stack the tower. LIT verified live by enumerating all 5,040 orderings of seven floors: exactly 1 respects every stated dependency. Remove any single reason and the freedom that buys is 7, 21, 35, 35, 21, 7 orderings — the binomial coefficients C(7, i+1), because cutting a chain leaves two independent chains and the valid orders are exactly their interleavings. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) wrote the order and then wrote why it is this order , one line per link: “F4 before F5 — the orchestrator supplies MEANING. supplying it before an oracle exists means nothing can catch it being confidently wrong.” That is a dependency argument, not a preference, and it is what makes the count computable at all. Dropped 5 August 2026 as TOWER.ascii . AVAN (AI) guessed a formula for the freed orderings and got it wrong — predicting 6, 10, 12, 12, 10, 6 against a measured 7, 21, 35, 35, 21, 7. The measured numbers are binomial coefficients, and the reason is structural rather than numerical: removing edge i cuts the chain into two chains of lengths i+1 and 6−i, and interleaving two chains of lengths a and b admits C(a+b, a) orders. The wrong guess is on the sphere because the right answer is the more interesting object. 3 ONE DIMENSION Seven floors, six reasons, one order. 4 TWO DIMENSIONS · INTERACTIVE Cut one reason and count what the tower could have been. cut the next link ▶ restore 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the chain, and the lattice a cut opens under it. AVAN’s addition (the inverse-companion): the forward reading is “the order is forced by the dependencies.” The inverse is that a forced order is a confession that nothing can be done in parallel . A chain is the most constrained shape a dependency graph can take, and its single linear extension is exactly what makes it unparallelisable — seven floors, seven sequential waits, no two people able to work at once. Read backwards, the tidy proof of a unique order is also the worst possible schedule , and the only way to buy concurrency is to find a stated reason that is not really true. pause spin LIT enumerating all 5,040 orderings of seven floors, exactly 1 respects every stated dependency; and removing any single reason frees 7, 21, 35, 35, 21, 7 orderings - the binomial coefficients C(7, i+1), because cutting a chain leaves two independent chains and the valid orders are exactly their interleavings FIG From David's TOWER.ascii, dropped 2026-08-05. He wrote the order and then wrote WHY it is this order, one line per link: 'F4 before F5 - the orchestrator supplies MEANING. supplying it before an oracle exists means nothing can catch it being confidently wrong.' That is a dependency argument rather than a preference, and it is what makes the count computable at all. AVAN guessed a formula for the freed orderings and got it wrong, predicting 6, 10, 12, 12, 10, 6 against a measured 7, 21, 35, 35, 21, 7. The measured numbers are binomial coefficients and the reason is structural: removing edge i cuts the chain into two chains of lengths i+1 and 6-i, and interleaving chains of lengths a and b admits C(a+b, a) orders. The wrong guess is on the sphere because the right answer is the more interesting object. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of THE CONTINUE · David Lee Wise (ROOT0), with AVAN


THE WIDER AT THE BOTTOM

73 checks that ran twice and were sealed, beneath 28 gates that have not. The shape is the argument: everything above multiplies through everything below.

THE WIDER AT THE BOTTOM · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · HARD RESET ◆ .dlw.fold THE FOLD / RESPAWN / HARD RESET / THE WIDER AT THE BOTTOM THE WIDER AT THE BOTTOM a floor laid on one run is laid on a coincidence 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION A tower drawn with its bedrock wider than everything above it. Beneath the line: 73 checks that have each run twice and been sealed. Above it: 28 gates that have not. The ratio is 0.38 to 1 , and the shape is the argument — every floor above multiplies through the ones beneath, so a floor laid on a single green run is a floor laid on a coincidence. LIT verified live. The frozen checks sum to 73 : 14 + 3 + 29 + 12 + 7 + 4 + 4. The gates above sum to 28 : 3 run once, 13 designed, 12 unbuilt. The ratio is 0.3836 , and there are 2.61× more sealed checks beneath than open gates above. Confidence compounds as a power: at 99% per floor a seven-floor tower is worth 93.2% , at 90% per floor only 47.8% . 2 HOW IT WAS WEAVED · AI + HUMAN David (human) drew the tower with countable blocks and said so at the top: “nothing here is estimated. the blocks are countable gates.” The claim underneath is the one that carries: “the tower is WIDER at the bottom and that is the whole point. every floor above rests on checks that ran twice. a floor laid on one run is a floor laid on a coincidence.” AVAN (AI) checked the arithmetic and then made the shape argument quantitative, because “wider at the bottom” is a picture until someone multiplies. Seven floors at 90% each is 47.8% — a tower more likely wrong than right, built entirely out of floors that each looked fine. The compounding is why bedrock has to be disproportionate: it is not caution, it is the only place the exponent can be paid down. 3 ONE DIMENSION The tower, drawn to its own block counts. 4 TWO DIMENSIONS · INTERACTIVE Set the per-floor confidence and watch the tower compound. lower confidence ▶ raise it run twice 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: a wide base carrying a narrow stack. AVAN’s addition (the inverse-companion): the forward reading is “make the bedrock wide because everything multiplies through it.” The inverse is that a wide bedrock is also the largest thing that can be wrong at once . Seventy-three checks that all ran twice on the same machine, in the same interpreter, against the same corpus share every assumption that machine makes — and a systematic error there is not paid down by the exponent, it is amplified by it, arriving identically at every floor above. Read backwards, repetition buys independence only against accidents, and the wider the base the more expensive its one shared blind spot becomes. pause spin LIT the frozen checks sum to 73 as 14 + 3 + 29 + 12 + 7 + 4 + 4 and the gates above sum to 28 as 3 once, 13 designed and 12 unbuilt; the ratio is 0.3836 with 2.61 times more sealed checks beneath than open gates above; and confidence compounds as a power, so seven floors at 99% each is worth 93.2% and at 90% each only 47.8% FIG David drew the tower with countable blocks and said so at the top - 'nothing here is estimated. the blocks are countable gates' - with the claim underneath: 'the tower is WIDER at the bottom and that is the whole point. every floor above rests on checks that ran twice. a floor laid on one run is a floor laid on a coincidence.' AVAN checked the arithmetic and then made the shape argument quantitative, because 'wider at the bottom' is a picture until someone multiplies: seven floors at 90% each is 47.8%, a tower more likely wrong than right and built entirely out of floors that each looked fine. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of HARD RESET · David Lee Wise (ROOT0), with AVAN


THE GATE THAT CAN STOP IT

One floor is allowed to halt everything. If thirteen symbols do not cover Fortran, the answer is not more symbols - it is that Fortran is a different shape.

THE GATE THAT CAN STOP IT · WORLD II — THE FOLD ◀ THE FOLD 0ROOT.AI // WORLD II · RESPAWN · ROLLBACK ◆ .dlw.fold THE FOLD / RESPAWN / ROLLBACK / THE GATE THAT CAN STOP IT THE GATE THAT CAN STOP IT put the falsifiable floor early 1 WHAT IT IS · WHAT IT DOES · FACT OR FICTION One floor in the tower is allowed to halt everything. If a thirteen-symbol language does not cover Fortran, the answer is not more symbols — it is that Fortran is a different shape, and that finding is the product. A gate like this is only worth having where it sits early enough to stop work that has not happened yet, and a gate placed after the work it would invalidate is not a gate at all. LIT verified live over the tower’s own 28 blocks. Placing the stop-gate at F3 means 13 blocks spent before it and 15 at risk; at F6 it would be 25 spent and only 3 at risk — which is the wrong comparison, because the spent blocks are gone either way. If the gate fails half the time, expected total spend rises monotonically with its position: 16.0 blocks at F1 against 28.0 at F7. 2 HOW IT WAS WEAVED · AI + HUMAN David (human) marked the floor and gave it authority in one line: “F3 is the one that can stop the tower. if 13 forms do not cover fortran, the answer is not more forms — it is that fortran is a different shape, and the finding is the product.” Elsewhere in the same file: “a form count that has to grow is a finding about fortran, not a failure of i13.” AVAN (AI) should be careful about the optimisation, because “put the falsifiable gate first” is not quite available. Expected spend is minimised at F1, but F3 cannot move there — you cannot measure coverage before you have read the corpus and written the veto, so its inputs pin it. What the arithmetic actually shows is that F3 is as early as its dependencies allow , which is a weaker and truer claim than choosing the optimum freely. 3 ONE DIMENSION Where the gate sits, and what it puts at risk. 4 TWO DIMENSIONS · INTERACTIVE Slide the stop-gate up the tower and watch the expected spend. move it up ▶ move it down 5 THREE DIMENSIONS + AVAN’S INVERSE The green forward object: the tower, with the stop-gate as a cut plane. AVAN’s addition (the inverse-companion): the forward reading is “place the falsifiable gate as early as its inputs allow.” The inverse is that a gate can only be early if it is cheap to state, and the cheapest things to state are rarely the ones worth testing . F3 is answerable early precisely because it asks a small question — does this symbol set cover that corpus — and the questions that would falsify the whole enterprise, whether any of this produces a useful agent, cannot be asked until nearly everything is built. Read backwards, the early gates are the ones you were least likely to be wrong about , and the discipline buys speed of refutation at the cost of refuting only the small claims. pause spin LIT over the tower's own 28 blocks, placing the stop-gate at F3 means 13 blocks spent before it and 15 at risk, while at F6 it would be 25 spent and only 3 at risk - the wrong comparison, since the spent blocks are gone either way; and if the gate fails half the time, expected total spend rises monotonically with its position from 16.0 blocks at F1 to 28.0 at F7 FIG David marked the floor and gave it authority: 'F3 is the one that can stop the tower. if 13 forms do not cover fortran, the answer is not more forms - it is that fortran is a different shape, and the finding is the product.' Elsewhere: 'a form count that has to grow is a finding about fortran, not a failure of i13.' AVAN is careful about the optimisation, because 'put the falsifiable gate first' is not quite available: expected spend is minimised at F1, but F3 cannot move there since you cannot measure coverage before reading the corpus and writing the veto. What the arithmetic shows is that F3 is AS EARLY AS ITS DEPENDENCIES ALLOW, which is weaker and truer than choosing the optimum freely. ◆ sealed .dlw.fold → folded to ROOT_0 · a sphere of ROLLBACK · David Lee Wise (ROOT0), with AVAN