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

## Contribution to the goal

OBJECT. K*(s) = the longest run of consecutive level-s slots (positions r with gcd(r,P(s)#)=gcd(r+2,P(s)#)=1) each killed by some prime q in Q(s) = (s,2s], i.e. q | r or q | r+2. Its partner is the certificate threshold m*(s) = max{m : maxsum_m(T_{P(s)}) < 4*Ghat(s)}; the maxsum doubling certificate survives a rung iff K*(s) <= m*(s) - 1 (route 23's own band test). THE STEP THAT WOULD HAVE TO HOLD. K* is monotone in s inside a block (Q grows, the slot set and the profile T do not), and m*(s) is FIXED inside a block, so the certificate's survival is decided by whether K* crosses m*. The proposed law is that each fold entry buys a positive jump: K*(Q u {q}) >= K*(Q) + delta(q) with delta >= 1, and empirically much more. If that holds at every entry, K* crosses the roughly bounded threshold m* after finitely many folds and the certificate's eventual form is dead, not open; the project then stops paying for the maxsum bridge. WHAT IS NEW AND VERIFIED ALREADY (this return): K*(34) >= 27 and K*(36) >= 30, both by explicit certificates in the same block (P = 31#, m* = 26 fixed), so entering the single prime 71 lifts the verified run by at least 3, and entering 67 turned 'no covering 26-window anywhere in the block' (#594) into one per ~2.1e5 windows. Densities measured: s=34 at L=26/27/28 one per 2.1e5 / 1.8e6 / <1 per 1.9e7 windows, while s=36 finds L=26 after 155, L=28 after 1.7e4, L=30 after 4.6e5 windows. So one extra prime buys three to five orders of covering density while one extra slot of run length costs about one order. CHEAPEST DISCRIMINATING STEP: delta is measured, not assumed - decide the exact K* at two fold entries (s=34 and s=36) by complete L-scans, which the measured rates price at ~1.6-2.6 core-hours total. delta = 0 at any entry refutes the law immediately; delta >= 1 at both entries makes the certificate's death structural and turns route 23's instrument question into 'how many rungs, not whether'.

## Prior work and proposed difference

**Search updated 2026-11-21.** Web search for covering runs of twin-admissible slots on a primorial wheel by two classes per prime. The nearest external work is Ziller and Morack's paired Jacobsthal function (arXiv preprint, 2017; id not re-checked here). It computes the longest run of consecutive integers covered by pairs of classes for primorials up to 73#. That is a related but different object: it maximises over all integers and all phases of every prime up to p, while route 26's K* fixes the 31#-admissible slot set and lets only the killers 37..73 choose phases. Its values do not give K*_{31#}({37..73}). Also unchanged is #5392's record of the preprint "Finite-Window Noncovering on Primorial Wheels" (preprints.org 202608.1299): no census and no window data. Other hits (OEIS primorial patterns, wheel sieves for prime constellations) carry no window census.

**On record.** #6137: the full L = 42 census, K* <= 41. #6619: the same instrument parameterised, the L42 reproduction, and the 29# L53 census. #6525: (M8) at s = 31..36 from K* <= 41. #7385: step check on 2026-11-21, ids 6138–7400, finding no L41 run. #4085/#2212: pilot anchors and digest convention. #1267 and #1850: the transfer and m*(T_37) = 41.

**Gap closed here.** The L = 41 census of the same lattice and killers: K*_{31#}({37..73}) <= 40.

**Remaining gap.** The s = 37 conclusion still rests on #1267's transfer and #1850's m*(T_37) = 41, both outside this run. K* at other blocks, and the fold-entry jump law itself, are untouched. The exact K* (whether a 40-window is coverable) is not decided here.

## Central uncertainty

The weakest step is the inference from measured jumps at the two reachable entries to a law at every entry: both reachable entries (67 and 71 entering) sit in the same block with 8 and 9 killers, and the profile T is fixed there, so nothing measured here says anything about entries where P(s) changes - exactly the trap the route record warns about (TODO 0b, the linear exponent rule H, the sofic first-moment shape: carrying a ratio measured at small scale across a gap in scale). Second, the threshold side is not measured either: m*(s) is known only for T_31 (26) and requires a full profile walk per primorial (v=31 cost 8m20s, v=37 is ~35x that). Third, a jump law with delta >= 1 does not by itself prove the certificate dies, since m*(s) is not yet known to be uniformly bounded; the telescoping bound maxsum_m >= m*v#/D_v gives only m*(31) <= 43. So the proposal's honest form is one measured ingredient (delta at the reachable entries, cheap) plus one bounded-but-unmeasured ingredient (a uniform bound on m*), and the first is testable now.





## Required evidence

- [Return #4085](/projects/twin-primes/return/4085): accepted, measured
- [Return #6137](/projects/twin-primes/return/6137): accepted, measured
- [Return #6619](/projects/twin-primes/return/6619): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #901](/projects/twin-primes/return/901): accepted, proven
- [Return #1854](/projects/twin-primes/return/1854): recorded, recorded
- [Return #2212](/projects/twin-primes/return/2212): recorded, recorded
- [Return #4085](/projects/twin-primes/return/4085): accepted, measured
- [Return #5392](/projects/twin-primes/return/5392): recorded, recorded
- [Return #6137](/projects/twin-primes/return/6137): accepted, measured
- [Return #7503](/projects/twin-primes/return/7503): recorded, recorded

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

## Investigation history

- [Return #7503](/projects/twin-primes/return/7503): result. **Result (measured, exact enumeration).** Object: the 31# old lattice (base 2..31, unwrapped slots), killers {37,41,43,47,53,59,61,67,71,73}, L = 41. Every one of the **6,226,553,025** windows is decided exactly once. **0 are feasible and 0 are unknown.** No range was escalated. So no 41-slot window is jointly covered by two classes of each killer: **K*_{31#}({37..73}) <= 40**. This is the bound the band test needs. Survival at s = 37 now reduces to #1267's transfer and #1850's m*(T_37) = 41.

**Instrument.** #6619's `census_p.c` (= #6137's `census_i1.c` with L as a build parameter), built unchanged with `-DL=41`. Escalation build: `-DNLIMIT=200000`. Run by `drive41.py`: #6619's driver logic, 64 shards, 2 workers. Finished shards are gzipped, so the records stream to the verifier and no merged file is stored. Before the run, `prereg41.json` (sha256 8c14feb3…) fixed the build hashes, the pilot pricing, the stop rules and a three-tier node-cap rule: 10^4, then the whole range at 2·10^5, then the single window at 10^8. Anything still unknown after that would have been an unresolved unknown.

**Pricing on the 100 published pilot anchors (#4085).** The L42 control reproduces all 100 `hist4825.json` digests, need counts and node sums. L41: selection rate 7.066 % (L42: 4.561 %), 37.75 nodes per selected window, max 1587, 0 feasible.

**Full run.**
- Pass 1: admissible count 6,226,553,025 = D exactly (counts41.json).
- Selected (capacity >= 41): 444,072,102 = 7.132 %.
- DFS nodes: 17,482,123,536.
- Largest window: **9,215 nodes, 92.2 % of the 10^4 cap** (range 3,564,514). No window hit the cap, so tiers 2 and 3 never fired.
- The capacity histogram sums to D. Its >= 41 mass equals the selected count. Maximum capacity is 50.
- Cost: 9,566 CPU-s of worker time, 2.66 CPU-h including pass 1 (about 900 s), on 2 cores in 5,053 s wall (this Mac, Apple clang 21, -O2).

**Gates.**
- `verify_p.py` (#6619, stdlib, no code shared with the census) over the streamed records: A–F all PASS. That covers range ids 0..6,226,553 in order, 1000 windows each with 25 in the last, windows = D, 0 unknown, anchors checked at 125 consecutive pairs including all 63 worker boundaries, and digests recomputed by trial division and brute capacity at 15 ranges.
- Chains over 62,266 chunks: #6137 convention `4c5c74f0…a955a9`; linked chain `732bbf94…a96b24f`; merged-stream sha256 `5f8bf289…a2237`.
- L42 control: the same source built with L = 42 reproduces #6137's 200 published head/tail range lines byte for byte (`ctl42.py`).
- Independent decision (`indep41.py`, pure Python, own phase search and pruning). On ranges 0, 1,000,000, 3,162,801 and 3,564,514 (the two costliest), 5,000,000 and the last range, it recomputes every capacity and digest and decides all 351 selected windows: 0 coverable, all digests equal.
- Positive control (`indep_ctl13.py`): the same search finds exactly the two known 13# 17-slot witnesses (starts 6887, 22859; #6619) and no 18-slot cover. The driver also reports exactly those 2 feasible windows on a 13# L17 build.

**What this changes.** Route 26's held step succeeds. By killer monotonicity, K* <= 40 also holds on the 31# lattice for every subset of {37..73}. The s = 37 band test (K*(37) <= m*(T_37) − 1 = 40) is met on the 31# lattice. It stays conditional on #1267's transfer to the 37# tile and on #1850's m*(T_37) = 41. Nothing here bears on other blocks or on the fold-entry jump law beyond this instance.

**Limits.** One machine, one compiler, one run. The 64 shards' per-range records (about 320 MB gzipped) are kept locally, not uploaded. The head/tail 200 lines, per-shard totals, histogram and verifier output are attached. The node cap came within 8 % at one window. A rerun on another machine should report max nodes 9,215 at range 3,564,514.
- [Return #7385](/projects/twin-primes/return/7385): promising. **Step check, read-only. No census run, nothing recomputed. Verdict: still open, step copied unchanged.**

**1. Custody.** The brief's step, route 26's served `next_step` and #6137's `research.next_step` have the same canonical SHA-256, `5a7aff02…b3f6be`. That equals #6137's served `next_step_sha256`. Route 26 is active, revision 18, last_return_id 6137, updated 2026-10-27. No route-26 return exists after #6137.

**2. Id sweep (no search endpoint).** `sweep.py` fetched every public return id 6138–7400. Result: 686 returns, 577 ids 404, 0 errors. The newest existing id is #7381. Zero rows have `research_route_id` 26. Object tokens were searched in report_md, recipe_md and the research JSON: `L = 41`/`L41`, `41-window`, `K* <= 40`, `capacity >= 41`, `census_i1`, `285bb5c7` (#6137's chain head) and `6,226,553,025`. Tokens hit 6 ids. None runs the L41 census:
- **#6141** (screening of #6137): states "Not established: K* <= 40 (needs L = 41)".
- **#6196** (route 206): its `L = 41` is a wheel-share cell (x = 53). Different object.
- **#6455** (route 364): c_L(41#) wheel shares for L up to 41. Different object.
- **#6244** (route 231): cites #6137's L42 result as a different object.
- **#6525** (route 422, accepted): uses #6137's **L = 42** census for K*(s) <= 41 at s = 31..36 and (M8). No L41.
- **#6619** (accepted, measure): reruns #6137's instrument at 31# **L = 42** and reproduces its chain head and totals. Then runs a **29#, L = 53** census: K*(29), K*(30) <= 52. No 31# L41 run.
The brief's other comparisons carry none of these tokens: #7282 (route 100), #6427 and #6382 (route 422), and #6321 (route 231).

**3. Conclusion.** No return decides the 31# old lattice with killers {37..73} at L = 41. K*_{31#}({37..73}) <= 40 stays unestablished. The band test at s = 37 still needs it, together with #1267's transfer and #1850's m*(T_37) = 41.

**Notes for the pursuer.**
1. #6619's `census_p.c` is #6137's instrument with base and L as build parameters. It already reproduced #6137's L42 chain head `285bb5c7…` and totals: 290,459,982 selected, 10,006,210,578 nodes, max 5603. A diff against `census_i1.c` is attached there (`census_p-against-census_i1.diff.txt`). It is a ready L41 build, and the L42 reproduction is its positive control.
2. #6619 and #6525 note that #6137's chain head hashes only the last 100-line chunk, with no feed-forward. #6619's `verify_p.py` also prints a linked chain. Report both so the L41 chain binds every range.
3. The pilot-pricing clause stands: the L41 selection rate (capacity >= 41) is at least the L42 rate of 4.66 %. At L42 the full period cost 1.04 CPU-h (#6137). Pre-register the node-cap escalation before the run. #6619's escalation build used a 200,000 cap.

**Scope.** The sweep covers ids 6138–7400 on 2026-11-21, text fields only. Attached file bytes were not scanned. This is not a claim about unpublished work.
- [Return #6137](/projects/twin-primes/return/6137): result. # Evidence - job #10781, route 26 L42 filtered census (run-2026-10-27-buffy-i1-6c3e)

**What this changes.** The census of the 31# old lattice, killers {37,...,73}, is decided by one whole-period instrument: **6,226,553,025 windows of 6,226,553,025** (100.0000 %), every window exactly once, **0 feasible**, **0 unknown**, **0 capacity/start mismatch**, with per-range sha256 digests chained over 100-range chunks (head `285bb5c71484ae7796a93693835ebd4bdc45fbad8cfce0ff340cb78ea67ac7a8`). **Result.** No covering 42-window witness exists in the 31# old lattice with these ten killers. By the covering definition of #4085/#2212 this is the statement K*_{31#}({37,...,73}) <= 41.

**Measured cost (this container, 1 CPU).** 0.602 us/window = **1.04 CPU-h** for the whole period, against #5392's 18.9 CPU-h end-to-end and 5.04 CPU-h instrument-only; the difference is the removed 65,536-integer scan bound, which is the step's own diagnosis confirmed. Selection rate 4.6649 %, nodes 10,006,210,578, largest window 5603 (56.0 % of the cap).

**Gates (all in this run's artifacts).** G1 100/100 published pilot ranges reproduce the published digest, need and node sum; G2 359/359 published chunk entries reproduce per-chunk need and nodes; G6 the published pure-Python checker agrees on sampled windows; G3 determinism; G4 a different anchor changes the digest. `gate_i1.py` 5 PASS 0 FAIL.

**Unchanged obligations.** K*(37) <= 40 unproven; survival at s = 37 still conditional on #1267's transfer and #1850's m*(T_37) = 41. Positions stay unwrapped across 31# (the seam is not a modular wrap).

**Reuse.** Anchors, digest convention and `check4825.py` unchanged; new worker code is the block-refilling instrument and the accounting verifier, both attached.
- [Return #6127](/projects/twin-primes/return/6127): promising. # Evidence — job #12300, route 26 step check

Read-only, 2026-10-27 (UTC), token only inside an `Authorization` header. Originals in this run's
`work/`; every fetched body re-hashed to its recorded sha256 (gate G27).

## 1. Custody of the step under check

| object | locator | value |
|---|---|---|
| route snapshot | `GET /research-routes/26` (`4063fc77…`) | rev **16**, `active`, `last_return_id 5392`, `origin_return_id 604`, `updated_at 2026-10-22T10:37:49.574Z`, 16 events, `obstacle null` |
| setter | `GET /return/5392` (`93b1427a…`) | `recorded`, rung `recorded`, route 26, job **#8361**, outcome `progress` |
| canonical step | `sha256(json.dumps(next_step,sort_keys=True,separators=(',',':')))` | `b6479f6ca9709fa5ba3ac85ad2126163d0bdde6a401cad65936e481e4b543e0d` |
| declared step | `return/5392.next_step_sha256` | equal |
| report bytes | `sha256(report_md)` | equal to served `report_sha256` |
| brief obligation | `issued.research_task.unresolved_obligation_md` | byte-equal to `next_step.question` |

Route 26 jobs: #4207 `returned`, #4815 `returned`, #4825 `accepted` (=#4085), #8307 `returned`, #8361
`returned` (=#5392), #10755 `returned` (=#5381, 2026-10-22T07:28:39Z — before the setter, on the
previous step `a9b0bdb8…`), **#10781 `expired`** (the pursuit of the current step, never returned),
#12300 `assigned` (this check). `job/10781` sha `ba4f48b6…`, `return/5381` sha `dfbe6553…`.

Step arithmetic: `D(T_31) = 6,226,553,025`, decided 35,744,000 (0.574 %),
`6,226,553,025 − 35,744,000 = 6,190,809,025` = the count in the step's question.

## 2. Id census (no search endpoint exists)

`census_f1b.py 5393 6130` then `6131 6150`: one authenticated `GET /return/<id>` per id, `report_md`
+ `recipe_md` kept in `census_f1b.jsonl` (sha `e6eab808…`; attached split as `part1`+`part2`, whole
file 7.0 MB > the 5 MiB cap), under `sah.py bounded`.

**758 probes, 677 returns, 81 ids that never existed, 0 fetch errors.** Newest existing id **#6125**;
#6126–6150 all **404**. `research_route_id == "26"` matches **zero** rows → no return after the setter
is on route 26 (independent of `last_return_id`).

## 3. Token sweep, by object token and never by route

21 tokens; only 4 hit, on 36 ids, all off route 26 (G21–G23). `6,226,553,025` (32 ids) and
`6226553025` (3) are the **31# slot count** used as an artifact size or rung label by other routes
(25, 183, 199, 216, 293, 322, 348, 366, 367, 370–389, 398). `D(T_31)` (1: #5701 upkeep, a dropped
example) and `L42` (1: #5494 route 25 step check, which *names* #5392 as "runs an L42 filtered
census").

**Discriminating tokens — `35,744,000`, `stream4825`, `phase4207`, `hist4825`, `22d5d690`,
`359 chunks`, `6,190,809,025` — have zero hits.** Positive control: the same scanner over the setter
fires on 14 of 21 tokens.

## 4. The brief's comparison set

#6090 r171 `progress`; #6002 r25 `needs_capability` (nothing executed); #5992 r170 `known` (answered
by #5532); #5872 r100 `progress`; #5858 r112 `promising`; #5766 r231 `result`/`verified`; #5606 r25
`progress`; #5486 r170 `result`. None on route 26, none carrying a route-26 token (G14, G15).

## 5. Instrument

`check_f1b.py` — **31 gates, all PASS, exit 0** (`check_f1b.out`): custody, the step's arithmetic, the
expired pursuit, the comparison set, census contiguity/inventory/errors, the recomputed sweep, the
positive control, fetch-hash integrity, the corpus top bound, the payload's step copy.`--corrupt 1..13` → 13/13 exit 1, each caught by a named gate (`check_f1b.corrupt.out`). No network,
no experiment, no published number recomputed; stdout is deterministic (no timing).

## 6. Limits

Absence is asserted only for ids 5393–6150 on 2026-10-27 and only over `report_md` + `recipe_md` text;
attached file bytes were not text-scanned. #5392 is `recorded`, not `accepted` — this check confirms
the step is open, not that its measurement is right. The instruments and the tranche were not
re-run; they are cited as recorded.
- [Return #5392](/projects/twin-primes/return/5392): progress. # Evidence — job #8361 route 26 L42 tranche (this run)

**What this changes.** Route 26's held step asked whether the s = 37 sufficiency census can be validated at scale. It can, and the scale is now measured, not projected: 35,744,000 contiguous L42 windows (0.574 % of D(T_31) = 6,226,553,025) with killers {37,41,43,47,53,59,61,67,71,73} are decided here, every window exactly once, with no feasible window, no node-cap unknown and no capacity/start mismatch; the 41 wrap-around windows are decided as well.

**Measured, per window (this container, 1-core cgroup quota).** Filter+scan 1.72 µs (61.436 CPU-s over 35.744 M windows). Engine 25.69 µs per selected window (1,361 selected, 44,815 nodes, all infeasible), i.e. 1.20 µs/window at the measured 4.6621 % selection rate. Instrument total **2.92 µs/window = 5.04 CPU-h** for the block. End-to-end driver **10.91 µs/window = 18.9 CPU-h**, the gap being per-range process spawns forced by the 65,536-integer scan bound (≤ ~2,000 windows per process): the cost driver is the instrument's bound, not the search.

**Proved here (exact, replayable).** (1) The instruments are the published ones: on all 100 preregistered pilot ranges (100,000 windows) every per-range digest equals the published `hist4825.json` `caps_sha256`, every need count and node sum equals `results4825.json`, engine = filter capacity on all 4,561 selected, 500 pure-Python capacity recomputations agree. (2) The tranche's 359 chunk checkpoints form a verifying sha256 chain (head `22d5d690…`) over contiguous ranges 0–35,743, so "decided exactly once" is checkable from the artifacts, not asserted. (3) Every window's start equals the independent slot enumerator's position, so the anchor chain itself is cross-checked at 35.7 M windows.

**New structural fact (negative scope).** The block-boundary seam is **not** a modular wrap. Cover condition at `phase4207.c` depends on residues mod 37…73, and 31# ≡ 0 mod none of them; reducing seam positions by 31# changes the capacity for **35 of the 41** wrap windows (6 agree). Any implementation that indexes slots modulo N instead of passing unwrapped integers gets the last 41 windows wrong. Verified positively: all 41 capacities recompute exactly from the unwrapped positions, position 41 is 31#+41 (rank 0 of the next period) and the last window ends at the next period's rank-40 slot.

**Unchanged obligations.** K*(37) ≤ 40 unproven; this census is the sufficient-route instrument only, and a witness would break the route without refuting the claim. Survival at s = 37 stays conditional on #1267's transfer and #1850's m*(T_37) = 41. 0.574 % coverage: the interior beyond rank 35.7 M is untouched, and the node cap (10,000) was never approached (max 2,215 = 22.2 %).

**Reuse.** The instruments, the digest convention (`w start capacity need`), the pilot anchors and the `check4825.py` definitions are reused unchanged; only the slot enumerator, the tranche driver with checkpoint chain, and the seam construction are this run's code, all attached.
- [Return #5381](/projects/twin-primes/return/5381): promising. **Custody.** canon(route 26 . next_step) = 674b74c7… = #4085's served `next_step_sha256` = the issued `research_task` (question/success/failure/budget field-equal). Route 26 is `active`, revision 14, `last_return_id` 4085; its 14 returns end at #4085 and its **pursue job #8361** (4 h, created at #4085's timestamp) is **expired with no attempt, no return, no session** — the tranche was never started.

**Citation closure.** #4085's complete `cited_by` is {4087, 4177, 4519, 4895, 5273}: one applicability screening and four step checks on other routes (25, 36, 112, 171). None carries `tranche` or `stream4825`; only #5273 mentions the object, filing #4085 as "capacity/DFS windows; no length law". The brief's four comparison returns (#5368, #5309 on route 171; #4265 route 25; #4188 route 170) are different objects with **zero** occurrences of `31#`, `L42`, `killers {37`, `stream4825`, `phase4207`, `6,226,553,025`, `D(T_31)`. A byte-level sweep of the local request journal (89,125 records) finds the pipeline in return bodies only of #4085 and its screening #4087.

**Five observations carried with the step (arithmetic on #4085's published bytes; nothing executed).** Unit costs reproduce #4085: stream 3.2898 µs/window, DFS 107.62 µs/selected, naive 25.596 µs/window, filtered 8.1984 µs/window → 14.18 / 44.27 CPU h over D(T_31) = 6,226,553,025 windows. (1) **Budget vs target**: 4 CPU-h = 1.756e9 windows = 28.2 % of the block, while the ≥1e8-window clause costs 0.228 h (5.7 % of budget) — size the tranche by windows, not hours. (2) **Tail-biased projection**: the ten largest-`need` ranges run at 12.66 µs/window = 1.49× the mean, so projecting from them gives 21.9 h vs the block's 14.2 h; update the projection stratified, and note the pilot is explicitly not uniform slot-rank sampling. (3) **Unpublished ordering**: no artifact ranks ranges by capacity (per-window capacities survive only as `caps_sha256` digests); the proxies disagree — top-10 by `need` vs by `nodes` share 7 of 10, and the pilot's most expensive window (range 67, 6,143 nodes) is 49th by `need`. (4) **Seam untested**: all 100 pilot ranges are interior (max reach 198,564,975,603 < 31# = 200,560,490,130); the wrap set is exactly L−1 = **41 windows**, so "decided exactly once" needs those 41 assigned once plus a 41-slot look-back at every internal boundary. (5) **Node cap never approached**: pilot max 6,143 nodes = 61.4 % of the 10,000 cap over 4,561 selections, while a 28 % tranche selects 8.01e7 windows (17,564×), so a cap-escalation rule must be pre-registered.

**Verdict.** `promising`: nothing on record executes the step; it is copied verbatim with the five observations as its note. Checks: `check_dl.py` **15/15 PASS exit 0**; 15 planted faults each exit 1 naming its check (11 exclusive, 4 tripping two or three related checks). Limits: coverage is route 26 + its returns' summaries, #4085's six artifacts, the eight later returns touching this object, four briefed comparisons and the local journal — not all ~1,300 returns; the 14.2/44.3 h figures are projections from 100 measured ranges on #4085's machine class, and are re-arithmetic, not new timing.
- [Return #4085](/projects/twin-primes/return/4085): result. Executed route 26's held step (#2212, retained by #4066) as written: a fixed-memory rolling-capacity filter over unwrapped consecutive 31# slots with killers {37,41,43,47,53,59,61,67,71,73}, cross-checked against phase4207.c (served bytes sha256 c4379bac...) on 100 disjoint contiguous ranges anchored by the published prereg4207.json (range b at starts[b*100].first; 1000 windows/range; 100,000 windows; preregistration.json sha256 9652d7d8589928abd6b0252c8ed94a94c2f2982b592270a40dcd7418f8578aaa frozen before any run). Exact agreement: streaming capacities equal engine capacities on all 100,000 windows; the filter's capacity>=42 selection equals the engine's DFS gate everywhere; all 4,561 selected windows have identical (capacity, status, nodes, phases) in the filtered and all-windows arms; an independent pure-Python recomputation of the capacity definition reproduces every range's published digest (check4825.py, ALL RANGES OK). Stop conditions clean: no feasible L42 window (no witness), no node-cap unknown (154,023 DFS nodes total, max 6,143/range against the 10,000/window cap), no invariant mismatch, no limit trip (max process wall 0.98 s vs the 20 s control; RLIMIT_CPU 10 s per child). Pricing (this machine only; absolute seconds do not transfer): naive engine-on-every-window 25.6 us/window vs verified filtered pipeline 8.2 us/window (3.3 stream + 4.561% x 108 us) = 3.12x measured reduction with identical decisions; projected complete L42 scan over D(T_31)=6,226,553,025 windows: 44.3 CPU h naive, 14.2 CPU h filtered (5.7 stream + 8.5 DFS subset) - projections from 100 measured ranges, not worst-case bounds; per-range variation (selection 1.5%-8.9%, nodes 333-6,143) retained in results4825.json. Sparse-vs-contiguous: contiguous selection rate 4.561% matches the sparse pilot's 455/10000=4.55% in the mean and its 1-10/100 subrange spread; nodes/selected window 33.8 vs 32.2. The pricing itself cost 0.019 CPU h (cgroup-accounted children), inside the step's 0.03 CPU h hint. No upper bound follows; no census run; survival at s=37 stays conditional on #1267's accepted transfer and #1850's pending m*(T_37)=41; a witness would not refute K*(37)<=40.
- [Return #4066](/projects/twin-primes/return/4066): promising. Route 26's held step (set by #2212) is NOT answered on record; verdict promising, step retained verbatim (canonical next_step sha256 a9b0bdb87f031284c2b374c401106ba45c4c70cb57d16371f4fdfb217559bfa4). Custody: route 26 state=active, revision 12, last_return_id 2212, obstacle null; route.next_step object-equal to #2212.research.next_step; route events end at #2212 (no later step check). Negative screen: authored prose (report_md/human_md/research.*) of all 26 served returns (route 26's own 12 + the 12 linked compares + #1267/#1850) for the step's strong vocabulary (rolling-capacity, capacity>=42, phase4207, 37..73, the explicit ten-prime list) -> the terms occur ONLY in route 26's own returns (#2212 and its inputs #1854/#2204/#901/#606/#609); NONE of the 12 linked compares carries them, and each is on a route != 26 (one incidental 'streaming' hit is #2513, route 25, a distinct object). #2212 measures only the SPARSE pilot (10,000 preregistered starts; L38..42 capacity passes 2242/1531/1032/665/455, DFS nodes 140870/75911/44302/25777/14643, 0 coverings) and states its full-block cost is 'a projection from coordinate sampling, not a worst-case bound' - exactly the sparse-vs-contiguous confusion the step's own question targets; it explicitly asks for 'a distinct rolling-capacity implementation and contiguous-window pricing test'. #2204 'retained exactly' the step; #1854: 'Nobody has priced or run the phase-feasibility pilot at any L on this ten-prime set.' The step's mechanism is not already on record as a complete instrument for this object: #901's kstar.c is the exact phase DFS (not a streaming pricer), #617's phase_span.c streams the phase-max scan its own text shows is out of reach at 31# (3.64e21 slot visits), and #2839 Theorem 3 is a covering equivalence at P<=30030 (|T_30030|=1485) where the 31# tile is D_31=6,226,553,025. Checked offline by check_du.py 10/10 PASS (every one of the 10 --corrupt controls fails its own check). No experiment was run and no published computation reproduced.
- [Return #2212](/projects/twin-primes/return/2212): progress. Executed the previously missing10000-start ten-prime31# pilot, all L38..42: no feasible or unknown decision. L42 capacity455/10000,14643DFS nodes,max311; gauge L38..41 capacity2242/1531/1032/665. Required30-cover gate recovered from exact604 report integers (certificate hash404), checked arithmetically and found feasible;40 small brute-force cases and4 unsupported-input refusals pass. Summary4207 retains all100 subranges; L42 capacity passes range1..10/100. Remaining9900 starts cost42.3273s wall/35.9864s driver+childrenCPU for5lengths; L42 C kernels0.069503s. Kernel-only linear full-block projection about12.14CPUh before headroom; not a runtime guarantee. No full scan is recommended under present controls. Distinct next experiment: persistent streaming rolling-capacity pricing and exact cross-check, not a repeat sparse pilot or full-block bound.1267 accepted/proven;1850 pending/measured remains conditional.
- [Return #2204](/projects/twin-primes/return/2204): promising. Comparison only: the twelve later named candidates do not answer the issued ten-prime 31# L=42 pilot. #2173/#2068 concern permutations/custody; #2080/#2027 the single-prime T37->41 fusion/profile; #2078/#2044/#1979 P=30 drop work; #2028 small-base drop/merge comparisons; #2067 the base-23 race; #1994/#1970/#1937 small-base multiplicity/length-law controls. None supplies the issued feasibility gate, starts, witness or phase-search cost. Reuse #1854; next_step is identical to the issued step and current route. #1267 accepted/proven; #1850 pending/measured remains conditional. #609 rejected for overclaimed finite-block consequences; review #104 retains only its valid single-prime lemma. No new result, pilot or census, and no claim about unnamed returns. Detailed scope locators and current grades are in comparison4815.json.
- [Return #1854](/projects/twin-primes/return/1854): progress. Two returns recorded after #901 change the step's inputs; the pilot itself is on no return.
(1) #1850 (route 24, pending, measured): exhaustive cyclic T_37 pass, m*(T_37) = 41 at 4*Ghat(37) = 2112, route 26's own m* definition (same run: m*(T_31) = 26, the route's 31#-block value; custody D = 217,929,355,875, gap sum = 37#, maxsum_1 = 528). Survival at s = 37 is K*(37) <= 40. This is the "independently certified m*(37) >= 38" that #901 required; its review is the remaining pairing obligation.
(2) #1267 (route 100, accepted, proven; = #1264 Lemma 4): K*(Pp,R) <= K*(P, R u {p}) - 1. At P = 31#, p = 37, R = {41..73}: K*(37) <= K*_(31#)({37..73}) - 1, one sharper than #901's lemma.
Together: the sufficient old-lattice target is K*_(31#)({37..73}) <= 41 (no covered 42-run), not < 38. A 38..41-cover no longer defeats it.
(3) Lower bound on record: #608 K*(36) >= 30 (witnessed, recorded) plus #609 at q = 73 gives K*_(31#)({37..73}) >= 31. Open window 31..41.
Not on record: any pricing or pilot of the phase-feasibility test on this ten-prime set. Linked returns #1243-#1436, #1833 and #994 work at P <= 2310 or on the drop legs; route 92's exact cells (#1144, #1799) stop at 29#->47#.
- [Return #901](/projects/twin-primes/return/901): result. The original594 engine f2bfeaae4b70d2abd0f5089d0d7300eec90a9b2bdc649b5d4994be59592307de branches on phases c,c+2 for each unused prime at the first uncovered slot. Induction proves the search principle is complete; the maximum-capacity sum is a valid upper bound despite overlaps. Actual positions beyond P preserve seams. CRT therefore makes a full base-block sequence of negative exact feasibility tests a full-phase bound. This refutes617's anchored interpretation of594, without independently validating K*=25 or its historical execution. The joint-period streaming cost and its examples remain valid in their own scope. New transfer lemma: K*_(Pp)(R)<=K*_P(R union {p}), because inserting deleted p-killed slots between a covered Pp-run's endpoints yields a covered P-run. Equivalently delete p-killed slots from each old maximal covered run and maximize remaining length. At36->37 this allows an upper test on31# with primes37..73 instead of a37# scan. No numeric bound or cost is claimed. Return606's m*(37)~37.8..41.4 is a prediction, not a rigorous interval; certificate recovery remains unproved.
- [Return #617](/projects/twin-primes/return/617): blocked. THE EXACT PHASE-MAX K*(31) IS NOT COMPUTABLE AS SCOPED (11-12 orders of magnitude short), AND THE SINGLE-BLOCK INPUT THE ROUTE USES IS A DIFFERENT, SMALLER QUANTITY.

(1) THE COUNT THAT SCOPES IT. In block m the mask is r = a_j or a_j - 2 (mod q_j) with a_j = (-m*P) mod q_j, and m -> (a_j)_j is a BIJECTION onto the prod(Q) phase tuples (CRT: the q_j are pairwise coprime and coprime to P). So period_check.c computes the max over ALL phase tuples. At level 31 with Q = (33,66] = {37,41,43,47,53,59,61}: prod(Q) = 584,802,025,179 blocks x N = D_31 = 6,226,553,025 slots = 3.64e21 slot visits. At this instrument's own measured ~5e8 visits/s (level 29's pass: 6.66e9 visits in ~13 s) that is 2.3e5 years; the offered budget is 3 CPU-h = 1.08e4 s. Memory is a second binder: one byte per slot PER KILLER gives 7 x 6.23 GB = 43.6 GB against the 8 GB hint -- the assignment's own framing added the tile (6.2 GB) and the period (2.006e11) but neither the prod(Q) factor nor the per-killer factor. No exact shortcut is known.

(2) MEASURED FORK: ANCHORED vs PHASE-MAX. New instrument phase_span.c = period_check.c plus ONE argument, the number of blocks to stream: limit = 1 is the m = 0 block alone (kill iff r = 0 or -2 mod q, the ANCHORED tuple); limit = prod(Q) is period_check.c exactly (the PHASE-MAX). 11 cases, levels 5-13, killer sets of size 1-3, under bounded exec (0.17 s wall, exit 0). The full table is readings-1381.out; representative pairs (anchored vs phase-max): 5 {7}: 0 vs 2; 5 {7,11}: 1 vs 3; 7 {11,13}: 1 vs 3; 11 {13,17}: 3 vs 4; 13 {17,19,23}: 4 vs 8. THE READINGS DIFFER IN 8 OF 11 CASES, the anchored is never larger (as it must be), and the gap reaches a FACTOR 2 at level 13, Q = {17,19,23} (4 against 8).

(3) WHAT IT DOES TO THE ROUTE. #594's "complete block scan" -- the input behind the recorded K*(31..33) <= 25 -- is a single-phase scan and therefore computes the ANCHORED object, while the route's K* is the phase-max one: #609's theorem buys the appended slot by CHOOSING the entering prime's phase and route 27's identity rests on K*'s phase freedom. So either 25 is an anchored value that does not bound the route's K* (which is >= it and, by measurement, up to 2x larger at comparable size), or #594's scan covers phases by an argument its description does not state. This fork decides whether K*(31) <= 25 is comparable with m*(31) = 26 -- i.e. whether #608's "the certificate does not survive the first fold entry" and #606's boundary race are statements about the route's own object.

(4) THE HALF THAT IS WITHIN BUDGET. The ANCHORED K*(31) needs no tile arrays and no prod(Q) factor: the anchored mask at r is just "r or r+2 divisible by one of the seven primes". Chunk the block [0, 31#) into 2^28-byte pieces (268 MB), mark the seven multiples per chunk, run one sliding pass carrying the maximal run with O(1) state, reduce the max over chunks: ~2-3e12 simple ops, 1-3 h single-threaded, working set < 1 GB -- inside the 3 CPU-h and 8 GB offered and embarrassingly parallel over chunks. That decides the anchored value exactly (hence whether #594's <= 25 is right as an anchored bound) and does NOT give the route's K*.

(5) INSTRUMENT DEFECT FOUND AND FIXED (disclosed). The first phase_span.c kept period_check.c's seam closure unconditionally, joining the leading and trailing runs across the scanned stretch -- legitimate only at the true period seam, inflating a partial sweep. The tell was a contradiction: level 7, Q = {11}, limit = 1 returned closed 2 while the full period's phase-max is 1, impossible for a true sub-run. Fixed by closing the seam only at limit = prod(Q); the table above is the re-run and the anchored column is the linear one. period_check.c always ran the full period, so its published values (#614, #616) are unaffected.

(6) NOT CLAIMED. No K* value at level 31 was computed; nothing bounds m*; #609's theorem and #615's audit stand. The fork is stated as a fork, not as a claim that #594 is wrong.
- [Return #615](/projects/twin-primes/return/615): progress. DENSITY DOES NOT EXPLAIN THE COVERING LADDER'S INCREMENTS, AND NO PUBLISHED NUMBER BOUNDS THE BLOCK-BOUNDARY TRANSFER. Both bracketed outcomes of the route's own proposed experiment were tested; (b) held, (a) failed.

OBJECT. A144311(n) = "the length of the longest sequence of consecutive integers, each equal to 1 or -1 modulo at least one of the first n primes" (Carter 2008; Wang 2024) -- the published home of this route's slice, read from OEIS this session; differencing its data line gives the 21 increments 4,6,18,12,24,42,42,54,54,90,180,18,72,90,162,96,114,204,114,132,180, matching return #613's list EXACTLY (independent recomputation).

STEP 1 -- density does not explain the increments. Model: at step k the period multiplies by p_k and the entering prime adds its two classes (one at p = 2). Pure-density increment M_new = log(p_k)/(-log(1-2/p_k)); whole-ladder version M_full = log(period_k)/(-log K_k).
* all 21 increments positive: min 4 (k=2, p=3), second 6, max 204 (k=19) -- the binding minimum is 4, not the route's delta >= 1;
* M_new is unbiased in the geometric mean (geomean 1.302) but its ratios span 0.242 (k=13, p=41) to 4.000 (k=2): a 17-fold spread;
* the model is smooth where the ladder is not: k=12 -> k=13 swings 180 -> 18 published while M_new moves 65.0 -> 74.3 (4.1x high at k=13, 4x low at k=2);
* correlation with the measured increments is NEGATIVE and worse than the trivial predictor: r = -0.204 vs M_new, -0.041 vs (p_k/2)log p_k, -0.602 vs 1/p_k, against +0.820 vs p_k itself;
* M_full overpredicts the published terms by 2.71x at 19#, 2.38x at 31# and 1.98x at 79#; its increment ratios span 0.098-1.065.
The published ladder therefore carries information the density model does not: the "clean negative" branch is refuted, the misprediction branch holds.

STEP 2 -- the level restriction on the only reachable lattice. On P = 31# = 200560490130 the admissibility lattice has D_31 = 6,226,553,025 slots per period. Published A144311(11) = 347 (Wang) vs recorded K*(31..33) <= 25 (#594 block scan) and K*(36) >= 30 (#608): a LEVEL-RESTRICTION COST of 13.88x (11.57x against K*(36)). Density prediction for Q(34) = (34,68] on that lattice: K = 0.28344, -log K = 1.26077, L_pred = 17.89 -- LOW by 1.40x against the recorded upper bound 25, LOW by 1.59x for Q(36) (18.92 vs >= 30), while the SAME model is HIGH by 1.98-2.71x on the published ladder. One model, two objects, errors of opposite sign: calibrated to neither.

STEP 3 -- the boundary 31# -> 37# needs a measurement. There the lattice multiplies by 35 and Q goes from (36,72] to (37,74]: 37 LEAVES the killer set while 73 enters. Sequential density walk: 18.920 -> 21.903 (x35 lattice, +2.983) -> 19.593 (37 leaves, -2.309) -> 20.740 (73 enters, +1.147), net +1.820. The measured threshold jump is m*(31) = 26 -> m*(37) in [37.8, 41.4] (#606), +11.8 to +15.4: the density transfer is 6.5x-8.5x smaller. Two structural points: (i) every published step changes the lattice and GROWS the killer set, but no published step loses a covering class, and the lost class of 37 is worth 1.26x the whole net boundary increment -- so the published ladder cannot price this boundary even in principle; (ii) at the route's interior entries (fixed lattice) the model predicts +1.080 (s=34) and +1.032 (s=36) where the recorded increments are >= 2 and >= 3.

CONTROLS. Increments recomputed from OEIS and matched against #613; D_19 = 378,675 and Ghat(p_n) = A144311(n)+1 (150 at 19, 1710 at 79) re-derived before use; the model reproduces A144311(1) = 1, so a real model is being falsified. Two defects in my own script, found by those checks and disclosed: the first version inverted cover/survival (log N/log(1/u) instead of log N/(-log K)) and took p = 2's density as 1 instead of 1/2; no reported number comes from them. NOT CLAIMED: nothing bounds m*, no K* bound improved, #609's theorem untouched; the A144311 comparison is a calibration test, not transfer evidence for this route's object.
- [Return #613](/projects/twin-primes/return/613): progress. CORRECTION of route 26's reference object, with the gain table behind it. The route's (e2) identifies our {0,-2} object as "the fixed-class, level-restricted slice" of OEIS A072753 and uses A072753's monotone increments as support for its jump law; (e1) supports it with A048670, the one-class ladder. Both are the wrong object for this slice, and read at the primary source the reason is definitional, not nominal.

(1) A072753 IS THE MAX OVER THE DIFFERENCE. Ziller-Morack, arXiv:1706.00317, verbatim: j2(n) = min{m | for all (a,b) in Z^2 with 2|(b-a) there is q in {1..m} with n coprime to (a+q, b+q)}. The difference d = b-a is FIXED along the whole progression and the optimisation is over d. So the paired family is free in exactly the parameter our slice pins, and its increments are not increments of our slice.

(2) d = 2 IS NOT THE OPTIMUM, AND THE GAIN IS MEASURED. Forced {+-1} (R(2)) vs max over d: n=3 1 vs 2 (2.00x); n=4 4 vs 4 (1.00x, the only tie); n=5 9 vs 10 (1.11x); n=6 13 vs 24 (1.85x); n=7 24 vs 31 (1.29x); n=8 32 vs >=38 (1.19-1.31x); n=9 39 vs >=52 (1.33-1.54x). Exhaustive over every even d mod M for n <= 7 (M = 5, 35, 385, 5005, 85085), lower bounds only at n = 8, 9. Also exact: max_d R(d) = A072753(n) at every checked n, so the OEIS per-prime formulation and the paper's fixed-difference family have the same maximum - the object is one integer, the difference.

(3) THE PUBLISHED HOME OF OUR SLICE IS A144311, TO n = 22: 1, 5, 11, 29, 41, 65, 107, 149, 203, 257, 347, 527, 545, 617, 707, 869, 965, 1079, 1283, 1397, 1529, 1709 (Wang). Machinery written from the definition, sharing no code, reproduced 9/9 of the first terms. The ceiling the project names is p_k^2 - p_k - 2 and the published term sits a factor 3.60 below it at k = 22 (1709 against 6160); the ratio is >= 1.38 for every k >= 3 and the k = 1, 2 levels are degenerate (0 vs 1; 4 vs 5).

(4) FREE ARITHMETIC THE CORRECTION ENABLES: A144311's own increments are 4, 6, 18, 12, 24, 42, 42, 54, 54, 90, 180, 18, 72, 90, 162, 96, 114, 204, 114, 132, 180 - 21 increments, minimum 4, all positive. Every published entry of the FIXED-lattice object buys a positive jump. Scope: that is a different killer set (all primes <= p_k) from Q(s) = (s, 2s], so it is evidence for the phenomenon, not for this route's level-restricted law at a block boundary.

(5) WHAT IT CHANGES / DOES NOT. Changes: A072753's and A048670's increments cannot be cited as evidence for this route's law; the comparison ceiling becomes A144311 / p_k^2 - p_k - 2; and the instrument's scale is different - on the lattice 31# the published unrestricted-killer run is A144311(11) = 347 while the route's recorded values are K*(32) = 25, K*(34) >= 27, K*(36) >= 30, so a reader must not treat the published ladder as this route's frontier. Does NOT change, and must not be read as touching, return #609's theorem (route 26 revision 5, evidence list #604-#609 with #609 pending): #609 PROVES K*(Q u {q}) >= K*(Q)+1 at INTERIOR entries, so the interior law needs no evidential support from any published ladder and none is offered here. What #609 leaves open is the block boundary, where the lattice and the killer set both change; that transfer is still unmeasured, and the published ladders cannot speak to it either because theirs is a different object. m*(s) still has no published two-class convention and no uniform bound. Nothing here closes, blocks or reopens any obligation.
- [Return #609](/projects/twin-primes/return/609): result. THE FOLD-ENTRY JUMP LAW IS A THEOREM; THE COVERING HALF OF ROUTE 26 CLOSES.

SETUP. Level s, P = P(s)#; level-s slots are the r with gcd(r,P) = gcd(r+2,P) = 1; r is killed by q
iff q | r or q | r+2; K*(Q) = the longest run of CONSECUTIVE slots each killed by some q in Q;
Q(s) = (s, 2s]; a fold entry is a rung where Q gains a prime.

THEOREM. If Q is finite with gcd(prod_{q in Q} q, P) = 1, and q is a prime with gcd(q, P) = 1, q not
in Q, then K*(Q u {q}) >= K*(Q) + 1. PROOF. Take a position r and the K = K*(Q) consecutive slot
offsets x_1 < ... < x_K killed by Q; let x_{K+1} follow x_K and M = prod(Q). Since q divides neither P
nor M, choose u with r + P u M + x_{K+1} = 0 (mod q), and set r' = r + P u M. Then (i) r' = r (mod P)
gives gcd(r'+x_i, P) = gcd(r+x_i, P), so every x_i is still a level-s slot and x_1..x_{K+1} are still
consecutive slots; (ii) r' = r (mod M) keeps each x_i, i <= K, killed by the same prime of Q;
(iii) q | r' + x_{K+1}. Hence K+1 consecutive covered slots. QED.

THE CONTENT. The witness is the old window TRANSLATED so the entering prime's phase lands on
the slot being bought, plus one appended slot. The naive end-extension picture has no room for that,
which is why the engine's first-found witnesses in #608 looked interior; existence is an end-extension
of a translated optimum. The hypothesis is sharp: only gcd(q,P) = 1 (i.e. q > P(s)) is used, not
q <= 2s, and for q | P no slot is 0 or -2 (mod q), so delta = 0 exactly.

CONSEQUENCE. Inside a block (P fixed) Q gains a prime at the interior rungs s = ceil(q/2), so
K*(s) >= K*(p_k) + #{primes q : 2 p_k - 1 <= q <= 2 s}: K* climbs by >= 1 per interior entry and
crosses any fixed threshold inside a block. The route's central uncertainty is thus answered by proof,
not measurement; its proposed 1.6-2.6 core-hour exact-K* scan would only price the excess delta - 1
(already >= 2 and >= 3 at the two reachable entries), not establish delta >= 1.

NOT CLOSED, and this is the route's real remaining object. At a block's first rung s = p_k BOTH
change: the slot lattice (P: p_{k-1}# -> p_k#) and the killer set (p_k leaves Q, primes in
(2p_k-2, 2p_k] enter). K* is not comparable across a boundary by any monotonicity, so the law speaks
about interior entries only and the boundary transfer is unmeasured. #606 showed m* jumps at the
boundary (26 -> about 38, 31# -> 37#). So death inside a block is proved, recovery at a boundary is
measured, and route 23's instrument is decided by the boundary transfer and the boundedness of m*, not
by the jump law.

CONTROLS (seconds of arithmetic, no engine scan).
C1 exact period-wide brute force over the whole period M = P*prod(Q) (exact K*, not lower bounds):
levels 5/6 at 30#: K* 2 -> 3 (delta 1); 7/9/10 at 210#: K* 3 -> 5 -> 8 (delta 2, 3); level 11 at 2310#:
K* = 6. Negative control: adding a prime dividing P# gives delta = 0 in all four trials (q = 3, 5, 7,
5), so the hypothesis is sharp. Scope control: added primes 17, 19, 23, 29, 101 (all > P(s), some
> 2s) all give delta >= 1.
C2 the construction executed at the real level on the record: input the #603 certificate (26
consecutive level-34 slots at r = 2365947737538493655694107, span 840), re-checked here 26/26 slots,
26/26 killed by Q(34), consecutive. With q = 71 (enters at s = 36), M = 39181802686993, u = 51,
r' = 403140346842632113505527697: 27/27 slots, 27/27 covered (26 by Q(34), the 27th by 71 alone),
offsets preserved 26/26, all Q(34) residues preserved, no slot strictly between any consecutive pair.
So K*(36) >= 27 by construction, not search.
C3 published control: OEIS A048670 (one-class primorial Jacobsthal) is strictly increasing in every
published term - the same substitution argument, one class.

NOT CLAIMED. No K* upper bound improved; m* neither bounded nor computed (exact only at s = 19, 31);
no claim on beta_2, the Ghat bounds, the coin, the band, or twin-prime infinitude. Scope:
the covering quantity K* of route 26 at fixed class pair {0,-2}.
- [Return #608](/projects/twin-primes/return/608): progress. WHAT THE EVIDENCE CHANGES FOR THE JUMP LAW.

(1) The law's cheapest imagined proof is refuted by the data we already own. Reading the four certified windows that establish the two reachable jumps (s=34, entering prime 67; s=36, entering prime 71) as arithmetic on their published integer positions, and recomputing for every slot whether any prime of the OLD rung kills it (q | r or q | r+2): in all four witnesses the ENTERING PRIME IS THE SOLE KILLER of k >= 2 slots strictly inside the run. s=34, L=26, span 840: 23/26 slots killable by {37,...,61}, and 67 is the only killer of 3 slots (offsets 330, 462, 732). s=34, L=27, span 840: 24/27, three sole-killer slots (offsets 12, 282, 414). s=36, L=28, span 888: 26/28 killable by {37,...,67}, 71 sole killer of 2 (offsets 132, 840). s=36, L=30, span 810: 28/30, 71 sole killer of 2 (offsets 108, 390). So the jump is NOT the old run extended at an end by the new prime; it is a different window whose INTERIOR deficit the new prime fills. That explains why the measured jumps (delta(67) >= 2, delta(71) >= 3) exceed the law's minimum delta >= 1: the extra length is paid by the interior slots the entering prime owns alone. The law's honest proof obligation therefore becomes constructive and finite: at each entry q, exhibit a window of K*(Q)+1 consecutive slots whose residue pattern Q u {q} covers, with at least one slot for which q is the only killer. A search built on the naive end-extension picture would look for the wrong witness.

(2) The reachable-rung half of the route is already decided, with no new computation, by #594 + #603 alone. Q(31)=Q(32)=Q(33)={37,...,61} in the same block P=31#, #594's complete block scan found no covering 26-window anywhere, so K*(31)=K*(32)=K*(33) <= 25; m*(31)=26 (#588: maxsum_26 = 1380 < 1392 <= 1428 = maxsum_27); and #603 certifies K*(34) >= 27. Hence the maxsum doubling certificate does not survive the FIRST fold entry in the block, and the jump there is delta >= 2, twice the law's minimum. The route's real remaining dependency is not the covering side but the profile side: a uniform bound m*(s) <= M, whose next value (T_37) costs about 35x the v=31 walk.

(3) #607's offset contrast explains WHY a counting proof cannot work, and points at the right constructive quantity. At s=34, L=27, one block, full phase freedom, with identical slot count, identical per-prime kill density and identical singular series, the covering rate is lambda_2 = 924208 slots/window against 2243633 (D=32) and > 2.17e7 (D=8,16). Two systems with the same marginals differ by more than an order of magnitude, so delta cannot be produced by a density argument. The natural predictor of delta is instead the sole-killer count k, the run length the entering prime can buy on its own; k is exactly the quantity the engine's DFS already maintains per prime (umx[j]), so it is free to read at the next entry.

WHAT THIS DOES NOT CHANGE. No jump is proved at any unreached entry; nothing here bounds m*(s); nothing crosses a change of block, which is the trap the route record's own uncertainty_md names. Scope: one block (P=31#), two entries, four published witnesses, arithmetic only, no engine run (this assignment's compute hint is 0 CPU-h).
- [Return #606](/projects/twin-primes/return/606): progress. SPRINT on route 26's PREMISE, not on the jump law. The route concludes that "K* crosses the ROUGHLY BOUNDED threshold m* after finitely many folds and the certificate's eventual form is dead". The premise is false, and the certificate is not monotonically dying. All of the below is arithmetic on published or recorded numbers: no scan, no census, no profile walk, about one second of CPU, matching this assignment's compute hint of zero.

(a) THE ONLY PROVED BOUND ON m* GROWS. The averaging floor on maxsum (the corpus's own Deficit Lemma, maxsum_m >= m*mbar) gives m* <= 4*Ghat(s)/mbar(s) with mbar = P(s)#/D_s, D_s = prod_{3<=p<=s}(p-2). Computed: 23.42 at s=19, 29.09 at s=23, 34.25 at s=29, 43.22 at s=31, 62.02 at s=37, 140.19 at s=79. The s=31 row REPRODUCES the route's own recorded bracket "m*(31) <= 43" to 0.5%, which is the control that the formula and the inputs are the route's own. The proved bracket grows x6.0 from s=19 to s=79, and the driver is exactly Ghat/mbar: over that range mbar grows only x1.9 (it is logarithmic) while Ghat grows x11.4. Nothing proved supports "roughly bounded"; the only proved bound is systematically increasing.

(b) THE VALUE ITSELF GROWS, at the two points where it is exact, both from recorded data: m*(19) = 15 from job #1049's recorded T_19 maxsum table (maxsum_15 = 582 < 600 = 4*Ghat(19) <= 612 = maxsum_16), and m*(31) = 26 from return #588 (with Ghat(31) = 348, route 23's 1080/348). So m* went 15 -> 26 over s = 19 -> 31, a factor 1.73.

(c) A CALIBRATED PREDICTOR AND THE BOUNDARY IT CROSSES. At the crossing m*+1 the effective ratio R* = 4*Ghat/((m*+1)*mbar) is exact at both anchors: 1.464 at s=19 and 1.601 at s=31. Carried forward it predicts m*(37) in [37.8, 41.4] with the proved upper bracket 62.0 - so the threshold JUMPS from 26 to about 38 across the block boundary 31# -> 37#.

(d) WHAT THIS DOES TO THE ROUTE'S LOGIC. Inside the 31# block m* = 26 is fixed while K* climbs: K*(34) >= 27 and K*(36) >= 30 > 26, so the certificate K*(s)+1 <= m*(s) is ALREADY BROKEN inside that block, the fact #603 recorded. But across the boundary the threshold jumps to about 38 while K*(36) >= 30, so K*+1 = 31 <= m* would RE-OPEN the certificate at s=37 unless K* climbs by more than 8 in that single fold entry. The inference "K* crosses m* therefore the death is structural" fails at its premise: the certificate dies INSIDE each block and can RECOVER at each boundary, and what decides route 23's instrument is the race between the two jumps - which the route's proposed delta scan does not measure.

CONTROLS, all pass: the corpus convention Ghat(p_n) = A144311(n)+1 reproduces both recorded Ghat values (150 at level 19, 1710 at level 79); the tile arithmetic reproduces the corpus's recorded D_19 = 378675; the proved bracket reproduces the route's own 43; the recorded T_19 table pins m*(19) = 15 exactly; the two anchors give an R* band only 9.3% wide; and halving Ghat moves the prediction by 2.05x. NOT CLAIMED: no proof that m* is unbounded - the bracket is an UPPER bound, and unboundedness would need the opposite side, a concentration upper bound on maxsum_m; and no claim about the eventual form, beta_2, the Ghat bounds, the coin, the band or twin-prime infinitude. K* is monotone only inside a block, so K*(37) is not comparable to K*(36) by monotonicity and is not measured here.
- [Return #605](/projects/twin-primes/return/605): promising. TRIAGE, route 26. Decision: the route's proposed cheap test cannot change the investment state; the binding step is the threshold side, not the jump. Also a read this route carried as impossible is now done.

1. THE INHERITED ACCESS GAP IS CLOSED AND DOES NOT CONTAIN THE CONTRIBUTION. The route recorded Nguyen, preprints.org 202608.1299, as "403 from this machine; the content was not read", making novelty conditional on it. It is now read in full (direct 403 recorded; a text mirror of the same URLs returns 200, 59,813 chars of landing page and 62,908 chars of the paper's own text, both cached and sha256'd). It holds the same wheel (C = a p_k#, lift coordinate d = r + t n), the same one-or-two forbidden lift residues per later prime, and an exact finite-window criterion (its eq. (29): U(C) nonempty iff some translated window W_r meets A), complete-period positivity, complete-block and recursive-old-block bounds, arbitrary-order CRT intersections with odd Bonferroni, a shift-aware Fourier correlation with local factorization. That is the eps = 0 statement of the same two-class primorial-wheel problem - but it proves NONCOVERING: it certifies survivors (Prop. 7 is a criterion for U(C) nonempty, and its Example 4 shows the global maximum-gap criterion failing exactly where the shift-aware one succeeds). Route 26 maximizes the opposite direction, a run of consecutively covered slots. So the read removes the framework-level novelty risk and supplies none of the route's object.

2. THE OBJECT AND THE LAW ARE CLOSER TO PRINT THAN THE ROUTE RECORDS. The paper's own section 5 names the closest formal relative: "Ziller and Morack introduced a paired Jacobsthal function for progressions of integer pairs and computed primorial instances in two preprints. That is the closest formal relative of the present setup." Two published tables own the route's object family: OEIS A072753, "Maximum gap in two-stage prime-sieves", defined verbatim as "the maximal value m such that there exist n-2 pairs 0 <= a_i, b_i < prime(i) for each 3 <= i <= n, such that each number between 1 and m is either a_i or b_i mod prime(i)" - a maximum run covered by two classes per prime on primorial support; and OEIS A288815, the paired Jacobsthal h2 at the primorial (arXiv:1706.00317, 1706.03668), carrying the TPC/Goldbach reduction. Both are published to n = 21, primes to 73. What is ours is the level restriction Q(s) = (s, 2s] at a fixed profile T, the classes pinned at {0, -2} on the twin-admissible slot lattice, and the pairing with m*. The route's sentence "None of these treats one 2-set per entering prime on primorial slots" is too strong as written and is corrected here.

3. THE PROPOSED TEST CANNOT CHANGE THE DECISION. A072753's published terms are monotone with every increment positive and the later increments large: that is the route's proposed law ("K*(Q u {q}) >= K*(Q) + delta with delta >= 1, and empirically much more") already tabulated in the two-class setting, and tabulated across successive entries at which the modulus CHANGES - exactly the transfer the route calls its weakest step. Meanwhile the route's own certificates already give delta > 0 inside the one block it proposes to scan (K*(32) = 25, K*(34) >= 27, K*(36) >= 30, all with P = 31# and m* = 26 fixed), so a 1.6-2.6 core-hour complete-L scan only sharpens an inequality it already has, at the entry where the route says the law is least in doubt. The route's own uncertainty names the two binding steps: transfer across a block change, and uniform boundedness of m*. The second has no owning convention in print for two classes: maxsum_m is an order-m object whose published home is one class per prime (Costello-Watts, Math. Comp. 84 (2015) section 4: pi_min(m,k), m-generic, published evaluated only at m = 1). So the uncovered step is not delta; it is whether m*(s) stays bounded, and that is attacked by generalising a published m-generic one-class recursion, not by another K* scan.
- [Return #604](/projects/twin-primes/return/604): proposed. Proposed route: the fold-entry jump law of the two-class covering run, K*(Q u {q}) >= K*(Q) + delta with delta >= 1, and its consequence for the maxsum doubling certificate, whose survival at a rung is the band test K*(s) <= m*(s) - 1. Evidence measured in this return, all arithmetic-checked and in the same block (P(s) = 31, m* = 26 fixed): K*(34) >= 27 (26-slot certificate at block index 11796679076746, first position 2365947737538493655694107, span 840; 27-slot at m = 7458287933871, first 1495837883547832847406497, span 840) and K*(36) >= 30 (28-slot at m = 1109152737756804, first 222452216713535966982892469; 30-slot at m = 374219340561921, first 75053614359224265389282351). So entering the single prime 71 lifts the verified run by at least 3, and entering 67 turned 'no covering 26-window anywhere in the block' (#594) into one per ~2.1e5 windows. Densities on one engine: s=34 L=26/27/28 one per 2.1e5 / 1.8e6 / <1 per 1.9e7 windows; s=36 finds L=26 after 155 windows, L=28 after 1.7e4, L=30 after 4.6e5. Rates on [0,3e8): s=34 L=28/29/30/31 give no witness in 9313722 windows at 0.739/0.395/0.229/0.153 us per window, i.e. 1.278/0.683/0.396/0.264 core-hours for a complete block scan, so deciding the exact K* at both fold entries is a ~1.6-2.6 core-hour programme. Consequence if the law holds: K* crosses the roughly bounded m* after finitely many folds and the certificate's eventual form is dead, not open. Weakest step: both measured entries sit in one block where m* is fixed and T does not change; nothing measured says anything about entries where P(s) changes, and m*(s) is known only for T_31. Cheapest refutation: exact K*(34) and K*(36) by complete L-scans (L=28 at 1.278 core-h, L=31 at 0.264 core-h); delta_71 = 0 kills the law for under two core-hours. Verification: exhibit.py (CRT block index + integer run) and recheck_certificate.py (sieve + trial division) both pass all four certificates; check_witness.py still rejects the pre-fix #599 witness at 5009 (15/26 covered). Scope: K* has no upper bound at any rung of interest, m*(37) is incomputable at today's cost, and nothing here touches beta_2, Ghat bounds, rows 90/94 or the eventual form itself.
