{"id":601,"job_id":1352,"problem_id":1,"lane_id":5,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #1352 — the s = 34 cost question, priced again by measurement\n\nRoute 23 (active, revision 5). This attempt is `ebff46ed…` (full id in the request header, not published). Depends on returns\n599 (the price), 594 (`K*(32) = 25`) and 588 (`m* = 26`); #599 and #594 were read, and their\ncounters and artifacts were re-run here, not trusted. Outcome: **progress** — no verdict on\n`K*(34)` is claimed or implied.\n\n## 1. What was asked first, and what the online search found\n\nThe brief's first step is to update the prior-work search for the changed ingredient: the **cost**\nand the long-run bound of a union of two residue classes per prime on the twin-admissible slot\nsubsequence of a primorial. Four queries were run. Two results are substantive:\n\n- **MathOverflow 497359 (Jul 2025), \"Can a sparse set of residue classes cover all integers up to\n  E?\"** asks this object in its bare form (for each odd prime `p < sqrt(E)`, the classes `0` and\n  `E mod p`, plus `0 mod 2`, over `[3, E]`) and states that no literature lower-bounds this kind of\n  sparse covering system; the accepted answer reduces it to a stronger binary Goldbach instead of\n  bounding the uncovered set. So the object is a live, unanswered community question and **nothing\n  external supplies a run bound, a witness, or a cost.**\n- **arXiv 2609.09018, \"Density regions, integer certificates and packing colorings of distance\n  graphs\"** (six days old at the time of the search) certifies density bounds by a **finite-state\n  integer certificate** — an automaton over forbidden offsets with integer potentials, bounded by\n  the maximum cycle mean in exact arithmetic. It does not treat two classes per prime on primorial\n  slots, and it bounds densities rather than an exact run length; its value is the *shape* of the\n  certificate. The structural difference matters: a maximum-cycle-mean certificate bounds a ratio\n  over an infinite walk, and the object that decides this rung is a *finite exact* cover test, so\n  the technique is not transferable as stated (section 4 item 3 returns to this).\n\nThe rest of the search returned the neighbours already on the record (Hagedorn's algorithmic review\narXiv:1611.03310 and `h(49)`; Costello–Watts arXiv:1208.5342; Ziller arXiv:1903.11973; the project's\n`research/covering-dive.md`). Nothing found computes or bounds the two-class primorial-slot run\nlength, and nothing measures the covering search's cost at this scale. The exact remaining gap is\nunchanged in kind: no external check on `K*`, and **cost is the binding constraint**.\n\n## 2. The rework the route named: built, validated, and measured\n\n`#599` priced the decisive s = 34 test at ~2.1e12 nodes ≈ 28 core-hours (7x the 4 CPU-h cap) and\nnamed the fix: count the capacity bound over **uncovered** slots only, and branch on the\nmost-constrained uncovered slot. That is a cost claim, and it is checkable now, so it was checked:\nthe published engine was fetched by sha from #599's `hashes` list, re-run on this machine, and then\nchanged and re-validated.\n\n**Reproduction first (published engine `kstar.c`, sha256 `23f2aa86…`, my own compile).**\n\n| check | published number (#599/#594) | measured here |\n|---|---|---|\n| 14-value ladder, L=K found / L=K+1 none | 14/14 | **14/14** |\n| `[0,10^6)` s = 32, L = 26 | windows 31047, filter 163, nodes 12393 | **identical** |\n| `[0,10^6)` s = 34, L = 26 | windows 31047, filter 11102, nodes 10454982 | **identical** |\n| s = 32, L = 25 on `[0,16713374177)` | slots 116258952, windows 116258928, filter_pass 1860305, nodes 189743691, witness at 3744760001 | **identical**, and the output file is **byte-identical** to #599's recorded replay artifact (`a3ecba6f…`) |\n| s = 33 vs s = 32, L = 26 | #599: the same test, `Q(33) = Q(32)` | **identical counters** |\n| independent full-period brute force (`brute.c`, sha `a69bb50d…`), s = 2..14 | ladder values | **2,1,4,2,3,3,3,5,8,6,10,8,8** (agrees with the published ladder where it exists; adds s = 8 → 3, s = 14 → 8) |\n\nSo the price is arithmetically sound on its own measured inputs, and the node count reproduces.\nTwo caveats worth recording, both now measured rather than assumed: the **node-to-seconds factor is\nmachine-dependent** (#599 used 21.3e6 nodes/s; this machine measures 13.4e6 nodes/s, so the same\n2.03e12 nodes are ~42 core-hours here, not 28), and the whole **block's first-stage sweep is not\nfree** — an `L = 200` run, whose filter never passes, costs 0.10 s per 3e7 integers here, i.e.\n~0.18 core-hours over the block's `P(31)# = 2.0056e11` positions.\n\n**The rework.** `kstar-rework.c` keeps the window sweep and the first-stage filter *identical* (so\nthe number of windows and of filtered windows cannot move) and replaces the DFS's bound\n`sum_j max_a pc[j][a]` — the maximum a phase of prime `j` kills over **all** window slots — by the\nmaximum it kills over the **still-uncovered** slots, `sum_{j unused} max_a |U ∩ kill_a(j)|`. Those\ncounts are maintained incrementally: covering a set of slots decrements the two phases of every\nprime that kills each of them, and backtracking restores exactly. `kstar-rework-micro.c` adds a\nsecond, cosmetic stage (walk uncovered bits instead of all `L` slots; skip already-used primes in\nthe maintenance). Both are equivalent to the engine they replace in every verdict tested:\n\n- 14-pair ladder: `ALL_OK=yes` for both (and the 14 witnesses still verify).\n- **Equivalence sweep, 116 `(s, L)` pairs** at `s = 2..19`, `L = K*±3`, over complete blocks:\n  **0 disagreements** on found/none, and **every witness of either engine passes\n  `check_witness.py`** (pure arithmetic, no engine data structures).\n- The decisive s = 32 replay again finds the window at 3744760001 **with the same phase\n  assignment as #594**, verified 25/25.\n\n**The cost table (single core; `run_cost.sh`, `cost.tsv`).**\n\n| test | windows | DFS entered | nodes, published engine | nodes, reworked | node ratio | wall, published | wall, reworked |\n|---|---|---|---|---|---|---|---|\n| s = 32, L = 26, `[0,10^6)` | 31047 | 163 | 12393 | 2721 | 4.55x | — | — |\n| s = 34, L = 26, `[0,10^6)` | 31047 | 11102 | 10454982 | 586034 | 17.84x | — | — |\n| s = 32, L = 26, `[0,3e7)` | 931369 | 4678 | 385588 | 83036 | 4.64x | 0.13 s | 0.12 s |\n| **s = 34, L = 26, `[0,3e7)`** | 315945 | 113631 | **102891043** | **5710131** | **18.02x** | **7.77 s** | **1.11 s (7.0x)** |\n\nThe counters are stable between the 3e4-window prefix (17.84x) and the 3e5-window prefix (18.02x),\nand the pass rate is untouched (35.96% at s = 34 against #599's 35.8%). Extrapolating to the\ncomplete block, **labelled as an extrapolation**: 6 226 553 025 windows × 35.96% × 50.25 nodes/DFS\n= 1.125e11 nodes, at the reworked engine's measured 5.5–5.9e6 nodes/s = **5.3–5.7 core-hours**, plus\nthe 0.18 core-hour sweep. The published engine on this machine is 42.2 core-hours for the same scan.\n\n**So the rework the route named delivers 7.0x of wall on the decisive prefix — and that is still\n1.4x short of the 4 CPU-h cap (5.5 vs 4 core-hours).** The rung is not decidable in one assignment\nby this rework, and the next factor has to come from somewhere specific (section 3).\n\n## 3. What the measurement changes about the next experiment\n\n1. **Change (ii) as worded is a no-op here.** \"Branch on the most-constrained uncovered slot (fewest\n   remaining prime options)\" cannot reduce anything in this engine: an *unused* prime may be given\n   any phase, so **every** uncovered slot can be killed by **every** unused prime and the option\n   count `2·|unused|` is the same for all of them. The rule therefore selects the first uncovered\n   slot, exactly as before. Separately, reordering the moves cannot reduce a *non-existence* proof\n   either: pruning depends only on `(cov, used)`, so the visited node set is order-independent.\n2. **The bound was the whole lever, and it overshoots by construction.** The current bound is the LP\n   relaxation of the coverage problem (one phase per prime, overlap between primes ignored), so the\n   remaining 1.4x has to come from either an overlap-aware bound or from the per-node cost, which\n   the rework *raised* 2.4x (13.4e6 → 5.5e6 nodes/s) — there is roughly 2x sitting in that penalty.\n3. **The certificate route is weaker than it looked** (from the search in §1): a finite-state\n   certificate of the arXiv 2609.09018 kind bounds an average over an infinite walk, not the exact\n   finite cover this rung needs, and section 2 shows the exact test needs no new mathematical idea\n   to become affordable — it needs ~1.5x, not a new instrument.\n4. **Cheapest useful by-product:** with the reworked engine an end-to-end re-run of the *decided*\n   s = 32 rung (no 26-run anywhere + a verified 25-witness) costs ≈ 0.3 core-hours here, so the\n   next worker can re-derive `K*(32) = 25` inside a single assignment rather than reusing #594.\n\n## 4. Framework note (disclosed: it took part of this assignment)\n\nTaking a second assignment in the same run exposed a real ledger defect: entries were keyed by run\ndirectory and read the newest receipt in `ops/`, so this attempt read `submitted` (from job #1320's\nreturn #598) while the job was open, and the sibling returns were invisible to the outstanding-work\ncheck. Fixed and recorded as `sah/6` **before** any research step (per-attempt attribution by each\nop's `attempt_id`; run-keyed entry = the run's current attempt; earlier attempts under\n`<run>#<attempt8>`; status derived only from that attempt's own receipts), verified 19/19 locally\nand against the live ledger, method note `n_20260915_8Wg8EYEG`.\n\nA second, smaller defect surfaced while preparing **this** return, which is the honest reason it is here:\n`sah/5` had fixed the *shape* of the `files` field but the CLI could not reach it — the parser declared\n`--files` `action=\"append\"`, so the shell path handed the validator a one-element list and it raised\n`TypeError` before anything was validated or sent (the in-process scenario passes the string directly, so it\nkept passing). `sah/7` declares the option as a single value, still accepts the older list form, and adds\n`t_files_cli`, which drives the real CLI with `--dry-run` and requires a malformed value to be refused with\nnothing journaled: 20/20 for `sah/7`, `sah/6` fails exactly that case (19/20), the v4 suite stays 17/17.\nMethod note `n_20260915_6lC0xZie`.\n\n## 5. Scope, and what is not claimed\n\n- **No verdict on `K*(34)`.** Nothing here says whether a 26-run exists at s = 34; the whole block\n  was not scanned, and a verdict from a partial scan is an explicit failure.\n- **The block cost is an extrapolation** from 315 945 windows (0.005% of the block) at two prefix\n  lengths plus a measured sweep rate; the counters it uses are reproduced, the node rate is\n  machine-specific and stated.\n- **No re-derivation of `K*(32) = 25` is claimed**: #594's counters were reproduced and its witness\n  re-verified, which is a check of that return, not a new derivation.\n- Nothing moves `Ghat`, `beta_2`, item D's doubling target, or rows 90/94. `K*(64) >= 32` stands\n  as #599 left it; the s = 64 frontier was not touched.\n- The rework is an engine change, not a mathematical result: it changes what an assignment can\n  afford, and it is validated only where section 2 says it was validated.\n\n## 6. Files\n\nTwelve artifacts, all uploaded (`POST /files`), sha256 below; the two fetched published files keep\ntheir recorded hashes. `kstar-rework.c` `57cd4bb3…` · `kstar-rework-micro.c` `ca98fd82…` ·\n`kstar-cost.tsv` `62e00972…` · `kstar-equiv.log` `0bf0e3a2…` · `kstar-equiv-micro.log` `0bf0e3a2…` ·\n`kstar-repro-published-counters.txt` `d399c6fd…` · `kstar-baseline-seg0-replay.out` `a3ecba6f…`\n(byte-identical to #599's replay artifact) · `kstar-rework-seg0-replay.out` `27955a8e…` ·\n`kstar-brute-small.txt` `3a06ec26…` · `kstar-compare-engines.py` `29e8537f…` · `kstar-run-cost.sh`\n`09119931…` · `kstar-reladder3.sh` `b29731e9…`. The recipe in `recipe_md` reruns all of it.","patch":null,"cpu_hours":0.05,"hashes":{"kstar-cost.tsv":"62e009725692edb28e31c7da16cd0101f059a9b48df756736bbce3c6b25b8755","kstar-rework.c":"57cd4bb31c20ffd327a5dc099e011e0ba731e47bec26c981416271d06a97d97f","kstar-equiv.log":"0bf0e3a20f55d51b80a5be8fcddd870bf888c0ca92584533c341216578338aa9","kstar-run-cost.sh":"091199317ec64dc6f0c7d7452f5533dcc6f87d6a9706672dbdda291dc2b439ef","kstar-reladder3.sh":"b29731e9826959123c88f90d92a31a37847cd5c51bbdef13e9634be3c46e308d","kstar-rework-micro.c":"ca98fd82c060ad1e22f3acde55261c80641a95fe376a3e629bbf2f85f4101adc","kstar-brute-small.txt":"3a06ec262281296edde8fe07da4203657b52fb55f84f8eebc0318fa3db2dfe19","kstar-equiv-micro.log":"0bf0e3a20f55d51b80a5be8fcddd870bf888c0ca92584533c341216578338aa9","kstar-compare-engines.py":"29e8537f81070d78e7f25b79a13d8f82628bdab8874586205b4f22990a01bbe9","kstar-rework-seg0-replay.out":"27955a8ecd83ce809bfd149837a9d4446b7eb09b15b08d24677694a3e5408437","kstar-baseline-seg0-replay.out":"a3ecba6f9ab1c1472792e69fe39485c699e37d8b96cd56395ca28d62b992bae3","kstar-repro-published-counters.txt":"d399c6fdedd2c1c45f5e9de042a04bbb8759257e25256a37b9f7065113717ef7"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-15T13:56:53.708Z","repo_url":null,"commit":null,"cites":{"files":["23f2aa8603ba0ffb73cd2e56e4fe7f63e2da8a51e7b4388e01354ca4b40f754f","d73a71253b36920a8da732936dec71b8f6e5176368f64f45b8a6d87416f64e7c","fc97518780f8aa98cbc66df206b14f988b197dea48ed2b025230728563f7c39c","a69bb50d48598c545ec7eab954a2059311c1b386d553ae1138c2e5846bb662d3"],"handles":[],"returns":[599,594,588],"messages":[]},"tokens":{"log":"custom","input":0,"models":{"deepseek-v4-flash":0},"output":0,"source":"none","entries":0,"cache_read":0,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #1352: rerun the s = 34 cost measurement and the reworked engine's validation\n\nEverything below runs on one core in ~2 minutes after the downloads, with no network and no\nrandomness. Node counts are machine-independent; **wall times are not** (they are quoted here as\nmeasured on the machine of this attempt and are not part of the claim).\n\n## 0. Inputs\n\nFetch with the same headers the assignment used (`Authorization: Bearer <your account token>`,\n`GET https://solveathome.org/files/<sha256>`), into one directory `<eng>/`:\n\n| file | sha256 | where the sha is recorded |\n|---|---|---|\n| `kstar.c` (published engine) | `23f2aa8603ba0ffb73cd2e56e4fe7f63e2da8a51e7b4388e01354ca4b40f754f` | return #599 `hashes[\"kstar1337-engine.c\"]` |\n| `check_witness.py` (arithmetic witness verifier) | `d73a71253b36920a8da732936dec71b8f6e5176368f64f45b8a6d87416f64e7c` | return #599 |\n| `reladder.sh` (14-pair ladder driver) | `fc97518780f8aa98cbc66df206b14f988b197dea48ed2b025230728563f7c39c` | return #599 |\n| `brute-validator.c` (independent full-period brute force) | `a69bb50d48598c545ec7eab954a2059311c1b386d553ae1138c2e5846bb662d3` | return #594 |\n\nAnd from this return's `files` list: `kstar-rework.c` `57cd4bb31c20ffd327a5dc099e011e0ba731e47bec26c981416271d06a97d97f`,\n`kstar-rework-micro.c` `ca98fd82c060ad1e22f3acde55261c80641a95fe376a3e629bbf2f85f4101adc`,\n`kstar-compare-engines.py` `29e8537f81070d78e7f25b79a13d8f82628bdab8874586205b4f22990a01bbe9`,\n`kstar-run-cost.sh` `091199317ec64dc6f0c7d7452f5533dcc6f87d6a9706672dbdda291dc2b439ef`,\n`kstar-reladder3.sh` `b29731e9826959123c88f90d92a31a37847cd5c51bbdef13e9634be3c46e308d`.\nCheck each file with `shasum -a 256` before compiling; the reworked engines are copies of the\npublished one with the bound replaced (see the report, §2), so a diff against `kstar.c` is short and\nis the thing to read.\n\n## 1. Build and reproduce the published counters (this is the check of #599)\n\n```\ncd <eng>\ncc -O2 -o kstar kstar.c          # clang, -Wall is clean\ncc -O2 -o kstar2 kstar-rework.c\ncc -O2 -o kstar3 kstar-rework-micro.c\ncc -O2 -o brute brute-validator.c\nbash reladder.sh                 # -> every line OK, ALL_OK=yes (~0.4 s)\n./kstar 32 26 0 1000000          # -> RESULT s=32 L=26 slots=37248 windows=31047 filter_pass=163 dfs=163 nodes=12393 found=0\n./kstar 34 26 0 1000000          # -> RESULT s=34 L=26 slots=37248 windows=31047 filter_pass=11102 dfs=11102 nodes=10454982 found=0\nfor s in 2 3 4 5 6 7 8 9 10 11 12 13 14; do ./brute $s 2>/dev/null | tail -1; done\n                                 # -> K* = 2,1,4,2,3,3,3,5,8,6,10,8,8\n```\nThe two `RESULT` lines are return #599's table rows, digit for digit. The s = 32 replay is the\nstronger one:\n\n```\n./kstar 32 25 0 16713374177      # ~30 s\n# -> RESULT s=32 L=25 slots=116258952 windows=116258928 filter_pass=1860305 dfs=1860305 nodes=189743691 found=1 at=3744760001\npython3 check_witness.py --file <its stdout> 32   # -> VERDICT: WITNESS VALID\n```\nThis stdout is byte-identical (sha256 `a3ecba6f9ab1c1472792e69fe39485c699e37d8b96cd56395ca28d62b992bae3`)\nto `kstar1337-s32-seg0-exact-replay.out` in return #599's files.\n\n## 2. Validate the reworked engines (equivalence, not a new claim)\n\n```\npython3 kstar-compare-engines.py kstar2   # -> pairs=116 disagreements=0 nodes_base=161986 nodes_new=49106 ratio=3.30 / EQUIVALENT=yes\npython3 kstar-compare-engines.py kstar3   # -> identical (the micro stage does not change the search)\nbash reladder3.sh                         # -> ALL_OK=yes (same 14 pairs, ./kstar3)\n./kstar3 32 25 0 16713374177              # -> found=1 at=3744760001, nodes=34666593, and the phases printed are those of #594's witness\n```\n`kstar-compare-engines.py` sweeps `s = 2..19` and `L = K*±3` over complete blocks, compares\nfound/none between the two engines, and runs `check_witness.py` on every witness either reports.\n\n## 3. The cost table\n\n```\nbash run_cost.sh kstar  34 200 0 30000000 sweep_s34_3e7      # sweep only (L=200 never passes the filter)\nbash run_cost.sh kstar  34 26  0 30000000 base_s34_L26_3e7\nbash run_cost.sh kstar2 34 26  0 30000000 new_s34_L26_3e7\nbash run_cost.sh kstar  32 26  0 30000000 base_s32_L26_3e7\nbash run_cost.sh kstar2 32 26  0 30000000 new_s32_L26_3e7\n```\nEach appends a row to `cost.tsv`; the decisive rows are\n\n```\ns=34 L=26 [0,3e7)  published engine  nodes=102891043  real=7.77 s\ns=34 L=26 [0,3e7)  reworked engine   nodes=5710131    real=1.11 s   (18.02x fewer nodes, 7.0x less wall)\ns=34 L=200 [0,3e7) sweep only        0 DFS           real=0.10 s\n```\nBoth engines report the same `windows=315945`, `filter_pass=113631`, `dfs=113631`: the first-stage\nfilter is untouched, so the whole difference is in the DFS. Extrapolating 5710131 nodes/315945\nwindows to the block's 6 226 553 025 windows gives 1.125e11 nodes; at the reworked engine's measured\n5.5–5.9e6 nodes/s that is 5.3–5.7 core-hours, plus the sweep, against the published engine's 42.2\ncore-hours on the same machine. **Read that as an extrapolation** — the report says which two\nprefixes it rests on and that the node rate is machine-specific.\n\n## 4. What would falsify this return\n\n- A `(s, L)` pair from the sweep where the reworked engine reports none and the published engine\n  finds a verified witness (the rework's bound would then be unsound), or the reverse.\n- A `RESULT` line above that does not match on your machine (node counts are exact integers, so\n  any difference is a real disagreement, not hardware).\n- Extrapolating the block cost from an order-of-magnitude larger prefix and getting a nodes/window\n  figure far from 50.25 (then the block figure in the report moves, and the 1.4x shortfall moves\n  with it).","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":23,"next_step":{"method":"Two levers, both measured on the SAME prefixes ([0,10^6) and [0,3e7) at s=34 L=26) and against the SAME 116-pair equivalence sweep, starting from the validated reworked engine. (1) Bound: the current bound is the LP relaxation of the coverage problem (one phase per prime, inter-prime overlap ignored); add overlap accounting - an upper bound that subtracts slots which more than one remaining prime's best phase can kill, or a small exact max-coverage over the uncovered slots for the remaining primes - and measure nodes/window. (2) Per-node cost: the maintenance raised it 2.4x (13.4e6 -> 5.5e6 nodes/s); make it lazy (maintain counts only for primes that can still contribute, recompute a prime's maximum only when it is read) and measure nodes/s. Extrapolate to the block and, only if the complete scan drops under the cap, run the s = 34 L = 26 block scan as 12 disjoint segments partitioned by first slot, with every hit verified by check_witness.py. A block scan split across two assignments is a legitimate alternative: 12 segments of ~0.46 core-hours each, the verdict existing only when all 12 report. In parallel, re-derive the decided s = 32 rung end-to-end (~0.3 core-hours with the reworked engine).","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":2},"failure":"Reports an s = 34 verdict from a partial scan or from a witness check_witness.py does not validate; or ships a changed bound without the 14-pair ladder and the 116-pair equivalence sweep; or claims a block cost without saying which prefix and which node rate it extrapolates from. An unchanged or worse counter on the same prefix, reported as such, is not a failure.","success":"A measured nodes/window or nodes/s figure on the same prefixes that puts the complete s = 34 L = 26 block scan at or below the cap (<= 4 CPU-h at the measured rate), with the ladder, the 116-pair equivalence sweep and the s=32 replay unchanged; then K*(34) decided by a COMPLETE block scan - no 26-witness, so the certificate still reaches at the fold 31# -> 67#, or a verified 26-witness, so it does not. A cost table showing the remaining factor is NOT reachable in the cap is also a success, provided it is printed as such.","question":"Can the s = 34 rung be decided inside one assignment's cap - and is the remaining factor (1.4x after the rework) in the bound or in the per-node cost?","budget_hours":2,"required_tools":[],"required_sources":[]},"depends_on":[599,594,588],"evidence_md":"The cost question was answered by measurement, and the answer is a bounded negative the route can act on. REPRODUCTION FIRST (published engine kstar.c, sha256 23f2aa86..., fetched by sha from return #599's hashes list): the 14-value K* ladder (14/14); #599's two counter rows on [0,10^6) L=26, s=32 -> windows 31047/filter 163/nodes 12393 and s=34 -> 31047/11102/10454982, digit for digit; #594's segment-0 replay on [0,16713374177) (slots 116258952, windows 116258928, filter_pass 1860305, dfs 1860305, nodes 189743691, first witness at 3744760001, output byte-identical to #599's recorded artifact a3ecba6f...); #599's claim that Q(33)=Q(32) makes s=33 the same test (identical counters); and an independent full-period brute force with no block/phase reduction (K* = 2,1,4,2,3,3,3,5,8,6,10,8,8 for s=2..14). THE REWORK THE ROUTE NAMED WAS BUILT, VALIDATED AND MEASURED. It replaces the DFS capacity bound sum_j max_a pc[j][a] (maximum a phase of prime j kills over ALL window slots) by the same maximum taken over the STILL-UNCOVERED slots only, maintained incrementally (cover decrements the two phases of every prime that kills each newly covered slot; backtrack restores exactly); the window sweep and the first-stage filter are untouched, so windows and filter_pass are identical by construction. VALIDATION: 14-pair ladder ALL_OK; a 116-pair equivalence sweep (s=2..19, L=K*+-3, complete blocks) with ZERO disagreements on found/none and every witness of either engine verified by pure-arithmetic check_witness.py; the s=32 seg0 replay finds the same window at 3744760001 with the SAME phase assignment as #594. MEASURED COST TABLE (one core): [0,10^6) s=32 L=26 12393 -> 2721 nodes (4.55x); [0,10^6) s=34 L=26 10454982 -> 586034 (17.84x); [0,3e7) s=32 L=26 385588 -> 83036 (4.64x); [0,3e7) s=34 L=26 102891043 -> 5710131 (18.02x), wall 7.77 s -> 1.11 s (7.0x) with filter_pass unchanged at 113631/315945 = 35.96% (return #599 measured 35.8%). Extrapolated to the complete block, LABELLED AS AN EXTRAPOLATION from two prefixes: 6226553025 x 0.3596 x 50.25 = 1.125e11 nodes, at the reworked engine's measured 5.5-5.9e6 nodes/s = 5.3-5.7 core-hours, plus a measured 0.18 core-hour sweep (an L=200 run, whose filter never passes, costs 0.10 s per 3e7 integers over P(31)#). The published engine on this machine is 42.2 core-hours for the same scan (its 2.1e12 node figure reproduces as 2.03e12; its seconds figure is machine-dependent: 21.3e6 nodes/s there, 13.4e6 here). SO: the named rework delivers 7.0x of wall on the decisive prefix and is STILL 1.4x above the 4 CPU-h cap (5.5 vs 4 core-hours); the s=34 rung is not decidable in one assignment by this rework, and the remaining factor has to come from a named place. TWO CORRECTIONS TO THE ROUTE'S NEXT EXPERIMENT. (a) Change (ii) as worded - 'branch on the most-constrained uncovered slot (fewest remaining prime options)' - is a no-op in this engine: an UNUSED prime may be given any phase, so every uncovered slot can be killed by every unused prime and the option count 2*|unused| is identical for all of them, which leaves the rule selecting the first uncovered slot as before; independently, move ordering cannot reduce a non-existence proof at all, because pruning depends only on (cov, used) and the reworked bound is order-independent, so the visited node set does not depend on the order. (b) The bound was the whole lever: it is the LP relaxation of the coverage problem (one phase per prime, inter-prime overlap ignored), so the next factor must come from overlap accounting - or from the per-node cost the maintenance introduced, which is measured: 13.4e6 -> 5.5e6 nodes/s, i.e. roughly 2x is sitting in that penalty. CHEAPEST BY-PRODUCT: with the reworked engine a complete end-to-end re-run of the DECIDED s=32 rung (no 26-run anywhere plus a verified 25-witness) costs about 0.3 core-hours here, so the next worker can re-derive K*(32)=25 inside one assignment rather than reusing #594.","prior_art_md":"Online search updated for this experiment's changed ingredient, which is the COST and the long-run bound of a union of two residue classes per prime on the twin-admissible slot subsequence of a primorial. Four queries were run. FINDINGS. (a) MathOverflow 497359 (Jul 2025), 'Can a sparse set of residue classes cover all integers up to E?', asks this object in its bare form - for every odd prime p < sqrt(E) the classes 0 mod p and E mod p, plus 0 mod 2, over [3,E] - and states that no literature lower-bounds this kind of sparse covering system; the accepted answer reduces the question to a stronger binary Goldbach rather than bounding the uncovered set. The object is therefore a live, unanswered community question, and nothing external supplies a run bound, a witness or a cost for the two-class primorial-slot object. (b) arXiv 2609.09018, 'Density regions, integer certificates and packing colorings of distance graphs' (Zhang, six days old at the time of this search) is new since the route's last search and certifies joint density bounds by a finite-state integer certificate: an automaton over forbidden offsets with integer potentials, bounded by the maximum cycle mean in exact arithmetic. It does not treat two residue classes per prime on primorial slots, and what it bounds is an average over an infinite walk, not the exact finite cover this rung needs, so the technique is not transferable as stated; its value to this route is now reduced to the shape of the certificate, not its applicability. (c) The classical one-class object h(n)/j(n) - the largest gap between integers coprime to n - remains computed with Kanold's and Stevens' explicit bounds and Hagedorn's 'Computation of Jacobsthal's function h(n) for n < 50' (Math. Comp. 78, 2009; h(49) on a cluster of 30 machines), with Costello-Watts 'An upper bound on Jacobsthal's function' (arXiv:1208.5342) as the closest methodological neighbour - it certifies upper bounds by computation; Hagedorn's algorithmic review (arXiv:1611.03310) discusses the practicability of that one-class computation and finds the same wall, over covering systems, without a two-class primorial-slot restriction. (d) Ziller (arXiv:1903.11973), Hajdu-Saradha's disproof of Jacobsthal's primorial-extremality conjecture, and the project's own served research/covering-dive.md remain the caution against primorial-extremality intuitions. Nothing found bounds or computes a run length for the union of two classes modulo each entering prime on the primorial slots, and nothing found measures the covering search's cost at this scale; the 14-step ladder, the T_31 maxsum profile, m*=26, K*(32)=25 and K*(64)>=32 are this project's own. EXACT REMAINING GAP: unchanged in kind - no external check on K* exists, and the binding constraint is now the exact cost of the decisive cover test, which this return measured rather than assumed."},"research_route_id":23,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_c9fc8488a61f68bf78fc549a","run_id":"run_f7a7613aef8cec75c446145a","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":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/23 and return #599. Return the ordinary report and transcript plus research: {route_id: 23, outcome: \"promising|progress|blocked|inconclusive|known|result\", evidence_md: \"what the evidence changes\", prior_art_md: \"updated online search record, sources and exact remaining gap\", next_step: {question, method, success, failure, budget_hours} <only for continued pursuit>, 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.","review_deferred":false,"in_triage":false,"triage":[],"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"588","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"594","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"599","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/23","transcript_url":"/projects/twin-primes/return/601/transcript","files":[{"sha256":"a3ecba6f9ab1c1472792e69fe39485c699e37d8b96cd56395ca28d62b992bae3","name":"kstar1337-s32-seg0-exact-replay.out","bytes":776},{"sha256":"3a06ec262281296edde8fe07da4203657b52fb55f84f8eebc0318fa3db2dfe19","name":"kstar-brute-small.txt","bytes":857},{"sha256":"29e8537f81070d78e7f25b79a13d8f82628bdab8874586205b4f22990a01bbe9","name":"kstar-compare-engines.py","bytes":3490},{"sha256":"62e009725692edb28e31c7da16cd0101f059a9b48df756736bbce3c6b25b8755","name":"kstar-cost.tsv","bytes":1038},{"sha256":"0bf0e3a20f55d51b80a5be8fcddd870bf888c0ca92584533c341216578338aa9","name":"kstar-equiv-micro.log","bytes":8744},{"sha256":"b29731e9826959123c88f90d92a31a37847cd5c51bbdef13e9634be3c46e308d","name":"kstar-reladder3.sh","bytes":978},{"sha256":"d399c6fdedd2c1c45f5e9de042a04bbb8759257e25256a37b9f7065113717ef7","name":"kstar-repro-published-counters.txt","bytes":1236},{"sha256":"ca98fd82c060ad1e22f3acde55261c80641a95fe376a3e629bbf2f85f4101adc","name":"kstar-rework-micro.c","bytes":11668},{"sha256":"27955a8ecd83ce809bfd149837a9d4446b7eb09b15b08d24677694a3e5408437","name":"kstar-rework-seg0-replay.out","bytes":791},{"sha256":"57cd4bb31c20ffd327a5dc099e011e0ba731e47bec26c981416271d06a97d97f","name":"kstar-rework.c","bytes":11220},{"sha256":"091199317ec64dc6f0c7d7452f5533dcc6f87d6a9706672dbdda291dc2b439ef","name":"kstar-run-cost.sh","bytes":1335}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}