L(T_x,p) is the |Q| = 1 covering capacity: #161's adjacent-kill table is route 26's ladder base

Investment state: result. This describes research progress; claims have separate evidence grades.

Contribution to the goal

A cross-lane identity that makes two independently built lanes check each other, plus one concrete bank and one concrete comparison.

THE IDENTITY. L(T_x, p) = K*({p}) at level x, for every prime p > x — #161's measured adjacent-kill run IS route 26's covering capacity with a single killer. Derivation: r ≡ a or a+2 (mod p) is p | u or p | u+2 for u = r - (a+2), i.e. exactly the anchored {0,-2} kill (the wraparound p - 2 is -2 mod p, not a second rule); and in K* the anchored phase of a killer at block m is -mP# mod p (the fact the #603 certificates rest on), which for p not dividing P# runs over EVERY translate as m varies. So the "free translate" #161 flags as a deviation from its brief is K's phase freedom, and the two lanes' conventions agree after this one step.

WHAT IT BUYS. (a) A lower-bound bank: K*({p}) = L(T_x,p) exactly, so #161's 1,307 measured entries already contain the single-prime capacity at levels T5..T29, and any route-26 K*(Q) with |Q| >= 2 should be compared against them rather than an empty baseline. (b) A joint ladder: with #609's proved step (K*(Q u {q}) >= K*(Q) + 1 for q > P(s)), Q containing p gives K*(Q) >= L(T_x,p) + #{entries}; #161's diagonal L(T_{p-}, p) = 2,1,2,2,2,3,2,4 at folds 7..31 is then the |Q| = 1 rung of the same ladder route 26 climbs, and L(T29,31) = 4 is the largest single-prime capacity on record. (c) A convention reconciliation: the two lanes are one object, so measurements from either are usable in the other without restating hypotheses.

WHAT SUCCESS WOULD CONTRIBUTE TO THE PROJECT GOAL. Route 26's question is whether the covering capacity keeps crossing the certificate threshold. Its only measured input at |Q| >= 2 is four certificates in one block at level 31#. The identity turns a 1,307-entry, 19-second table at levels 5..29 into the base of that ladder and makes each entry a checkable prediction for the covering instrument, so the capacity side of the eventual-form question gets a cheap, wide calibration instead of four points. The link is exact, not conjectural; what is conjectural is nothing - only whether the instrument reproduces the table, which is a measurement.

HOW TO DISPROVE THE IDEA. One entry of #161's grid that an independent level-x, Q = {p} instrument does not reproduce refutes the identity as stated (or exposes an indexing difference in the brief's "p >= x"). The identity is also void if the tile framing in #161 is not one period of the x-sifted numbers (x#), which its W = 6,469,693,230 = 29# for T29 contradicts.

Prior work and proposed difference

Online search2026-10-04 reused route27 revision24/#2213/#2276 comparisons, then queried exact L(T37,43),L(T_37,43),L(T37,47), covering-capacity T37, and Holt sieve/constellation terminology. No exact-cell answer located; this is not a novelty certificate. Inspected Fred B. Holt, arXiv2608.26384v4(2026-09-28), abstract, https://arxiv.org/abs/2608.26384v4: population recursion for constellations among primorial units with a small-span condition. Also Holt arXiv1503.00231v2(2015-03-06), abstract, https://arxiv.org/abs/1503.00231v2. Inspected statements do not give these ordered twin-slot capacities. Project method closest to the adaptation: #2080 report Cheap conditional bound and a failed strengthening and raw pattern4_4539.py; source manifest contains exact URLs/digests. #2187 aggregate loose-run records disclose boundary undercounts; no full repeated comparison or census. New contribution is the missing43/47 conditional upper bounds plus exact attained local witnesses, not a repeated41 fold or improved timing. Remaining gap is independent establishment of inherited global span premise, not a claimed unconditional theorem.

Central uncertainty

The weakest step is the substitution of K*'s phase freedom for L's free translate, and it rests on one exponent: that the tile T_x of #161 is the level-x slot set with the SAME kill rule, i.e. that its "2-set {a, a+2} with wraparound p - 2 admitted" is not a genuinely wider rule. I read that as the same rule because p - 2 = -2 (mod p); if the intent were "any two residues at distance 2 OR p - 2 apart" for a class set not of the form {a, a+2} anchored, the identity would need restating. Second: the identity is proven here from the two DOCUMENTED definitions and has NOT been reproduced numerically — this assignment offered no compute hint, so the rung is "proven from definitions" and one bounded run is what would make it measured. Third: the level correspondence (T_x <-> level x with P = x#, and the brief's "p >= x" meaning p is not a sifting prime of the tile) is inferred from #161's own T29 = 29# and its diagonal phrasing L(T_{p-}, p); if the corpus indexes tiles differently the identity becomes a shift of the level index rather than a false statement, and the test would show it.

Required evidence

Unaccepted premises remain conditional.

Evidence behind continued investment

These investigations led to the current experiment. Their claims retain their own evidence grades.

Investigation history

Because every T_31 slot == 5 (mod 6), a translate kills two CONSECUTIVE slots r < r' only if r' - r == +-2 (mod 163); among multiples of 6 up to 348 the candidates are {165, 328} for +2 -- neither a multiple of 6 -- {163, 326} for 0 -- neither a multiple of 6 -- and {161, 324} for -2, i.e. only 324; a three-slot chain would need two of them and 2324 > maxgap. So L(T_31,163) is 1 or 2 and is decided by that single count: L(T_31,163) = 1. The citing row's 2 has no carrier in the tile, and #637's own text lists T_31's gap vocabulary as 6k for 1 <= k <= 53 plus 330 and 348, which omits 654 = 324 -- so that cell is a defect localised to one cell of 35, with this scan as its cheapest check.

The full row is measured, not just the disputed cell, and by two routes: L >= 2 from the whole-period gap multiset, L >= 3 from the adjacent-pair multiset, and the three deeper cells from a targeted chain pass. Result: L = 4 at p = 37, L = 3 at 41 and 53, L = 2 for the 27 primes 43..157 and 173, L = 1 at 163, 167, 179, 181, 191, 193, 197, 199; maximum 4. Agreement with the cited row: 34 of 35 cells, the single disagreement being p = 163. Independently re-measured: the L >= 3 set is exactly {37, 41, 53}; the largest prime with L >= 2 is 173, carried by gap 348 = 2*173 + 2 = maxgap.

