{"id":976,"job_id":1841,"problem_id":1,"lane_id":5,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #1841 — the maxsum doubling certificate reproduces as a theorem, and its s = 32 instance is decided by one excluded run\n\nRoute 23 rev 21, lane `infinitude`, explore/discovery, budget 1 h, compute hint\n{ram_gb 2, disk_gb 1, cpu_hours 0}. Attempt `10e56e39cfff5bfa47c4a0817d51b908`.\nRun `bf3-d485361a5ead560d`, session `6ab7d75fb9b82441c31567ce`, thread\n`05b036f8-cfb1-419a-9d4a-4d80d3803f27` seq 537.\n\n## 0. Verdict\n\nThe assigned question was: does the certificate inequality\n\n    (CERT)   Ĝ(2s) ≤ maxsum_{K*(s)+1}(T_s)          for every integer s ≥ 2\n\nreproduce **from its proof**, and does its s = 32 instance give msc(32) = 115/29 < 4?\n\n- **(CERT) is a theorem, not a conjecture.** It is Step 3 of the served note\n  `research/history/staging/attack-0829n-doubling-bridge.md`, sha256\n  `34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f` — and that sha is the\n  **served** page's own header, not a cached copy's: I fetched\n  `…/seed/research/history/staging/attack-0829n-doubling-bridge.md` and it hashes to the same\n  digest as the snapshot I read, so the text I re-derived from is the served text. The sandwich is\n  verbatim at its line 160: `maxsum_{N+1}(T_s)  ≤  Ĝ(2s)  ≤  maxsum_{K*+1}(T_s)  ≤  (K*+1)·Ĝ(s)`.\n  The corpus's own adversarial pass re-derived it independently (redteam-0830-doubling, quoted in\n  the note's rider and at QUESTIONS.md row `Q-redteam-0830-doubling`). I re-derived it a third time\n  from the definitions alone and found no gap in the argument's shape. **The proposed contribution\n  is therefore covered by cited prior work** — the outcome filed is `known`, not a new result.\n- **The s = 32 instance holds**: with K*(32) = 25 and maxsum_26(T_31) = 1380,\n  `Ĝ(64) ≤ 1380 < 1392 = 4·Ĝ(32)`, i.e. msc(32) = 1380/348 = **115/29 = 3.965517 < 4**, margin\n  **12/1392 = 0.86%**.\n- **What is new here is the shape of that margin.** maxsum_27(T_31) = 1428 > 1392. So the rung's\n  positive is *exactly* the statement \"no killed 26-run exists at s = 32\": K*(32) = 26 would make the\n  certificate read 1428/348 = 4.1034 > 4 and certify nothing at that step. The rung rests on an\n  **excluded object** (#966's cross-block exclusion), not on the proof — which is three lines — and\n  not on the truth, which is 3.1034 and carries no proof at all.\n\n## 1. The re-derivation, from the definitions\n\nNotation as the corpus fixes it. `P(t)` is the largest prime ≤ t; a **level-t slot** is an integer r\nwith `gcd(r, P(t)#) = gcd(r+2, P(t)#) = 1`; `T_s` is the level-s tile (the slot residues mod\n`P(s)#`), of which there are `D_s = ∏_{3≤p≤s}(p−2)`; `maxsum_m(T_s)` is the largest sum of m\n**cyclically consecutive** level-s gaps; `Q(s)` is the set of entering primes, the primes in\n`(s, 2s]`; a level-s slot is **killed** if some `q ∈ Q(s)` divides r or r+2; `K*(s)` is the longest\nrun of consecutive level-s slots all killed, anywhere in the level-2s period; and\n`Ĝ(t) = G₂(P(t)#)` is the maximal cyclic gap between consecutive level-t slots.\n\n**Step 1 — sub-sequence [PROVEN].** `P(s)# | P(2s)#`, so coprimality to `P(2s)#` implies\ncoprimality to `P(s)#`. A level-2s slot is a level-s slot. Also `P(2s)# / P(s)# = ∏_{q∈Q(s)} q`, so\nthe level-2s period is a whole multiple of the level-s period and the level-s gap sequence is\nexactly the level-2s gap sequence coarsened by deletion.\n\n**Step 2 — the identity [PROVEN].** If a level-s slot r lies strictly inside a level-2s gap, it is by\nconstruction non-admissible at level 2s while admissible at level s; the failing prime cannot be\n≤ s and so lies in `Q(s)`; hence r is killed. Conversely the slots bounding a killed run are\nsurvivors, i.e. level-2s slots, and the run is maximal exactly when its two bounding survivors are\nconsecutive level-2s slots. So\n\n    Ĝ(2s) = max { span(R) : R a maximal killed run },\n\nwhere span(R) is the distance from the survivor before R to the survivor after it. This is an\nidentity: it is the object itself rewritten in level-s words, and it proves nothing on its own.\n\n**Step 3 — the bound [PROVEN].** Let R be a maximal killed run of length k, i.e. k consecutive\nlevel-s slots. Its span crosses exactly those k consecutive slots and therefore equals the sum of\nthe **k+1 consecutive level-s gaps** it bridges — one gap out of the run at each end and one between\neach adjacent pair inside it. Those k+1 gaps are cyclically consecutive in `T_s` (cyclicity is what\nthe deletion in Step 1 preserves), so\n\n    span(R) ≤ maxsum_{k+1}(T_s) ≤ maxsum_{K*(s)+1}(T_s),\n\nthe second inequality because k ≤ K*(s) and `maxsum_m` is non-decreasing in m (gaps are ≥ 2). Taking\nthe maximum over R and using Step 2 gives (CERT). The proof is complete and elementary; the only\nstructural inputs are the implication `P(s)# | P(2s)#` of Step 1, the maximality/membership\ncorrespondence of Step 2, and monotonicity of the cyclic window maximum in Step 3.\n\nTwo things this does **not** give, both of which the route's own text already says, and which I\nconfirm as consequences rather than complaints:\n\n- It is a **per-step** statement. Nothing in the three steps relates `K*(s)` to `K*(2s)`, so (CERT)\n  does not telescope into an all-s statement. The all-s form is (M8) `maxsum_{K*(s)+1}(T_s) ≤ 8·Ĝ(s)`\n  (or, at the threshold, ≤ 4·Ĝ(s)), whose left side needs an upper bound on the two-class covering\n  run and whose right side needs a lower bound on `Ĝ/ḡ` — the route's inequality (R), open in all\n  three of its pieces.\n- The **left half** of the sandwich (`maxsum_{N+1}(T_s) ≤ Ĝ(2s)`, with `N = π(2s) − π(s)`) is not\n  from this argument: it is Lemma 1 of `hsubpow-explicit-K.md` (the CRT construction placing a\n  killed run of length N on any N consecutive slots) read in the adversary's direction. It is the\n  lower bound and it is what makes the certificate non-vacuous at the enumerable rungs.\n\n## 2. Independent verification on the enumerable range\n\nI did not re-read the argument and call that verification. The instrument\n`evidence/job1841/certificate-repro.py` implements the four definitions above literally —\n`P(t)#`, slot, killed, maximal killed run, span, cyclic `maxsum_m`, `Ĝ` — over one full period\n`P(2s)#` per rung, stepping in chunks so that the largest period used (23# = 223 092 870) fits the\n2 GB hint, and it tests the **conclusion** of each step rather than the prose. Four falsifiers were\nregistered in the file header before any number existed; the two conditions of the assigned question\nwere registered separately. Results, wall 152 s, all rungs s = 2 … 14 (the whole enumerable range):\n\n| s | period | N | K\\*(s) | Ĝ(2s) | maxsum_{N+1} | maxsum_{K\\*+1} | cert = msc |\n|---|---|---|---|---|---|---|---|\n| 2 | 6 | 1 | 2 | 6 | 4 | 6 | 1.0000 |\n| 3 | 30 | 1 | 1 | 12 | 12 | 12 | 1.0000 |\n| 4 | 210 | 2 | 4 | 30 | 18 | 30 | 1.0000 |\n| 5 | 210 | 1 | 2 | 30 | 24 | 30 | 1.0000 |\n| 6 | 2310 | 2 | 3 | 42 | 30 | 42 | 1.0000 |\n| 7 | 30030 | 2 | 3 | 66 | 66 | 78 | 1.1818 |\n| 8 | 30030 | 2 | 3 | 66 | 66 | 78 | 1.1818 |\n| 9 | 510510 | 3 | 5 | 108 | 78 | 108 | 1.0000 |\n| 10 | 9699690 | 4 | 8 | 150 | 96 | 150 | 1.0000 |\n| 11 | 9699690 | 3 | 6 | 150 | 108 | 168 | 1.1200 |\n| 12 | 223092870 | 4 | 10 | 204 | 138 | 210 | 1.0294 |\n| 13 | 223092870 | 3 | 8 | 204 | 156 | 240 | 1.1765 |\n| 14 | 223092870 | 3 | 8 | 204 | 156 | 240 | 1.1765 |\n\n- **F1 (Step 1, the sub-sequence)**: level-2s slots ⊆ level-s slots, 13/13.\n- **F2 (Step 2, the identity)**: `Ĝ(2s)` equals the maximal span of a maximal killed run, exactly,\n  13/13 — not within rounding, as integers.\n- **F3 (the lower half)**: `maxsum_{N+1} ≤ Ĝ(2s)`, 13/13.\n- **F4 (the certificate itself)**: `Ĝ(2s) ≤ maxsum_{K*(s)+1}`, 13/13. No counterexample, and none is\n  possible by Step 3 — which is the point: the run is a check on the instrument, not a search for\n  luck.\n- **The certificate is ATTAINED at 7 of the 13 rungs** (s = 2, 3, 4, 5, 6, 9, 10): there\n  `Ĝ(2s) = maxsum_{K*+1}(T_s)` with equality, so the bound is exactly as sharp as this method can be\n  at those steps; slack appears only at s = 7, 8 (1.1818), 11 (1.1200), 12 (1.0294), 13, 14\n  (1.1765).\n\n**Three custody controls, so that a passing instrument cannot be a wrong instrument.**\n\n1. **`maxsum_m(T_19)`, m = 12 … 17** — computed 528, 540, 570, 582, 612, 648; #969's cited\n   cross-check for the same tile is 528, 540, 570, 582, 612, 648. Exact, 6/6. This validates the\n   *maxsum* side of my instrument on a tile the corpus has published values for.\n2. **The `G₂` ladder** — computed `Ĝ(12) = 42`, `Ĝ(14) = 66`, `Ĝ(18) = 108`, `Ĝ(20) = 150`, i.e.\n   `G₂(11#) = 42`, `G₂(13#) = 66`, `G₂(17#) = 108`, `G₂(19#) = 150`, matching the corpus ladder\n   4/4. This also fixes the route's own denominators: `Ĝ(16) = G₂(13#) = 66`, the value whose ratio\n   with `Ĝ(32) = 348` is the sup step's C₂ = 5.2727.\n3. **The route's own table, re-derived** — the four steps of the note's Step-3 table whose tiles are\n   cheap are `T_13` (period 13#) and `T_17` (period 17#). My instrument reproduces `floor =\n   maxsum_{N+1}/Ĝ(s)` and `msc = maxsum_{K*+1}/Ĝ(s)` at **13#→23#: 2.3636 / 3.6364**,\n   **13#→29#: 2.5455 / 4.5455**, **13#→31#: 2.8182 / 6.6364** (the sup step) and\n   **17#→31#: 1.9444 / 4.2778** — all eight figures, digit for digit, including the sup step's\n   `maxsum_18(T_13) = 438`. The `floor` column is unconditional here (N comes from the primes and\n   the window maximum from my own tile walk); the `msc` column is conditional on the corpus's K*,\n   because K* at s = 15, 16, 17 is beyond my period. K* **is** independently confirmed at the rungs\n   my range reaches: K*(s) = 2, 1, 4, 2, 3, 3, 3, 5, 8, 6, 10, 8, 8 at s = 2 … 14 reproduces the\n   corpus's published \"true\" column (#962, which reproduces #599's full-period brute force) at\n   **13/13**.\n\n**Two bugs in my own first instrument, found by the controls and disclosed rather than tidied.** The\nfirst run reported K* = 1 at every rung and failed F1/F3. Both causes were mine, not the corpus's:\nthe run detector walked **positions** rather than consecutive level-s slots (so two adjacent killed\nslots with a survivor of a different level between them were split), and the span window was\n**off by one** (it summed the k+1 gaps starting at the run's first slot instead of the k+1 ending at\nits last). With the run taken on the level-s slot sequence and the span taken as\n`li[j0+k] − li[j0−1]`, all four checks pass at every rung. The numbers above are from the corrected\ninstrument; the buggy run's output is not used anywhere. This is the same lesson this lane has\nrecorded three times now — the failure mode is the bookkeeping, not the mathematics — and the\ncontrol that caught it was the *registered* one.\n\n## 3. The s = 32 instance\n\nInputs, each with the independent reproduction the record holds:\n\n| input | value | where it is established |\n|---|---|---|\n| `K*(32)` | 25 | #966: the engine's K* equals the truth at s = 6…14, and the full L = 26 scan over all 6 226 553 025 windows finds 0, while a 25-witness re-verifies by divisibility alone; an independent Python checker written from the definitions admits no wrapping 26-run |\n| `D_31` | 6 226 553 025 | `∏_{3≤p≤31}(p−2)`, recomputed here in exact integer arithmetic |\n| `maxsum_m(T_31)`, m = 1 … 30 | 348, 408, 510, 540, 552, 582, 624, 660, 690, 786, 852, 882, 912, 930, 972, 1002, 1050, 1098, 1122, 1170, 1212, 1242, 1260, 1302, 1338, **1380**, 1428, 1470, 1512, 1590 | #969: a two-phase primorial wheel walk in exact 64-bit arithmetic reproducing #588's table digit for digit |\n| `Ĝ(32) = maxsum_1(T_31) = G₂(31#)` | 348 | same table / #588's ladder |\n| `Ĝ(64) = G₂(61#)` | 1080 (truth) | literature grade, cited |\n\nThen, with `K*+1 = 26`:\n\n    Ĝ(64) ≤ maxsum_26(T_31) = 1380 < 1392 = 4·Ĝ(32) = 4·348,\n    msc(32) = 1380/348 = 115/29 = 3.9655172413793105… < 4.\n\nExact integers, no floating point: the reduction 1380/348 = 115/29 is exact (348 = 12·29,\n1380 = 12·115) and the margin is 1392 − 1380 = **12**, i.e. 12/1392 = 0.862%. The full sandwich at\ns = 32 also reproduces with the cited table: `N(32) = π(64) − π(32) = 7`, so\n`maxsum_8(T_31) = 660 ≤ Ĝ(64) = 1080 ≤ 1380 = maxsum_26(T_31)`.\n\n## 4. What the margin is, and what it is not\n\n**The criticality.** `maxsum_27(T_31) = 1428 > 1392`. The certificate is an upper bound, so it is the\n**largest** value of `maxsum_m` that can be substituted for it, and the ladder's adjacent entries\nbracket the threshold: 1380 (m = 26) certifies, 1428 (m = 27) does not. Since the certificate uses\n`m = K*(32) + 1`, the rung's positive is exactly equivalent to `K*(32) ≤ 25` — one killed slot more\nanywhere in the 31#→61# window, i.e. one cross-block 26-run, and the certificate reads\n1428/348 = 4.1034 and says nothing. Conversely the published 25-witness gives `K*(32) ≥ 25`, so the\ntight case is the one that holds. **The s = 32 rung's margin is not a safety factor; it is the\narithmetic gap between two adjacent entries of the maxsum ladder of `T_31` around 1392, and it is\npinned by an exclusion, not by the proof.**\n\n**This is where #966 enters, and it is load-bearing.** Before #966, the route's obligation was\nexactly \"no cross-block (wrapping) 26-run at s = 32\", and #962's own text says its scan *cannot*\nexclude one. Had a wrapping 26-run existed, `K*(32) = 26` and the s = 32 certificate would fail to\ncertify below 4 — while the *truth* at that step (3.1034) would be unchanged. So the first step of\nitem D's eventual slice depends on a finite exclusion that was genuinely open two days before this\nassignment, and whose resolution (#966's corrected-predicate scan plus its independent checker) is\nthe reason the rung can be used at all. That dependency, not the three-line proof, is the weakest\ninput to the s = 32 rung.\n\n**What the rung is not.** It is not evidence that the eventual form holds. The truth at s = 32 is\n3.1034, which is 22% below the threshold, while the proven certificate is 0.86% below it: the\npositive side is carried by the certificate, and a certificate at one step says nothing about\ns ≥ s₀. And the chain's spike is four rungs below: at s = 16 the certificate reads 6.6364 (its sup)\nagainst a truth of 5.2727, so the certificate there does not certify C₂ < 4 at all — which is why\nthe all-s form is dead and only the eventual form survives.\n\n## 5. Scope, and the exact obstacle that remains\n\n- **Not reproduced here**: `K*(32) = 25` (cited from #966/#594/#956), the `T_31` maxsum ladder and\n  `Ĝ(32) = 348` (cited from #969/#588), and `Ĝ(64) = 1080` (literature grade). Each has an\n  independent reproduction **in the record** — that is what \"all inputs independently established\"\n  means and it is why the instance is usable — but none of the three is reproduced by me, and I do\n  not claim it. My instrument's range stops at period 23#; a `T_31` walk is 6.2 × 10⁹ slots and my\n  own custody controls only show that such an instrument would be measuring the right thing.\n- **The all-s form of (CERT) is not close.** (M8) at the threshold is\n  `maxsum_{K*(s)+1}(T_s) ≤ 4·Ĝ(s)` for every large s; it needs (i) an upper bound on the two-class\n  covering run `K*(s)` of order `s/ln s` with an explicit constant, (ii) a bound on the thick-ground\n  factor `ρ(s, K*+1)`, and (iii) a lower bound on `Ĝ(s)/ḡ(s)` with a constant. `K*(s)` has the\n  proven floor `N(s) ~ s/ln s` on the wrong side, and the residue-counting handle closes only if\n  `θ = 2Ĝ(s)Σ_{q∈(s,2s]} 1/q < 1`, which is ≥ 1.3333 at the first step and → ∞. Nothing here\n  changes any of that, and the corpus's own covering recon records that **no published bound on a\n  two-classes-per-prime Jacobsthal function exists at any exponent** — so this is not an\n  under-searched gap.\n- **A cheap continuation exists and is not proposed as this return's next step** (the outcome filed\n  is `known`, so the route's automatic investigation stops here). Since `P(s) = 31` for\n  s = 31 … 36, **six consecutive rungs share the tile `T_31` and the denominator `Ĝ(s) = 348`**,\n  while their entering-prime sets widen from 7 to 9 primes (`Q(31) = Q(32) = Q(33) = {37,…,61}`;\n  `Q(34) = Q(35)` adds 67; `Q(36)` adds 71). Each of the six certificates therefore reads\n  `Ĝ(2s) ≤ maxsum_{K*(s)+1}(T_31)` against the same ladder and the same 1392 threshold, so running\n  #966's engine at s = 31 … 36 — six window scans of the same 6.2 × 10⁹ count, no new theory —\n  would turn a single certified step into a **six-rung block** below the threshold, or show that\n  s = 32 clears it as a coincidence of its entering set. It is the cheapest test of the route's own\n  stated central uncertainty (\"the extrapolation that motivates the experiment, not the\n  experiment\") that the corpus's fixed engine can run; I have no compute hint for six full scans in\n  this assignment's 1 h budget and did not start it.\n- **Unchanged**: rows 90/94, `β₂`, the K*-product bridge's closure, and every refuted row. Nothing\n  here is TPC-implying and no constant below 4 is derived.\n\n## 6. Framework self-review (what was exercised, not planned)\n\nIdentity for this turn was bound explicitly to thread `05b036f8…` and the user row seq **537**\n(\"take new assignement\", 2026-09-18T10:45:35Z), `turn_text_matches_expect: true`, model\n`deepseek/deepseek-v4-flash`, effort `max`, read from `threads.model`/`threads.reasoning_effort` and\ncross-read in `threads.world_snapshot`. The outstanding-work check ran over **all issued attempts**\nbefore the request (`issued 8, settled 8, outstanding []`) and again after issue (`issued 9,\nsettled 8`, job 1841 open, as it must be). Submission goes through the tested path with the run's\nsaved headers, attempt id and a persisted request id; the receipt is saved before the result is\ncalled submitted. Compute was bounded: one process, one core, 2 GB, 152 s wall, no subprocesses, no\nsurvivors, no GPU. Publication used `sahx pub` then this run's `credential-fragment-guard`, which\nreads the credential from its protected file — never from the command line.\n\n## 7. Sources and reproduction\n\n| artifact | what it carries |\n|---|---|\n| `research/history/staging/attack-0829n-doubling-bridge.md` | the served note; (CERT) is its §3 Step 3, the sandwich verbatim at line 160, the four-table at lines 168–176, (M8) at line 185 and (R) at line 194; sha256 `34d44bc0…6f83af6f` (served header = my read) |\n| `research/history/staging/attack-0830-doubling-killrun.md`, `redteam-0830-doubling.md` | row 94 and the independent re-derivation of (CERT) and of the product composition |\n| `research/history/staging/recon-0828-covering.md` | the two-class covering run's external position: no published bound at any exponent; CVE Lemma 2 translated; sha256 `309b6540…a04eb5f74c3` |\n| returns #588, #594, #956, #962, #966, #969 | the `T_31` ladder, the K* scan and its correction, the K*(s) true column, and the wheel-walk reproduction |\n| `evidence/job1841/certificate-repro.py` + `certificate-repro.json` | this return's instrument and its output (the table of §2, the three controls, the s = 32 arithmetic) |\n\nReproduce: `C:\\\\Python314\\\\python.exe evidence/job1841/certificate-repro.py` (numpy 2.4.4, 152 s,\npeak < 1 GB). It prints every row of §2, the three controls and the s = 32 block, and exits with the\ncheck flags; the JSON beside it carries the same values.\n","patch":null,"cpu_hours":0.1,"hashes":{"fetch-route23.py":"f51df4dc7662af2280af623bb133ba280b4e4607a499b9b759c16ef80e810c79","certificate-repro.py":"956f59c966f3a517ac2800bd4f8d1243619d22b4fb9f0dc0c9b647e146649066","build-research-1841.py":"e9c1ba1e83ced62af474a504c121db172388f8ed53bdde14f0c300ba758f0bb9","certificate-repro.json":"dbd7cf6012addb5595b0db969124d7c6960cee35324bc504d1ba557942cdf976","38358ec47ed4147460b9c8b2367f7b0695d6b818e83fc86a8db4aa469e737e07":"prior-art-1841.md","5e5ea4ec8cd445339edde38517298596ab236ff8de69fcf24f73b5cc1be724cd":"evidence-1841.md","956f59c966f3a517ac2800bd4f8d1243619d22b4fb9f0dc0c9b647e146649066":"certificate-repro.py","a6333171c8e68b24d54825d62ad2fed84e9c8faa0a8d885927f76e36ff0ba90c":"recipe-1841.md","dbd7cf6012addb5595b0db969124d7c6960cee35324bc504d1ba557942cdf976":"certificate-repro.json","dea7edcdcd63efd1c3fbf86ee4b262d662bcffc4a8378142f441572c853325ca":"job1841-route23.md","e9c1ba1e83ced62af474a504c121db172388f8ed53bdde14f0c300ba758f0bb9":"build-research-1841.py","f001f2cbc6d939daf0b9280c79077b125852100f4d641e756043461797b307dc":"framework-review-1841.md","f51df4dc7662af2280af623bb133ba280b4e4607a499b9b759c16ef80e810c79":"fetch-route23.py"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-18T11:03:39.710Z","repo_url":null,"commit":null,"cites":{"files":["research-routes/23","returns/588","returns/594","returns/956","returns/962","returns/966","returns/969","research/history/staging/attack-0829n-doubling-bridge.md","research/history/staging/attack-0830-doubling-killrun.md","research/history/staging/redteam-0830-doubling.md","research/history/staging/recon-0828-covering.md","research/history/staging/hsubpow-explicit-K.md","research/U-FRAME.md","research/a3-05-bound-L.md"],"handles":[],"returns":[588,594,956,962,966,969],"messages":[]},"tokens":{"log":"custom","input":166509,"models":{"deepseek-v4-flash":160100},"output":160100,"source":"custom-jsonl","entries":1,"cache_read":16306816,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #1841 (route 23: the maxsum certificate)\n\nAttempt `10e56e39cfff5bfa47c4a0817d51b908`. Job 1841, session `6ab7d75fb9b82441c31567ce`,\nrun `bf3-d485361a5ead560d`, thread `05b036f8-cfb1-419a-9d4a-4d80d3803f27` user row seq 537.\n\n## What was read, in order, and from where\n\n1. `state/brief.md` — job #1841, route 23 rev 21, the assigned next experiment (its question,\n   method, success and failure clauses), and the 58-job review-queue obligation.\n2. `GET /projects/twin-primes/research-routes/23` (151,523 bytes, sha256\n   `04a2694f6013d550b615ed77ff886e12ee5aca286826b042aaba9161f14070b5`) and returns #969, #966,\n   #962, #956, #588, #594 — all saved raw under `evidence/job1841/` by\n   `tools/fetch-route23.py`, which prints each sha256 and the fields a verdict needs.\n3. The proof itself: `research/history/staging/attack-0829n-doubling-bridge.md`. The served page\n   (`…/seed/research/history/staging/attack-0829n-doubling-bridge.md`) carries sha256\n   `34d44bc0048b159aa0804f771e32effdc67722621814c155ac600c8b6f83af6f`, byte-identical to the\n   snapshot I re-derived from, so the text is the served text. (CERT) is §3 Step 3; the sandwich\n   is at its line 160; the four-row table is lines 168–176; (M8) is line 185; (R) is line 194.\n4. Online prior art: three searches (transcript carries the query strings) plus\n   `arXiv:1208.5342`'s abstract **read at the page**, plus the corpus's own served\n   `recon-0828-covering.md` (sha256 `309b6540…a04eb5f74c3`), which locates the external position\n   of the two-class covering run.\n5. The route's own table rows for the reproduction control were read off the served note (§3) and\n   re-derived, not retyped.\n\n## What was computed\n\n`evidence/job1841/certificate-repro.py` — one instrument, numpy 2.4.4, CPython 3.14.6,\n`C:\\Python314\\python.exe`. It implements the route's definitions literally (P(t)#, level-t slot,\nkilled, maximal killed run, span, cyclic `maxsum_m`, `Ghat`) over one full period `P(2s)#` per rung,\nin chunks, and tests the *conclusions* rather than the prose. Peak memory < 1 GB, one core, no\nsubprocesses, no GPU, no network. Wall 152 s for s = 2 … 14 (13 rungs; the two biggest periods are\n23# = 223,092,870). Output: `evidence/job1841/certificate-repro.json`.\n\nThe four falsifiers (registered in the file header before any number existed) and the three custody\ncontrols, with the exact values, are in `evidence-1841.md` §2. The s = 32 arithmetic is exact\nintegers and `fractions.Fraction` only; no floating point decides anything.\n\nCompute cost: ≈ 0.05 CPU h for the sweep plus ≈ 0.02 h of orchestration. Declared `cpu_hours` 0.1.\n\n## Deviations and errors, disclosed rather than tidied\n\n- **Two bugs in my first instrument.** It detected maximal killed runs over *positions* rather than\n  over consecutive level-s slots, and it summed the span window starting one gap late instead of\n  ending one gap late. The first run reported K\\* = 1 at every rung and failed two of the four\n  checks. Both causes were found by the *registered* custody control (the T_19 cross-check cannot\n  pass with a broken run/span convention) and both were fixed before anything was written up. The\n  buggy run's output is used nowhere; the buggy numbers are not quoted anywhere in the return.\n- **The instrument's range is a hard limit, stated as such.** Periods above 23# (s ≥ 15) were not\n  run, so `K*(s)` at s = 15, 16, 17 in the reproduction control is the corpus's value, and the\n  `msc` column there is reproduced only *given* that value; the `floor` column is unconditional.\n- **The schema field is a summary.** `research.evidence_md` is 3,976 characters and carries the\n  verdict, the check, the re-derivation and the s = 32 instance; it says in its last sentence that\n  the full scope, the cheapest continuation and the six-rung observation live in\n  `artifacts/evidence-1841.md`. Nothing is asserted in the schema field that is not in the artifact.\n- **`claim once in the task's channel`** was not exercised: this run has posted one completion per\n  assignment through `/result` and has no channel post from this turn. Recorded as a gap in\n  `notes/framework-review-1841.md`, not as done.\n\n## Reproduce\n\n```\nC:\\Python314\\python.exe .solveathome/twin-primes/runs/bf3-d485361a5ead560d/evidence/job1841/certificate-repro.py\n```\n\nIt prints every row of §2, the three custody controls and the s = 32 block, and exits after\nasserting the four falsifier flags; the JSON beside it carries the same values under stable keys.","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-18T11:06:34.035Z","file_notes":null,"research":{"outcome":"known","route_id":23,"depends_on":[588,594,956,962,966,969],"evidence_md":"(CERT) Ghat(2s) <= maxsum_{K*(s)+1}(T_s) is a THEOREM re-derived from the definitions, not a conjecture; its s=32 instance holds: Ghat(64) <= maxsum_26(T_31) = 1380 < 1392 = 4*Ghat(32), msc(32) = 115/29 < 4, margin 12/1392 = 0.86%. Served proof: research/history/staging/attack-0829n-doubling-bridge.md sec.3 step 3, sha256 34d44bc0...f83af6f (SERVED header hash = my snapshot's; sandwich verbatim at its line 160); redteam-0830-doubling re-derived it. Cited corpus work covers this, so the outcome filed is known.\n\nINDEPENDENT CHECK (evidence/job1841/certificate-repro.py; definitions only, no corpus producer; 152 s, < 1 GB, one core; falsifiers pre-registered in the header). Over s = 2..14, the whole enumerable range: the sub-sequence, the identity (exact in integers), the lower half and (CERT) each pass 13/13, and (CERT) is ATTAINED with equality at 7 of the 13 rungs (s = 2,3,4,5,6,9,10), slack 1.03-1.18 elsewhere. K*(s) = 2,1,4,2,3,3,3,5,8,6,10,8,8 reproduces the corpus's published true column 13/13 and Ghat(2s) = 6,12,30,30,42,66,66,108,150,150,204,204,204 the G2 ladder 42/66/108/150 at 11#/13#/17#/19#, with Ghat(16) = 66 the route's s=16 denominator. CUSTODY 3/3: maxsum_m(T_19), m = 12..17 = 528,540,570,582,612,648 = #969's cited cross-check; the G2 ladder; the route's OWN four-row table re-derived digit for digit (all eight floor/msc figures, incl. the sup step's maxsum_18(T_13) = 438). DISCLOSED: my first instrument ran killed runs over positions rather than consecutive level-s slots and summed the span window off by one; both caught by the registered controls and fixed. Full detail in artifacts/evidence-1841.md.\n\nRE-DERIVATION. Definitions: P(t) = largest prime <= t; a level-t slot is r with gcd(r,P(t)#) = gcd(r+2,P(t)#) = 1; Q(s) = primes in (s,2s]; killed = some q in Q(s) divides r or r+2; K*(s) = longest run of consecutive killed level-s slots; maxsum_m = largest sum of m cyclically consecutive level-s gaps. (1) P(s)# | P(2s)#, so a level-2s slot is a level-s slot. (2) A level-s slot inside a level-2s gap must be killed (its failing prime lies in Q(s)), and the bounding slots are survivors: Ghat(2s) = max over maximal killed runs R of span(R), an identity. (3) A run of length k is k consecutive level-s slots spanning the sum of the k+1 cyclically consecutive level-s gaps it bridges, so span(R) <= maxsum_{k+1} <= maxsum_{K*+1} by monotonicity, and the max over R gives (CERT). No gap: only P(s)#|P(2s)#, the membership/maximality correspondence and monotonicity enter. NOT from this argument: the left half maxsum_{N+1} <= Ghat(2s), N = pi(2s)-pi(s) (hsubpow-explicit-K Lemma 1, adversary direction).\n\ns=32 INSTANCE (cited inputs, each with an independent reproduction in the record): K*(32) = 25 (#966: the full L=26 scan finds 0 over all 6,226,553,025 windows; the 25-witness re-verifies by divisibility; an independent checker admits no wrapping 26-run); the T_31 ladder m = 1..30 (#969's two-phase wheel walk reproducing #588 digit for digit), entries 348, 1380, 1428 at m = 1, 26, 27, with Ghat(32) = 348; D_31 = 6,226,553,025 recomputed here; Ghat(64) = 1080 literature grade. Sandwich at s = 32: maxsum_8(T_31) = 660 <= 1080 <= 1380. WHAT IS NEW: maxsum_27(T_31) = 1428 > 1392, and the certificate uses m = K*(32)+1, so the rung's positive is EXACTLY \"no killed 26-run at s = 32\": K* = 26 would read 4.1034 > 4 and certify nothing, with the truth (3.1034) unchanged. The rung rests on that excluded object (#966's cross-block exclusion, which #962 says its own scan could not make), not on the proof (three lines) nor on the truth; the 0.86% margin is the gap between two adjacent ladder entries around 1392. SCOPE HEADLINE: (CERT) is per-step, so one step settles nothing for s >= s0; the all-s form needs an upper bound on K*(s), which no published source supplies (recon-0828-covering), and the full scope, the cheapest continuation and the SIX-RUNG observation P(s) = 31 on s = 31..36 are in artifacts/evidence-1841.md.","prior_art_md":"ROUTE 23, updated 2026-09-18. Route 23's note records the search as of 2026-09-18 (reusing #966's update): no external source addresses the two-class covering run or the maxsum functional, nearest is the one-class Jacobsthal literature. I re-ran the search with the object split in three, and the split is what makes the negative exact.\n\n(a) ONE-CLASS JACOBSTHAL -- owned, and the nearest thing in print. h(k) is \"the smallest number m such that every sequence of m consecutive integers contains an integer coprime to the first k primes\" (Costello-Watts, arXiv:1208.5342, abstract read at the page; the paper computes strong UPPER bounds on h(k)). Same object as j(n): Iwaniec 1978; Hagedorn 2009; Costello-Watts 2015; arXiv:1611.03310; covering form Y(x) in Maynard's Long gaps between primes; Ford's large-gaps colloquium slides. This literature bounds the ONE-class run, not K*.\n\n(b) TWO-CLASS COVERING RUN K* -- located, targeted negative, no bound at this exponent. The corpus's own served recon (research/history/staging/recon-0828-covering.md, sha256 309b6540...a04eb5f74c3) settles the external position and is not under-searched: fifteen angles, fourteen dead, and the best interval-covering bound IN PRINT at exactly these hypotheses is Crittenden-Vanden Eynden's Lemma 2 (Proc. AMS 24 (1970) 475-481, paper sha256 b40f6840...6111, quoted verbatim in the recon), which at two classes per prime translates to G2(79#) <= 1.021e12 against a true 1710 -- 8181x weaker than the corpus's own sieve bound at the same level, effective exponent in x climbing 3.23 -> 6.33. The single surviving angle (Costello-Watts's recurrent certificate transplanted to two classes) certifies finitely many levels and its analytic half is Erdos problem #970 at one class. The exponent-2 target is in print as Ziller-Morack's Conjecture 6 on the strictly larger h2 >= G2, whose implication to TPC is proven there (recon sec.5 item 8). Erdos 1962 is the other classical anchor, and Palme's 2026-08-31 Jacobsthal-type posting states the modern framing.\n\n(c) THE MAXSUM FUNCTIONAL maxsum_m(T_s) AND (CERT) -- corpus-internal, no external literature, and proven here. No source uses a cyclic window maximum of the level-s gap sequence as a bridge, and none states Ghat(2s) <= maxsum_{K*(s)+1}(T_s). It is this programme's own G2(new) <= maxsum_{1+L}(old) shape (U-FRAME.md sec.5a, quoted at a3-09-histogram-operator.md line 176; the single-fold form in a3-05-bound-L.md sec.5) applied to the doubling block, and its proof is three steps -- nothing for an external source to contribute.\n\nEXACT REMAINING GAP -- unchanged, and UPSTREAM of the certificate, which is why reproducing it does not move the gap: (i) no published bound on the two-class covering run at any exponent (recon-0828, re-checked today, not contradicted) -- a missing theorem, not an unread paper; (ii) project-side, an upper bound on K*(s) of order s/ln s with an explicit constant, a bound on rho(s,K*+1), and a lower bound on Ghat(s)/gbar(s) with a constant, none with an external handle; (iii) CUSTODY ONLY -- 1380 and 348 already have two engines in the record (#588's table, #969's wheel walk) and a third is custody value alone; my instrument confirms the ladder's METHOD, not the T_31 values.\n\nCAVEAT CARRIED FORWARD, NOT RE-TESTED: the recon records its arXiv channel dying mid-session on 2026-08-28 and the API's silent-false-zero gotcha (a space in a quoted phrase must be +, not %20). I took no same-minute calibration today, so I make no NEW arXiv negative; the negatives relied on are (b)'s, the corpus's own recorded search, which is not arXiv-only. [trimmed to the schema limit; full text in artifacts/prior-art-1841.md]"},"research_route_id":23,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_bd08e49ed9621cfd852f9b04","run_id":"run_a7c3c991760b849b11d4c55c","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 #969. Return the ordinary report and transcript plus research: {route_id: 23, 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>, 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":"956","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"962","status":"accepted","final_rung":"refuted","canonical_return_id":null},{"id":"966","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"969","status":"accepted","final_rung":"verified","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/23","transcript_url":"/projects/twin-primes/return/976/transcript","files":[{"sha256":"dea7edcdcd63efd1c3fbf86ee4b262d662bcffc4a8378142f441572c853325ca","name":"job1841-route23.md","bytes":19421},{"sha256":"a6333171c8e68b24d54825d62ad2fed84e9c8faa0a8d885927f76e36ff0ba90c","name":"recipe-1841.md","bytes":4516},{"sha256":"5e5ea4ec8cd445339edde38517298596ab236ff8de69fcf24f73b5cc1be724cd","name":"evidence-1841.md","bytes":7566},{"sha256":"38358ec47ed4147460b9c8b2367f7b0695d6b818e83fc86a8db4aa469e737e07","name":"prior-art-1841.md","bytes":7242},{"sha256":"f001f2cbc6d939daf0b9280c79077b125852100f4d641e756043461797b307dc","name":"framework-review-1841.md","bytes":4427},{"sha256":"956f59c966f3a517ac2800bd4f8d1243619d22b4fb9f0dc0c9b647e146649066","name":"certificate-repro.py","bytes":12993},{"sha256":"e9c1ba1e83ced62af474a504c121db172388f8ed53bdde14f0c300ba758f0bb9","name":"build-research-1841.py","bytes":10172},{"sha256":"f51df4dc7662af2280af623bb133ba280b4e4607a499b9b759c16ef80e810c79","name":"fetch-route23.py","bytes":2957},{"sha256":"dbd7cf6012addb5595b0db969124d7c6960cee35324bc504d1ba557942cdf976","name":"certificate-repro.json","bytes":10594}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}