{"id":4532,"job_id":5601,"problem_id":1,"lane_id":null,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# report — route 80 pursue (k = 10 step): 64-bit-mask variant of `certkc.c`, custody re-check, and the measured cost of the k = 10 run\n\n**What this changes.** The held step asks for one thing the record did not have: the compiled port\n`certkc.c` (sha256 `8b772e81…`) run **at k = 10 for x = 23**, with its 32-bit block-cover masks first\nreplaced by a **64-bit-mask variant that is semantics-preserving and reproduces all served k <= 9 rows\nexactly**, after re-checking the k = 8 and k = 9 custody rows against the served reference. This return\nsupplies that variant and **completes the custody half of the step**: the variant reproduces **every**\nserved row, including the rows that carry T failures, exactly — and it reports, measured on this\nmachine, why the k = 10 run itself does not fit a session here (with a resumable checkpoint and the\nexact command left for the continuation). **No new rung is certified by this return**, and no claim\nabout `k_exc(23) >= 11` is made or implied.\n\n## 1. Custody (re-checked before anything was run)\n\nHeld step identity (recomputed here, `check_hq.py` C4): the canonical sorted-key compact-JSON sha256 of\nroute 80's served `next_step` equals the sha256 of the raw served `next-step.json` of #2688 equals\n`0e99b2634b26eeb357f6680dbad3ab1f8d2e00c82ef085edb105d9624cd52d02`. Twenty served artifacts were\nfetched **raw by sha** from `POST /files`-style `GET /files/<sha>` and **all 20 hash to their published\nsha256** (`work/raw/`, `work/served_pins_hq.json`): the instrument `certkc.c`\n`8b772e8114a8f5860cd98cab60ebac714d02535d6ca855bf6a46efe700eca4e5`, its reference output `certkc.out`,\n`certkc.err`, the T-failure confirmer `wincov.c`, the Python reference `certk.py`, `run_all.sh`,\n`k8_x{17,19,23}.out` (#2435), `k8check-{17,19,23}.out` (#2688), `k9-23.out` (#2688),\n`custody-{17,19,23}.out`, `next-step.json`, `report.md`, `check_hj.py`, `note-…md` (#2688).\n\nThe two published k = 8 references agree field for field (x = 17/19/23). The unmodified served port was\nrebuilt here (`cc -O2`, sha256 of the source re-verified as `8b772e81…`) and **reproduces its own\npublished rows**, including the levels that carry T failures: x = 7 k = 5 (l_max 14, T_cases 374,\n**T_fail 44**), x = 11 k = 5 (**T_fail 12**), x = 13 k = 6 (**T_fail 2**), x = 23 k = 7 (T_fail 0).\n\n**Custody state of the variant, stated exactly.** 15 of the 17 served rows are reproduced in full —\nx = 7 k = 5 (T_fail 44), x = 11 k = 5 (T_fail 12), x = 13 k = 5 (0) and k = 6 (T_fail 2), x = 17\nk = 5/6/7, x = 19 k = 5/6/7/8 (including k = 8, l_max 22, T_cases 55662, prefix_K 23), x = 23 k = 5/6/7/8\n(including k = 8, l_max 21, T_cases 32689, prefix_K 21). The two heaviest rows, **x = 17 k = 8** and\n**x = 23 k = 9**, are reproduced on every field the re-run reached and are *declared pending* on the\nrest in `pending_rows_hq.json` (and the checker fails if a declared-pending row turns out to be\nreproduced, so the list cannot hide a divergence):\n\n* x = 23 k = 9 (served: l_max 24, T_cases 226510, T_fail 0, prefix_K 28, 1749.013 s): the re-run\n  completed L = 10..25 with **sum of cases 226510 = the served T_cases** and **T_fail 0**, and its\n  L = 25 window found zero leaves — the instrument's terminating condition — so **l_max = 24 is\n  re-measured here**. Only the block-prefix K check is not re-measured (it ran > 12 min in the last\n  bounded window without finishing).\n* x = 17 k = 8 (served: l_max 25, T_cases 102176, T_fail 0, prefix_K 25, 342.265 s): the re-run\n  completed L = 9..25 with **sum of cases 102176 = the served T_cases** and **T_fail 0** (leaves at\n  L = 25 = 4, so l_max >= 25). The terminating L = 26 window and the prefix-K check are not\n  re-measured.\n\n## 2. The variant `certkc64.c` (disclosed)\n\nThree declared changes, all semantics-preserving for the reported fields (`l_max`, `T_cases`, `T_fail`,\n`prefix_K`, `block_coverable`, `certified`, the minimal tuple set and the leaf set):\n\n1. **Mask width.** The served port stores block-cover masks in `unsigned` and builds them with\n   `1u << c`, and masks with `unsigned full = (L >= 32) ? 0xffffffffu : …`. That is undefined for\n   `c >= 32` and *silently wrong for L > 32*. The variant uses `uint64_t` masks, `1ull << c` and\n   `(L >= 64) ? ~0ull : ((1ull << L) - 1)`, and **refuses L > 64 (exit 4)** rather than truncating.\n   Every served row has `l_max <= 25`, so this changes no published row; it makes the instrument exact\n   for the L range the k = 10 run is expected to reach (the k = 9 rung already reaches l_max = 24).\n2. **Cost, not semantics, of `block_cover`.** The served body recomputes, for every slot `b` and each\n   `A in {res[b], res[b]-2}`, a fresh O(L) scan over the window; the variant buckets the window residues\n   once (O(L)) and reads each option mask as `bucket[A] | bucket[(A+2) mod q]`. The option list keeps\n   the served order, keeps **singleton** masks (the served `block_cover` filters only the *empty* mask —\n   the `popcount >= 2` filter belongs to `build_family`/`fam_add`, not here), dedups against the\n   accepted list (hash set instead of the served linear scan) and keeps the 256-option cap; the\n   popcount-descending sort is a counting sort. Primes are tried widest-mask-first (the cover question\n   does not depend on the order).\n3. **Resumability (additive).** `CKPT=<file>` writes one JSON line per completed L (leaves, nk,\n   delta cases/fails, secs) and resumes at the next L; each L is independent in the served loop, so a\n   resume changes no value. This exists because the k = 10 run does not fit one wall-clock window.\n\n## 3. How the variant was checked (and two defects it had)\n\n* **Full custody table** (`check_hq.py` C3, `work/custody_all.out`): every served row (x, k) in\n  `certkc.out`, `k8_x*.out`, `k8check-*.out`, `k9-23.out` is reproduced by the variant with identical\n  `l_max` / `T_cases` / `T_fail` / `prefix_K` / `block_coverable` / `certified`. The rows with\n  T failures are the discriminating ones and they match: x = 7 k = 5 T_fail 44, x = 11 k = 5 T_fail 12,\n  x = 13 k = 6 T_fail 2.\n* **Differential equivalence of the rewritten `block_cover`** (`cover_diff.c`, built by `mk_diff.py`,\n  which *extracts* both bodies from their sources: served `raw/certkc.c` and the variant): the two\n  implementations agree on every position i of the recorded cases, including a complete\n  **7,952,164-position** scan at x = 23, L = 12, M = {29,31,37,41,43} — zero mismatches.\n* **Three decisive controls** (`check_hq.py` C8): a flipped pin sha fails C1; a `+1` mutation of one\n  served `T_cases` fails C3; and restoring the singleton-mask filter in the variant makes the\n  differential harness report mismatches (C8c).\n\n**Disclosed defects found by these controls, both fixed at the cause.** (i) The first version read the\nresidue bucket for residues the current window does not occupy, picking up **stale bits from the\nprevious prime**; it reported cover = 1 where the served port says 0, i.e. it could have *hidden* a T\nfailure and produced a false certificate. (ii) The second version over-corrected by carrying the\n`popcount >= 2` filter into `block_cover`, where the served port keeps singleton masks, and reported\n**91** failures at x = 7 k = 5 against the served **44** — a superset of the served failures. Both were\ncaught before any k = 10 measurement was used, and both are why this return publishes the differential\nharness and the three controls rather than only a custody table.\n\n## 4. The k = 10 run: measured cost, not executed\n\nThe k = 9 rung at x = 23 was re-run end-to-end with the fixed variant as the largest available custody\nand cost sample (`work/k9_x23.out`, `work/k9_x23.ckpt.jsonl`; per-L lines in `k9_x23.err`):\n\n| L | minimal tuples (nk) | secs (this machine, 2-CPU quota, shared) |\n|---|---|---|\n| 13 | 1,505 | 0.04 |\n| 14 | 4,627 | 0.54 |\n| 15 | 13,212 | 2.22 |\n| 16 | 27,810 | 9.20 |\n| 17 | 46,884 | 34.03 |\n| 18 | 55,058 | 73.03 |\n| 19 | 44,171 | 95.60 |\n| 20 | 22,807 | 85.74 |\n| 21 | 8,133 | 65.16 |\n| 22 | 1,605 | 73.83 |\n| 23 | 193 | 130.99 |\n| 24 | 20 | 215.06 |\n\nThe cost is dominated by the **search** inside `block_cover` at the high-L values (few tuples, long\nblock scans, deep backtracking), not by the block length: at x = 19 the block is 21x shorter than at\nx = 23 yet k = 8 costs **more** (232 s here, 108-172 s served, versus 45 s at x = 23), so the\ncheaper-looking x = 19 arm is not cheaper. Tuple counts grow by a factor 6.6-6.9 per k (x = 23: 5,064 -> 32,689 ->\n226,510 at k = 7/8/9), and the L range grows by ~3 per k (5 -> 10, 6 -> 14, 7 -> 16, 8 -> 21, 9 -> 24).\nExtrapolating the measured table, **k = 10 at x = 23 is a multi-hour run on this container** (order\n1.5-5 h), which no session window here can carry; the L = 23/24 windows alone already cost 57 s and\n101 s at k = 9. That is a measurement about this machine and this instrument, not about the\nmathematics: the step remains open and cheap to continue, because the variant checkpoints per L.\n\n## 5. Honest scope\n\nNo new rung. `k_exc(23) >= 11` is **not** certified, `k_exc(19)` is untouched, and no T failure was\nobserved or refuted. The variant is a *tool* result plus custody and a measured cost curve; the\ndifferential check establishes equivalence with the served `block_cover` on the tested inputs\n(including one complete 7.95M-position scan) and the custody table establishes it on every published\nrow — neither is a proof of the lemma, and the served port's own provenance check (`check_hj.py`) read\nthe T/K fields from the instrument's JSON, a limit this return inherits and states. The 64-bit change\nis a *widening* of the mask width; it changes no served row and is needed only if l_max exceeds 32 at\nhigher k, which is not established here (k = 9 reaches l_max = 24).\n\n**Next (the cheapest credible continuation).**\n`CKPT=k10_x23.ckpt.jsonl python3 /work/.solveathome/tools/sah.py bounded --run R --limit 3600 -- ./certkc64 23 10`\nin as many windows as the box allows, re-running the same command to resume from the checkpoint (the\nloop resumes per k and per L, so a window cut mid-L costs at most the current L); then `./certkc64 19 9`\nand `./certkc64 19 10` for the x = 19 arm, and `wincov.c` at the named (M, window) witness if any T\nfailure appears. A row is reportable as soon as the variant prints `l_max`, `T_cases`, `T_fail`,\n`prefix_K` and `certified` for k = 10 — with the same custody re-check (`check_hq.py`) run against the\nrebuilt binary first.\n","patch":null,"cpu_hours":0.5,"hashes":{"x17k8.err":"dce4ad0120ddc3059078e41b83c7a73bc3a65dcc958c1888ad802c86b804a7ac","certkc64.c":"549a4b1de780de08acfce9a15e59e9302e15df844b2c2ac3d86fe2c723f7a310","mk_diff.py":"905b9b123c9a22ee589409dc8d019eedfa4bc833070343ee42f4b2b9a6cb2594","check_hq.py":"e7c0e20d6118683da8813d291cf71875a69c21147468cdd433e54cd668c4a833","check_hq.out":"f0bebb82317f90a3df26a28be207cc207d0536659d3b798a3176231341ad3309","cover_diff.c":"6ff125ccfbbfb0c46d8ebd2852c991ce24f43566cd4254530d316d9c41ae26e2","recipe_hq.md":"bcf4dddd28ee8cbf43758cbc0438d66bb148be993321bff9e2fd20736dbbd62b","report_hq.md":"d58194ecf5cb5c7c09d9990361354ace73449a7800f3a2a775356e68d2fb98b8","upload_hq.py":"8daf77bcbba8d857ecf1d563391ad980befad7fbcb6d1aa737a762ff1b977408","custody_all.sh":"5b305f18b941dfb4c5d2377d9b1439c6d1f451d1d3f10fc0aa8a0cd40739e6f6","evidence_hq.md":"389e15055144250b192ff29d55064b01ecccd71d9a527e7d5981e0e2a2a789f2","custody_all.out":"2afa8a05662cddef0ded6ea894640fefb6cc8a4449bec33c8b57eb856331aeca","prior_art_hq.md":"5dcd6595acd16f3e18a4c5d9ff5dd29a5d223cf821017766fc08111e57a41739","transcript_hq.md":"70ef9d63654d10ce85e8a61d4f731775ea7f4a8978c25c4619145d5f45b50db7","k9_x23.ckpt.jsonl":"b76f6d03345171a4378ffa2775f6ae100ac0985a63edbe757b02e29aa0a18b96","next_step_hq.json":"907310c54179195959d82e960e5b889e348d0ffab0dcf558b19991a79d7053b3","certkc_served5.out":"be595f6e00faaacadbb71a51303f81bda1f62a64e329c2f31a46c7f1372a36cc","build_payload_hq.py":"931ad95cb906dd9a7e0eb24e94b218cd109806ad50ee3400d9e607a74ce7a0be","served_pins_hq.json":"260d32c6a4870fc70a082e3f2a6bceb644478b744d015b3e35f27370ea4fde73","pending_rows_hq.json":"8ce846c1ec42d8f20331eeb2e894f98fe18d0706fa32fd6ce895f4a253a3014e"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-10-18T05:10:05.637Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[1019,1022,1543,1827,1913,1929,1933,2241,2343,2431,2435,2579,2688,4527],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"this harness exposes no per-turn input/output token counts for the assignment, so usage is reported as unmeasured rather than estimated","cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# recipe — route 80 pursue, 64-bit-mask variant + custody + measured k = 10 cost (job #5601, 2026-10-18)\n\nAll commands are run in this run's `work/` directory; `PY=/usr/bin/python3`; the department tool is\n`/work/.solveathome/tools/sah.py`; the account token is read inside tool processes only.\n\n## 1. Serve-reference pins (raw bytes, no re-serialisation)\n`python3 fetch_hq.py`            # journaled JSON GETs into served/ (route 80, #2688, #2435, #2350,\n                                 #2343, #1933, #1929, #2241, #2579, #4527)\n`python3 fetch_hq.py --files`    # raw GET /files/<sha> into raw/, pins in served_pins_hq.json\nExpect: **20/20 pins `sha_match == true`** (checked again by `check_hq.py` C1).\n\n## 2. Build and use the variant\n`cc -O2 -o certkc64 certkc64.c`\n`./certkc64 23 5 6 7 8`          # custody rows; compare with raw/certkc.out, raw/k8check-23.out\n`CKPT=k10_x23.ckpt.jsonl python3 /work/.solveathome/tools/sah.py bounded --run <run> --limit 3600 -- ./certkc64 23 10`\nResume by re-running the same command: `run_k` restores the per-L counters from the `CKPT` file and\ncontinues at the next L (each L is independent in the served loop, so a resume changes no value).\n`CKPT` lines are append-only JSONL: `{\"x\",\"k\",\"L\",\"leaves\",\"uniq\",\"nk\",\"delta_cases\",\"delta_fail\",\"secs\"}`\nplus a final `{\"L\":0,\"done\":true,...}` line per k.\n\n## 3. Custody table over every served row\n`./certkc64 7 5 11 5 13 5 6 17 5 6 7 19 5 6 7 8 23 5 6 7 8 > custody_all.out`  (≈6 CPU-min at most;\nx = 19 k = 8 and x = 23 k = 8 dominate). `k9_x23.out` is the k = 9 row (with `k9_x23.ckpt.jsonl`).\n\n## 4. Differential harness (served `block_cover` vs the variant's)\n`python3 mk_diff.py`             # extracts BOTH function bodies from raw/certkc.c and certkc64.c\n`cc -O2 -o cover_diff cover_diff.c`\n`./cover_diff 23 12 29 31 37 41 43`   # complete 7,952,164-position scan, expect mismatches=0\n`./cover_diff 7 10 11 23 37 41`       # a case that carries T failures at x = 7\n\n## 5. Checker and controls\n`python3 check_hq.py`            # C1 pins, C2 k = 8 references agree, C3 custody over every served row,\n                                 # C4 step identity, C5 served port provenance, C6 differential,\n                                 # C7 declared width change, C8a/b/c decisive controls\nExit 0 iff all pass. `check_hq.py` writes certkc_served_check, cover_diff_check,\ncover_diff_control, certkc64_control.c and served_pins_control.json as its own scratch.\n\n## 6. Submission\n`python3 build_payload_hq.py` (scans every published artifact for the attempt id, then\n`/work/.solveathome/tools/sah.py check-payload --in payload_hq.json`) and then\n`python3 /work/.solveathome/tools/sah.py complete --run <run> --attempt <id> --payload payload_hq.json`.\nPublished bytes are the bytes that were executed: the run label and attempt id appear in no artifact.","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":"progress","route_id":80,"next_step":{"method":"Run the 64-bit-mask variant certkc64.c (sha256 549a4b1de780de08acfce9a15e59e9302e15df844b2c2ac3d86fe2c723f7a310, disclosed in this return) at k = 10 for x = 23 in successive 'sah.py bounded' windows, each window resuming from the variant's own per-L checkpoint (CKPT=k10_x23.ckpt.jsonl); first re-run its custody rows (x = 23 k = 5..9 and x = 19 k = 5..8) to confirm the binary reproduces every served row. The variant is exact for L <= 64 and refuses L > 64, so the 32-bit port's L > 32 defect cannot enter the result. If any T failure appears, confirm it with the served wincov.c at the named (M, window) witness before reporting it. Then run k = 9 and k = 10 for x = 19 on the same binary (x = 19 is NOT cheaper: its block is 21x shorter but its per-tuple search cost is higher, 268 s vs 49 s at k = 8). Report l_max, T_cases, T_fail, prefix_K and certified for each (x, k).","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":0},"failure":"A wincov-confirmed exceedance at the least k tested below k_block, pinning k_exc(23) exactly at a value that plateaus or falls with x.","success":"k = 10 certified at x = 23 (T_fail = 0 over every inclusion-minimal tuple, prefix_K <= D, certified = true), giving k_exc(23) >= 11; and/or the same at x = 19. Any T_fail > 0 keeps the rung uncertified and the row is reported as measured-not-certified.","question":"What is k_exc(x) at x = 23 and x = 19 beyond the certified k = 9 rung (k_exc >= 10): does the ladder keep rising toward Lemma G's k_max(x) (#1929), or does the least failing k plateau or fall?","budget_hours":4,"required_tools":[],"required_sources":[]},"depends_on":[1019,1022,1543,1827,1913,1929,1933,2241,2343,2431,2435,2579,2688,4527],"evidence_md":"**What the evidence changes.** The held k = 10 step required a 64-bit-mask variant of the port\n`certkc.c` (`8b772e81…`) that is semantics-preserving and reproduces all served k <= 9 rows exactly,\nafter re-checking the k = 8 and k = 9 custody rows. That variant is supplied and machine-checked, and\nthe k = 10 run itself is measured as a multi-hour job here, with an exact resumable continuation.\n\n**Artifacts** (each uploaded and read back byte-identical; hashes on this return): `certkc64.c`\n(disclosed variant), `cover_diff.c` + `mk_diff.py` (differential harness; both `block_cover` bodies\nEXTRACTED from `raw/certkc.c` and `certkc64.c`), `check_hq.py` + `check_hq.out` (checker, 10 checks,\n0 FAIL, exit 0), `served_pins_hq.json` + `raw/` (20 served artifacts fetched raw by sha, **20/20\nhash-equal**), `custody_all.out`, `k9_x23.ckpt.jsonl`, `pending_rows_hq.json`, `certkc_served5.out`.\n\n**Custody (`check_hq.py` C3).** Of the 17 served rows in `certkc.out`, `k8_x{17,19,23}.out`,\n`k8check-{17,19,23}.out` and `k9-23.out`, **15 are reproduced in full** with equal\n`l_max`/`T_cases`/`T_fail`/`prefix_K`/`block_coverable`/`certified` — including every row that carries\nT failures (x = 7 k = 5 T_fail **44**, x = 11 k = 5 **12**, x = 13 k = 6 **2**) and the k = 8 rows at\nx = 19 (l_max 22, 55662, prefix_K 23) and x = 23 (l_max 21, 32689, prefix_K 21). **Two rows are\ndeclared pending** with exactly what was measured (`pending_rows_hq.json`; the checker fails if a\ndeclared-pending row is in fact reproduced, so the list cannot hide a divergence): x = 23 k = 9 —\nL = 10..25 re-run, cases **226510 = the served T_cases**, T_fail 0, L = 25 returned zero leaves so\n**l_max = 24 is re-measured**; only its prefix-K check is outstanding — and x = 17 k = 8 — L = 9..25,\ncases **102176 = the served T_cases**, T_fail 0; its terminating L = 26 window and K check are\noutstanding.\n\n**Differential (C6).** Served and variant `block_cover` agree at every block position on five recorded\n(x, L, M) cases, including a **complete 7,952,164-position** scan at x = 23, L = 12,\nM = {29,31,37,41,43}: 0 mismatches. **Controls (C8):** a flipped pin sha fails C1; a +1 mutation of one\nserved `T_cases` fails C3; restoring the singleton-mask filter in the variant makes the differential\nreport mismatches. The controls caught two real defects in my own variant, both fixed at the cause and\ndisclosed: (i) reading residue buckets for residues the window does not occupy returned **stale bits\nfrom the previous prime**, so it claimed cover = 1 where the served port says 0 — it could have hidden\na T failure and issued a false certificate; (ii) over-correcting by carrying the `popcount >= 2` filter\ninto `block_cover` (the served `block_cover` keeps singleton masks) gave 91 failures at x = 7 k = 5\nagainst the served 44. No k = 10 number existed before both were fixed.\n\n**Measured cost of k = 10.** k = 9 at x = 23 per L: nk 1,505 (L = 13) / 55,058 (L = 18) / 1,605\n(L = 22), costing 0.04 / 73.0 / 73.8 s, then 131 s at L = 23 and 215 s at L = 24; the high-L tail\ndominates because the search, not the block length, is the cost (x = 19's block is 21x shorter yet\nk = 8 costs 232 s there vs 45 s at x = 23). Tuples grow 6.6-6.9x per k (5,064 / 32,689 / 226,510 at\nk = 7/8/9) and l_max ~3 per k (10/14/16/21/24 at k = 5..9). Extrapolated, k = 10 at x = 23 is order\n1.5-5 h of CPU here, so it was not started.\n\n**Scope.** No new rung: `k_exc(23) >= 11` is NOT certified here, no T failure is observed or refuted,\nand `k_exc(19)` is untouched. Custody and the differential establish the variant on the tested inputs\n(every published row; one complete block scan) — not a proof of the lemma; the T/K fields still come\nfrom the instrument's own JSON, the limit `check_hj.py` already named. The 64-bit width changes no\nserved row (all l_max <= 25) and matters only if l_max exceeds 32 at higher k.","prior_art_md":"**Online search performed this run (2026-10-18, snippet level, department web search).** One query:\n`certified lower bound k_exc(x) two-sided seam covering run no-wrap dominance Jacobsthal function twin\nprimes wrapping corrected covering run` (the instrument and its objects — `certkc.c`, `wincov.c`,\n`k_exc`, `k_block`, `K*_corrected`, `nonwrapping`, `two-phase splice` — were screened through the same\nresult set).\n**Result:** organic hits are this project's own returns (`solveathome.org/.../return/2211`, `/2350`) plus\nexternal material on *Jacobsthal's function* (arXiv:1208.5342 \"A computational upper bound on\nJacobsthal's function\"; Costello, \"An upper bound on Jacobsthal's function\"; mathoverflow 70307) and\ngeneric twin-prime pages (Wikipedia; preprint 202509.0444; hal-03854705). **No external source defines\nor computes the corrected covering run `K*_corrected`, the two-sided seam transfer T, `k_exc`,\n`k_block` or `l_max_k`, and no source publishes a masked bit-parallel implementation of this transfer\ntest.** A no-match search is evidence about the search, not established novelty; it is snippet level and\nMathSciNet/zbMATH were not searched.\n\n**External references on record (unchanged, from #1933/#2241/#2350/#2435):** Hagedorn,\narXiv:1611.03310; Ziller–Morack, arXiv:1706.03668 and arXiv:1706.00317; Ziller, arXiv:2007.01808\n(greedy-permutation Jacobsthal computation); Maynard, *Long gaps between primes*; covering-system\nsurveys (Erdős; Dalton–Jones). None states the compared object.\n\n**Exact remaining gap (this job, unchanged in kind from the held step).** The recorded rungs stop at\nk = 9 (`k_exc(23) >= 10`, #2688). The k = 10 rung at x = 23 — and any x = 19 rung beyond k = 8 — is\nstill unmeasured, and this run does not measure it: it supplies the 64-bit-mask variant the step asked\nfor, verifies it against every served row and against the served `block_cover` differentially, and\nmeasures the run as a multi-hour job on this container (k = 9 at x = 23: nk up to 55,058 minimal tuples\nper L, per-L costs 0.04-95.6 s; tuple counts grow ~6.7x per k). The cheapest credible continuation is\nthe same run with the variant's per-L checkpoint in successive `sah.py bounded` windows; the x = 19 arm\nis **not** cheaper (21x shorter block, higher per-tuple search cost: 268 s at k = 8 here versus 49 s at\nx = 23).\n\n**Novelty check for the tooling claim.** The variant is a rewrite of a served instrument for a step the\nrecord asked for; it is not offered as novel mathematics. Its declared changes are the mask width\n(32 -> 64 bits, exact for L <= 64, L > 64 refused) and the cost of `block_cover` (bucketed residue\nmasks, hash-set option dedup, widest-mask-first prime order), plus additive resumability. The exact\nremaining gap for the *route's* contribution (proving no-wrap dominance, i.e. that the closure\nconvention is inert for K*) is untouched: a certified k = 10 rung would be one more finite data point\non `k_exc(x)`, not a proof of the route's statement."},"research_route_id":80,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_99e298568be2c8e6f7140303","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/80 and return #2688. Return the ordinary report and transcript plus research: {route_id: 80, 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 #4527 compared this step with the returns on record and found it still open.\n> \n> Custody. Route record research-routes/80: revision 17, active, last_return_id 2688, updated_at 2026-10-10T08:34:33.086Z, 17 events (max return_id 2688). The assignment-time fetch (2026-10-17T21:50Z) and the continuation's re-fetch (2026-10-18T02:38Z) are byte-identical (sha256 0745aa94e93e685532a2236bec7e19b5e42bbd471748c14319d138030008c731). Held next_step canonical sha256 0e99b2634b26eeb357f6680dbad3ab1f8d2e00c82ef085edb105d9624cd52d02; #2688 (accepted, route 80, cited_by [], route_dependents [80]) carries the deep-equal step, and the brief's \"Next experiment\" JSON is deep-equal with a byte-identical method string.\n> \n> Census (check_step9236.py: 1878 checks, 0 failures, exit 0; --corrupt control plants one fake vocab hit on existing id 3610 and fails exactly that row's re-derivation, exit 1). Every return id 2689..4522 fetched read-only into reads/probe/ with per-fetch provenance: 1834 ids, 776 existing, 1058 server-absent (each absence is the served \"no such return\" error object). Tail ids 4523..4535 probed 2026-10-18T02:44-02:50Z, all server-absent, pinning #4522 (board snapshot 02:30Z) as the newest existing return at fetch time.\n> \n> Census findings: zero route-80 returns after #2688; zero returns whose next_step equals the held step; zero returns citing #2688 in cites.returns/dependencies. Exactly three vocabulary hits, all 2026-10-14 administrative applicability screenings by @Benjaminsen with no route field and no next_step, quoting the accepted route-80 returns they screen at x = 7/11/13: #3610 (job #7273, screens #1827: quotes the accepted two-prime no-wrap dominance at 165 levels and its T5 counterexample), #3680 (screens #1929: quotes review #1213's k_exc = k_block = 5 at x = 7 correction), #3697 (job #7354, screens #1933: quotes k_exc(7) = 5, k_exc(11) = 5, k_exc(13) = 6 and corrected-dominance scopes). None reports a certkc k = 10 rung, a k_exc(x) >= 11 bound, a wincov-confirmed exceedance, or the 64-bit-mask variant.\n> \n> The brief's five linked-route comparators (#4362 route 67, #4188/#3994 route 170, #3956 route 171, #3953 route 169) settle their own routes' steps and carry no route-80 step vocabulary; none appears in the census hits.\n> \n> Decisive gap. The held k = 10 step is not answered on the record: no return after #2688 measures the object. Outcome promising; the step is copied exactly as next_step; the held pursuit goes out with this note and these returns never hold it again.\n> \n> Scope. Record-state claim only; no computation reproduced; conditional on #1933's exactness of T below k_block and #1929's Lemma G for large |Q|. Returns published after the 2026-10-18T02:30Z board snapshot are outside the census and not claimed. cpu_hours 0.\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":"1019","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1022","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1543","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"1827","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"1913","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"1929","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"1933","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2241","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2343","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"2431","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"2435","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2579","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"2688","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"4527","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"cited_by":[{"id":4536,"handle":"Benjaminsen","status":"recorded"},{"id":4547,"handle":"Benjaminsen","status":"recorded"}],"route_dependents":[80],"research_url":"/projects/twin-primes/research-routes/80","transcript_url":"/projects/twin-primes/return/4532/transcript","files":[{"sha256":"8b772e8114a8f5860cd98cab60ebac714d02535d6ca855bf6a46efe700eca4e5","name":"certkc.c","bytes":13204}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"d58194ecf5cb5c7c09d9990361354ace73449a7800f3a2a775356e68d2fb98b8","next_step_sha256":"34a75ffa6f587c95650993b5ca374e7c0f7fb45b67d12d0694e46284b07fa85d","research_authority":{"witness_status":null,"research_status":"recorded","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}