{"id":5369,"job_id":10712,"problem_id":1,"lane_id":32,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Report — job #10712 (explore, `first_look`, route 173, lane `dir-558`, general mode) — step check\n\n**Verdict: `progress`.** Route 173's held step (set by #4004, held pursuit #8163) is **not answered by\nany return on record** — no return computes `K*(28)`, `K*(29)`, the `29#` tile pass or its maxsum — but\nthree things recorded **after** #4004 change **what the rung can certify and what it costs**, so the\nstep is replaced rather than handed out unchanged. **No experiment was run**: no tile was sieved, no\ncover was searched, no witness re-derived, no ceiling recomputed. `cpu_hours 0.02` (12 journaled GETs,\n21 offline checks, all of them in `check_df.py`, **21/21 PASS exit 0**, each `--corrupt 1..21` exit 1).\n\n## 1. Custody\n\nThe held step is #4004's served `research.next_step`, unmodified: canonical sha256 under the server's\nown convention (`json.dumps(step, sort_keys=True, separators=(\",\",\":\"))`) is\n**`a93f2da34dd6c2b9cc14c8a5a4a9ae8a3c6a65b9e1efc1a979c5e90b3b0add39`**, exactly #4004's recorded\n`next_step_sha256`, and the issued `research_task.predecessor_returns` is `[4004]` (C01–C03). Route 173\nis `active`, revision 3, `last_return_id` **4004** of 2026-10-15T14:54:54Z, so **no on-route return\npostdates the setter**; its pursuit jobs #4532 and #8163 both **expired with no return**, while the two\nfirst looks (#4524, #8155) returned (C20). Read for this check: returns 4004, 2022, 2025, 5110, 5158,\n5305, 4061, 5126 and the records of routes 173, 172, 221, 344, 347, 349 (§7 states the sweep limit).\n\n## 2. What the record already settles, and this check neither repeats nor re-derives\n\n* **(M8) is certified on `s ≤ 24`**: #2022 (accepted) has `K*(24) = 21`, `Ĝ(24) = G₂(23#) = 204`,\n  `maxsum_{22}(T_24) = 924`, ratio `77/17 = 4.5294` (C07, C08), with a complete all-start exclusion at\n  every start and an exact witness verified by direct divisibility.\n* **The ladder start is exact and walk-free**: #2025 (recorded) proves `K*(s) ≤ Kcap(s)` from the\n  capacity test alone, and measures `Kcap − K* = 1,6,6,2,4,10,9` at `s = 13,15,16,17,19,22,24`; at base\n  `23#` it reports `Kcap = 30, 30, 37` for the three `Q_s` sets, computed to `kmax = 40` (C15). Its exact\n  cover search ran only for `D ≤ 22 275`, so nothing smaller than `19#` supplies a `29#` value (C16).\n* **The base-level denominator is on record**: #5110 (accepted) *computes* `G₂(29#) = 258` with\n  `CERT(258) = 0` and `m = 2`, two instruments, reproducing #5106's full-period sieve (C09). This is a\n  local measurement, not an OEIS citation; it is the denominator the step's ratio needs.\n* **The `T_29` tile is not new**; `K*` on it is. #4061 (recorded) reports that a served note streamed\n  **all 214,708,725 `T_29` slots** for the fold `L(31) = 4`, and that its own `K*` set runs over\n  \"all seventeen s-values\" (`s ≤ 18`), leaving \"(M8)/(R) for `s > 18`\" untouched (C17, C18). So the\n  enumeration has been done once for another purpose (a reused stream would be legitimate; it contains\n  no `K*`), while the kill-run measurement has not.\n\n## 3. What changed after #4004 — the three corrections (this check's finding)\n\n### (a) Both proposed rungs bridge to the same ceiling, and that ceiling is now exact\n\nThe maxsum bridge #2022 used is `(MB) Ĝ(2s) ≤ maxsum_{K*(s)+1}(T_s)` (#2025). For `s = 24` it certified\n`Ĝ(48) = G₂(47#) ≤ 924`. For **both** new rungs the doubled base is `53#`: `P(56) = P(58) = 53`, so\n`s = 28` and `s = 29` certify the **same** ceiling (C06). That ceiling is no longer open: `CERT_870 = 0`\nat `53#` (#2197, replicated in #5305 §1) with `m(53#) = 2 > 0` (#5158 §4, reproduced from the\ncertifying side in #5305 §3) gives **`G₂(53#) = 870` exactly, two-sided** (C11, C12). Three consequences\nthe step should carry, because #2022's phrasing (\"certifies `Ĝ(48) ≤ 924`\") invites a reader to expect\nceiling progress:\n\n1. `maxsum_{K*+1} ≥ 870` **necessarily** at both rungs: a printed value below 870 is an instrument or\n   bridge defect, not a discovery.\n2. The ratios are **bracketed before the run**: `s = 28` has `870/204 ≤ ratio ≤ 8`, i.e. `[4.2647, 8]`;\n   `s = 29` has `870/258 ≤ ratio ≤ 8`, i.e. `[3.3721, 8]`; `8·258 = 2064` is the (M8) allowance at `s =\n   29` and `8·204 = 1632` at `s = 28` (C10, C12).\n3. The rungs' only **new** content is the (M8)/(R) row itself, exactly as the step's\n   `progress.rationale_md` says. The `s = 28` control is still worth its 0.1 CPU-h as a cost and\n   `K*`-monotonicity calibration, but its ceiling consequence is redundant by construction.\n\n### (b) The declared 2 CPU-h is below the record's own price for the work the step orders\n\n#2022 measured **303 CPU s** over `D = 7,952,175` starts for the whole `23#` ladder (38.1 µs/start,\nladder 22…32) (C13). `×27` starts is **2.27 CPU-h for the producer alone** (C14) — already above the\nstep's `compute.cpu_hours = 2`. The step then also orders (i) the **independent** re-derivation\n(`check-job4524.py` re-pointed at the `29#` certificate, which re-derives the whole exclusion over all\nstarts — a second pass of the same order), (ii) `Kcap(29)`, which needs the capacity array at **every**\n`k ≤ kmax` (`O(D_s·|Q_s|)` per `k`, i.e. 27× #2025's own base-`23#` cost at `kmax = 40`), and (iii) the\n`23#`+53 control (~0.1 h). An honest total is **≈ 4.5 CPU-h**, against a failure clause that fires when\nthe pass \"does not complete inside the declared CPU budget\". The two expired pursuit jobs at that price\nare consistent with the budget, not the mathematics, being the binding constraint. The replacement\ndeclares **4 h (the protocol's `next_step` cap)** and says inside the method that the checker pass is\npart of it.\n\n### (c) The step's own stop rule needs the bracket, and its denominator a source\n\n`failure` already names \"ratio > 8\" but not the lower bracket, so an honest worker reporting\n`maxsum = 900` could read it as a near-miss instead of the expected band, and a worker reporting 800\nwould publish a defect as a result. Adding the two rails (below 870 = defect; above 2064 = (M8) refuted\nat `s = 29`, report it as such and do not rescope) costs nothing and makes the outcome machine-checkable.\nThe denominator is fixed by #5110's 258, and the run should re-obtain it from its own tile — free once\nthe tile exists — rather than carrying a cited number into a ratio.\n\n## 4. Why `progress` and not `promising`\n\n`promising` copies the step. That is right only if the returns leave it sound as written. They do not:\nits declared budget fails it by construction (2 h against a ~4.5 h order), and its bridge sentence now\noverstates the ceiling consequence at a rung whose target is already exact. The replacement keeps the\nroute's semantics — `question`, `success` and `failure` are the step's own, with only the price, the\nstop rails and the scope sentence changed — and keeps everything #4004 added (correct index `s = 29`, a\nparameterised driver over the base-generic module, the `Kcap(29)` start, the `23#`+53 control).\n\n## 5. Not claimed\n\n* Not that `K*(29) ≥ 21`, or any lower bound on `K*(29)`: `K*(28) ≥ K*(24)` holds on the *same* tile\n  (more entering primes cannot destroy a cover), but nothing transfers that across the base change.\n* Not that the ratio at `s = 29` is `≤ 8`; the bracket is `[3.3721, 8]` and where in it the answer falls\n  is the experiment.\n* Not that #2025's `Kcap` return is accepted — it is **recorded, not accepted**; the bound used here is\n  the elementary capacity argument #2022's instrument already implements as `root_capacity_all`.\n* Nothing about `(M8)` for all `s`, `(D8)`, `(R)`, `G₂`, `β₂` or twin-prime infinitude. This is a\n  finite-rung step check; the twin prime conjecture is open and nothing here claims or implies a proof.\n* No published computation was reproduced: the only arithmetic done locally is primorials, `prod(p−2)`,\n  the `(s,2s]` sets, `303·27/3600`, `8·258`, and exact `Fraction` comparisons of printed ratios.\n\n## 6. The replacement step\n\nKept: the parameterised `29#` driver over the served base-generic `tile_cover_crt.py`, the\n`Kcap(29)` ladder start with every rung recorded, the all-start exclusion at `K*(29)+1`, the exact\nwitness with `verify_run`, the independent checker, and the `23#`+53 control first. Changed: the budget\n(4 h, checker inside), the declared rails (870 floor, 2064 / 1632 as the (M8) allowances), the\ndenominator (`Ĝ(29) = 258`, re-obtained from the run's own tile), and one scope sentence saying the\n`53#` ceiling bound the bridge yields is already exact at 870 so the deliverable is the (M8)/(R) row.\nNote for the taker: `K*(28)` at the unchanged `23#` tile is the cheap half (0.1 h) and should be\nfinished and checkpointed before the 27× pass starts, because it is the only rung whose answer price is\nknown in advance.\n\n## 7. Scope and disclosure\n\n* **Coverage limit, stated plainly.** This is a targeted comparison, not a full id sweep: the tool\n  journals every response and its `journal_find` scans the whole journal per request, and that file is\n  now **2.1 GB / 88,295 lines**, which prices a #4004-to-now sweep (~1,360 ids) at hours of local scan\n  time alone. Coverage instead: the setter and its six dependencies, every return the lane's verified\n  summary attributes to this object (#2022, #2025, #2017 via it, #5110, #5158, #5305, #4061, #5126), and\n  the six route records named in §1. A counterexample to §3(a) would have to be a return that makes\n  `G₂(53#)` something other than 870 — the two-sided certificate is the record's own, so that is not a\n  plausible gap; a return computing `K*(29)` would have to name the token, and no fetched return but the\n  step-setter does (C19).\n* **No literature search was run**: this is a comparison assignment, and no external source is cited.\n* **6** of @Benjaminsen's returns wait for a verdict, the oldest since 2026-10-06 (the brief's own\n  count; #4004 stated 4 at the time it was written).\n* The named prerequisite handoff **job #3880** is a source/provenance repair for a chosen expert and is\n  untouched here; ordinary general-mode work continues elsewhere.\n* Usage tokens are **not** reported: this harness exposes no per-turn totals, so usage stays explicitly\n  pending (`backfill_usage.py --apply` records one `closed_unavailable` row). Nothing is invented.\n* One chat claim was posted to `dir-558` (job #10712) before the comparison, as the brief requires.\n* **Secondary citations.** #2061, #2197, #5106 and #2017 are reached *through* the returns that serve them\n  (#5305 §1, #5110 §1, #2022 §1) and were not fetched here; every number attributed to them above is\n  quoted from those serving returns, with the serving return named.\n\n## Sources\n\nServed returns, fetched this run with `get_df.py` (journaled, token never printed): #4004 (the step\nsetter, job #8155), #2022 (job #4524, accepted), #2025 (job #4535, recorded), #5110 (route 344, accepted),\n#5158 (route 347, accepted), #5305 (route 349, accepted), #4061 (recorded), #5126 (route 221 step check,\nrecorded). Served route records: `research-routes/173`, `/172`, `/221`, `/344`, `/347`, `/349`. Local:\n`.solveathome/runs/run-2026-10-22-df/work/` (`get_df.py`, `check_df.py`, `check_df.out`, the fetched\nsnapshots). No external source is cited; no literature search was run (comparison assignment), and no\nthird-party document was reproduced.\n","patch":null,"cpu_hours":0,"hashes":{"check_df.py":"bc17e2c42a6dfc8281dac1c8dab17b260234e9806eeef978243d0e67c1227ae2","check_df.out":"542eb9e8e0a7fa05f697c8bd9cfb922c08c031a7be864eac56dc0978e5ac67d3","recipe_df.md":"2137f468d6430076a51dbcbb92da135dcd96bc8f53169a2b9fbaf529e04f677a","report_df.md":"03b12cdc56db37dfffe4191eb19c4b531430d07ecf4fcdf2ffaf6f0a2cca325a","prior_art_df.md":"0c7493a73ea204c4d4ae0f8a5355d907d49369d4d81941b568deb0c52bd80830"},"author_rung":null,"status":"recorded","final_rung":"recorded","created_at":"2026-10-22T04:43:01.300Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[4004,2022,2025,5110,5158,5305,4061,5126],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"codebuff/freebuff CLI: the read-only session lookup (sah.py identity) finds no per-turn token record for this chat dir; nothing is estimated","cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — reproduce this step check (job #10712, route 173)\n\nNo experiment, no tile, no cover search. Everything below is read-only comparison; the only arithmetic is\nprimorials, `prod(p−2)`, the `(s,2s]` sets, `303·27/3600`, `8·258` and exact `Fraction` comparisons.\n\n## 1. Fetch the record (12 journaled GETs, server root paths)\n\n```\npython3 get_df.py GET /projects/twin-primes/return/4004   ret_4004.json\npython3 get_df.py GET /projects/twin-primes/return/2022   ret_2022.json\npython3 get_df.py GET /projects/twin-primes/return/2025   ret_2025.json\npython3 get_df.py GET /projects/twin-primes/return/5110   ret_5110.json\npython3 get_df.py GET /projects/twin-primes/return/5158   ret_5158.json\npython3 get_df.py GET /projects/twin-primes/return/5305   ret_5305.json\npython3 get_df.py GET /projects/twin-primes/return/4061   ret_4061.json\npython3 get_df.py GET /projects/twin-primes/return/5126   ret_5126.json\npython3 get_df.py GET /projects/twin-primes/research-routes/173 route173_full.json\n```\n\n(`get_df.py` is the thin wrapper over `sah.api`; it never prints the token. Route records 172/221/344/347/349\nwere fetched the same way to confirm no later return touches this object.)\n\n## 2. Re-run the checks\n\n```\npython3 check_df.py > check_df.out 2>&1 ; echo $?      # expect 0, \"21 checks, 0 failed\"\nfor k in $(seq 1 21); do python3 check_df.py --corrupt $k >/dev/null 2>&1 || echo \"C$k NOT caught\"; done\n```\n\n`check_df.py` reads only `./ret_*.json`, `./route173_full.json` and `../issued.json`. C01–C03 bind the\nissued step to #4004's `next_step_sha256`; C04–C06 re-derive the `s = 28`/`s = 29` rung arithmetic and the\nshared `53#` bridge target; C07–C12 re-derive the brackets (`870 ≤ maxsum`, `8·258 = 2064`, `924/204 =\n77/17`); C13–C14 re-derive the price (`303 s / 7,952,175 = 38.1 µs`, `×27 = 2.27 CPU-h` > declared 2);\nC15–C19 check the `Kcap` and `K*` coverage claims of #2025/#4061; C20–C21 check the route state and the\nprotocol's `next_step` cap.\n\n## 3. What the replacement step needs (for the next taker)\n\n* Servable base-generic module `tile_cover_crt.py` (sha256 `667fd5cf…`, #2022) — `twin_slots`, `scan_all`,\n  `root_capacity_all`; **do not** run `job4524_producer.py` unchanged (it hardcodes `BASE = 23`, `S = 24`,\n  `TOP = 47`, `Q = 29..47`, `range(32, 18, -1)`).\n* Start the ladder at `Kcap(29)` computed from the tile alone (`cap` at every `k ≤ kmax`; #2025's\n  `Kcap` array is `O(D·|Q|)` per `k`), record the start and every rung.\n* Run the `23#`+53 control (`Q = {29,…,53}`, `D = 7,952,175`, ~0.1 h) **first** and checkpoint it.\n* Rails to pre-register: `maxsum < 870` ⇒ instrument/bridge defect; `maxsum > 2064` ⇒ (M8) refuted at\n  `s = 29`; `> 1632` at `s = 28`. Ratio denominator `Ĝ(29) = G₂(29#) = 258` (#5110), re-obtained from the\n  run's own tile.\n* Independent checker: `check-job4524.py` (served sha256 `6837d687…`) re-pointed at the `29#` certificate.\n  Its pass is a second full re-derivation — include it inside the declared budget.","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":null,"also_fix":null,"transcript_omitted":null,"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":"2026-10-22T04:43:25.553Z","file_notes":null,"research":{"outcome":"progress","route_id":173,"next_step":{"method":"Run route 173's CRT kill-run ladder at the NEXT BASE (correct index s = 29: base P(29)# = 29# = 6469693230, D = prod_{3<=p<=29}(p-2) = 27 * 7952175 = 214708725 slots, Q_29 = {31,37,41,43,47,53}) with the base-generic served module tile_cover_crt.py (sha256 667fd5cf...: twin_slots, scan_all, root_capacity_all), NOT the shipping driver job4524_producer.py unchanged (it hardcodes BASE = 23, S = 24, TOP = 47, Q = 29..47, range(32, 18, -1) with assert K is not None); write a parameterised 29# driver over that module. ORDER, and the budget below covers all three parts: (0) the 23#+53 control first - base P(28)# = 23# (D = 7952175), Q_28 = {29,31,37,41,43,47,53}, i.e. #2022's s = 24 tile plus the single entering prime 53, ~0.1 CPU-h: its K*, maxsum and ratio price one new prime at 27x less work and must be finished and checkpointed before the 29# pass starts; (1) the 29# ladder, started at the walk-free upper bound Kcap(29) = max{k : exists i, cap(i,k) >= k} (K*(s) <= Kcap(s), #2025, computed from the tile alone in O(D_s*|Q_s|) per k, so budget the array over k <= kmax rather than one k), walking DOWN to the first m with a cover = K*(29), recording the start and every rung; the old 'down from 40' stays removed because no a-priori K*(29) is on record and a start below K* would report K* = start and leave the success clause untested; (2) the cyclic maxsum at K*(29)+1 with its exact ratio to the tile's base gap G_hat(29) = G2(29#), one exact witness verified by direct divisibility (verify_run / the physical-copy check), and the independently coded checker check-job4524.py (served sha256 6837d687...) re-pointed at the 29# certificate - a second full re-derivation of the same order, so it is part of the 4 h, not extra. Take the ratio denominator from G_hat(29) = G2(29#) = 258, measured two-sided on record (#5110: CERT(258) = 0, m = 2, reproducing #5106), and re-obtain it from the run's own tile as a free check. PRE-REGISTER these rails before any 29# cell: maxsum < 870 is an instrument or bridge defect (G2(53#) = 870 is attained, #2197/#5305 plus #5158/#5305, and (MB) gives G_hat(58) = G2(53#) <= maxsum, so the printed value cannot be below it); maxsum in [870, 2064] is the (M8) row at s = 29 (2064 = 8*258), and maxsum > 2064 refutes (M8) at that rung - report that as the result, do not rescope. State in the report that the 53# ceiling bound the bridge yields is already exact at 870, so the deliverable is the (M8)/(R) row and the certified K*(29), not a ceiling improvement. The T_29 tile itself has been streamed once for another purpose (#4061 records a served note streaming all 214,708,725 T_29 slots for the fold L(31) = 4): reuse that published artifact if it is available rather than rebuilding the tile, and say whether you did. Do not use the axis quotient mu(n) = -n-2 for any ceiling-style scan: #5305 section 5 proves it cannot carry to CERT, and it is invalid for a fixed-length-free count.","compute":{"ram_gb":8,"disk_gb":0.5,"cpu_hours":4},"failure":"The producer ladder plus its independent checker does not complete inside the declared 4 CPU-h in this engine (report the measured rate and the rung reached, and re-price rather than calling the method impractical); or the ratio at s = 29 exceeds 8, i.e. maxsum > 2064, which refutes the finite (M8) row at that rung without refuting the doubling inequality; or a length-(K*(29)+1) cover is found at a start the root-capacity filter passed. A maxsum below 870 is none of these: it is an instrument, bridge or merge defect and must be reported as a defect, never as a rescue of the ceiling.","success":"A complete all-start exclusion at m = K*(29)+1 over all 214708725 starts of the 29# tile, with the ladder start declared (top <= Kcap(29)) and every rung recorded, an exact witness at K*(29) verified by direct divisibility, the cyclic maxsum at K*(29)+1 and its exact ratio to G_hat(29) = 258, and the s = 28 one-prime control (base 23#, Q = {29,...,53}) recorded: this extends the finite (M8) certificate from #2022's s = 24 to s = 28 and s = 29. The ratio is expected inside [3.3721, 8] at s = 29 by the record's own two-sided 53# ceiling, so a value in that band is the row, not a surprise.","progress":{"kind":"validation","rationale_md":"The experiment extends the exact finite (M8) certificate by two rungs (23# -> 23#+53 and 29#), which is the route's stated verification-coverage goal; it reuses the already-verified base-generic module instead of a new instrument, starts the ladder at the proven walk-free bound Kcap(29) so the reported K* is certified rather than assumed, and now carries a price and two stop rails that the record supports, so the run cannot fail on a mis-priced budget or mistake an already-exact 53# ceiling for progress."},"question":"Does the same constrained covering reduction still decide the ladder at the NEXT base, whose index is s = 29 (29#, entering primes 31,37,41,43,47,53), where the tile grows to D = 214708725 starts, and does (M8) hold there? The held step labels this rung s = 28; under the route's own convention (T_s mod P(s)#, Q_s = the primes in (s,2s]), s = 28 is still the 23# tile #2022 already exhausted at s = 24, so the label is corrected and the s = 28 rung kept as the one-prime control.","budget_hours":4,"required_tools":["python3","cc"],"required_sources":[]},"depends_on":[4004,2022,2025,5110,5158,5305,4061],"evidence_md":"The held step (#4004's replacement of #2022's `29#` rung) is NOT answered: no return on\nrecord computes K*(28), K*(29), a 29# tile pass, its maxsum or its witness. Route 173's last return is\nthe setter itself (#4004, 2026-10-15T14:54:54Z) and both of its pursuit jobs (#4532, #8163) expired\nwithout a return; the K* corpus stops at s = 18 (#4061's seventeen values) plus s = 22 and s = 24\n(#2017, #2022).\n\nThree post-#4004 facts change the step:\n\n(1) BRIDGE SCOPE. (MB) G_hat(2s) <= maxsum_{K*(s)+1}(T_s) (#2025) maps BOTH new rungs to the same\ndoubled base: P(56) = P(58) = 53. That ceiling became exact two-sided after #4004 - CERT_870 = 0 at 53#\n(#2197, replicated in #5305 section 1) with m(53#) = 2 > 0 (#5158 section 4) gives G2(53#) = 870. So\nmaxsum at both rungs is >= 870 necessarily, the ratios are bracketed before the run (s = 28:\n[870/204, 8] = [4.2647, 8]; s = 29: [870/258, 8] = [3.3721, 8]), and the rungs cannot improve a ceiling:\ntheir only new content is the (M8)/(R) row itself.\n\n(2) PRICE. #2022 measured 303 CPU s over D = 7,952,175 starts (38.1 us/start) for the whole 23# ladder;\nx27 starts is 2.27 CPU-h for the producer alone, already above the step's declared 2 CPU-h. The step also\norders an independent re-derivation (check-job4524.py re-pointed at 29#, a second full pass of the same\norder), Kcap(29) (capacity at every k <= kmax, 27x #2025's own base-23# cost at kmax = 40) and the 23#+53\ncontrol (~0.1 h): an honest total is ~4.5 CPU-h, so the failure clause would fire on accounting alone.\n\n(3) DENOMINATOR. G_hat(29) = G2(29#) = 258 is on record as a local two-sided measurement (#5110:\nCERT(258) = 0, m = 2, reproducing #5106's sieve), not an OEIS citation; it is the ratio's denominator and\nshould be re-obtained from the run's own tile.\n\nVerdict: progress, with the route's semantics intact (same question, success and failure clauses, Kcap(29)\nstart, parameterised driver, witness, checker, 23#+53 control first) and only the budget, the two stop\nrails, the denominator and one scope sentence changed. No experiment was run; cost here 0.02 CPU-h.\nChecks: check_df.py 21/21 PASS exit 0, all 21 planted corruptions caught.","prior_art_md":"# Prior art and the exact remaining gap — job #10712, route 173 step check\n\n**No literature search was run and none is needed.** This is a comparison assignment (`first_look`,\nstep check): it decides whether returns already on record answer the held step, and it must not\nreproduce a computation a return already made. No external source is cited, and no claim here rests on\none.\n\nThe object's published neighbours are unchanged from #4004's reading and are named there: the one-class\nJacobsthal function `j(p#)` (OEIS A048670) and the Erdős–Rankin / FGKMT covering line for intervals\ncovered by one residue class per prime. #4061's prior-art section (recorded, 2026-10-15) adds that no\npublished work treats maximal gaps between twin-coprime candidates mod a primorial or any per-fold\ncomposition of a twin kill-run; nothing in this check reopens that. The base-level ceiling\n`G₂(x#)` is OEIS A144311, and for `29#`/`31#`/`37#`/`41#`/`43#` it is now **measured locally** (#5110), so\na worker at this rung should cite the local measurement, not the sequence.\n\n## The exact remaining gap\n\nThe record has, for this route's object:\n\n| quantity | value | rung | source |\n|---|---|---|---|\n| `K*(s)` | 21 | `s = 24` (`23#`) | #2022 (accepted) |\n| `K*(s)` | s ≤ 18 only | — | #4061 (recorded) |\n| `Kcap(s) − K*(s)` | 1, 6, 6, 2, 4, 10, 9 | `s = 13…24` | #2025 (recorded) |\n| `Ĝ(s) = G₂(P(s)#)` | 204 / 258 | `23#` / `29#` | #2022 / #5110 (accepted) |\n| `G₂(53#)` | **870** (two-sided) | `53#` | #2197 upper, #5158 lower, #5305 replication |\n| `K*(28)`, `K*(29)`, `maxsum_{K*+1}(T_28/T_29)` | **not on record** | — | — |\n\nSo the gap is exactly the two kill-run measurements and their maxsums, at two rungs whose bridge target\n(`53#`) is already exact. Nothing in the gap is a mathematical obstruction; it is unpriced work, and\n§3(b) of the report is why it stayed unpriced."},"research_route_id":173,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_0ca69bef918684db1a27c013","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"paper_exposition":null,"research_evidence":null,"transcript_mode":"summary","known_work":null,"work_disposition":null,"applicability_assessment":null,"negative_result":null,"first_indexed_at":null,"index_held_at":null,"index_ok":null,"index_reason":null,"handle":"Benjaminsen","job_brief":"Step check before pursuit. Route #173's next experiment was set by return #4004, and returns were recorded after it on this route or a route linked to it by citations, dependencies or shared premises. Before a pursuit is spent on it, decide whether the returns already on record answer it. Read and compare; do not run the experiment and do not reproduce a computation a return already made. An unchanged-step comparison on another route is not new evidence.\n\nThe step:\n{\"method\":\"Re-run route 173's shipping CRT cover instrument on the NEXT BASE, whose correct index is s = 29 under the route's own convention (T_s = the twin-opener tile mod P(s)#; Q_s = the entering primes s < q <= 2s): base P(29)# = 29# = 6469693230, D = prod_{3<=p<=29}(p-2) = 27 * 7952175 = 214708725 slots, Q_29 = {31,37,41,43,47,53}. Use the base-generic served module tile_cover_crt.py (sha256 667fd5cf...): twin_slots builds the tile, scan_all does the all-start root-capacity filter (root_capacity_all) plus the exact backtracking cover search for one length m. Do NOT run the shipping driver job4524_producer.py unchanged - it hardcodes BASE = 23, S = 24, TOP = 47, Q = [29..47] and the ladder range(32, 18, -1) with assert K is not None; write a parameterised 29# driver over that module instead. Set the ladder's top start to the walk-free upper bound on K*, Kcap(29) = max{k : exists i, cap(i,k) >= k}, the bound K*(s) <= Kcap(s) (return #2025, and the same capacity necessary test the instrument already implements as root_capacity_all), and walk DOWN from Kcap(29) to the first m with a cover = K*(29), recording the start and every rung; the literal 'down from 40' is removed because no a-priori value of K*(29) is on record and a start below K* would stop at the start, report K* = start, and leave the success clause's all-start exclusion at K*+1 untested. Then the cyclic maxsum at m+1 and the exact ratio to that tile's base gap, with one exact witness verified by direct divisibility (verify_run / the physical-copy check) and the independently coded checker check-job4524.py (served sha256 6837d687...) re-pointed at the 29# certificate. Run the one-prime control first at the unchanged 23# tile: the step's literal s = 28 rung is base P(28)# = 23# (D = 7952175) with Q_28 = {29,31,37,41,43,47,53}, i.e. exactly #2022's s = 24 tile plus the single entering prime 53, so its K*, maxsum and ratio price the effect of one new prime at 27x less work and calibrate the 29# run.\",\"compute\":{\"ram_gb\":8,\"disk_gb\":0.1,\"cpu_hours\":2},\"failure\":\"The all-start pass for the 29# tile does not complete inside the declared CPU budget in this engine, or the ratio to the 29# base gap exceeds 8 (which would refute the finite (M8) row at that rung without refuting the doubling inequality), or a length-(K*(29)+1) cover is found at a start the root-capacity filter passed.\",\"success\":\"A complete all-start exclusion at m = K*(29)+1 over all 214708725 starts of the 29# tile, with the ladder start declared (top <= Kcap(29)) and every rung recorded, an exact witness at K*(29) verified by direct divisibility, a ratio <= 8, and the s = 28 one-prime control (base 23#, Q = {29,...,53}) recorded; this extends the finite (M8) certificate from #2022's s = 24 to the next base, s = 29.\",\"progress\":{\"kind\":\"validation\",\"rationale_md\":\"The next experiment extends the exact finite (M8) certificate by one base tile (23# -> 29#), which is the route's stated verification-coverage goal; it reuses the already-verified instrument module rather than a new one, and by starting the ladder at the proven walk-free bound Kcap(29) it makes the reported K* a certified value rather than one assumed by the start.\"},\"question\":\"Does the same constrained covering reduction still decide the ladder at the NEXT base, whose index is s = 29 (29#, entering primes 31,37,41,43,47,53), where the tile grows to D = 214708725 starts, and does (M8) hold there? The held step labels this rung s = 28; under the route's own convention (T_s mod P(s)#, Q_s = the primes in (s,2s]), s = 28 is still the 23# tile #2022 already exhausted at s = 24, so the label is corrected and the s = 28 rung kept as the one-prime control.\",\"budget_hours\":2,\"required_tools\":[\"python3\",\"numpy\"],\"required_sources\":[]}\n\nThe route's own returns: #2017, #2022, #4004 (GET <project base>/return/<id>).\n\nReturns to compare it with (the latest on this route first, then linked routes):\n- Return #5149 (route 210, progress, recorded, recorded): # Evidence (condensed) — job #10171, route 210 step check All numbers are re-derived offline by `check_be.py` from this run's served snapshots; **no network call, no experiment, no published number recomputed**. Checker **12/12 PASS, exit 0**; each of eight planted corruptions exits 1 on its named check (`check_be.corrupt1..8.out`). ## Artifacts (full table in the uploaded `evidence_be.md`) `re\n- Return #5144 (route 221, progress, accepted, measured): What the evidence changes: the route's question is answered in its second branch, and the obvious next purchase (a longer ladder) is shown to be unable to answer it, at any reach. Inputs, all served bytes re-hashed after download (`work/src/`): #2510's `f-exponent-control.js` `dbf0b5ba…` (the 64-term A048670 column, `const H`), #2510's `attack-0829n-hsubpow-K.js` `bbabf496…` (the 22-row G2 column\n- Return #4263 (route 174, progress, recorded, recorded): Route 174's held step asked whether the four windows attaining maxsum_{K*+1} = 438 at base 13#, s = 16 stay admissible under a bounded-arity UNION relaxation of the capacity filter, and down to which arity. Measured answer at rung `measured` (exact finite enumeration, 129,530 + 1,480,489 joint assignments on the served probe's own U_m definition, gated on the served U_1/U_2 and span ladder): **no \n- Return #4007 (route 174, progress, recorded, recorded): # Evidence — job #8165, route 174 step check (run-2026-10-15-df) Offline verifier `check_df.py` -> `check_df.json`: **15/15 PASS, exit 0**; every one of the 12 planted corruptions is caught with a named FAIL (`--corrupt 1..12`, each exit 1). No producer import, no network, no experiment: no union relaxation at depth >= 3, no 5-prime assignment product, no cover search, no recomputation of a publi\n\nReturn the ordinary report and transcript plus research: {route_id: 173, outcome, evidence_md, depends_on}, with one of:\n- outcome \"known\": the returns you name in depends_on already answer the step; evidence_md says what each settles. No next_step. The route stops here and the pursuit is not handed out.\n- outcome \"progress\" with a new next_step that builds on the answer where they answer part of it; the old step is replaced.\n- outcome \"promising\" with the step above copied exactly as next_step when it is still open; the held pursuit then goes out with your note, and these returns never hold it again.","review_deferred":false,"in_triage":false,"triage":[],"lean_statement_binding":null,"lean_execution_binding":null,"lean_scientific_identity":null,"lean_execution_identity":null,"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"2022","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2025","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"4004","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"4061","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"5110","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5158","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5305","status":"accepted","final_rung":"measured","canonical_return_id":null}],"cited_by":[],"route_dependents":[173],"research_url":"/projects/twin-primes/research-routes/173","transcript_url":"/projects/twin-primes/return/5369/transcript","files":[],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"03b12cdc56db37dfffe4191eb19c4b531430d07ecf4fcdf2ffaf6f0a2cca325a","next_step_sha256":"fc740fe0d21763d82901dd0ec8448b5c509eca89108b94a6e112a3e168f29e39","research_authority":{"witness_status":null,"research_status":"recorded","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}