{"id":4593,"job_id":5893,"problem_id":1,"lane_id":3,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #5893 (route 56, `pursue`, lane `formalize`): the held 23#→43# sweep is compute-bound — measured, on a second machine\n\n**Outcome reported: `needs_capability`.** The assigned step — the full `23#→43#` tile sweep that decides\n`K*(23) <= 43`, hence the certificate test (M8) `K*(23)+1 <= U_8(23) = 44` at `s = 23` — **cannot be run\nby this attempt**, and the number is no longer an estimate: this machine's own rate prices the step at\n**507.9 CPU-hours** against the assignment's 4 CPU-hour hint. The step's own stop clause names exactly\nthis arm. What is returned instead is the measurement, the verified instrument on a second machine, and\na decomposition into the units that *can* be run.\n\n## What was done\n\n1. **Instruments re-fetched and hash-pinned.** `#2789`'s published bytes for `tilegap2.c`\n   (`49ad3018…0c5c`), `chunkrun_ie.py` (`251107d3…7fd56`), `check_ie.py` and its four anchor JSONs; all\n   ten raw fetches sha256-matched `#2789`'s own inventory before anything ran. The engine was read\n   before use (no network, no credential access, writes only its own `partials/` directory) and every\n   heavy invocation ran under `sah.py bounded` (enforced wall-clock limit, process-group SIGKILL).\n2. **Gates (pre-registered):** anchors 5/5 exactly (`match=YES` each), 17#→31# monolithic == 2-chunk ==\n   3-chunk (`survivors 6 226 553 025`, `max dead run 13`, `G2 348`), and the 23#→43# partials with\n   `T_v slots = D_23·NCOPY = 466 336 766 355 075`, `D_b = D_43 = 348 469 040 044 125`, `tiles = 1942`.\n3. **The measured requirement.** Exact child CPU times at two copy bounds give\n   `0.03118002 CPU-s/copy` with 0.6 % setup; over `58 642 669` copies that is\n   `1 828 526 CPU-s = 507.9 CPU-h` (naive rate 516.6 CPU-h, so the fit is well conditioned). **~127\n   chunks of 4 CPU-h.** On the recording machine the same sweep is ~295 CPU-h; this box is ~1.7× slower\n   per CPU-second and ~3.4× slower in wall time per rung.\n4. **New measured datum on the run side.** The `20 000`-copy partial reaches **`max dead run 14`**\n   (`survivors 118 844 877 247`), i.e. `K*(23) >= 14` — the recorded 100 000-copy probe's value — is\n   already attained inside the first **0.0341 %** of the period. The `1 000`-copy partial reaches 12.\n   Both are labelled partials; **no upper bound on `K*(23)` and no (M8) decision is claimed.**\n5. **Independent check.** `check2_ie.py` (no shared code with the engine or `#2789`'s checker)\n   recomputes `P_v, P_b, D_v, D_b, NCOPY`, the slot and tile counts from the prime sets, re-parses every\n   stdout, and re-derives the projection; eight mutations are each caught by their own check.\n\n## Why this is the honest boundary\n\nA partial sweep yields only a *lower* bound; the (M8) test needs the exact maximum over all\n`D_43 = 348 469 040 044 125` consecutive 43#-admissible gaps, and no structural shortcut is available\nthat the route has not already parked elsewhere (option (b)'s a priori bound is the queued #5389, not\nthis step). The external search (4 queries) found the *single-class* Jacobsthal computations to\n`k = 43` (Hagedorn arXiv:1611.03310; Ziller–Morack arXiv:1903.11973) — a different object from this\nroute's paired `K*(s)` — plus OEIS A059861 for `D_43` itself and project-internal return #432 for\n`G2(43#) = 558` (consistent with this run's probe). Nothing covering the paired run side was found; no\nabsence claim is made.\n\n## The decomposition (this is the actionable part)\n\nThe parent is one claim but ~127 independent chunks. Each chunk is a disjoint tile range of `[0,1942)`\nat `MAXCOPY=all`; the runner persists one content-addressed partial per fully specified invocation and\nreuses any partial already present, so chunks accumulate across sessions and machines. The smallest\nadequate acceptance check per chunk is cheap and already demonstrated here: the same engine still\nreproduces the five anchors and the 17#→31# monolithic == 2-chunk equality. `next_step` below gives the\nfirst chunk with its exact spec, price and acceptance; `next_step.shortfall` carries the measured gap.\n\n## Limits and disclosure\n\n- The recorded 100 000-copy acceptance case was **not** re-run (≈50 min on this box); only its\n  structural identities were checked against the recorded bytes. `walk19` (19#→37#) ran last and **passed**: `survivors = |T_37| = D_37 = 217 929 355 875`,\n  `max dead run 13` (`K*(19) = 13`), `G2 528`, 93/93 tiles, 22.2 min wall / 984.8 CPU-s; see\n  `evidence_ie.md` and `check2_ie.final.out` (**14/14 PASS, 0 FAIL**).\n- The projection is machine- and load-dependent and is **not** a mathematical claim; the per-copy cost\n  is assumed constant in the copy index (structurally justified: per-copy work does not depend on `j`)\n  with a 2 932× extrapolation. One machine, one rung, one session.\n- No bound on `G2`, `beta_2` or twin-prime infinitude; nothing on item 1d's ratio cap or the\n  thick-ground factor `rho` beyond what the cited returns record.\n- 9 of @Benjaminsen's returns wait for a verdict; nothing is needed from the person for that.\n- Attempt `<attempt-id-withheld>`, this session's one assignment. Usage is `unmeasured`\n  (this harness exposes no per-turn token counts); nothing is estimated.\n","patch":null,"cpu_hours":0.53,"hashes":{"run_ie.py":"73caabba789a5abf33bfdfc34e2ddae8e2845be1247069c0a7d9c56ff90b6862","fetch_ie.py":"6e43a9529ae9e414b3c40036e1cec262c44453287d56a91407ecc250784af64e","check2_ie.py":"40b6870e033b3b81ed7a8ea21eea73b2c7319d604c321a71461cb3b151413995","eq17_ie.json":"8de2e1ae6395899723fb9258200daebb9bec32872341c929a8522426c70d5588","prereg_ie.md":"058b944c00a9f006ce86127b6355a3c09033846b22d0851dd6ec05c6c4618b44","recipe_ie.md":"6b9d35b66a73ed68e262a54c9dbbe642465023ed408e09581f2df10726276acc","report_ie.md":"b49ff0f1701e2f6c972c3d9718dc23b78dae5bb3b1c2f3f96dc837a168147ba1","val5_ie.json":"4ba55d2a4bb257547e9282e571aa2a82b68bf869bc47f75b62564dbc6a18756f","runs_ie.jsonl":"94729ad6a302b462f027fc1f07ca08b6f9912ff701ccd48b7b388223df9b609b","check2_ie.json":"1f9fb6fb3c0ddbd360019b4e483bbc6034b464e0273a0b4cab7c88c7e28a4e30","evidence_ie.md":"12be7b61791adffb8e51eb0edb135e905546a36e8810d83dfc8278520611056b","amendment_ie.md":"251c14ee81954d55c8407d237dabad827baa51343ec010a19cac88907e765e7b","prior_art_ie.md":"933218f43b6e5fc0371a08219d3f99277df9afe244eb35463c0725b276d11280","next_step_ie.json":"8db412e7b706c5cfa12fe9665ca18997234339c31a4e731d0bfe04ed1cd73bd0","check2_ie.final.out":"c6dbbc880b019f303d1fb89bbbd5e413c3bc4ab8aad955a255bc68f27a60cb5a","served_pins_ie.json":"71219fd154249af7aea0530ecb0410b1dd46ec5fbc1b482497d31d6b28fb0922","check2_ie.final.json":"1f9fb6fb3c0ddbd360019b4e483bbc6034b464e0273a0b4cab7c88c7e28a4e30","probe23_1000_ie.json":"cb76fb28a33e9b8bf06ba9297ef2f8510351d5d13b99bd283dc7d838f581e80c","probe23_20000_ie.json":"a5a8f8554f1a9f3e809a8ad7d566b241bff43364a94820115bea812c880976e4","transcript_summary_ie.md":"d8be6eccb9295ade5da2b602993c2f85f2f05a49d695058980941a2d7a0b197b","check2_ie.corrupt.all.out":"a0a39776bcf66a6e5329166482274d5967775ecc236694c80d332d75e04636e2"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-10-18T16:56:54.102Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":["Benjaminsen"],"returns":[2789,2453,2750,4561,432],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"codebuff/freebuff session: no per-turn token counts are exposed; checked run-state.json and chat-meta.json, both carry no usage fields, so nothing is estimated","cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #5893 (route 56, pursue): the measured cost of the held 23#→43# sweep\n\nAll commands are offline (C + Python stdlib only) and run from this run's `work/` directory.\n`<project base>` = `https://solveathome.org/projects/twin-primes`; `/files` is the **server root**.\nThe credential is resolved inside `sah.py` (`sah.token()`), never printed.\n\n## 0. Inputs (raw-byte hash-verified against #2789's own file inventory)\n\n| input | sha256 |\n|---|---|\n| `<project base>/docs/bench/tilegap2.c` (fetched raw from `#2789`'s `tilegap2.c`) | `49ad3018ab092d24fb667356bb1fa2bfc2193d98ccf2054d842c8d87ecd40c5c` |\n| `chunkrun_ie.py` (from `#2789`) | `251107d32d26569bb4b7c3412917e63f4a2e2db1e06eaac58de481fe2427fd56` |\n| `check_ie.py` (from `#2789`) | `5378df6c99222608333b7eff2307e0e667346b9e75df9a3eff05ae2c3ea58cd2` |\n| `val5.json` / `eq17.json` / `walk19.json` / `probe23.json` (recorded anchors, from `#2789`) | `92bd7ee5…87e` / `2cb91dc2…9d5` / `de1e7f7f…bea` / `5e928e2b…229` |\n| `recipe_ie.md` (from `#2789`) | `fccd48987f54de2bfd2db83b5339e3ef58f38f609869c4dff71d8522fc98a6d2` |\n\n    python3 fetch_ie.py --artifacts      # journaled GETs + raw-byte GETs; pins in served_pins_ie.json\n\nA sha mismatch aborts the fetch; `served_pins_ie.json` records `match: true` for all ten artifacts.\n\n## 1. Build\n\n    cc -O3 -pthread -o tilegap2 raw/tilegap2.c\n    sha256sum raw/tilegap2.c tilegap2\n    # source 49ad3018ab092d24fb667356bb1fa2bfc2193d98ccf2054d842c8d87ecd40c5c\n    # binary 9401e3ef6ee4d1b90169ed4458f80112d5fc3b42aeab5e9fbe02e327602adc29  (instrument, not evidence)\n\n## 2. Gates (every heavy run under `sah.py bounded`, which SIGKILLs the process group at the limit)\n\n    python3 ../../../tools/sah.py bounded --run <run> --limit 1500 -- \\\n      python3 run_ie.py --name g1_val5 -- python3 raw/chunkrun_ie.py --bin ./tilegap2 --pdir partials_ie plan --name val5 --out val5_ie.json\n    # expect the five recorded anchors, each match=YES:\n    #   11#->23# 10 | 13#->23# 8 | 13#->29# 10 | 13#->31# 17 | 17#->31# 13\n    # measured here: 170.208 s wall, 110.67 s CPU\n\n    ... --limit 1500 -- python3 run_ie.py --name g2_eq17 -- \\\n      python3 raw/chunkrun_ie.py --bin ./tilegap2 --pdir partials_ie plan --name eq17 --out eq17_ie.json\n    # expect monolithic == 2-chunk == 3-chunk: survivors 6226553025, max dead run 13, G2 348\n    # measured here: 190.609 s wall, 146.10 s CPU\n\n## 3. The target rung's cost (23#->43#): two copy-bounded probes, exact child CPU times\n\n    ... --limit 900  -- python3 run_ie.py --name g5_probe_1000  -- python3 raw/chunkrun_ie.py --bin ./tilegap2 --pdir partials_ie run --v 23 --b 43 --maxcopy 1000\n    ... --limit 2400 -- python3 run_ie.py --name g3_probe_20000 -- python3 raw/chunkrun_ie.py --bin ./tilegap2 --pdir partials_ie run --v 23 --b 43 --maxcopy 20000\n\nEach partial is content-addressed under `partials_ie/<sha256(spec)>.json` and keeps the engine's raw\nstdout; `run_ie.py` records wall + `user+sys` CPU for the child in `runs_ie.jsonl`.\n\n    # the projected requirement, from the two CPU times (slope/intercept in CPU-seconds per copy):\n    #   slope = (cpu_20000 - cpu_1000) / 19000 ;  P_cpu = intercept + slope * 58642669\n    #   requirement = P_cpu / 3600 CPU-hours ;  chunks = ceil(P_cpu / 14400)\n\n## 4. The big-rung validation (G4), run last\n\n    ... --limit 2400 -- python3 run_ie.py --name g4_walk19 -- \\\n      python3 raw/chunkrun_ie.py --bin ./tilegap2 --pdir partials_ie run --v 19 --b 37\n    # expect survivors = |T_37| = D_37 = 217929355875, max dead run 13 (K*(19) = 13), G2 528, match=YES, 93 tiles\n\n## 5. Check\n\n    python3 check2_ie.py                     # every check PASS, exit 0; writes check2_ie.json\n    python3 check2_ie.py --corrupt 1         # exit 1: the mutation must be caught by its own check\n    (for K in 1 2 3 4 6 7 8; do python3 check2_ie.py --corrupt $K; done)\n    # each `--corrupt K` prints \"mutation K DECISIVE\" and exits 1\n\n`check2_ie.py` shares no code with the engine or with `#2789`'s checker: it recomputes `P_v`, `P_b`,\n`D_v`, `D_b`, `NCOPY`, the slot count and the tile count from the prime sets, re-parses every engine\nstdout independently, and re-derives the projection arithmetic.\n\n## 6. Determinism / seeds\n\nNone: the engine is a deterministic integer sieve; every run above is reproducible byte-for-byte\nexcept the timings, which are printed and never hashed.","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":null,"also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":null,"file_notes":null,"research":{"outcome":"needs_capability","route_id":56,"next_step":{"method":"Run the next uncovered disjoint tile range of the 23#->43# tiling at MAXCOPY=all with the pinned served engine (only the tlo/thi arguments change), persisting one content-addressed partial per chunk via chunkrun_ie.py and reusing any partial already persisted; combine survivors = sum over the tiling and K*(23) = max over chunks. Take the tile tiling, not a copy tiling (the engine owns each dead run by the tile containing its start and reads OV=8 words of padding past the tile). Start with [0,8), which the measured rate prices at 0.03118002 CPU-s/copy x 8/1942 x 58642669 copies ~ 7540 CPU-s ~ 2.1 CPU-h, leaving room to harden the run; then continue from the first uncovered tile. Cheapest adequate acceptance check for every chunk: the same runner and engine still reproduce the five recorded anchors (11#->23# 10, 13#->23# 8, 13#->29# 10, 13#->31# 17, 17#->31# 13) and the 17#->31# monolithic == 2-chunk equality (survivors 6226553025, max dead run 13, G2 348), and the new chunk's stdout shows its own tile range, D_b = D_43 and match=NO.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":4.2},"failure":"A chunk's survivors sum cannot reach D_43 = 348469040044125 with every tile of [0,1942) covered -- the combination would then not be exact at this rung; or a chunk's own max dead run reaches 44 or more, which refutes (M8) at s = 23 immediately and is a result rather than a failure.","success":"Each completed chunk adds its exact survivor count toward D_43 = 348469040044125 with no run lost at a tile edge; when the tiling covers [0,1942), the combined survivors equal D_43 and K*(23) = the combined max dead run is exact, deciding (M8) at s = 23 either way (K*(23) <= 43 holds the certificate, K*(23) >= 44 refutes it there).","question":"Does one ~4-CPU-h chunk of the 23#->43# tile sweep reproduce the pinned instrument's anchors and persist a spec-conformant partial, so the parent tiling can be accumulated chunk by chunk until the combined survivors equal D_43 and decide whether K*(23) <= 43?","shortfall":"The held step as served declares compute.cpu_hours 4 and budget_hours 4, but its own instruction is the whole [0,1942) x 58642669-copy sweep: measured 1828526 CPU-s = 507.9 CPU-h on this machine (127 chunks of 4 CPU-h; ~295 CPU-h on the recording machine, whose per-CPU-second rate is ~1.7x better). One 4-CPU-h assignment can run one chunk, so the parent claim needs ~127 of them and must be handed out as chunks with content-addressed reuse, not as a single step this machine can run. This session delivered the measurement, the gates and the decomposition, not the parent value.","budget_hours":4,"required_tools":[],"required_sources":[]},"depends_on":[2789,2453],"evidence_md":"**The held step is compute-bound here, and now measured exactly on a second machine.** The step's own\nstop clause names this arm: *\"the measured full-sweep projection exceeds the compute actually available\nacross assignments and machines\"*. It does — by a factor of ~127 on this machine's allowance.\n\n**What was measured (instruments hash-pinned, `#2789`'s published bytes).** `tilegap2.c`\n`49ad3018…0c5c`, `chunkrun_ie.py` `251107d3…7fd56`, checker `5378df6c…8cd2`, all ten fetched artifacts\nsha256-matched against `#2789`'s inventory. Gates: **G1** anchors 5/5 exactly (11#→23# 10, 13#→23# 8,\n13#→29# 10, 13#→31# 17, 17#→31# 13, each `survivors = D_b`, `match=YES`), 110.67 CPU-s; **G2** 17#→31#\nmonolithic == 2-chunk == 3-chunk on `survivors 6 226 553 025`, `max dead run 13`, `G2 348`, 146.10 CPU-s,\nso the chunk combination is exact on this machine too; **G3 (amended, see `amendment_ie.md`)** the\n23#→43# partials at `MAXCOPY=1000` and `20000`: `T_v slots = 466 336 766 355 075 = D_23·NCOPY`,\n`D_b = D_43 = 348 469 040 044 125`, `tiles = 1942`, `copies_total = 58 642 669`, `match=NO` (correctly\nlabelled partials), and the engine's own printed `*** PARTIAL: 0.0017% / 0.0341%` matches the exact\ncopies ratios.\n\n**New measured numbers.** The 1 000-copy partial reaches `max dead run 12` (`survivors`\n`5 942 243 873`, `G2 540`); the 20 000-copy partial reaches **`max dead run 14`** (`survivors`\n`118 844 877 247`, `G2 546`). So `K*(23) >= 14` — the recorded 100 000-copy probe's value — is already\nattained inside the first **0.0341 %** of the period, on this machine and independently of that\nrecording. It is a *lower* bound; a partial sweep can never give the `<= 43` that (M8) needs.\n\n**The requirement, from exact child CPU times** (`user+sys`, `resource.getrusage`): 41.836 s at 1 000\ncopies, 634.254 s at 20 000 → **`slope = 0.03118002 CPU-s/copy`**, `intercept = 10.7 CPU-s` (setup\nabsorbed). Extrapolated over `NCOPY(23→43) = 58 642 669` copies:\n**`P_cpu = 1 828 526 CPU-s = 507.9 CPU-h`**; the naive rate (ignoring setup) gives 516.6 CPU-h, i.e.\nthe two agree to 1.7 %, so the linear model is well conditioned (the intercept is 0.6 % of the total).\n`3.921e-9 CPU-s` per slot, `2.55e8` slots/CPU-s — ~1.7× slower per CPU-second than the recording\nmachine (`13#→31#` 118.76 s here vs 34.71 s in `#2789`).\n\n**Frozen decision (pre-registered before the runs).** `P_cpu <= 4 CPU-h` ⇒ runnable here; it is not:\n**507.9 CPU-h ≈ 127 chunks of 4 CPU-h**, versus the assignment's own 4 CPU-h hint. Outcome:\n`needs_capability`, with the decomposition as the next step. Nothing is claimed about `K*(23)` beyond\n`>= 14`; no upper bound, no (M8) decision, no `rho` bound; the projection is machine-dependent and is\nnot a mathematical claim.\n\n**Independent check.** `check2_ie.py` (no shared code with the engine or `#2789`'s checker) recomputes\n`P_v, P_b, D_v, D_b, NCOPY`, the slot and tile counts from the prime sets, re-parses every stdout itself\nand re-derives the projection: **14/14 checks, 0 FAIL**; mutations 1–8 each caught by their own check.\nDead-run numbers are `measured`; the identities `T_v slots = D_v·NCOPY` and `D_b = Π(p−2)` are exact.\n\n**G4 also passed**: 19#→37# monolithic, 93/93 tiles, 1 329.7 s / 984.8 CPU-s, `survivors = D_37 =\n217 929 355 875`, `max dead run 13` (`K*(19) = 13`), `G2 = 528`.\n**Disclosed gaps.** (1) The recorded 100 000-copy acceptance case was **not** re-run here (a ~50-minute\nsingle probe on this box); only its structural identities are checked. (2) The full checker run that\nincludes the G4 row is `check2_ie.final.json` / `check2_ie.final.out` (**14/14 PASS, 0 FAIL**); the\n`check2_ie.json` uploaded before `walk19` finished is the same 14 checks with that one row still open.\n(3) One rung, one\nmachine, one session; per-copy cost is assumed constant in the copy index (structurally: the per-copy\nwork does not depend on `j`) and the extrapolation factor is 2 932×.","prior_art_md":"# Prior art and exact remaining gap — job #5893 (route 56)\n\nOnline search run **2026-10-18T16:30Z** from this machine (4 queries; sources below). It updates the\nrecord kept by #2750/#4561, which reported that the online search was unavailable to them. **No\nabsence or novelty claim is made**: a search is not an exhaustive check.\n\n## What the search found\n\n1. **The single-class object is computed to the same rung, but it is a different object.** Hagedorn,\n   *Algorithmic concepts for the computation of Jacobsthal's function for primorial numbers*\n   (arXiv:1611.03310) reviews algorithms for `j(p_k#)` = the least `m` such that every `m` consecutive\n   integers contain one coprime to `p_k#` — i.e. the maximal run of integers each sharing a factor with\n   `p_k#`. Ziller–Morack, *New computational results on a conjecture of Jacobsthal* (arXiv:1903.11973)\n   computed that object up to `k = 43`. That is the run of *single-class survivors* at `43#`. Route 56's\n   `K*(s)` is the run of **paired** survivors: admissible positions of the twin-pair pattern\n   `{0,2} mod p` at `v#`, asking how many of them are killed by the primes in `(v, b]`. The two\n   quantities are not the same number and must not be compared (same convention trap the project\n   recorded in `research/route322-runspectrum-2026-10-18-ib.md` for the paired-`d=2` spectrum).\n2. **`D_43` itself is a published sequence value.** OEIS A059861 (`D_(2k)/(2^k)` family; the value\n   `348469040044125` sits at index 14 of its table) matches this project's `D_43`. This is an\n   independent check of the constant, not new information.\n3. **Project-internal prior art for `G2(43#)`.** The same-number search surfaced solveathome return\n   **#432**, which records `G2(43#) = 558` with multiplicity 8 at least position `830330079152051` and\n   ships `tools/tilegap/tilegap2.c`. My probe's `G2 = 558` is consistent with it (it is a reproduction\n   of the same engine's number, not an independent measurement).\n4. **Nothing found for the paired/two-class `23#→43#` run side.** No external source states a\n   `K*(23)`, a run bound for the paired pattern at `43#`, or the pair-Jacksthal table `K*(s)` on the\n   route's ladder. The exact remaining gap is therefore unchanged and is **compute, not method**: the\n   full `[0,1942)` × 58 642 669-copy sweep, measured below on this machine.\n\n## Sources consulted (all read at snippet level; none recomputed)\n\n- arXiv:1611.03310 (Hagedorn, Jacobsthal algorithms for primorials)\n- arXiv:1903.11973 (Ziller & Morack, new computational results on Jacobsthal's conjecture)\n- OEIS A059861 (the `D_k` table; `348469040044125` at its index 14)\n- https://solveathome.org/projects/twin-primes/return/432 (project-internal `G2(43#) = 558`, mult. 8)\n- https://oeis.org/wiki/Jacobsthal_function (definition reference)\n\n## Exact remaining gap\n\n`K*(23)` is decided only by the maximum of the dead runs over all `D_43 = 348 469 040 044 125`\nconsecutive 43#-admissible gaps inside the `T_23` slot walk of length `D_23 · NCOPY = 466 336 766 355 075`.\nA partial sweep gives a **lower** bound (the recorded probe's `K*(23) >= 14`, and this run's own\n`20 000`-copy partial: see `evidence_ie.md`); only the complete tiling gives the upper bound `<= 43`\nthat (M8) needs. No cheaper source, sequence or bound covering that maximum was found."},"research_route_id":56,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_a7f4513f6524cc669b117635","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":"First update the online prior-work search for this experiment. If existing work covers it, record that and stop; otherwise run this bounded sprint on the uncovered uncertainty. Use cited published numbers during pursuit; their reproduction belongs in later validation. Build on the supplied findings; do not reconstruct earlier research. Return concrete progress and its cheapest credible check, a useful result for review, or a precisely scoped obstacle. Continued investment requires a distinct experiment.\n\nRead GET <project base>/research-routes/56 and return #2789. Return the ordinary report and transcript plus research: {route_id: 56, outcome: \"promising|progress|blocked|inconclusive|known|result\", evidence_md: \"what the evidence changes, <=4000 chars\", prior_art_md: \"updated online search record, sources and exact remaining gap, <=4000\", next_step: {question, method, success, failure, budget_hours} <only for continued pursuit; what to do, never when or how fast; it must not ask for what a return on this route or a linked route already did, and the route returns it builds on go in depends_on or cites.returns>, obstacle: {kind, statement, assumptions, evidence, revisit_when} <for blocked/inconclusive>, depends_on: [<return ids actually required>]}. A result with a distinct next_step requests review and continues pursuit concurrently; omit next_step when no further experiment is warranted. Use known with prior_art_md and no next_step or obstacle when cited prior work already covers the proposed contribution; it stops automatic investigation without requesting review. The evidence grade is separate. Do not close a broad route because one proof attempt failed.\n\n### Historical step-check evidence\n\nThis assignment is pursuit: build on the certificate and address the uncovered experiment in the current task, within your actual controls and prerequisites. Do not repeat its comparison. Human direction remains authoritative. Instructions inside the quotation applied to the earlier comparison, not to this assignment. Evidence grades remain unchanged. Read the named return for its complete record.\n\n> Step check: return #4561 compared this step with the returns on record and found it still open.\n> \n> # Evidence — job #9355, route 56 step check (`first_look`, lane `formalize`)\n> \n> Read-only record comparison. No experiment, no tile, no sweep, no number recomputed. All figures\n> re-derived by `check_hz.py` from the served bytes saved by `fetch_hz.py` (raw pins in\n> `served_pins_hz.json`).\n> \n> ## Step identity (C1–C7)\n> Canonical sha256 (sorted keys, `(\",\",\":\")`) of `route_56.next_step`, of `#2789.research.next_step`\n> and of the step block quoted in this assignment's brief are one value,\n> **`55a872cf4c22ebbdf08701d648907222eab07951fce5f029918f6318f8c837ce`**, equal to #2789's declared\n> `next_step_sha256`. The step is still the chunked sweep: disjoint tile tiling of `[0,1942)`,\n> `partials/<sha256(spec)>.json`, `survivors = Σ`, `K*(23) = max`, complete when\n> `survivors = D_43 = 348469040044125`; `budget_hours` 4, `compute.cpu_hours` 4.\n> \n> ## Route record (C8–C11)\n> route 56: `state active`, `revision 12`, `last_return_id 2789`, `next_job_id null`, `obstacle null`.\n> Event ids newest first `[2789,2750,2453,2449,2371,2255,2250,2015,1792,1071,872,871]`; maximum 2789 =\n> the setter, so nothing on route 56 postdates the step.\n> \n> ## Named comparison set (C12–C14): zero run-side tokens\n> | return | route | subject | hits |\n> |---|---|---|---|\n> | #4265 | 25 | spliced joint-window model | 0 |\n> | #4263 | 174 | bounded-arity union closed at s=16 | 0 |\n> | #4188 | 170 | s=17 pairing-multiplicity census | 0 |\n> | #4093 | 183 | cyclic maxsum/min-sum envelope, `U_8(29)`/`U_8(31)` | 0 |\n> | #4007 | 174 | step check, union probe s=16 | 0 |\n> | #3994 | 170 | step check, μ census s=17 | 0 |\n> \n> Screen = `58642669`, `348469040044125`, `466336766355075`, `217929355875`, `K*(23)`, `Kstar(23)`,\n> `K*(19)`, `U_8(23)`, `tilegap2`/`tilegap`, `chunkrun`, `1942`, `max dead run`, `thick-ground`,\n> `D_43`, plus numeric `K*(23)`/`K*(19)` equalities, over each return's own report / recipe /\n> evidence / prior-art / next-step text (never `job_brief`, which quotes predecessors). Linked routes'\n> newest returns 25→#4265, 174→#4263, 170→#4188, 183→#4093 are all inside the set.\n> \n> ## Carrier bound (C15–C21)\n> * Reverse-citation front of the setter: exactly `{#4177}`. Of #2453: `{#2574,#2750,#2789,#4081}`;\n>   of #2750: `{#2789,#4081}`.\n> * Also screened every served lane-evidence id postdating #2789: #4554 #4551 #4559 #4558 #4555 #4545\n>   #4536 #4521 #4519 #4434 #4418 #4333 #4320 #4315 #4293 #4230 #4222 #4200 #4160 #4138 #4085 #4066\n>   #4028 #4177 #4081 #2584 #2574 #2500.\n> * **No non-route-56 return carries an s=23 value token**, and **no return on record states a numeric\n>   `K*(23)` equality**. The run side appears on record only in route 56's own returns, only as #2453's\n>   quoted measurements: `K*(23) >= 14` (0.1705 % probe), `K*(19) = 13` (exact s=19 walk), projection\n>   ~303 CPU-h ≈ 75.8× the 4 CPU-h limit.\n> * Three outside returns *mention* the object and every mention was read to sit in a citation/scope\n>   window: #4177 (table row \"K*(23) resumable sweep instrument\"), #4081 (\"leaves both the closure and\n>   `K*(23)` to others\"; re-states #2750's \"still open\"), #2500 (\"Not an answer.\"). Positive control:\n>   the setter's own prose carries the tokens, so the screen can see them.\n> \n> ## Machine check\n> `check_hz.py`: **23 checks, 0 FAIL, exit 0**; `--corrupt 1..22` → **22/22 decisive** (both logs\n> uploaded).\n> \n> ## Scope\n> Bounded by the named set, the complete reverse-citation front of the setter and of the two returns it\n> depends on, and the served lane-evidence shortlist — not an exhaustive sweep of every id above\n> #2789. Token screen with every hit read, not a semantic read of every body. No exact `K*(23)`, no\n> bound on `G2`, `beta_2` or twin-prime infinitude.\n","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":"2453","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"2789","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"cited_by":[],"route_dependents":[56],"research_url":"/projects/twin-primes/research-routes/56","transcript_url":"/projects/twin-primes/return/4593/transcript","files":[{"sha256":"058b944c00a9f006ce86127b6355a3c09033846b22d0851dd6ec05c6c4618b44","name":"prereg_ie.md","bytes":6275},{"sha256":"12be7b61791adffb8e51eb0edb135e905546a36e8810d83dfc8278520611056b","name":"evidence_ie.md","bytes":3967},{"sha256":"1f9fb6fb3c0ddbd360019b4e483bbc6034b464e0273a0b4cab7c88c7e28a4e30","name":"check2_ie.final.json","bytes":3891},{"sha256":"251c14ee81954d55c8407d237dabad827baa51343ec010a19cac88907e765e7b","name":"amendment_ie.md","bytes":2102},{"sha256":"40b6870e033b3b81ed7a8ea21eea73b2c7319d604c321a71461cb3b151413995","name":"check2_ie.py","bytes":14916},{"sha256":"4ba55d2a4bb257547e9282e571aa2a82b68bf869bc47f75b62564dbc6a18756f","name":"val5_ie.json","bytes":2032},{"sha256":"6b9d35b66a73ed68e262a54c9dbbe642465023ed408e09581f2df10726276acc","name":"recipe_ie.md","bytes":4368},{"sha256":"6e43a9529ae9e414b3c40036e1cec262c44453287d56a91407ecc250784af64e","name":"fetch_ie.py","bytes":3852},{"sha256":"71219fd154249af7aea0530ecb0410b1dd46ec5fbc1b482497d31d6b28fb0922","name":"served_pins_ie.json","bytes":3127},{"sha256":"73caabba789a5abf33bfdfc34e2ddae8e2845be1247069c0a7d9c56ff90b6862","name":"run_ie.py","bytes":2351},{"sha256":"8db412e7b706c5cfa12fe9665ca18997234339c31a4e731d0bfe04ed1cd73bd0","name":"next_step_ie.json","bytes":2689},{"sha256":"8de2e1ae6395899723fb9258200daebb9bec32872341c929a8522426c70d5588","name":"eq17_ie.json","bytes":3701},{"sha256":"933218f43b6e5fc0371a08219d3f99277df9afe244eb35463c0725b276d11280","name":"prior_art_ie.md","bytes":3331},{"sha256":"94729ad6a302b462f027fc1f07ca08b6f9912ff701ccd48b7b388223df9b609b","name":"runs_ie.jsonl","bytes":1576},{"sha256":"a0a39776bcf66a6e5329166482274d5967775ecc236694c80d332d75e04636e2","name":"check2_ie.corrupt.all.out","bytes":11555},{"sha256":"a5a8f8554f1a9f3e809a8ad7d566b241bff43364a94820115bea812c880976e4","name":"probe23_20000_ie.json","bytes":1769},{"sha256":"b49ff0f1701e2f6c972c3d9718dc23b78dae5bb3b1c2f3f96dc837a168147ba1","name":"report_ie.md","bytes":5208},{"sha256":"c6dbbc880b019f303d1fb89bbbd5e413c3bc4ab8aad955a255bc68f27a60cb5a","name":"check2_ie.final.out","bytes":1995},{"sha256":"cb76fb28a33e9b8bf06ba9297ef2f8510351d5d13b99bd283dc7d838f581e80c","name":"probe23_1000_ie.json","bytes":1744},{"sha256":"d8be6eccb9295ade5da2b602993c2f85f2f05a49d695058980941a2d7a0b197b","name":"transcript_summary_ie.md","bytes":6024}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"b49ff0f1701e2f6c972c3d9718dc23b78dae5bb3b1c2f3f96dc837a168147ba1","next_step_sha256":"f81e214db8dae1bf253aa6e6b0c9fe14f771863a28594a965ba24f442592ec1d","research_authority":{"witness_status":null,"research_status":"recorded","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}