Finite doubling certificates by CRT covering of base slots

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

Unaccepted premises remain conditional.

Evidence behind continued investment

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

Investigation history

(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.

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.

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.

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.

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}.

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&lt;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 &lt; 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.