Gates, all before any level-31 number. (1) Tiles built by direct coprime sieve (no CRT lift) reproduce |T_5..T_23| = 3, 15, 135, 1485, 22275, 378675, 7952175. (2) At levels 5..13 over all primes x < p <= 199 the definitional scan (all p translates, materialised period, second period's residues shifted by M mod p) and the gap-multiset route agree 148/148; the diagonal at folds 7..29 is 2,1,2,2,2,3,2; the nine seam-sensitive bank cells are all 1; and the live control -- the same scan with the second copy unshifted -- returns 2 at T_7/11, reproducing #627's defect on demand. (3) The level-29 stream gives 214,708,725 slots, 41 distinct gaps, maxgap 258 and the 36-cell row cell for cell. (4) The chain instrument reproduces L(T_29,31) = 4, L(T_29,37) = 3, L(T_29,41) = 2 before it is used at level 31. The block rule is pinned by numbers, not assumed: M_23 mod 29 = 17 and M_23 mod 31 = 6 drive the killed classes and the resulting slot count equals 212729*378675 = 6,226,553,025 exactly.

Rung: measured, over the complete period, no ceiling hit, no sampling; both instruments are new code. Cost: gates 38.2 s inside the harness's bounded exec (receipt served, no residual processes), level-29 stream 6.3 s, level-31 stream ~290 s, chain pass ~170 s per prime. NOT claimed: any asymptotic, sieve bound, discrepancy or certificate; route 26's threshold question; T_37 is not built; the identity's second leg remains proven-from-definitions, not measured. Honest limit: the two instruments share the definition (hence any error in it) but no code, no tile construction, no L algorithm and no seam handling.

INSTRUMENT. One x#-period is built by the block decomposition (T_29 = 29 blocks over the T_23 tile, T_31 = 899 blocks over T_23, never materialised as values) and scanned by residues mod p; the cyclic closure carries M mod p: period k is scanned by translate b_k = a - k*M, so a boundary run is S(b) + P(b - M), not S(b) + P(b). The two-boundary case needs a whole period killed (S_max = P_max = 1 everywhere measured) and is checked, not assumed.

GATES (all green, all before any quoted cell). lift-built == directly sieved tile, levels 5,7,11,13: 4/4. Block decomposition == lift, levels 11,13,17: 3/3. Folded algebra vs a LITERAL definitional scan (3 materialised periods, every translate, plain run counting) over levels 5..13 and all 166 bank primes: 166/166 agree. #622's 280-cell bank under the corrected closure: 280/280. Level-29 slot count 214,708,725 = 27 x 7,952,175 (as cited). Level-31 slot count 6,226,553,025, exactly #637's count, with 55 distinct gaps, min 6, all multiples of 6, max 348 = #637's maxgap(T_31).

RESULT 1 - the level-29 row stands, measured. L(T_29,31) = 4 by the folded closure AND by an algebra-free definitional scan of two materialised periods (429,417,450 slots, a = 5); L(T_29,37) = 3; L(T_29,p) = 2 at p = 41,43,47,53; the remaining 30 cells decided by the tile's own cyclic gap-tuple sets (41/730/7,184/45,855 distinct tuples for k = 1..4, wrap gap 30, max gap 258). Mismatches against the cited row: 0 of 36 (counts 16/18/1/1 as cited). No k = 4 tuple satisfies the criterion at p = 31, so the |Q| = 1 maximum is 4, exactly.

RESULT 2 - the seam is not a formality. The unshifted closure (re-anchoring at the period) is wrong in exactly 9 of #622's 280 published bank cells: T_7/p=11, T_11/p=31, T_11/p=37, T_11/p=191, T_13/p=41, T_13/p=43, T_13/p=61, T_19/p=199, T_23/p=173 (each over-reports 2 where the truth is 1; T_7/p=11 is the fold-11 diagonal cell #642 mis-measured). The bank is therefore seam-SENSITIVE, and it is #622's values that are right: the corrected closure reproduces all 280. These nine cells are a cheap regression test for any folded instrument.

RESULT 3 - one cited level-31 cell is defective. T_31's row is reproduced in 34 of 35 cells, including p = 173 (carried by the cited gap 348) and p = 167. The exception is L(T_31,163): this instrument gives 1, #637 published 2. T_31 slots are == 5 mod 6, so every gap is a multiple of 6 and <= 348; the only multiple of 6 that is == 0 or +-2 mod 163 is 324 = 2*163-2. The full gap census of the same tile contains 318 and 330 and no 324, so the criterion gives 1. Cheapest refutation, and it is cheap: count consecutive-slot pairs with difference exactly 324 over the 899 blocks (~8 min of the same code). If such a gap exists the cell is 2 and this claim is wrong.

UNCHANGED: the tool flags nothing new about the identity itself, and the row maximum (4, at T_31/p=37) is untouched.

OBJECT. T_x = twin-admissible residues mod M = x#, one period, increasing. Slot r killed by p under translate a iff r mod p in {a, a+2}; L(T_x,p) = max_a longest CYCLIC run of consecutive killed slots. CORRECTED CLOSURE: the slot after res[i] in the next period is res[i]+M, so its residue is (res[i]+M) mod p; for p > x, p does not divide M, and closing with the unshifted head is #627's documented defect (repeated by #642 and by #643's first two instruments).

MEASURED. Source: #622's own L-grid.json, fetched this run from the server by content address (GET /files/b7451a99...f3c9 -> 200, work/L-grid-622.json, 80567 B): entries 280, levels 5,7,11,13,17,19,23 (every prime x < p <= 200), all_gates_pass true. Tiles rebuilt by CRT, anchors exact: |T_5| = 3, |T_7| = 15, |T_11| = 135, |T_13| = 1485, |T_17| = 22275, |T_19| = 378675, |T_23| = 7952175; M_19 = 9699690, M_23 = 223092870. Two instruments (work/bank-diff.py, 14.8 s wall under the harness's bounded exec, exit 0): INSTRUMENT-LITERAL, the definitional scan on the corrected doubled residue array (shares no code with the bank); INSTRUMENT-GAP, #640's gap-chain reduction on the tile's true cyclic gap sequence (wrap gap (res[0]+M) - res[n-1], cyclic gaps summing to M).

RESULT. (1) literal instrument vs bank on the 6 affordable diagonal folds: 6/6 (2,1,2,2,2,3 at (5,7),(7,11),(11,13),(13,17),(17,19),(19,23)). (2) gap instrument vs literal, same 6 cells: 6/6. (3) corrected instrument vs bank, all 280 cells: 280/280, cells_changed 0. So the answer to the assigned question is exact and negative on change: the corrected wrap reproduces every one of #622's 280 entries below level 23. #622's three methods closed the period without carrying M mod p into the wrap, and for x <= 23, p <= 199 that altered no value -- the seam carries no maximal run in this domain. #643's seven-fold diagonal agreement is thereby extended from 7 gates to the bank's whole 280-cell domain, and #627's 'engine 37/37, #622's row unaffected' is confirmed by an instrument written against the definitions, not by re-reading the row.

INSTRUMENT INTEGRITY (this is what changed twice in-run). The hand-built reduction was wrong in three revisions and its own literal gates caught each: rev1 had both an off-by-one in the chain->L map (block length loses its first position) and a forced boundary at index 0; rev2 dropped the off-by-one but kept the illegitimate forced boundary (a chain may span index 0 -- it re-appears intact in the second copy); rev3 exposed the real bug -- prev was the forward fill of 'last nonzero index' on an array where EVERY element is nonzero (barriers coded 9), so prev[j] = d[j] and the alternation rule fired at every allowed gap, truncating every chain to 0; rev4 takes the last nonzero STRICTLY BEFORE j (prev = d[filled-1]) and gates 6/6. Hand check at T_5, p = 7: gaps 6,12,12 -> mod 7 6,5,5 -> signs 9,-1,-1 -> breaks at the barrier and at the equal nonzero pair -> one gap chain -> L = 2 = literal = bank. Lesson, fourth occurrence in this lane: gate a reduction against the definitional instrument BEFORE it emits a table, and never report the numbers of a failing gate.

SCOPE. Measured: levels 5..23, every prime x < p <= 200 (the bank's own domain). The literal gate was run on the 6 diagonal cells, not on all 280 (the gap instrument covered all 280, gated 6/6). CITED, not recomputed: L(T_29,31) = 4 (#627) and #637's level-31 row -- 6.2e9 / 2.0e11 slots. The identity's second leg (K*'s phase freedom supplies L's free translate) is untouched: proven from definitions, not measured. No route-26 or certificate consequence is drawn; this is not a new source for the bank's values.

OBJECT. slot r of T_x killed by p under translate a iff r mod p in {a, a+2}; L(T_x,p) = max_a longest CYCLIC run of consecutive killed slots.

THE SEAM. T_x is the admissible residue set mod M = x#; the slot after res[i] in the next period is res[i] + M, so its residue mod p is (res[i] + M) mod p. The question is asked for p > x, where p never divides M, so doubling the residue array UNSHIFTED silently closes the seam as if p | M. That is verbatim the defect #627 found in its own first revision ('right only if p | P, never for p > level ... at T_23, p = 173 that invented a compatible seam pair, true residue difference 30, not 2'). #642's instrument uses exactly that convention (payload = bytes(r % p for r in res) * 2); so did my first two instruments this session, until a printed witness exposed it.

MEASURED (diagonal-check2.py, 6.9 s; builder reproduces |T_19| = 378675, |T_23| = 7952175; both conventions on the SAME tile). Fold p = 7, 11, 13, 17, 19, 23, 29 with L unshifted / L corrected / brief = gate: 7: 2/2/2; 11: 2/1/1; 13: 2/2/2; 17: 2/2/2; 19: 2/2/2; 23: 3/3/3; 29: 2/2/2. Corrected seam: 7 of 7 affordable folds reproduce the brief's diagonal 2,1,2,2,2,3,2 and #622's gates entry for entry. Unshifted seam: 6 of 7, failing only at fold 11. Fold 31 (L(T29,31) = 4, #627 G4) needs the 29# tile (6.2e9 slots) and is cited, not recomputed.

THE FOLD-11 WITNESS. Unshifted, T_7 reports L = 2 via consecutive slots 209 and 11 (a = 0, both residues 0 mod 11). The true cyclic successor of 209 is 209 + 210 = 419 = 1 (mod 11), not 11, and the kill rule needs a residue difference of 2: 419 - 209 = 1 (mod 11). Consistency check: T_7's gaps are all multiples of 6 with maximum 30, so a killed pair needs gap = 2 (mod 11) with even gap <= 30, i.e. 24; T_7 has NO gap of 24 (inventory 6, 12, 18, 30). So L(T_7,11) = 1 is what the definition gives once the period is closed correctly -- the corpus entry is not a slip.

WHAT CHANGES. (1) The identity's diagonal is NOT refuted: under the corpus's fold index (fold p <-> L(T_{p-}, p)) an instrument sharing no code with the lane behind #637/#640 reproduces all seven affordable entries, and the eighth is #627's measured 4; #642's 'refutation at four folds' is withdrawn in substance by this measurement. (2) #642's numbers have two independent causes: the unshifted seam above, and a fold-index misalignment -- it paired (x, p) = (7,11), (11,13), ... but compared those six rows against the diagonal's FIRST six values instead of folds 11, 13, 17, 19, 23, 29; its L column also adds one (L = 1 + best) to a run length that already is L. (3) Framework lesson, third occurrence in this lane: #627's first revision, #642's instrument and my own first two instruments all doubled an unshifted residue array; a tile instrument must carry M mod p into the wrap, and witnesses should be printed as integers so the wrap can be checked by hand -- which is what exposed it.

LIMITS. Fold 31 / the T_29 row are cited (#627), not recomputed: 7 of 8 entries. This does not re-derive #622's 280 entries, and does not touch the identity's other leg (that K*'s phase freedom supplies the free translate), still proven from the two documented definitions. Agreement with #622's gates confirms those gates at the affordable folds; it is not a new source for them.

CHEAPEST CHECK. python3 diagonal-check2.py (~7 s, deterministic stdout): corrected column must be 2,1,2,2,2,3,2, unshifted 2,2,2,2,2,3,2; setting second = R reproduces the fold-11 failure on demand. Entry to review: fold 11.

CONDITION. With the tile's cyclic gap sequence g_1..g_N and #637's reduction (a window of k+1 slots is killed by p iff every partial sum of its k gaps lies in {0,2} or all in {0,-2} mod p), the partial sums live in a two-element set, so the walk has two states: state 0 = running sum is 0 (a gap may be 0, stay, or +2, go to state 2); state 2 = running sum is 2 (gap 0, stay, or -2, go to state 0). Then

L(T_x,p) = 1 + max_j max(len0[j], len2[j]),
len0[j] = 0 if g_j !~ {0,+2} else 1 + (len0[j+1] if g_j ~ 0 else len2[j+1]),
len2[j] = 0 if g_j !~ {0,-2} else 1 + (len2[j+1] if g_j ~ 0 else len0[j+1]),

cyclically. Equivalently: L is 1 plus the longest run of consecutive gaps that, after deleting the gaps = 0 mod p, alternates +2,-2,+2,... mod p. Three consequences: L>=2 needs exactly one gap = +-2 mod p (so for p > maxgap the row's L>=2 range is decided by gap values alone); a gap = 0 mod p is free, not a barrier, so arbitrarily long 0-runs are chains (an 'alternating +-2 only' statement is wrong whenever p <= maxgap); L>=5 needs four consecutive gaps of shape (0|+2),(0|-2),(0|+2),(0|-2) mod p in one of the two parity starts.

CHECKED, twice. (1) Conventions against the corpus before any new number: |T_19| = 378675; fold chain 212729378675; |T_23| = 7952175; T_23's inventory is 33 distinct gaps 6..204 and its largest prime with L>=2 is 103, carried by gap 204 = 2103-2 -- exactly #627's cutoff, gap and all. (2) Equivalence on a full row: the literal partial-sum definition and the two-state scan agree 37/37 on the T_23 row (both computed on the same tile, entry for entry). The row: L=3 only at p=31; L=2 for 29,31,37,41,43,47,53,59,61,67,79,83,89,97,101,103; L=1 for 71,73 and all 107<=p<=199. No L=4 and no L=5 at level 23.

A PRE-PASS FILTER. From the gap inventory alone (no positions), L>=5 is possible only with four gaps = 0, or one +2 and one -2, or two of each mod p. On T_23 this rules out L>=5 for 31 of the row's 37 primes with no positional pass; the six surviving head primes all have true L in {2,3}, so there it is a filter, never a witness. Honest boundary: the exact scan needs the level's gap SEQUENCE, so a level can be screened before its window pass, but not before its tile -- the part that costs the 5 CPU-h at T_37.

NOT CLAIMED. No speedup: this naive implementation is slower than the naive definition scan at level 23 (81 s vs 77 s over 37 primes) because the definition exits after 2-4 steps. The gain is structural (one linear pass per prime, no k-tuple enumeration, 0-gaps made explicit). Precision and test evidence: work/job1406/{screen.py,screen-t23.json,level23-full/screen-t23.json} and return #627's cutoff sentence, which the tile reproduces exactly.

The level-31 row L(T_31,p), 37 &lt;= p &lt;= 199, is measured with a new route to the object: a window of k+1 consecutive slots is killable by p iff all its partial gap sums lie in {0,2} or all in {0,-2} mod p, so

L(T_x,p) = 1 + max{k : some cyclic k-tuple of consecutive gaps has all partial sums in one of those sets}

The reduction is validated before use: it reproduces return #622's T_23 row 37/37 and return #627's T_29 row 36/36, entry for entry, in one pass for all primes and at about a fifteenth of the compute.

The level-31 period P_31# = 200 560 490 130 is never built; the tile is a two-level fold of T_23, 899 blocks, 6 226 553 025 slots.

Three exactness gates, all passed. (1) The slot count equals the independent chain 21*27*29*378675 = 6 226 553 025, anchored on the corpus's |T_19| = 378675 and |T_q| = (q-2)|T_{q-1}|. (2) Before the seam is closed, the k = 1,2,3 totals are N-1, N-2, N-3; measured exactly that. (3) After closing, all three are N. Plus a synthetic test of the block-boundary rule on 400 random cyclic words, distribution-exact, not merely totals.

Gate 2 caught a defect of mine. The rule "a tuple is new iff its start is at or after the carried gaps" is wrong; it must be i &gt;= own - k + 1. Effect measured exactly: 1 796 triples lost, 2 per block boundary, plus 3 at the seam -- 1 799 of 6.2e9. The support was unaffected so the row was identical, but the certificate was false. Redone from scratch after fixing and testing the rule; the old state is kept and the per-key difference is the 1 796 boundary triples over 40 keys.

The cited value is now exact. L(T_31,37) = 4, not merely &gt;= 4; the citing script is named a3-10-lower-tightness.js. The k = 3 multiset cannot decide this (the absence of a 4-tuple is a fourth-order fact), but a working k = 4 tuple must have a working k = 3 prefix, so only the certified prefixes [72,150,72] (188 occurrences) and [150,72,150] (28) need their continuations counted. After [72,150,72] the continuation histogram is 18:87, 30:35, 6:31, 36:23, 66:7, 60:4, 78:1 -- none is 150 or 222 -- and after [150,72,150] it is 18:24, 12:4 -- neither is 72 nor 294. Zero working k = 4 tuples. Independent gate: 216 matched in the pass plus 0 at the seam equals the 216 certified occurrences of the two prefixes; tested first on 300 synthetic cycles covering 3 181 filtered k = 4 tuples.

The rest of the row. L &gt;= 3 only at p = 37, 41, 53; L &gt;= 4 only at 37; maximum 4, so no |Q| = 1 row reaches 5. Every gap of T_31 is a multiple of 6 (6k, 1 &lt;= k &lt;= 53, plus 330 and 348), so L &gt;= 2 is a statement about single named gaps: the largest prime with L &gt;= 2 is 173 and its carrier is 348 = 2*173 + 2 = maxgap, exactly the maxgap/2 prediction of #627's rule, and the cutoff sequence extends 113 (T_29) -&gt; 173 (T_31).

For route 26's threshold question: the single-prime capacity did not grow across the last block boundary (4 at T_29, 4 at T_31) after growing from 3 to 4 across the previous one. Measured for the route, not asserted about any asymptotic: nothing here bounds a sieve, a discrepancy, u or H_alpha.

Full text served as evidence.md; this is that evidence, trimmed to the 4000-character inline limit.

1. The stream, never materialised

killrun.js: a run of L consecutive slots is killable iff their residues mod p occupy at most two values differing by 2 (some a has all residues in {a, a+2}). The level-29 period P_29# = 6,469,693,230, D_29 = 214,708,725 is not built: the conditions at primes <= 23 depend only on r mod P_23#, so the level-29 slots in sorted order are 29 blocks, block j = { v + j*P_23# : v a T_23 slot, 29 !| that value and 29 !| it + 2 }. Measured: sum = 214,708,725 = 27 x 7,952,175, 29 x 223,092,870 = 6,469,693,230; the block lengths are not all equal (they start 7,403,764 / 7,403,740 / 7,403,733).

2. Gates — all pass (T29-grid.json, gates.json)

3. Two further independent paths

Brute force (materialise a period, test EVERY cyclic window of every length; no chunking, no rolling AND, no census): 205/205 agreement with return #622's bank on levels 5..17 — and the engine agrees with that brute force 205/205.

The gap rule. A length-2 window is killable iff some cyclic gap g has g = 0, ±2 (mod p). Gap multisets: T_23 33 distinct, 6..204, T_29 41, 6..258, all even. Against the measured rows: 73/73 agree; beyond maxgap/2 the congruence can only be g = p ± 2, so it sharpens to "for p &gt; maxgap/2, L &gt;= 2 iff p−2 or p+2 is a gap" — 34/34 agree. The cutoff is carried by a named gap: T_23 by g = 204 = 2*103 − 2, T_29 by g = 228 = 2*113 + 2, so L is 1 for every prime above 103 and 113.

4. The row

36 entries, primes 31..199: L = 4 at p = 31 (witness 1321026611 … 1321026857, residues {18,20}); L = 3 at p = 37; L = 2 for the 18 primes 41..113; L = 1 for the 16 primes 127..199. The full row and the combined 316-entry table are in L-TABLE-29.md; the cutoff prime rises with the tile — 11, 11, 23, 37, 59, 71, 107, 127 at levels 5..29.

5. The seam, and what it cost to get wrong

The first revision closed the cyclic seam with the unshifted head — right only if p | P, never for p &gt; level. At T_23, p = 173 that invented a compatible seam pair (true residue difference 30, not 2). G1 caught it as a 21-of-37 disagreement, the brute force settled it, and after the shift the engine is 37/37, #622's row unaffected. A second defect was in the certificate check: at L = 1 no census entry exists, so it read 21 correct entries as disagreements — the fourth case in this run of a check inventing a fault.

6. Not claimed

The identity L(T_x,p) = K*({p}) is definitional; T_31 is cited, not measured; the 1,307-entry domain of return #161 is unreconciled (this domain: levels 5..29, every prime level &lt; p &lt;= 200); the census counts are this engine's; no route-26 or certificate consequence is drawn.

Full text served as evidence.md; this is the same evidence trimmed to the server's 4000-character inline limit, stating nothing evidence.md does not.

1. #161's table is gone

GET /projects/twin-primes/return/161 -> 200 with files: [] and a 9-entry hashes map, and all nine quoted shas -> 404. So #161 (two out-L files, prereg.md and six src files) is reachable by no route: not from its page, not by sha. Route 27's success criterion ("1,307 of 1,307 agree") cannot run as written. Reproducible: fetch161.py -> fetch161.json (reachable: 0 of 9); the server's answer kept in r161/return161.json.

2. The object, sourced rather than assumed

docs/research/killrun.js: in the folded tile the killed classes are {-kW, -kW-2} mod p, and as k ranges over copies those are ALL 2-sets {a, a-2}; a run of L consecutive slots is killable iff their residues mod p occupy at most two values differing by 2. Its corrected diagonal (quoted also in U-FRAME.md §6): L = 2,1,2,2,2,3,2,4 at folds 7,11,13,17,19,23,29,31 — L(T23,29) = 2, not the refuted 3.

3. The regeneration: 280 entries, three methods, every witness re-proven

Domain stated up front: levels T_5..T_23, every prime p with level < p <= 200 -> 280 entries (L-grid.json). T_29 not built (6.5 GB tile vs the 2 GB hint). Methods, agreeing at every entry: (A) class-union with the 2-set {a, a-2}; (B) the mirrored {a, a+2} — a different code path and pair family, so a convention error cannot pass; (C) killrun.js's streaming state machine, exhaustive at all 145 entries of levels <= 17. Result: A == B at 280/280; C agrees wherever run; 0 inconsistencies. Every witness is re-proven from raw integers: residues recomputed into a 2-set differing by 2, slots consecutive mod the period, so a seam-crossing run verifies. Gates green 7/7: L(T5,7)=2, L(T7,11)=1, L(T11,13)=2, L(T13,17)=2, L(T17,19)=2, L(T19,23)=3, L(T23,29)=2.

4. What the bank says

Per level — entries / max L at p / (L=1, L=2, L=3): T_5 43 / 2 @7 / 42,1,0 · T_7 42 / 1 @11 / 42,0,0 · T_11 41 / 2 @13 / 38,3,0 · T_13 40 / 2 @17 / 35,5,0 · T_17 39 / 2 @19 / 30,9,0 · T_19 38 / 3 @23 / 27,9,2 · T_23 37 / 3 @31 / 21,15,1. Overall: L = 1 in 235 of 280 entries (83.9%), L = 2 in 42, L = 3 in 3; max 3. The bank is not "flat at 2-3": it is 1 almost everywhere, and the corpus's diagonal is the exceptional row. Read as a lower-bound bank for route 26's K*(Q) with |Q| >= 2, 235 of its 280 entries bank 1. Both direction claims of U-FRAME.md §6 hold over the whole domain: max L over p >= 150 is exactly 1 at all 7 levels; and at fixed p the value rises monotonically with the tile (p=29: 1,1,1,2,2,2,2; p=31: 1,1,1,2,2,3,3; p=37/41/43/53: 1,1,1,1,2,2,2; p=199: all 1).

5. What is NOT claimed

6. Framework lesson

The gate caught my own verifier inventing a fault, twice: it demanded consecutive integer values (the run is over consecutive slots, whose offsets are sparse), then compared raw values against the base instead of residues mod the period, rejecting the legal seam-crossing witness at T5,p=7 ({29,41}, 41 = 11 + 30). Third instance of this run's recurring defect after #621 and the served_files audit. A framework lesson, not a research result.

The identity, measured. The route's derivation checked and used: r = a or a+2 (mod p) is p | u or p | u+2 for u = r-(a+2), so both sides are the longest run of consecutive level-x slots v with v = a or a-2 (mod p) for ONE class, maximised over the translate. single_prime.py builds the tile itself, doubles the period (so a seam-crossing window uses the SAME class, as the object requires), gathers each residue class once by stable argsort, merges the two classes per translate and reads the longest maximal consecutive block starting inside the first copy. Diagonal, recorded vs measured: T_5/7 2=2, T_7/11 1=1, T_11/13 2=2, T_13/17 2=2, T_17/19 2=2, T_19/23 3=3, T_23/29 2=2. The route's own disproof test has not triggered.

Thirteen new entries, and they are flat. K*({p}) at the two tiles where this run has multi-prime values: T_19 → p = 23:3, 29:2, 31:3, 37:2, 41:2, 43:2; T_23 → 31:3, 37:2, 41:2, 43:2, 47:2, 53:2 (plus 29:2 on the diagonal). Min 2, max 3 over 13 measurements; the largest |Q|=1 capacity on record anywhere is 4 (T_29, p=31, cited). It does not grow with p.

Claim (a), bank K*(Q) &gt;= max_{p in Q} K*({p}): holds 6/6, gap 10-21, ratio 4.33-8.00. T_19: Q={23,29,31,37} 13 vs 3 (4.33); {..41} 16 vs 3 (5.33); {..43} 18 vs 3 (6.00). T_23: Q={29..43} 16 vs 3 (5.33); {..47} 21 vs 3 (7.00); {..53} 24 vs 3 (8.00).

Claim (b), ladder floor K*(Q u {q}) &gt;= K*(Q)+1: holds 4/4, increments +3, +2, +5, +3 (slack 1-4). T_19: 13→16 adding 41; 16→18 adding 43. T_23: 16→21 adding 47; 21→24 adding 53. The floor is never attained and never violated, and the increments do not grow with |Q| (3 then 2; 5 then 3), so no per-prime rate is extrapolable.

What it changes. The two lanes are one object, so their measurements are mutually usable without restating hypotheses, and #161's table is a valid screen (an instrument that misreads a single-prime entry is broken). But the route's hope of giving "the capacity side a cheap, wide calibration instead of four points" is half right: the calibration is cheap and wide and it calibrates the instrument, not the threshold. Nothing at |Q|=1 can approach m*(19#)=15 or m*(23#)=18 — the standoff is 5-9x — so no single killer can stress the certificate threshold; the crossing requires accumulating 4-7 entering primes, exactly the regime where the bank carries no signal. The measured flatness is itself the datum: capacity growth lives in accumulation.

Scope and limits. 7 of #161's 1,307 entries are checked: the recordable diagonal, not the grid. T_29's 4 is cited, not measured (the 29# tile is 6.5 GB against a 2 GB hint). The multi-prime K*(Q) used for the comparison is this run's own recomputation, done earlier in this session and served with this return (bandtable-final.json, BAND-TABLE-26.md); it is not a published return, and the anchored values route 26 recorded are lower (6/8/10, 8/9/10). #609's +1 step is cited, not re-proved. Cost this assignment: 0.01 CPU-h, one core.

MEASURED (period_check.c unchanged, full period = phase-max; 414 s wall = 0.115 CPU-h under bounded exec, exit 0, timed_out false): p: 31 37 41 61 101 109 113 127 131 K*({p}): 4 3 2 2 2 2 2 1 1

COST AND SCOPE, STATED. A full column to p = 131 at level 29 costs ~18 min (each invocation re-sieves the 6.47e9-position tile, ~12 s, plus p x 0.4 s of block scan), more than the 0.25 CPU-h offered, so the column was SAMPLED at nine primes bracketing its structure, and the run used 0.115 CPU-h. Per-prime wall times 25-67 s, sieve-dominated. A TWO-CLASS column at level 29 was not attempted: prod(Q) = 31 x 37 = 1147 blocks x 214.7M slots is ~500 s for a SINGLE prime, i.e. several CPU-hours for even a short column. NOT CLAIMED: no law for the plateau starts, no monotonicity claim between samples, nothing about |Q| >= 2, nothing on route 26's blocked phase fork, no asymptotics.

MEASURED (period_check.c unchanged, full period, one run per (level, prime); 68 pairs, 34.2 s wall under bounded exec, exit 0):

THREE FURTHER MEASUREMENTS. (1) The PLATEAU-START LADDER: the first prime from which the column is 1 for good is 11, 23, 37, 59, 71, 107 at levels 5, 11, 13, 17, 19, 23; the ratios to the level grow monotonically (2.2, 2.1, 2.9, 3.5, 3.7, 4.7) over six points -- no law claimed, but the opposite of a fixed proportionality. The T17/T19/T23 entries reproduce #161's transitions verified in #616 (59, 71, 107), so this sweep is a second sight of that claim with the same instrument. (2) T7 IS DEGENERATE in the swept range (K*({p}) = 1 for all p = 11..43), so any per-level statistic must survive a column with no entry above 1. (3) The one-class maxima are tiny and discrete (2 everywhere except T7 = 1 and T19/T23 = 3) while the two-class ladder of #614 reaches 7: the |Q| = 1 rung is far below the |Q| = 2 rung at these levels (2 -> 3 at level 23), which is the scale route 26's delta numbers should be read against.

METHOD AND CHECKS. Instrument unchanged (period_check.c recompiled from the shipped source, full period = the phase-max object); the driver only tabulates. Internal cross-check: the T17/T19/T23 plateau starts equal the transitions reproduced in #616 by the same instrument. SCOPE: 68 (level, prime) pairs, bounds p <= 41/43/47/53/79/127/127, so "final 1-plateau" means "from the last p with K* > 1 inside the swept range", not an infinite-tail claim. Level 29 was NOT swept though it is reachable (tile D_29 = 214,708,725; a full column to p = 127 is ~60 s). NOT CLAIMED: no law for the transitions or the recoveries, nothing about |Q| >= 2, nothing on route 26's blocked phase fork, no asymptotics; the identity this route measures is untouched.

WHAT WAS TESTED. Route 27's own next experiment: reuse period_check.c UNCHANGED, one run per (level, prime), levels 17/19/23, every prime above the level up to just past the claimed transition, plus two primes beyond to confirm the 1s continue. Published claims (return #161): T17 reads 1 from p = 59, T19 from p = 71, T23 from p = 107.

MEASURED. T17: 19:2 23:2 29:2 31:2 37:2 41:2 43:2 47:2 53:2 59:1 61:1 67:1 71:1 73:1 79:1 -> transition p = 59, MATCH. T19: 23:3 29:2 31:3 37:2 41:2 43:2 47:2 53:2 59:2 61:2 67:2 71:1 73:1 79:1 83:1 -> transition p = 71, MATCH. T23: 29:2 31:3 37:2 41:2 43:2 47:2 53:2 59:2 61:2 67:2 71:1 73:1 79:2 83:2 89:2 97:2 101:2 103:2 107:1 109:1 113:1 127:1 -> transition p = 107, MATCH. With this, the reproduced record is the 8 of 8 diagonal folds and the T29 column transition (#1377), the 4 of 4 column statements reached in #1376, and these 3 of 3. Route 27's base is settled where an exact period computation can reach.

NEW, AND NOT CARRIED BY THE PUBLISHED STATEMENTS. (1) K*({p}) is NOT monotone in p. T23 does not go 2 -> 1 and stay: it dips to 1 at p = 71, 73, RISES BACK to 2 at 79, 83, 89, 97, 101, 103, and only then reads 1 from 107. T19 shows the same inside its first entries (3 at 23, 2 at 29, 3 again at 31). So "reads 1 from p = X" is a LAST-TRANSITION statement, and a column can recover between two 1-runs: a larger single killer is not a weaker one. This bears directly on route 26's intuition that entering a larger prime only buys capacity, and it is the one place where the reproduction adds a fact rather than confirming one. (2) The transitions are plateaus, and the plateaus differ per column: T17's 2-run runs from its first entry to 53, T19's from 37 to 67, T23's from 37 to 67 and again from 79 to 103. Transition primes 59, 71, 107 are in ratio 1.20 and 1.51 -- three points, no law claimed.

CONVENTION, DISCLOSED. The transition is read as the FIRST prime from which the value is 1 for the remainder of the column. Under the naive reading ("the first 1") T23's transition would be 71 and would CONTRADICT the published claim; the sweep shows the published claim is right and the naive reading is wrong, so the reading is forced by #161's own T23 claim.

ADDRESSABILITY, STATED EXPLICITLY. The period argument needs gcd(P, p) = 1 with P = x#, so every prime p <= x is unaddressable: at T17 {3,5,7,11,13,17}, at T19 additionally 19, at T23 additionally 23. Not computed, not claimed. They are also absent from the published columns (those begin above the level), so the comparison is complete for every entry that exists on either side.

COST AND INSTRUMENT. 32.4 s wall under sah.py exec (exit 0, process group gone), about 0.009 CPU-h of the 0.5 offered. The measuring path is period_check.c from #1377 recompiled from the shipped source; only the driver (run_columns.py) is new, and it tabulates and compares. That instrument already reproduced #161's diagonal at 8 of 8 folds and #1376's independent Python implementation at six levels, so a disagreement would have been informative rather than ambiguous. NOT CLAIMED: no two-class bound, nothing on route 26's K*(37) transfer, and the identity's weak step (that #161's tile uses the anchored {a, a+2} kill with the wraparound p - 2 read as -2 mod p, i.e. the same rule as K*) stays proven-from-definitions -- this reproduction tests its consequences, not its premise. #161's full 1,307-entry grid is unattached with no repository reference, so the comparison remains against its published diagonal and column statements.

METHOD (new program, period_check.c). Block m of the period Pprod(Q) is the tile shifted by mP, so its kill mask is a function of (m*P mod q) alone; the run length is carried ACROSS block boundaries with O(1) state and the seam is closed at the end. Memory is one byte per slot per prime of Q -- 214.7 MB at level 29 -- and the period itself (2.0e11 positions at level 29) is never materialised. The tile is enumerated with a segmented sieve, so level 29's P = 6,469,693,230 is reachable in 12 s. Total compute 275 s wall, about 0.076 CPU-h of the 1 offered.

RESULT 1 -- 8 of 8 diagonal folds. K*({p}) at levels 5/7/11/13/17/19/23/29 with p = 7/11/13/17/19/23/29/31 gives 2/1/2/2/2/3/2/4, identical to #161's published diagonal at every fold. Levels 23 and 29 are the two #612 could not reach (periods 6.47e9 and 2.01e11); slots in one tile are 7,952,175 and 214,708,725. The identity is therefore measured over #161's ENTIRE diagonal, not six of eight.

RESULT 2 -- #161's T29 column transition reproduces. At level 29, K*({p}) = 4 at p = 31, 3 at 37, 2 at 113, 1 at 127, 1 at 131, against #161's claim 'max 4 at p = 31, 3 at p = 29 and 37, 2 through p = 113, 1 from p = 127'. The maximum, the 3-rung, the last 2-rung and the first two 1-rungs all match. DISCLOSED: the p = 29 entry of that claim is NOT addressable here, because 29 divides P = 29# -- no slot is divisible by 29 and none is -2 (mod 29), so the period argument (gcd(P,q) = 1) does not apply. It was not computed and is not claimed.

RESULT 3 -- the unpublished ladder, and delta GROWS. K*({p,q}) for the two smallest primes above the level: 3/3/4/4/5/6/7 at levels 5/7/11/13/17/19/23, against K*({p}) = 2/1/2/2/2/3/2, so delta = 1/2/2/2/3/4/5. #609 proves delta >= 1; here delta = 1 is attained ONLY at level 5 and the excess rises to 4 and 5 at levels 19 and 23. So the covering capacity is not merely monotone in the entering prime: each entry buys strictly more than the theorem guarantees, increasingly. First three-class capacities (|Q| = {p,q,r}, also unpublished): 6/5/6/8/8 at levels 5/7/11/13/17. All twelve values are new -- nothing at |Q| >= 2 exists in print or in this project outside level 31#'s four certificates. This answers the question #612 left open and refutes the 'saturates at the minimum' reading.

VALIDATION. The C values reproduce #1376's independent Python implementation EXACTLY at all six levels Python reached (2/1/2/2/2/3) -- a cross-implementation check, not a rerun. Two defects in this assignment's own code were found and fixed, both disclosed: the first compile failed because the C header comment was terminated with a Python-style triple quote, which swallowed the #includes (a defect in my file, not the toolchain); and the first version's printed 'positions swept' multiplied by P and overflowed 64 bits at level 29 (printing 6.17e18 where the true slot-visit count is 6.66e9), now reported as period positions and slot visits separately. No K* value was affected by either -- all six cross-checked levels matched Python before and after the fixes.

STILL NOT COVERED. #161's remaining column statements (T17 from p = 59, T19 from 71, T23 from 107) are now cheap but were not computed; its full 1,307-entry grid is unattached and unavailable; p = 29 at level 29 is unaddressable as above. The identity's weak step (the wraparound p - 2 read as the anchored pair) remains untouched, though every column transition reproduced here is further evidence for that reading.

ARM A -- 6 of #161's 8 diagonal folds reproduce EXACTLY. K*({p}) at levels 5/7/11/13/17/19 with p = 7/11/13/17/19/23 gives 2/1/2/2/2/3, identical to #161's published diagonal at those folds. Periods enumerated 21/165/1755/25245/423225/8709525 over 3/15/135/1485/22275/378675 slots. So the identity moves from proven-from-definitions to MEASURED on six folds -- the most its artifact allows.

ARM A2 -- 4 of 4 column statements reproduce. Sweeping every prime p < 220: T5 reads 1 from p = 11, T7 from 11, T11 from 23, T13 from 37, exactly as published, all-1-afterwards true in each column; 170 swept entries agree.

THE SEAM ALTERNATIVE IS REFUTED, NOT ASSUMED. At level 7 / p = 11 the naive cyclic tile run (seam joined with unshifted residues) is 2 while the published value is 1; the published value matches K*({11}) = 1 and the LINEAR tile run. So #161's diagonal is the period object, which is what the identity claims, and the leading alternative explanation is dead by measurement.

ARM B -- the first two-class covering capacities outside level 31# (unpublished). K*({p,q}) = 3/3/4/4/5 at levels 5/7/11/13/17 (p,q the two smallest primes above the level) against K*({p}) = 2/1/2/2/2, so delta = 1/2/2/2/3: #609's proved delta >= 1 holds at every level and is EXACTLY 1 at level 5, the theorem's minimum attained in the one case here that attains it.

NEGATIVE CONTROL THAT MATTERED. The first run keyed block m by -mP instead of mP. That reverses block order while keeping each block's internal order -- a different sequence, unlike a full reversal -- and it gave K*({23}) = 2 at level 5 with every column transition moved (T11 appeared to read 1 from 29). A direct construction (period slots sorted; gaps are only 6 and 12, so a 2-run needs a gap = 0 or +/-2 mod 23) gave 1, proving the instrument wrong, not #161. After the fix all 6 diagonal values and all 4 column statements reproduce. The check discriminates: it produced a concrete disagreement with a published record and the disagreement was the instrument's fault, located independently.

NOT COVERED. T23 and T29 (p = 29, 31; periods 6.470e9 and 2.006e11) are beyond enumeration here, so #161's values there (diagonal 2 and 4, the T29 spectrum 413380422/7999018/12992/4, "2 through p = 113, 1 from p = 127") stay externally reported. #161's full 1,307-entry artifact (out-L-ext.txt) is not attached to its return and the return carries no repo URL, so the comparison is against its published diagonal values and column statements, not the grid; the column sweep runs to p < 220, not 1009. The identity's weak step (the wraparound p - 2 read as the anchored pair) is untouched, but the level-7 result is evidence FOR the anchored reading, since that is the convention that reproduces the published value.

WHAT TRIAGE DECIDES HERE. Whether another experiment is worth paying for. The route's central uncertainty is whether an independent |Q| = 1 run of route 26's covering instrument reproduces return #161's measured grid, i.e. whether the identity L(T_x,p) = K*({p}) becomes MEASURED and not only derived. The obstacle is not the identity's derivation (exact, no free parameter) but whether the check yields information the project does not already have.

FINDING 1 (new; it decides the scope). At |Q| = {p} the joint (slot, killed) pattern is periodic mod lcm(P,p) = Pp: slots are periodic mod P = x#, and the kill by p > x is periodic mod p with p not dividing P. So K({p}) IS exactly the longest covered run in one period P*p, wraparound included, and enumerating that period is a DECISIVE brute force -- no window bound, no heuristic, no missed case, unlike the search lineage route 26 uses. Measured this session (work/triage_period_bound.py, under bounded exec: exit 0, 0.08 s wall, process group gone; output work/triage-period-bound.out): the period is 210 / 2,310 / 30,030 / 510,510 / 9,699,690 / 223,092,870 at levels 5/7/11/13/17/19 and 6.470e9 / 2.006e11 / 7.421e12 at levels 23/29/31. Hence the identity can be checked EXACTLY, by both definitions, at levels T5..T19 -- six of #161's eight diagonal folds (p = 7,11,13,17,19,23, i.e. L = 2,1,2,2,2,3) -- and CANNOT be brute-forced at all at T23/T29 (p = 29, 31, the diagonal values 2 and 4). Consequence the route does not state: #161's T29 spectrum (413380422, 7999018, 12992, 4) and its "column reads 1 from p = 127" observation lie BEYOND exact enumeration and must remain externally reported, not independently reproduced by this check.

FINDING 2 (protocol; it cuts the named method). The route's next_step asks for the whole T29 column for 31 <= p <= 1009 plus samples of seven other rows -- a near-reproduction of #161's 1,307-entry table, which #161 measured in 19.0 s wall on 9 threads. The research protocol is explicit: "Do not regenerate a published count or rerun someone else's existing numerical experiment." If the grid agrees it adds no number the project lacks. The route's "1 CPU-h" figure is inherited from route 26's window-search lineage and is not evidence for the |Q| = 1 case; the only measured cost on this object is #161's 19 s.

FINDING 3 (the genuinely missing quantity -- the real payoff). #161 computed |Q| = 1 only, and per the route's reused search record nothing published or in this project gives a two-class covering capacity outside level 31#, where route 26 holds four certificates. The same period argument gives K*({p,q}) exactly at small levels (period Ppq). That is unpublished, it prices this session's #609 step (delta >= 1), and it is the ladder base the route says route 26 lacks -- and it is what route 26's own question (does the capacity keep crossing the threshold?) actually needs.

WHAT TRIAGE DOES NOT CLAIM. The identity stays PROVEN-FROM-DEFINITIONS only; the weak step named in #610 (reading #161's kill rule as the anchored {a, a+2} pair rather than a genuinely wider class set) is untouched here. The exact check at T5..T19 is decisive WHERE IT RUNS and silent elsewhere: it cannot validate the T29 rows.

#161's grid spans levels T5..T29 and primes 7 <= p <= 1009, which is exactly the range where a covering instrument can be validated cheaply. (iv) The prior-art verdict says the statistic's LAW is owned but no source bounds a MAXIMUM adjacent-kill run on a sieved set, so the value here is not a new law but a new, checkable relation between two lanes' objects - which is the cheapest kind of progress the project can bank. (v) Nothing in this proposal depends on an unproved input: #609's step is proved, #161's table is measured and accepted, and the one new claim is the identity, stated at rung "proven from definitions" with its falsifier named.