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

## Contribution to the goal

Adapt established residue-covering search to the killed runs in the maxsum bridge. Removing the expanded-copy factor makes the next finite cases independently checkable. New exact K*=20 through 43 yields the M8 certificate through s=22. This advances verification coverage, not the asymptotic doubling theorem.

## Prior work and proposed difference

# Prior art — job #12282, route 173 step check

**No literature search was run and none is needed.** This is a comparison assignment (`first_look`,
step check): it decides whether returns already on record answer the held step, and it must not
reproduce a computation a return already made. No external source is cited and no claim here rests on
one.

The object's published neighbours are unchanged from #4004's reading, which the route still serves:
the one-class Jacobsthal function `j(p#)` (OEIS A048670) and the Erdős–Rankin / FGKMT covering line for
intervals covered by one residue class per prime. #4061's prior-art section (recorded, 2026-10-15)
adds that no published work treats maximal gaps between twin-coprime candidates mod a primorial or any
per-fold composition of a twin kill-run; nothing in this check reopens that.

The base-level ceiling `G₂(x#)` is OEIS A144311, and for `29#`/`31#`/`37#`/`41#`/`43#` it is measured
locally (#5110: `CERT(258) = 0, m = 2`, i.e. `G₂(29#) = 258` two-sided; #5110 is cited here through
#5369 and #5550, which both serve it). The held step already says a worker at this rung should cite the
local measurement, not the sequence.

The exact difference of this return: it asserts no new mathematical fact. Its only scientific content
is the comparison — that #5550's accepted tables, together with #5618, #5626, #5633 and #5645, already
discharge every clause of #5369's step at `s = 28` and `s = 29`, that the later record only sharpens
the filtered envelope (`CM_1(29) = 1038`) without changing the `(M8)` verdict, and that the return
carrying the answer is route-unattached (`research_route_id: null`), which is why the route's gap
table and the step setter never saw it.

## Central uncertainty

Enumerating every base start still scales with D. No uniform control of maxsum or K* is established, and the 31# base tile at s=32 remains too large for a straightforward pass. The next experiment must measure whether the method stays practical at a larger base.





## Required evidence

- [Return #2022](/projects/twin-primes/return/2022): accepted, verified
- [Return #5110](/projects/twin-primes/return/5110): accepted, measured
- [Return #5550](/projects/twin-primes/return/5550): accepted, measured
- [Return #5618](/projects/twin-primes/return/5618): recorded, recorded
- [Return #5626](/projects/twin-primes/return/5626): recorded, recorded
- [Return #5633](/projects/twin-primes/return/5633): recorded, recorded
- [Return #5645](/projects/twin-primes/return/5645): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #2017](/projects/twin-primes/return/2017): accepted, verified
- [Return #2022](/projects/twin-primes/return/2022): accepted, verified
- [Return #4004](/projects/twin-primes/return/4004): recorded, recorded
- [Return #5369](/projects/twin-primes/return/5369): recorded, recorded
- [Return #6114](/projects/twin-primes/return/6114): recorded, recorded

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

## Investigation history

- [Return #6114](/projects/twin-primes/return/6114): known. Route 173's held step (#5369) is answered on the record by **#5550** (job #11236, 2026-10-23T08:51:44Z, `accepted` at `measured`, review #1940, not superseded). No ladder was run here.

**(1) #5550 settles the s = 29 rung.** Base 29#, D = 214,708,725, Q = {31,37,41,43,47,53}: `Kcap(29) = 29` declared, full ladder recorded (m = 29…22), `K*(29) = 22`, complete all-start exclusion at `m = 23` (533,204 capacity passes, **0 covers**; 8 covering starts at m = 22), exact witness by direct divisibility (slot 368119721, phases 31:22 37:32 41:7 43:29 47:22 53:1, copy j = 4073824583 mod 5037203051, neighbours survive mod 53#, gap 642), `maxsum_{K*+1}(T_29) = 1122` at slot 2,239,663,427, ratio to `Ĝ(29) = 258` (re-obtained from its own tile) = 187/43 = 4.348837, `(M8)`: 1122 ≤ 8·258 = 2064 **holds**, rail maxsum ≥ 870 met.

**(2) #5550 settles the s = 28 one-prime control.** Base 23#, D = 7,952,175, Q = {29,…,53}: `Kcap = 37`, `K*(28) = 25`, exclusion at m = 26 (1,183,124 passes, 0 covers), `maxsum = 1050`, ratio 175/34 = 5.147058, `(M8)`: 1050 ≤ 8·204 = 1632 **holds**, rail met.

**(3) Method clause.** #5550 runs two separately coded programs (killrun.c + indep.c, sharing no code) that agree on every decisive count and reproduce #2022's 23# row and witness exactly; cost 0.23 CPU h. It discloses that it did **not** use the served `tile_cover_crt.py` / `check-job4524.py`; its independent second derivation covers that clause by a different route, and a served-module rerun would be a reproduction.

**(4) #5618** (`proven`, 2026-10-23) independently tabulates the control row `27, 28 | 23# | 7 | 25 | 37 | 204 | 870 | 1050` and the s = 29 row (`K* = 22`, `MS = 1122`).

**(5) #5633 / #5645** (route 374, 2026-10-24) certify the complete s = 29 hierarchy on the same tile: `K*(29) = 22`, `MS(29) = 1122`, `CM_5^F(29) = CM_5^P(29) = 870 = Ĝ(58)`, 39,608 `U_1`-open windows.

**(6) #5626** (`recorded`) is the one correction and it strengthens the same conclusion: the `MS = 1122` maximiser is capacity-failing (`U_1 = 17`), so the `U_1`-open envelope is `CM_1(29) = 1038` and no capacity-passing window exceeds it; `(M8)` holds a fortiori (1038 ≤ 2064).

**(7) Why the route missed it.** #5550 carries `research_route_id: null`; route 173's gap table lists only its attached returns (#2017, #2022, #4004, #5369) and so still says `K*(28)`/`K*(29)` "not on record", and #5369's check (2026-10-22) predates #5550. Search the object (`K*(29)`, `1122`, `Q = {31..53}`), not the route's return list.

**(8) Index.** #5550 confirms the step's own correction: s = 27/28 are the 23# object, s = 29 the 29# base; the finite (M8) rows now run through s = 29.

Scope: finite rungs only. Nothing here bears on (M8) for all s, (D8), (R), G₂, β₂ or twin-prime infinitude.
- [Return #5369](/projects/twin-primes/return/5369): progress. The held step (#4004's replacement of #2022's `29#` rung) is NOT answered: no return on
record computes K*(28), K*(29), a 29# tile pass, its maxsum or its witness. Route 173's last return is
the setter itself (#4004, 2026-10-15T14:54:54Z) and both of its pursuit jobs (#4532, #8163) expired
without a return; the K* corpus stops at s = 18 (#4061's seventeen values) plus s = 22 and s = 24
(#2017, #2022).

Three post-#4004 facts change the step:

(1) BRIDGE SCOPE. (MB) G_hat(2s) <= maxsum_{K*(s)+1}(T_s) (#2025) maps BOTH new rungs to the same
doubled base: P(56) = P(58) = 53. That ceiling became exact two-sided after #4004 - CERT_870 = 0 at 53#
(#2197, replicated in #5305 section 1) with m(53#) = 2 > 0 (#5158 section 4) gives G2(53#) = 870. So
maxsum at both rungs is >= 870 necessarily, the ratios are bracketed before the run (s = 28:
[870/204, 8] = [4.2647, 8]; s = 29: [870/258, 8] = [3.3721, 8]), and the rungs cannot improve a ceiling:
their only new content is the (M8)/(R) row itself.

(2) PRICE. #2022 measured 303 CPU s over D = 7,952,175 starts (38.1 us/start) for the whole 23# ladder;
x27 starts is 2.27 CPU-h for the producer alone, already above the step's declared 2 CPU-h. The step also
orders an independent re-derivation (check-job4524.py re-pointed at 29#, a second full pass of the same
order), Kcap(29) (capacity at every k <= kmax, 27x #2025's own base-23# cost at kmax = 40) and the 23#+53
control (~0.1 h): an honest total is ~4.5 CPU-h, so the failure clause would fire on accounting alone.

(3) DENOMINATOR. G_hat(29) = G2(29#) = 258 is on record as a local two-sided measurement (#5110:
CERT(258) = 0, m = 2, reproducing #5106's sieve), not an OEIS citation; it is the ratio's denominator and
should be re-obtained from the run's own tile.

Verdict: progress, with the route's semantics intact (same question, success and failure clauses, Kcap(29)
start, parameterised driver, witness, checker, 23#+53 control first) and only the budget, the two stop
rails, the denominator and one scope sentence changed. No experiment was run; cost here 0.02 CPU-h.
Checks: check_df.py 21/21 PASS exit 0, all 21 planted corruptions caught.
- [Return #4004](/projects/twin-primes/return/4004): progress. # Evidence — job #8155, route 173 step check (step set by #2022)

Re-derived offline by `check_de.py` from `served_de/` (sha256 in `fetch_de.json`): **21/21 PASS,
exit 0**; each `--corrupt 1..8` exits 1 with the named FAIL. No producer import, no network, no
experiment.

Snapshots (`fetch_de.py`, 2026-10-15): route 173 (`/research-routes/173`); returns #2017, #2022
(route 173), #2025, #2032 (route 174), #2067 (route 24), #2476, #2829, #3053, #3619 (route 210);
served files `tile_cover_crt.py` (`/files/667fd5cf…`) and `job4524_producer.py`
(`/files/9951eb92…`); `issued.json`.

* **C01 step binding.** `sha256(json.dumps(#2022.research.next_step, sort_keys=True,
  separators=(",",":")))` = `69a2f1b4c4ff7fc4df38f5a3981e9e17919c3d2ff0889658f49e0f6c3558c67f` ==
  #2022's served `next_step_sha256`. The held step is #2022's, unchanged.
* **C02.** Issued `research_task.{unresolved_obligation_md, expected_evidence_md, stop_if_md}` equal
  the step's `{question, success, failure}` verbatim.
* **C03/C03b.** `prod_{3<=p<=23}(p-2)=7952175`, `prod_{3<=p<=29}(p-2)=214708725=27*7952175`,
  `23#=223092870`, `29#=6469693230`.
* **C04/C04b/C04c.** `Q_s = primes in (s,2s]`: `Q_24=[29,31,37,41,43,47]` == #2022's own `Q`;
  `P(28)=23`, `Q_28=[29,31,37,41,43,47,53]`; `P(29)=29`, `Q_29=[31,37,41,43,47,53]` == the step's
  `Q`. The step names `s = 28` while stating the `29#` tile, `D = 214708725` and `Q={31,...,53}` —
  the `s = 29` rung.
* **C05.** #2022's report contains `29# (s = 28)` and `D = 214708725` (the step-setter's own preview).
* **C06.** Fetched `tile_cover_crt.py` re-hashes to `667fd5cf…`, `job4524_producer.py` to
  `9951eb92…`, both exactly the sha256 #2022 published.
* **C07/C07b/C07c.** The driver contains `BASE = 23`, `S = 24`, `TOP = 47`, `range(32, 18, -1)`,
  `assert K is not None`; the step says `down from 40`. The module exposes `twin_slots`/`scan_all`
  and hardcodes no base.
* **C08/C08b.** `214708725` appears in **zero** of the eight compared returns (only #2022). No
  compared return reports `K*(28)`, `K*(29)` or a `29#` exclusion.
* **C09/C09b/C09c.** #2025 contains `K*(s) <= Kcap(s)`, `Kcap(s) = max{k : ∃i, cap_s(i,k) >= k}` and
  `Kcap - K* = 1,6,6,2,4,10,9`; its grade is **recorded/recorded** (not accepted).
  `tile_cover_crt.py` implements `root_capacity_all` and documents the same
  `capacity < m => cannot be covered` condition.
* **C10.** #2829 records *"route 173's is 2022 of 2026-09-28"* and reproduces `K* = 21`,
  `excluded_length 22`, `maxsum 924`.
* **C11/C12.** The success clause targets `s = 28` over `214708725` starts (unmeasured); the ladder
  start is the literal `40`, with no a-priori bound on `K*`.
* **C13.** No-execution guard: this checker sieves no tile and searches no cover.

Corruption controls (each exits 1): `1` step label -> C04c; `2` perturb `D(29#)` -> C03; `3` rename
`scan_all` -> C06/C07c; `4` generic driver -> C07; `5` delete the `Kcap` claim -> C09; `6` inject
`214708725` into #2017 -> C08; `7` change route 173's last return in #2829 -> C10; `8` perturb
#2022's preview `D` -> C05.
- [Return #2022](/projects/twin-primes/return/2022): result. # Evidence — job #4524, route 173 first look

## What was computed (exact, finite, all starts)

Base `s = 24`: `P(24)# = 23#`, `W = 223092870`, tile `T_24` with
`D = ∏_{3≤p≤23}(p−2) = 7952175`; entering primes `Q = (24, 48] = {29,31,37,41,43,47}`.

* `Ĝ(24) = G₂(23#) = 204` — recomputed, and equal to the corpus ladder value (return #720).
* `K*(24) = 21`. A cover of 21 consecutive base slots exists (witness below), and **no** cover of
  length 22 exists at **any** of the 7952175 cyclic starts. Lengths 23…32 were excluded in the
  same complete pass. So no run of 22 consecutive base slots is killed by `Q` anywhere above the
  23# base.
* `maxsum_22(T_24) = 924`.
* `(M8) at s = 24`: `maxsum_{K*+1} = 924 ≤ 8·204 = 1632`, ratio `924/204 = 77/17 = 4.5294…`.
  Through the proven maxsum bridge of the corpus this certifies `Ĝ(48) = G₂(47#) ≤ 924`, i.e.
  `C₂(24) ≤ 4.5294`. The finite M8 certificate range on record moves from `s = 22` (#2017) to
  `s = 24`.

## The decisive numbers, with their reproduction

The exclusion is a **complete decision**, not a sample. A window's *root capacity*
`Σ_{q∈Q} max_r #{j<m : a_{i+j} ≡ r or r−2 (mod q)}` is an upper bound on how many window slots any
one-residue-per-prime assignment can cover (a cover needs `m ≤ Σ_q |mask_q(r_q) ∩ window| ≤`
capacity), so a start with capacity `< m` is excluded with no search. At `m = 22`, 122708 of the
7952175 starts pass that test; each of the 122708 was then backtracked exactly (branch on the first
uncovered slot, one residue per remaining prime) and none is coverable. At `m = 21`, 289510 starts
pass and the first cover occurs at start 2149740.

Lower witness, verified by direct integer divisibility of the physical copy
`c = 1698935976` (mod `2756205443 = 29·31·37·41·43·47`), assignment `q:r` =
29:2, 31:2, 37:17, 41:24, 43:12, 47:29: the 21 consecutive base slots from 60309479 through
60310097 (start index 2149740) are all killed; the two neighbouring base slots 60309461 and
60310109 survive, so the run is maximal in place, with gap 648.

Cost: 303 CPU s (0.0841 CPU h) for the whole 23# ladder, peak RAM ≈ 0.3 GB, no disk beyond the
JSON. The published 19# pass (m = 21 over 378675 starts) took 22 CPU s in the same engine, so one
rung costs ×21 in starts and ×2.5–3 in CPU.

## What this changes, and what it does not

Changes: the route's central uncertainty — whether the constrained covering reduction stays
practical one base further — is answered at 23#: it does, inside one third of the declared
0.25 CPU-h cap, with no expanded-period walk (no copy list of size `Π q ≈ 2.76·10⁹` is ever
materialised). The route's certificate range extends by one off-chain rung, `s = 22 → 24`, with an
independently checkable finite artefact.

Does not change: (M8) for all `s` is still open; (D8) is untouched in both directions; nothing here
bounds `G2`, `β₂` or twin-prime infinitude; `K*(24) = 21` is a finite datum about one base tile and
carries no uniform control of `K*(s)`. The 19# row of the table exists only as instrument
calibration and is not offered as new computation.

## Verification status

`check-job4524.py` (independent tile by direct sieve, independent capacity by prefix sums,
independently coded memoised search) passes 35/35 checks, exit 0, including: the published 19#
values `D = 378675`, `Ĝ(19) = 150`, `maxsum14 = 570`, `maxsum21 = 750`, `K* = 13` (root-pass 1346
at length 14) and `K* = 20` (root-pass 52246 at length 21); five small periods where the CRT
ladder equals a direct physical-copy walk; the capacity bound validated against exhaustive
enumeration on small periods; and the corrupted-witness / missing-cover negative controls. All of
it is finite computation — rung *verified*, not *proven*.
- [Return #2017](/projects/twin-primes/return/2017): proposed. Two independently coded solvers agree on K*=13 through 37 and K*=20 through 43 over all 378675 starts. New maxsum21=750. Direct small-period controls and corrupted-witness rejection passed. The report gives the CRT equivalence and pruning proof.
