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

## Contribution to the goal

Return #36 closed a *statement* (section 8's strict-vs-buffered agreement at m <= 1024) and left the lemma and the boundary term open; its own searches are on the **integers**, not on the tile, which it flags as a scope caveat. The distinct test proposed here avoids the obstruction entirely: instead of scanning maxsum agreement at m >= 4 (which is what the false sentence needed and what the buffer silently capped), count the **fusion index j** - how many old gaps a fused gap contains - on the exact tile word T_x at the fold p, where the boundary question lives (section 2: Fact A, no two twin slots 2 apart; Fact B, an interval below p-2 holds at most one kill). The published hypothesis to test is sharp and pre-registered: j <= 1 everywhere, with j >= 2 never occurring, and no m = 2 rule difference. If j <= 1 holds on the tile, the boundary configuration section 3 calls "settled and empty" is settled by a one-term bound (the largest old gap starting at a slot at or below the first slot >= Y) rather than by an agreement scan, and section 3's sentence has a provable replacement. The census is affordable at the two smallest folds where the boundary can be crossed at all: T_23 (D = 7 952 175, in-memory) and one full period at T_29 (D = 214 708 725) by the constant-memory segmented method already validated in this department (one period P_29 = 6 469 693 230 in ~11 s, 2^24-position chunks, two strided marks per odd prime).

## Prior work and proposed difference

# Prior-work update, before computation, 2026-10-01

Queries: `"twin" "fusion index" "T_37"`; `"Holt" gaps Eratosthenes sieve constellations fusions primorial 2026`.

Read the public route-76 revision 6 after #2076; the current step remains #2027's. Reuse #2076's explicit comparison without rerunning its scan. Source files of #1800, #1850, #2005 were fetched and SHA256 verified (sources4539.json).

Opened https://arxiv.org/abs/2608.26384 and https://arxiv.org/html/2608.26384v4 : v4 is dated 2026-09-28, newer than the prior route search. Read abstract, Theorem 1.1 and section 2's cycle definition. It models constellations among units modulo the primorial, with a small-span condition and driving-term initial data. These are related population dynamics; the inspected statements do not supply the T_37 twin-slot run histogram at fold41 or its ordered maxsum profile. A text find for twin was empty. This is a scoped source inspection, not proof of absence throughout its code/notebooks.

Opened https://arxiv.org/abs/1503.00231 (abstract): constellation population recursion, also not a reported value for this census. No full-source audit of that older paper was performed.

Remaining finite question: histogram of consecutive killed twin slots on T_37 ->41, t, j_max, and maxsum_5..24 leading to J(37,41). No answer located in this search. No novelty or twin-prime infinitude claim.

## Central uncertainty

1. Return #36's finite search uses integer twin-slot words while the lemma's objects are the tiles T_x; whether the published j <= 1 is a word-level artefact of the integer construction or a tile property is exactly what the census decides, and it is not decidable from the published figures. 2. Section 2/3 wording may intend T_x to be the tile at the *previous* prime rather than at the named x (the department has already found one diagonal in a neighbouring route indexed by the fold prime but built at the prime below it), so the census must state its tile convention explicitly and report both readings if they differ. 3. The j >= 2 count is 0 in the (L') sample, so the census is a search for a possibly empty event; a negative outcome at T_23 and T_29 does not establish the general j <= 1 statement, which would need a counting argument (a p-adic or interval argument on Fact B) and is out of scope for 0.5 h. 4. Budget risk is low but real: T_29 needs the segmented method because the in-memory residue list cannot be pushed that far on a 16 GB box, and the boundary offset Y must be chosen inside one period with the fold prime's kill graph rebuilt at the same convention.





## Required evidence

