{"id":599,"job_id":1337,"problem_id":1,"lane_id":5,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #1337 -- does the maxsum doubling certificate keep reaching at the next rung?\n\nRoute 23, attempt `fdfde638c75f151bce29c82d3a4658fb`. Engine: the block+phase reduction of\n#594 (`kstar.c`, re-validated here), plus a new independent witness verifier.\n\n## Summary\n\nThe instrument's reach past the `31# -> 61#` fold is now **priced, not decided**. Three new\nfacts, in order of weight.\n\n1. **The decisive test at the next rung costs ~28 core-hours (7x this assignment's cap), and the\n   reason is identified.** The block+phase reduction still applies at s = 34 (same block `31#`),\n   but the covering search's pruning collapses: over the same `[0,10^6)` prefix the capacity\n   filter passes **0.53%** of windows at s = 32 and **35.8%** at s = 34, and a DFS that averages\n   76 nodes at s = 32 averages **942** at s = 34. Whole-block node count therefore goes from\n   2.6e9 (measured: 0.45 core-h, #594) to **2.1e12 nodes ~ 28 core-hours**. The reduction made\n   s = 32 affordable; it does not extend one rung as implemented.\n2. **A latent engine bug that produced a false witness, found by verifying instead of trusting.**\n   The pre-fix engine indexed residues as `pc[j][a]` with `a < q`, sized `[8][64]`; the moment\n   `q = 67` enters (s >= 34) that is an out-of-bounds write. Its s = 34 output contains `q38`,\n   `q42` -- not primes -- and its recorded 26-slot \"witness\" fails an independent arithmetic\n   check (only 15/26 slots covered). **The s = 34 result in this job's first attempt is retracted\n   here.** A new tool (`check_witness.py`) verifies any witness by pure arithmetic (genuine-slot,\n   span, cover) and is now run on every witness; it validated all 6 witnesses reported below and\n   re-validated #594's s = 32 witness.\n3. **K\\*(64) >= 32, with verified witness** -- the assignment's second listed deliverable.\n\n## 1. The certificate at the walkable rungs s = 32..36 (definitional part)\n\n`P(s)#` is the primorial of the largest prime <= s, and the certificate is\n`Ghat(2s) <= maxsum_{K*(s)+1}(T_s)`. For s in [32, 36], `P(s) = 31`, so **the block and the\nthreshold are shared**: `T_s = T_31`, `Ghat(s) = G2(31#) = 348`, band test\n`maxsum_{K*(s)+1} < 4*348 = 1392`, and with `m* = 26` measured in #588\n(`maxsum_26 = 1380 < 1392 <= 1428 = maxsum_27`) that is exactly\n\n> the certificate holds at rung s  <=>  `K*(s) <= 25`.\n\n| s | Q(s) = primes in (s, 2s] | \\|Q\\| | new relative to s=32 | K\\*(s) |\n|---|---|---|---|---|\n| 32 | 37 41 43 47 53 59 61 | 7 | -- | **25** (#594) |\n| 33 | 37 41 43 47 53 59 61 | 7 | none (Q and block identical) | **25**, no computation |\n| 34 | ... + 67 | 8 | +67 | **open** (see 2) |\n| 35 | ... + 67 | 8 | none (Q identical to s=34) | = K\\*(34), no computation |\n| 36 | ... + 67 71 | 9 | +67, +71 | >= K\\*(34), monotone |\n\nSo of the five walkable rungs only **two** carry new information: s = 34 (the prime 67 entering\nthe kill set) and s = 36. s = 33 is a definitional duplicate of s = 32, not a new rung -- the\ninstrument reaches exactly one distinct fold (`31# -> 61#`, truth 1080/348 = 3.1034) and the\nquestion is whether the very next distinct fold `31# -> 67#` is reachable.\n\n## 2. What the s = 34 test costs, measured\n\nDeciding \"K\\*(34) <= 25\" needs the whole block: 6 226 553 025 windows (exactly `D_31`), one per\nslot, cyclically. Measured on the prefix `[0,10^6)` with the fixed engine, at 21.3e6 nodes/s:\n\n| s | windows | DFS | pass rate | nodes | nodes/DFS |\n|---|---|---|---|---|---|\n| 32 | 31 047 | 163 | 0.53% | 12 393 | 76 |\n| 34 | 31 047 | 11 102 | **35.8%** | 10 454 982 | **942** |\n\nExtrapolating to the block (5.1888e8 windows per 1/12 segment): **1.75e11 nodes per segment,\n2.27 h single-core, ~28 core-hours for the block -- 6.8x the 4 CPU-h cap** (against 0.45 core-h\nfor the s = 32 test that #594 completed). The dominant term is the DFS on the 35.8% of windows\nthat pass the capacity filter, and the filter is weak here precisely because it counts every\nwindow slot, not only the still-uncovered ones: with |Q| = 8 the capacity sum\n`sum_j max_a pc[j][a]` clears L = 26 for a third of all windows. **I did not run the s = 34 test\nand I make no claim about K\\*(34).**\n\n## 3. Engine bug, retraction, and the verifier that caught it\n\nThe first s = 34 run (pre-fix build) reported `found=1` twice, hence \"K\\*(34) >= 26, the\ncertificate dies at the next fold\". That claim is **withdrawn**: segment 5's output prints phases\n`q38={0,36} q42={29,27}`, which are not primes, and segment 0's recorded 26-slot window at 5009\nfails an independent check -- all 26 slots are genuine level-34 slots (gcd with `31#` = 1 for r\nand r+2), but the printed phases cover only **15/26** of them. Cause: `cnt`/`pc`/`hist` were\nsized `[8][64]` in the residue index while `a` runs to `q-1 = 66` once q = 67 is in Q; every\nladder case has q <= 31, so the 14-value regression could not see it. Fix: 16 x 256 / 16 x 512\narrays, 16-wide per-prime dimension, 128-bit primorial (`61# = 1.17e23` overflows uint64), masks\nwidened to 64 bits so L > 31 is expressible.\n\nNew tool **`check_witness.py`**: given a witness (slots and phases) it checks (1) each slot is\ngenuine for the level, (2) the span, (3) the phases cover every slot -- arithmetic only, the\nengine's own state is not consulted. It is now part of the reporting path.\n\nRe-validation of the fixed engine, all with the fixed binary:\n* the published 14-value `K*` ladder reproduces exactly (L = K found, L = K+1 none, 14/14);\n* s = 32, L = 25 on the recorded segment-0 range `[0, 16713374177)`: counters match #594's\n  segment 0 **digit for digit** (slots 116258952, windows 116258928, filter_pass 1860305,\n  dfs 1860305, nodes 189743691, `at=3744760001`), and the fresh 25-slot witness verifies 25/25;\n* so `K*(32) = 25` -- the value the certificate's s = 32 rung rests on -- is unchanged.\n\n## 4. K\\*(64) >= 32, verified (the second deliverable)\n\nThe upper bound on `K*(s)` was not obtained; the lower-bound alternative was, and it is a real\nmeasurement rather than a search for a bound:\n\n| L | found in `[0,200000)` / `[0,300000)` | wall | verdict |\n|---|---|---|---|\n| 13 | first window (start 71) | 8 ms | VERIFIED (equal to Lemma 1's floor, pi(128)-pi(64) = 13) |\n| 20 | first window (start 71) | 267 ms | VERIFIED |\n| 28 | first window (start 71) | 15.8 s | VERIFIED |\n| 30 | first window (start 71) | 3.2 s | VERIFIED |\n| 32 | 5th window (start 149) | 25.3 s | VERIFIED |\n| 36 | not within 260 s | -- | open |\n\n`K*(64) >= 32`, block `61#` (D_63 = 2.6895e21 slots), covered by the 13 entering primes\n(67 ... 127). Witness: 32 consecutive level-64 slots starting at **149**, span 1128, phases\nq67={15,13} q71={22,20} q73={20,18} q79={66,64} q83={62,60} q89={82,80} q97={84,82} q101={27,25}\nq103={94,92} q107={86,84} q109={94,92} q113={36,34} q127={15,13}; every slot is genuine and\nevery slot is covered (32/32). Per-prime coverage 2,2,2,3,3,3,3,2,2,2,2,3,3.\n\nComparison with the provable floor and with the model:\n* Lemma 1 gives only `K*(64) >= |Q| = 13`; the demonstrated run is **2.46x the floor** (at s = 32\n  the ratio was 25/7 = 3.57), so the instrument's runs are visibly shorter relative to the floor\n  as the block grows.\n* the growth model `K* ~ c*ln(M_s)/ln(1/p_s)` that predicted s = 32 correctly (c = 0.68 predicted\n  25.3, measured 25) gives, at s = 64, `M_64 = 9.2055e46`, `p_64 = 0.2525`,\n  `ln M/ln(1/p) = 78.6`, hence **K\\*_pred = 53.4** (c = 0.69 -> 54.2, c = 0.73 -> 57.4).\n  A lower bound cannot refute an upper prediction, so this is **drift evidence, not a\n  refutation**: the exhibited run is 60% of the model's next value, and the searchable frontier\n  (32) sits far below it.\n* on the maxsum side the certificate at s = 64 stays open in both directions: the T_61 profile is\n  incomputable, and the telescoping floor `maxsum_m(T_61) >= m*61#/D_61 = 43.6m` gives\n  `maxsum_33 >= 1439` against `4*Ghat(64) = 4320`, so the floor decides nothing there.\n\n## 5. What this changes for route 23\n\n* The instrument reaches its first eventual rung (s = 32, `Ghat(64) <= 1380 = 3.9655*Ghat(32)`);\n  that value survives a stricter re-validation than it was obtained with.\n* The **next distinct fold is not shown reachable and not shown unreachable**: it is shown to cost\n  ~28 core-hours with this engine (7x the cap) because the block+phase reduction's pruning, not\n  the reduction itself, fails at |Q| = 8. The obstacle is the cover test, and it is fixable in\n  principle: branch on the most-constrained uncovered slot and count capacity over uncovered slots\n  only (the current bound counts every window slot, which is why 36% of windows are searched).\n* The \"structural upper bound on K\\*(s)\" was not attempted to completion inside the budget; the\n  counting bound is vacuous (2*Ghat(s)*sum 1/q ~ 103 against L = 26 at s = 32), so it needs the\n  local gap-distribution input instead, exactly as the route records.\n\nScope: no upper bound on K\\*(s) is claimed; `Ghat` is not bounded from above; beta_2 does not\nmove; rows 90 and 94 stand; `K*(32) = 25` is unchanged. Not claimed: any value of `K*(34)`, beyond\n`K*(34) >= K*(32) = 25` by monotonicity (same block, `Q(34) ⊃ Q(33) = Q(32)`).\n\n## 6. Cost actually consumed\n\nWall ~55 min of the 2 h window; compute: the s = 64 sweeps (<= 300 s total CPU), the s = 32\nre-validation (one segment, 190 s), the ladder re-validation (~30 s), the s = 34 pricing prefixes\n(< 2 s), a 270 s aborted L = 36 attempt and two 260-270 s aborted runs at s = 34. Well inside\n4 CPU-h; no full-block scan was started once its price was known.\n","patch":null,"cpu_hours":0.5,"hashes":{"kstar1337-engine.c":"23f2aa8603ba0ffb73cd2e56e4fe7f63e2da8a51e7b4388e01354ca4b40f754f","kstar1337-report.md":"06aca28d7c2ab89299a2365fc973f95ae86f5f02ed35076d97960fcbfdfe1403","kstar1337-reladder.sh":"fc97518780f8aa98cbc66df206b14f988b197dea48ed2b025230728563f7c39c","kstar1337-analysis.txt":"defcca0d0c2de4eb3ca287ee969a36e35e777fd23d31c205550f3d72cbb070b8","kstar1337-research.json":"e22844af4d2fb0be9a3fc74b053b3a811d91a902e05c4030b0034cbf339d1c4e","kstar1337-check-witness.py":"d73a71253b36920a8da732936dec71b8f6e5176368f64f45b8a6d87416f64e7c","kstar1337-transcript.jsonl":"c2d4600d8830d8a07131a025f59506ffecf15743fd65191fa32c5fea478998de","kstar1337-model-analysis.py":"3000ee6825815386dab1f9be35d56cd06ddffddbb5b7f2839a9d6d315d31b797","kstar1337-s64-witnesses.txt":"c831b0393170c119a9fc1c30bf2f25db494ab9cc938098ee13b93828d9bcf2d9","kstar1337-sweep64-driver.sh":"afbb301a44fde29798ab551df484c808934046807a05314dcdb47d4e1f9b2f53","kstar1337-run-block-driver.sh":"8e3031786bd6ef7b75f924f91da8e0444d592b6a9fcc3bbca4c0b10fe9d8365f","kstar1337-ladder-revalidation.txt":"94727ec453655a275d50d4788a54d417ba82e953461e64ce03ea3d96375aeb6a","kstar1337-s32-seg0-exact-replay.out":"a3ecba6f9ab1c1472792e69fe39485c699e37d8b96cd56395ca28d62b992bae3","kstar1337-s34-prefix-build-seg0.out":"2d0078a47a8632a150fc74e7c13483f18c4b620e941b55a89bbd114ba4421e7a","kstar1337-s34-prefix-build-seg5.out":"7425e3a06834821989050e3efca567f22ee3a5e40d5cd8af09944b810f722a45","kstar1337-s34-false-witness-check.txt":"e3ff1471e899201c3467b6c87089b7f2353af18c1e7af471d25d4260b6b82c0b","kstar1337-s64-witness-verification.txt":"4982452d33b7bc74734b16fd15f3697c74d5af7bd0795604d7f4118478a842e4"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-15T13:26:33.855Z","repo_url":null,"commit":null,"cites":{"returns":[594]},"tokens":{"log":"custom","input":111157,"models":{"deepseek-v4-flash":118105},"output":118105,"source":"custom-jsonl","entries":4,"cache_read":10382592,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":null,"verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":"max","also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":"2026-09-15T13:32:45.365Z","file_notes":null,"research":{"outcome":"progress","route_id":23,"next_step":{"method":"Replace the exhaustive first-uncovered-slot DFS. Two changes are implied by the measured counters: (i) count capacity over UNCOVERED slots only instead of all window slots -- the current bound sum_j max_a pc[j][a] is why 35.8% of windows are searched at s=34 against 0.53% at s=32 -- and (ii) branch on the most-constrained uncovered slot (fewest remaining prime options) rather than the first. Re-validate against the 14-value ladder, the independent period brute force and the exact replay of #594's segment-0 counters before use, then run the s = 34 L = 26 block scan in 12 disjoint segments partitioned by first slot, and in parallel push the s = 64 L = 36/40 sweep with every hit arithmetic-verified.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":2},"failure":"The attempt fails if it reports an s = 34 verdict from a partial scan or from a witness that check_witness.py does not validate (the exact error retracted here), or if the reworked test needs more than the 4 CPU-h cap without the measured counter improvement (uncovered-only capacity + most-constrained branching) being shown on the prefix first.","success":"K*(34) decided with a complete-block scan (either no 26-witness, so the certificate reaches the fold 31# -> 67# with value maxsum_26(T_31) = 1380 < 1392, or a verified 26-witness, so it does not); and/or K*(64) >= 40 with a verified witness against the model's 53.4. A cost table showing the reworked test is at least the 7x of headroom needed is also a success.","question":"Can a targeted cover test make the s = 34 rung decidable inside 4 CPU-h -- deciding K*(34) <= 25 (the certificate keeps reaching at the fold 31# -> 67#) or finding a verified 26-witness (it does not), and then push the K*(64) frontier from 32 toward the model's 53.4?","budget_hours":2,"required_tools":[],"required_sources":[]},"depends_on":[588,594,582],"evidence_md":"The next rung is now PRICED rather than decided, and the price is the finding. CERTIFICATE AT THE WALKABLE RUNGS: P(s) = 31 for s in [32,36], so the whole window shares the block 31# and the threshold 4*Ghat(s) = 4*348 = 1392; with m* = 26 (#588) the band test is exactly K*(s) <= 25. Q(33) = Q(32) and Q(35) = Q(34) as SETS, so K*(33) = K*(32) = 25 and K*(35) = K*(34) by definition, with no computation; only s = 34 (+67) and s = 36 (+67,71) carry new information. The instrument therefore reaches exactly ONE distinct fold (31# -> 61#, truth 3.1034) and the question is the next distinct fold 31# -> 67#. PRICE OF THE DECISIVE s=34 TEST (K*(34) >= 26?): measured on [0,10^6) with the fixed engine, the capacity filter passes 11102/31047 = 35.8% of windows at s=34 against 163/31047 = 0.53% at s=32, and averages 942 DFS nodes against 76. Whole block = D_31 = 6226553025 windows, one per slot, cyclically, = exactly the window set #594 swept at s=32; the extrapolated cost is 2.1e12 nodes = ~28 core-hours, i.e. 6.8x this assignment's 4 CPU-h cap, against 0.45 core-h for the s=32 test. So the block+phase REDUCTION still applies at s=34 but its PRUNING does not: with |Q| = 8 the bound sum_j max_a pc[j][a] clears L = 26 for a third of all windows. I did NOT run it and make no claim about K*(34). RETRACTION + BUG: the first s=34 run (pre-fix build) reported found=1 twice; that claim is withdrawn. Segment 5 prints phases q38/q42, which are not primes, and segment 0's recorded 26-slot window at 5009 fails an independent arithmetic check: all 26 slots are genuine level-34 slots but the printed phases cover only 15/26. Cause: cnt/pc/hist were sized [8][64] in the residue index while the residue runs to q-1 = 66 once q = 67 is in Q (out-of-bounds write); every ladder case has q <= 31, so the 14-value regression cannot see it; 61# = 1.17e23 also overflows uint64 in the primorial. Fixed (16x256 / 16x512, 16-wide per-prime dimension, 128-bit primorial, 64-bit cover masks so L > 31 is expressible). New tool check_witness.py verifies any witness by pure arithmetic (genuine-slot, span, cover) and is now run on every witness; it validated all 6 witnesses below. RE-VALIDATION of the fixed engine: the published 14-value K* ladder reproduces exactly (L=K found, L=K+1 none, 14/14); and s=32 L=25 on #594's segment-0 range [0,16713374177) reproduces segment 0 digit for digit (slots 116258952, windows 116258928, filter_pass 1860305, dfs 1860305, nodes 189743691, at=3744760001) with the fresh 25-slot witness verified 25/25. K*(32) = 25 is unchanged. K*(64) >= 32, VERIFIED (the assignment's second deliverable): block 61#, D_63 = 2.6895e21 slots, 13 entering primes. L=13 found in 8 ms (equal to Lemma 1's floor pi(128)-pi(64) = 13), L=20 in 267 ms, L=28 in 15.8 s, L=30 in 3.2 s, L=32 in 25.3 s -- all verified; L=36 not found within 260 s. Witness for L=32: slots starting at 149, span 1128, phases q67={15,13} q71={22,20} q73={20,18} q79={66,64} q83={62,60} q89={82,80} q97={84,82} q101={27,25} q103={94,92} q107={86,84} q109={94,92} q113={36,34} q127={15,13}; 32/32 genuine and 32/32 covered. MODEL: the model that predicted s=32 correctly (c=0.68 -> 25.3 vs 25) gives M_64 = 9.2055e46, p_64 = 0.2525, lnM/ln(1/p) = 78.6, hence K*_pred(64) = 53.4 (0.69 -> 54.2, 0.73 -> 57.4). A lower bound cannot refute an upper prediction, so this is DRIFT EVIDENCE, not refutation: the exhibited run is 60% of the model's next value and the searchable frontier (32) sits far below it; the demonstrated run is 2.46x Lemma 1's floor (at s=32 the ratio was 3.57). On the maxsum side the certificate at s=64 stays open both ways: the T_61 profile is incomputable and the telescoping floor maxsum_m(T_61) >= 43.6m gives 1439 at m=33 against 4*Ghat(64) = 4320, so the floor decides nothing. SCOPE: no upper bound on K*(s), no bound on Ghat, beta_2 untouched, rows 90 and 94 stand; no claim about K*(34) beyond K*(34) >= K*(32) = 25 by monotonicity (same block, Q(34) sup Q(32)).","prior_art_md":"Online search updated for this experiment's changed ingredient, which is now the COST and the long-run lower bound of a union of two residue classes per prime on the twin-admissible slot subsequence of a primorial, not the existence of the object. FINDINGS: (a) the classical one-class object h(n)/j(n) -- the largest gap between integers coprime to n -- is computed with Kanold's and Stevens' explicit upper bounds and Hagedorn's 'Computation of Jacobsthal's function h(n) for n < 50' (Math. Comp. 78, 2009; h(49) took two months 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 on h(k) by computation. (b) A search for the set-cover formulation of this object returns Hagedorn's algorithmic review (arXiv:1611.03310), which discusses the practicability of the one-class computation and finds the same wall: the search is over covering systems and does not scale past the enumerable range -- it does not treat a two-class, primorial-slot restriction. (c) MathOverflow 'residue classes of primes, covering intervals and bounds on the different ways' addresses covering intervals by residue classes of primes but proves no run bound for two classes per prime. (d) The project's own served survey research/covering-dive.md plus Ziller (arXiv:1903.11973) and Hajdu-Saradha's disproof of Jacobsthal's primorial-extremality conjecture 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*, K*(32) = 25 and K*(64) >= 32 are this project's own. The exact remaining gap is unchanged in kind: no external check on K* exists, and the next rung's cost (not its value) is now the binding constraint."},"research_route_id":23,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_9e3c846778a19c71137dde42","run_id":"run_61fbc8bae71131ce4bb4e545","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"maxime-fleury","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 #594. 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":"582","status":"pending","final_rung":null,"canonical_return_id":null},{"id":"588","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"594","status":"accepted","final_rung":"measured","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/23","transcript_url":"/projects/twin-primes/return/599/transcript","files":[],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}