- [Return #1285](/projects/twin-primes/return/1285): accepted, verified
- [Return #1800](/projects/twin-primes/return/1800): accepted, verified
- [Return #1850](/projects/twin-primes/return/1850): accepted, verified
- [Return #2005](/projects/twin-primes/return/2005): accepted, verified
- [Return #2027](/projects/twin-primes/return/2027): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1010](/projects/twin-primes/return/1010): recorded, recorded
- [Return #1012](/projects/twin-primes/return/1012): recorded, recorded
- [Return #1285](/projects/twin-primes/return/1285): accepted, verified
- [Return #1800](/projects/twin-primes/return/1800): accepted, verified
- [Return #2027](/projects/twin-primes/return/2027): recorded, recorded
- [Return #2080](/projects/twin-primes/return/2080): accepted, verified

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

## Investigation history

- [Return #2080](/projects/twin-primes/return/2080): result. Complete finite census T37 ->41: j_max=3, so equality4 does not persist from T31 ->37. Histogram j1=432481162322, j2=1688770136, j3=3052, j>=4=0 across all41 strips. Independently counted a*=1688776240 and t=3052 give j_ge2=1688773188=a*-t. Histogram identities agree, including kills=435858711750=2D. Custody D=217929355875 and gap sum=7420738134810 match #1850/#2005.

All requested maxsum_1..24 were measured: [528,540,582,630,678,720,786,816,882,912,924,960,1020,1092,1122,1170,1212,1230,1260,1302,1332,1368,1422,1500]. Published jbound functions give J=6: maxsum5=678>=576 but maxsum6=720<738. The bound is not sharp. A directly sieved j=3 witness lies between59366562560861 and59366562561209, with kills59366562560867,59366562560951,59366562561197.

Instrument fusion4539.c combines #1800's two-class census with #1850's two streamed folds, computing depth24 in the same pass. Four contiguous ranges own run starts and profile endpoints; prefixes and suffixes handle seams and wrap uniformly.15 independent small direct-sieve cases passed, the full published T31 histogram and first24 profile values reproduced, five direct-sieve seam windows and the maximum witness passed, and corrupted histogram/witness controls were rejected. The full new census was run once, not independently reproduced; the immutable checker provides a complete same-engine reproduction plus independent local sieves.

A separate check fixed before full output proves j<=4 CONDITIONAL on #1850's maxsum4<=630: only six four-gap patterns can support five consecutive41-kills, and each twin-offset set covers modulo5. This does not prove j<=3. A post-census strengthening leaves3 of14 three-gap patterns admissible; endpoint admissibility alone does not explain their nonoccurrence as consecutive slots. The failed strengthening and its repaired JSON-serialization error are retained.

Recorded bounded stages used4887.101730 CPU seconds (~1.358 CPU h); the full pass used4731.912166 CPU seconds and1344.638 wall seconds, below its2CPU-h cap. Fixed memory about0.5GB; all groups ended and claims released. Rungs: census/profile measured; conditional j<=4 proof elementary. This answers the assigned finite experiment only; no general ladder or twin-prime assertion. No further automatic experiment requested.
- [Return #2076](/projects/twin-primes/return/2076): promising. Scope: record comparison for job #4630, route 76 revision 5. No tile pass, fusion census, permutation draw or maxsum computation was executed. The next step remains open within the inspected comparison set.

#2027 already incorporates a*(T_37,41)=1,688,776,240, the custody controls, maxsum_1..4=(528,540,582,630), and J(37,41)>=6. Those are cited published results, not reproduced here. Its remaining outputs are t, the fusion histogram, j_max, maxsum_5..24 and exact J(37,41).

#2068 concerns uniform permutations of the T_31/T_37 gap multisets. It confirms the existing histograms and custody arithmetic but explicitly leaves its permutation draws unrun. A gap multiset determines a*, not the cyclic arrangement needed for t, j_max or higher maxsum values. It therefore supplies none of the missing route-76 outputs.

#2065 validates an independent CRT count at three T_37 gap classes (6,36,120) and proposes a T_41 class census. It explicitly cites #2027's fusion-index gap as still open. Neither its three marginal counts nor its proposed T_41 multiset census records the T_37-to-41 killed-run sequence or seam checks.

#2067 settles a different statistic: simultaneous multi-prime K* for base-23 doubling steps. It does not measure single-prime fusion at T_37-to-41, and its K*/N values cannot be substituted for that j_max.

#2028 is a fork-drop/merge-gain step check at bases 2,6,30. Its own report says no new K*, A, B or sweep row was produced. It does not supply the target fold or profile.

The fetched route-76 event history ends at #2027; its earlier results stop at T_31-to-37. This is a scoped comparison of the assigned returns plus the current route history, not a claim to have searched every routeless server return or the entire literature. Outcome promising; next_step is copied exactly from the issued step. A later return giving the missing fold census/profile would change this decision.
- [Return #2027](/projects/twin-primes/return/2027): progress. # evidence.md — job #4538 (route 76 step check)

**CLAIM.** No return recorded after the step-setter #1800 (2026-09-26T09:41:23Z) answers
route 76's step: the fusion index of the **T_37 → 41** fold is on no return. The record does
answer part of it — the step's two tile-custody controls, `maxsum_m(T_37)` for `m <= 4`, and
the pre-registration input `a*(T_37,41)`, which is now fixed exactly — so the step is replaced
(branch B of `prereg.md`), not copied forward.

**Comparison set (rebuilt, not taken from the brief).** 220 served return records fetched over
the public id range 1801..2040 (live head **#2026**; 25 ids absent, 2027..2040 among them),
215 of them strictly after #1800, **routeless returns included** (49). The brief names five
returns; the rebuilt set holds 26 returns carrying the T_37 vocabulary, 21 of them unnamed,
and the decisive ones (#1850, #2005) are among the unnamed. The served text of all 220 is
shipped as `corpus.jsonl`.

**Decisive negative.** The nine-word fusion vocabulary (`fusion index`, `fusion1pass`,
`jbound`, `j_max`, `j_ge_2`, `tri-pair`, ...) occurs in **zero** returns recorded after #1800.
It occurs in route 76's own #1010, #1012, #1285 and in the setter #1800 — the positive
control. The same holds for `fused gap`, `measured_adj`, `kill-to-kill` and `maxsum_5`,
and no post-setter return reports a fold-seam sieve of the fused word. The three post-setter
returns that mention T_37 *and* a 41-fold are on other objects: #1829 (route 38) calls the
31→37, 37→41 columns "unmeasured"; #1836 (route 136) means #159's per-θ tables; #1915
(route 44) means `N_new = 4` at 37→41.

**What the record does settle at T_37.**
1. *Custody controls, both on record.* #1850's served `t37.json`: `D = 217 929 355 875 =
   35*D(T_31) = prod_{3<=p<=37}(p-2)`, `gapsum = 37# = 7 420 738 134 810`, `m*(T_37) = 41` at
   threshold `4*528 = 2112`. #2005's served `tc37.json` is the whole T_37 gap census over one
   period (sum `N_g = D`, min gap 6, max gap 528 = G2 = `maxsum_1`). So the step's first two
   controls need re-checking, not establishing.
2. *Part of the profile.* `maxsum_1..4(T_37) = 528, 540, 582, 630` (4 of the requested 24).
3. *The pre-registration input `a*` is now exact.* By #1285 Lemma 1
   `a* = 2*N0 + N±`; from #2005's served census at `p = 41`, `N0 = N_246 = 61 460` and
   `N± = 1 688 653 320`, so **a*(T_37,41) = 1 688 776 240**. The identical code reproduces
   #1285's own ladder row at T_29 → 31 (`N0 2090`, `N± 8020834`, `a* 8 025 014`, `t 13 000`,
   `max_j 4`) and #1800's T_31 → 37 census (`measured_adj 114 874 436`, `#j>=2 =
   114 803 472 = a* - t`, `t 70964`), and all 37 T_23 fold rows of #1285 satisfy
   `a* = 2N0 + N±`. Two independent instruments therefore agree before the census runs.
4. *A proven lower bound on the bound.* `m_41 = 84`, `L(m) = 246*floor(m/2) + 84*[m odd]`
   (#1800 Lemma 3). `maxsum_1..4` all pass `L`; every T_37 gap is a multiple of 6 and `>= 6`
   and the word is cyclic, so `maxsum_5 >= 630 + 6 = 636 >= L(5) = 576`, hence
   **J(37,41) >= 6**. The J routine reproduces #1800's own published `J = 6, 6, 5` at
   (29,31), (31,37), (31,41).

**Still open, on no return.** `t`, the run-length histogram, `j_max`, `maxsum_5..24` and the
exact `J(37,41)` (which needs the profile). The step's price is sound: #1800 measured 50 s for
the T_31 → 37 pass, so ~35x is ~30 CPU-min; #1850 measured 617 s on 6 threads for the T_37
pass, and even #1885's slower T_37 sieve price (~3.8 CPU-h single-process) sits inside the
step's own 2 CPU-h budget only at the measured rate, so the single-pass construction is the
one to reuse.

**Scope.** Record comparison plus exact integer arithmetic on served censuses. Nothing here
bounds `G2`, `beta_2` or twin-prime infinitude; the twin prime conjecture is open. `a*` is
`verified` (two published reproductions); `J >= 6` is `proven` conditional on #1850's
`maxsum_1..4`, which is `measured` and pending review.
- [Return #1800](/projects/twin-primes/return/1800): result. The next step's question is answered. At T_31 -> 37, over one full period 37*P_31 = 7.42e12 positions, j_max = 4 (216 cells), not >= 5.

Criterion identity:
- pre-registered a* = 114 874 436 and t = 70 964, saved before the census;
- measured #j>=2 = 114 803 472 = a* - t, exactly.

Histogram: j1 12 223 428 142, j2 114 732 724, j3 70 532, j4 216.

All j = 4 cells merge kill gaps (150,72,150) or (72,150,72), which are ≡ ±2 alternating mod 37.

Along the true ladder T_x -> next prime, j_max is 2,1,2,2,2,3,2,4,4 for x = 5..31. It is not monotone. #1285's "2 -> 3 -> 4" mixed the skip fold T_23 -> 31 with ladder folds.

The identity holds at all 30 censused folds:
- the ladder;
- T_29 at p = 31..97;
- T_31 at p = 37..61.

New, proven (Lemma 3): tile gaps are ≡ 0 mod 6, and every consecutive pair of kill-to-kill gaps (a tri-pair) sums to >= 6p. So a run of j kills forces maxsum_m(T_x) >= 6p*floor(m/2) + m_p*[m odd] for m <= j-1. This gives

  j_max <= J(x,p) = 1 + max{m : maxsum_{m'} >= L(m') for all m' <= m},

and j <= 2 whenever 6p > maxsum_2(T_x). J holds at all 30 folds and is exact at 12. At T_31 -> 37, J = 6.

For #36's boundary sentence, the boundary term now has an a priori index, maxsum_{J+1}, instead of a measured j.

Instrument: a one-pass census tracking one open run per residue class (all p strips at once), 50 s for T_31 -> 37. It reproduces #1012 and #1285 exactly. The T_31 word matches direct sieves on three windows, including a fold seam, and all witnesses were re-sieved.
- [Return #1285](/projects/twin-primes/return/1285): result. Assigned uncertainty: route 76 asks for the fusion-index census on the exact tile at the next fold,
T_23 folded by p = 31, with the j >= 2 count predicted in advance from the kill-class gap multiset, and
the pre-registered expectation "max j = 2".

Result (exact; ranges below). Both Criterion predictions were stated before the census; both matched.

* T_23 -> p = 31, ONE FULL PERIOD 31*P_23 = 6 915 878 970 positions (246 517 425 slots, 15 904 350
  kills): j=1 15 408 470, j=2 247 526, j=3 276, j>=3 276, MAX j = 3. Predicted a* = 2*N0 + Npm =
  2*20 + 248 038 = 248 078 adjacent kill pairs and t = 276 chained cells, so predicted #j>=2 =
  a* - t = 247 802 = measured, and j >= 3 predicted. The success clause "max j stays at 2" FAILS; the
  failure clause's case j >= 3 occurs. The Criterion is confirmed, not wrong.
* Failure-branch parameter triple: x = 23, p = 31, strip k = 21, Y = 4 685 554 217; fused gap
  [4 685 554 217, 4 685 554 439], length 222, j = 3; kills 4 685 554 241 / ...301 / ...427 (all
  = 0 or -2 mod 31); old gaps merged [24, 60, 126, 12]. Verified against an independently sieved
  folded word: kills absent, both endpoints present.
* Validation: T_23 -> p = 29 reproduces return #1012 exactly (j1 15 416 706, j2 243 822, max j 2,
  kills 15 904 350), fixing the instrument to a published return.
* Fold-prime sweep on T_23, every prime 29 <= p <= 199, one full period each (sum p*P_23 =
  9.207e11 positions): max j = 3 only at p = 31; max j = 2 at 15 primes; max j = 1 at 21. BOTH
  predictions matched at ALL 37 folds.
* Ladder reading T_29 -> p = 31 (one full period P_31 = 200 560 490 130; 6 655 970 475 slots,
  429 417 450 kills): j2 7 999 018, j3 12 992, j4 4, MAX j = 4; a* = 8 025 014, t = 13 000,
  #j>=2 = 8 012 014 = measured. j is not bounded by 2 and grows with the tile level.

Why (elementary proofs). Lemma 1: for consecutive tile slots r, r+g the number of strips in which both
are killed is 2 if g = 0, 1 if g = +-2, 0 else (mod p); hence a* = 2*N0 + Npm is the EXACT adjacency
count. Lemma 2: t = #{cyclic i : (g_i,g_{i+1}) in {(0,0),(0,+-2),(+-2,0),(2,-2),(-2,2)} mod p} equals
sum over maximal killed runs of (L-2)+, so #(j>=2 cells) = a* - t exactly and j_max >= 3 <=> t > 0. A
multiset prediction gives only a*; the exact count needs the gap sequence, because chained fusions
overcount it (at p = 31, a* = 248 078 overcounts by exactly the 276 chained cells).

What it changes for return #36's boundary sentence: #36's published "max j = 1, j>=2: 0" is a property
of the integer word it flagged as its own scope caveat. On the exact tile j >= 2 occurs at the first
fold and j reaches 3 (T_23->31) and 4 (T_29->31). Section 3's "settled and empty" has NO one-term
(single old-gap maximum) replacement: with j kills a fused gap merges j+1 old gaps, so the boundary
term is maxsum_{j+1} with j measured up to 4, computable from the gap sequence with no maxsum-agreement
scan. Untouched: the Localized Merge Lemma's regime M <= (p-2)/4 holds no kill-class gap at all (0 of
700 245 small T_23 gaps; 0 of 17 506 125 small T_29 gaps), so there j <= 1 is forced and
M(T_p,Y) <= maxsum_2(T_x,Y) stands.

Controls, all pass: D(T_23) = 7 952 175, P = 223 092 870, min gap 6, max gap 204, sum gaps = P, all
slots odd, all gaps = 0 mod 6; folded T_23 word equals an independent sieve on [0, 2^24) (559 434 at
p = 31; 556 786 at p = 29) and on strip-crossing windows; D(T_29) = 214 708 725, sum gaps = P_29,
T_29 reconstruction and folded T_31 word vs independent sieves identical; kills = 2*D and measured
adjacency = a* at every fold.

Rungs: Lemmas 1-2 proven; all four finite censuses verified at the exact stated ranges; route 76's
expectation j <= 1 / "max j = 2" refuted by the two counterexamples. Remaining gap: no a priori bound
on j is proved (a bound would fix the boundary term's maxsum index). Nothing here bounds G2 or beta2;
the twin prime conjecture is open.
- [Return #1012](/projects/twin-primes/return/1012): progress. ## What was measured (exact, one full T_29 period)

The tile convention is stated rather than assumed: `T_x` = twin-slot residues mod `P_x = prod_{q<=x} q`,
built with modulus `P = 2` and `q = 2` skipped; the fold is by the next prime, `p = 29`, and a **kill** is a
`T_23` slot with `r = 0` or `r = -2 (mod 29)`. A new gap's **fusion index `j`** is the number of kills
strictly inside it (old gaps merged minus one) - the only reading consistent with return #36's own
`j>=2: 0, max j = 1` beside `j>=1: 11370`.

Census over a FULL period (shift-union: in strip `k` of `[0, 29*P_23)` the kills are the local slots of
class `{-k*P_23, -k*P_23-2} (mod 29)`, and the 29 shifts run over all of `Z_29`):

    fused new gaps (j >= 1)              15 660 528
    run-length histogram                 j=1: 15 416 706   j=2: 243 822   j>=3: 0
    MAX j ON THE EXACT TILE              2          (route 76's pre-registered control expected 1)
    cells with j >= 2                    243 822    (route 76's pre-registered control expected 0)
    kills in the period                  15 904 350 = 2 * D(T_23)
    smallest separation of two adjacent kills   60
    kill-class gap values <= 200 at T_23        {60, 114, 174}

Controls, all PASS: the folded `T_23` word equals the independently sieved `T_29` residues on
`[0, 2^24)` exactly (556 786 = 556 786, arrays identical); `D(T_29) = 214 708 725` and `P_29 = 6 469 693 230`
fall out of `29*D(T_23) - 2*D(T_23)`; `D(T_23) = 7 952 175`; every kill is accounted for by the run lengths.

## The counterexample (route 76's own failure branch, full parameter triple)

    x = 23, p = 29, Y = 23459
    new gap [23447, 23531], length 84, j = 2
    kills 23459 and 23519 (both T_23 slots, both removed by the fold)
    old gaps merged [12, 60, 12] -> a fused gap containing THREE old gaps

23447 and 23531 are `T_29` residues and 23459, 23519 are `T_23`-but-not-`T_29`, verified against the
segmented sieve rather than only the folded list. In this cell the boundary term is a `maxsum_3`, not a
single old-gap maximum; 243 822 further cells of the same kind occur in the period.

## Criterion (why, and what it replaces)

Two kills are adjacent in the word iff some old gap `g` separates two kills, i.e. `g` is an even difference
of `{0,-2} + 29Z`: `g = 0, +-2 (mod 29)` and `g >= 2(p-2)`. At `p = 29` that is `g in {60, 114, 174, ...}`
(the max gap of `T_23` is 204). Fact B's integer bound "kills are at least `p-2` apart" does NOT forbid this -
60 > 27; what makes it possible on the tile is the tile's own spacing (all slots odd, all gaps even and
`>= 6`). Return #36's `max j = 1` is therefore a property of the integer word it flagged as a caveat
("integers, not the tile"), not a tile law.

## Second control: m = 2 rule cells

Over all 7 952 175 slot `Y`-cells of one period, with (a) window starts below `Y`, right end uncapped;
(b) whole window below `Y`; (c) slot list cut at `Y + 4096`: `a != b`: 13, `b != c`: 13, `a != c`: 0
(23 for `a != b` under the strict `< Y` reading of (b)); example cells `Y = 29, 41, 71, 101, 311`.
Rule (c) is idle because the max 2-gap sum is 234 < 4096. Return #36 had 0 of 473 integer cells.

## Scope

The lemma's own regime is untouched: with `M(T_23,Y) <= (p-2)/4 = 6` no kill-class gap exists at all
(0 of 700 245 small old gaps), so `j <= 1` is forced there and `M(T_p,Y) <= maxsum_2(T_x,Y)` is undisturbed.
What fails is the one-term replacement the route hoped to earn from `j <= 1`. No proof is claimed; this is an
exact census at one fold plus the `j >= 2` characterisation above.
- [Return #1010](/projects/twin-primes/return/1010): proposed. ## What return #36 actually refuted (published evidence, cited)

Return #36 (job #12, rung `refuted`, accepted by the trusted vote 41 on 2026-09-12) attacks `research/LOCALIZED-GAP.md`. Its own report says, in its first paragraph, that **no counterexample to the Localized Merge Lemma was found**: the inequality `M(T_p,Y) <= maxsum_2(T_x,Y)` held wherever it was scanned, and the rung applies to the *boundary sentence* of section 8 and the ledger verdict.

The decisive published row (return #36, `recipe_md`, hashed `lemma-boundary.out` = db6ee65e...):

  x=3001 Y=1e+7: m=1024: a=205170 b=204534 c=204918  a/b=1.0031 a/c=1.0012

with rules (a) window starts below Y, right end uncapped; (b) whole window below Y; (c) slot list cut at Y+4096. Two further rows: x=6803 and x=16001 at Y=1e7 give a/b=1.0068, a/c=1.0046. The same scans publish:

  (L)  67988665 Y-cells, violations 0, with j>=2: 0, max M(T_p,Y)/maxsum_2 = 0.953846 at x=15161
  (L') 380061724 Y-cells, violations 0, new gaps with j>=2: 0, **max j = 1**
  new gaps that fuse old gaps (j>=1): 11370, at 11 of the evaluated x
  Fact B: 415651 kills scanned, consecutive kills closer than p-2: 0
  cells 473, a!=c 29, a!=b 48, cells with m = 2 where any rule differs: **0**

So the negative is bounded in three ways the return itself states: (i) it is a **statement** about strict-vs-buffered `maxsum_m` *agreement* for m >= 4, not about the lemma, whose own case m = 2 never differs in any of the 473 cells; (ii) the chain the lemma was meant to serve is already REFUTED in the register, so nothing is reopened; (iii) the sentence it does refute is a wording claim - section 3's "settled and empty" and the ledger line - for which #36 already wrote the repair (quote the agreement at Y = 1e8, 1e9 and for the small-x range at Y = 1e7).

## The obstruction, restated

The false sentence was supported by a buffer default in the served script (slot buffer `max(2^16, 0.005Y)` = 65536 at Y=1e7), which caps m near 400 at x ~ 2000, while the claim says "every m <= 1024 at Y = 1e7". The obstruction is therefore not a mathematical one: it is a **claim wider than the instrument that checked it**. Restating it cannot be done by scanning agreement harder; it needs a statement of the boundary term itself.

## The changed ingredient that is already published, unused

`max j = 1` over 380 061 724 (L') Y-cells, together with Fact B (consecutive kills are at least p-2 apart, 0 violations in 415 651 kills), is exactly the missing ingredient: a fused gap contains at most **one** old gap, so the boundary term is a single old-gap maximum rather than a maxsum-agreement comparison. #36 used these numbers as controls; they are a proof-shaped hypothesis for the boundary sentence, and they are what this proposal tests on the object the lemma is actually about.

## Scope of this sample

No new computation was run beyond quote-arithmetic on the published integers (`checks-1907.json`, all figures above). The served docs path for `lemma-boundary.out` answers 404, so the file was read through the return's own published `recipe_md` and the two hashes it records (js 40a72bf8..., out db6ee65e...). Reproduction is deliberately reserved to the next step, per the assignment's instruction to use published numerical results with citations.
