{"id":5305,"job_id":10467,"problem_id":1,"lane_id":32,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Two-sided at 59#: CERT closes the ceiling, and the axis quotient does not carry to CERT\n\n**Job #10467** (`explore`, stage `first_look`, lane `dir-558`, **general mode**, research route **349**,\nassignment 1 of 1, attempt `7de0d1…`). Rung: **measured** for the certificates (exact-integer covering\nsearch over the complete slot domain, kernel validated against a brute-force enumeration), **measured**\nfor the 47#/53# control, **proven** for §5's obstruction (two lines, plus the slot-level demonstration).\n\n## 1. Result\n\n**The ceilings at 59# and 61# are now measured on both sides.** Complete covering searches over the\ntwin-admissible slots modulo `19#` return **no covered run longer than the ceiling** at either rung:\n\n```\nCERT_966(59#)  = 0 over all 378,675 slots  =>  G2(59#)  <= 966\nCERT_1080(61#) = 0 over all 378,675 slots  =>  G2(61#) <= 1080\n```\n\nTogether with #5158's counts `m(59#) = 8 > 0` and `m(61#) = 4 > 0` (a run of exactly that length\nexists) this gives\n\n```\nG2(59#) = 966  and  G2(61#) = 1080    (attained and bounded above; previously cited from OEIS A144311)\n```\n\n`47#` and `53#` replicate the upper bounds already certified by #2061/#2197 (`CERT_708 = 0`,\n`CERT_870 = 0`), and their positive controls reproduce the published ceiling multiplicities `m = 4` and\n`m = 2` **from the certifying side** (see §3). **67# was not certified here** (§6 prices it).\n\n**The route's method claim fails, and the assignment's own stop condition fires.** Route 349 proposed to\ncertify these ceilings at *half* cost with the axis quotient `mu(n) = -n-2` (#5276 §3, correcting #5158 §6).\nThe 47#/53# control required by the assignment **disagrees with the full domain at both rungs, on the\npositive control**: at 47# the full scan counts the four ceiling runs (`CERT_702 = 4`) and the quotient\ncounts **0**; at 53# full counts **2** and the quotient counts **0** (§4). So `#5158 §6` stands, `#5276 §3`\nis wrong, and every ceiling certificate stays priced at the un-quotiented full-domain cost. §5 gives the\nreason in two lines and shows it is not a bug in the scan.\n\n## 2. The instrument: what `CERT_G` is\n\nNotation as in #5139/#5158: `x#` the primorial, a residue `n` **twin-admissible** when\n`gcd(n(n+2), x#) = 1`, `Z_x` the admissible residues mod `x#`, a **gap** the distance between consecutive\nelements of `Z_x`, and `G2(x#)` the largest gap. `S = Z_19` has `|S| = prod_{5<=p<=19}(p-2) = 378,675`;\nfixing `n mod 19#` leaves one free residue class `m_q` per prime `19 < q <= x`, and every `n mod x#` is\nsuch a choice.\n\nFor a slot `r` and a length `G`, let\n\n```\nCERT_G(x#) = sum over r in S, over all class choices m_q, of\n             1[ n is admissible  and  every integer in (n, n+G] is non-admissible ].\n```\n\n**Equivalence.** `CERT_G = 0` iff no admissible `n` has all of `(n, n+G]` non-admissible, i.e. iff every\nadmissible `n` has its next admissible point at distance at most `G`, i.e. iff `G2(x#) <= G`. Conversely,\nif `J(n) > G` for some admissible `n` then the class choice belonging to that `n` is counted, so\n`CERT_G >= 1`. Each admissible `n` contributes exactly one system, so `CERT_G` is literally **the number\nof residues `n mod x#` whose gap exceeds `G`**, and running it at `G-6` recovers the ceiling multiplicity\n`m` exactly. That last identity is what makes the positive controls below possible: `CERT_{G-6} = m`\nmeasures `m` with an instrument independent of the counting code of #5158.\n\nThe kernel is the container's pinned census engine, **bytes unchanged**\n(`engine_cd.py`, sha256 `fb65b5f22bd17aa4005a9bfba938aa5270ff3fe0392e9d4933834fcc8cd9495b` = #5090's\n`engine_ei.py`); `cert_cd.py` only adds the slot domain, the resume-safe block layout and the parallelism.\nCounts are exact integers; no float enters a verdict.\n\n## 3. Validation, and the positive controls\n\n**(a) Independent enumeration at 23#.** The largest rung whose whole period fits here is `23# =\n223,092,870`. A plain flag array (no slots, no DFS, share nothing with the engine) gives\n`|Z_23| = 7,952,175 = prod_{5<=p<=23}(p-2)`, every gap a multiple of 6, `sum of gaps = 23#`,\n**`Gmax = 204`** and **`m = 4`** at `n = 76,166,567 / 108,991,247 / 114,101,417 / 146,926,097`\n(`brute_cd.py`, `brute_cd.json`). The covering kernel on the same rung returns\n`CERT_198(23#) = 4` at exactly the four residues `{76166567, 108991247, 114101417, 146926097} mod 19#`\nand `CERT_204(23#) = 0`. So the kernel counts the right objects, at the right length, with the right\nmultiplicity — end to end, against a different method.\n\n**(b) Cross-instrument agreement with the record at 47# and 53#.** `CERT_{G-6}` recovers `m` and the\nattaining slots mod `19#`:\n\n| rung | `CERT_{G-6}` | slots mod 19# (systems) | `m` (#5158) | published attaining slot |\n|---|---|---|---|---|\n| 47# | `CERT_702 = 4` | 1531841 (2), 8167139 (2) | 4 | 1531841 (#2061, #5158 §4) |\n| 53# | `CERT_864 = 2` | 1984889 (1), 7713929 (1) | 2 | 1984889 (#2197, #5158 §4) |\n| 59# | `CERT_960 = 8` | 3259691 (4), 6439031 (4) | 8 | 3259691 (#5158 §4) |\n| 23# | `CERT_198 = 4` | four slots, 1 each | 4 | — (brute force, §3a) |\n\nThe two slots at each rung are the `T_19` mirror pair of the record (e.g. `1531841 + 8167139 = 9699484 =\n19# - 206`, and `psi_966(3259691) = 6439031`), and the system counts reproduce `m` exactly. So #5158's\n`m(59#) = 8` — a single-instrument number as of that return (§8 item 2) — now has a second, independent\nmeasurement, and the two agree.\n\n## 4. The control the assignment asks for: half domain versus full domain\n\nRoute 349's stop condition: *if the half-domain `CERT` and the full-domain `CERT` disagree at 47# and 53#,\nthe quotient is invalid at `CERT` scale.* Both modes were run over the same slots, same engine, same\nlengths (`halfq` = one slot per `psi_G(r) = -r-G-2` pair, restricted to\n`S' = {r in S : r+G in S}`, exactly the correction #5158 introduced for `COUNT`).\n\n| rung | length | full domain | half domain (`halfq`) | slots scanned (full / half) |\n|---|---|---|---|---|\n| 47# | 708 (`= G`) | **0** | **0** | 378,675 / 36,855 |\n| 47# | 702 (`= G-6`) | **4** | **0** | 378,675 / 68,640 |\n| 53# | 870 (`= G`) | **0** | **0** | 378,675 / 73,710 |\n| 53# | 864 (`= G-6`) | **2** | **0** | 378,675 / 18,428 |\n\nThe two modes agree at the ceiling length — trivially, because both are zero there — and **disagree\ncompletely at the positive-control length**: the quotient loses every ceiling run the full scan finds, at\nboth control rungs. A control that ran only at `G` would have \"passed\" while the method was already\nbroken; the `G-6` length is what makes the control informative.\n\nA third mode, `halfall` (pairing over all of `S` without the `S'` correction), does not even exist: the\ndriver refuses with `mirror image 9698957 of slot 29 is not in the domain` at 47# (and `9698951` at\n`708`). `psi_G(r) = mu(r+G)`, and `r+G` is not admissible in general, so the pairing is **defined only on\n`S'`**. #5158's `S'` correction is not a convenience; it is forced.\n\n## 5. Why the quotient cannot carry to `CERT`\n\n`mu(n) = -n-2` maps a gap of length `J` starting at `n` to a gap of the same length `J` **ending** at\n`mu(n)`: the endpoint pair `(n, n+J)` maps to `(-n-J-2, -n-2)`, both endpoints admissible and every\ninterior point admissible-preserved, so gap starts of length `J` are permuted by `psi_J(r) = -r-J-2`.\nThat is why a **fixed-length** scan pairs: `COUNT_J` counts objects of one length `J`, so `COUNT_J` can\nbe summed over half the `psi_J` pairs, and #5158 §4 did exactly that.\n\n`CERT_G` is not a fixed-length object: it counts gaps of **every** length `J > G` at once. Take a gap of\nlength `J > G` at `n`, and ask what the partner slot `psi_G(n)` says about it. The window there is\n`(psi_G(n), psi_G(n)+G]`, whose far endpoint is\n\n```\npsi_G(n) + G = -n - G - 2 + G = -n - 2 = mu(n),\n```\n\nwhich is **admissible** (`mu` preserves `Z_x`). A covered run longer than `G` must have its far endpoint\nnon-admissible, so `CERT_G(psi_G(n)) = 0` **necessarily** — the partner can never carry the evidence, for\nany `G` and any rung. The half scan therefore answers \"does a long run *start* at the slots I kept?\" and\nsilently never asks the question for the slots it dropped. The reflection of a run is a run ending at\n`mu(n)`, and a run that ends somewhere is not a run that starts there.\n\nThe slot data show the two regimes side by side: at 23# the four `CERT_198` hits pair up **under\n`psi_204`** (`1430747 <-> 8268737`, `2294657 <-> 7404827`) and not under `psi_198`\n(`psi_198(1430747) = 8268743`, which is not a hit). Pairing lives at the run's own length, which is what\n`COUNT` exploits and `CERT` cannot.\n\n## 6. Cost (measured) and what is still uncertified\n\nAll times measured on this container, 16 worker processes, exact-integer counts (wall clock; the block\ntail dominates, so these are end-to-end prices, not per-core sums):\n\n| rung | full-domain `CERT_G` | full-domain `CERT_{G-6}` | quotient `CERT_G` |\n|---|---|---|---|\n| 47# | 263 s | 334 s | 13 s (36,855 slots) |\n| 53# | 161 s | 170 s | 31 s (73,710 slots) |\n| 59# | **169 s** | 339 s | not run |\n| 61# | **2,094 s** | not run | not run |\n\n**Still uncertified: 67#.** The measured DFS-node counts per fixed slot sample scale\n`59# : 61# : 67# = 1 : 3.4 : 58`. That ratio **under-predicted the 61# run by a factor 3.6** (projected\n574 s, measured 2,094 s), so the `67#` certificate is priced from the corrected model at about **9-10\nwall hours on 16 workers (order 10^2 CPU-hours)** — reachable in principle, not in this session's slot\n(`next_step_cd.json` states the requirement). The quotient would have made it cheap; §5 is why it cannot\nbe used.\n\n## 7. What this changes, and what it does not\n\n- The ladder's `G` column is no longer cited at `59#` or `61#`: both are attained (#5158) **and** bounded\n  above (here). With `37#/41#` (#5110) and `47#/53#` (#2061, #2197) that is **7 of 13 rungs** two-sided;\n  `67#` remains cited, and it is now the only rung in the ladder with no upper-side measurement here or on\n  the record.\n- `m(59#) = 8` is now a two-instrument number (§3b), which is what #5158 §8 item 2 asked for at a rung\n  where it was single-instrument. The orbit count `k = m/2` of #5158 §4 / #5276 §1 is unaffected.\n- The **method** result is negative and it is the reusable part: the axis quotient is valid for\n  fixed-length counting and invalid for ceiling certification, for the structural reason in §5, and the\n  control that detects this must include a length below `G`.\n- Nothing here moves an exponent or bears on infinitude: this constrains the lane's ceiling object only.\n- **Not discharged:** `67#`; the `61#` positive control at `G-6` (the `59#`, `47#`, `53#` and `23#`\n  controls are in §3); and `m` remains measured from one model family, though by two instruments.\n\n## 8. Notes for the record\n\n5 of @Benjaminsen's returns wait for a verdict; nothing for the person to do. No credential was read,\nprinted or written by any script here.\n","patch":null,"cpu_hours":2.55,"hashes":{"cert_cda.py":"3c4712f854fc662a00d2bdcd6a23e670998b90f386115bf990f85e98c105c48b","brute_cda.py":"53c315b35fb9565fdc527fe74e163c79c74453399071f46f1afca8035ec76c76","check_cda.py":"65f44fef9cde0dba54ca2ed61b4773e6c8b5c5d1fa203d59e8ade5e1f6e6bcb8","check_cda.out":"4dc3ba00a5ff166341e9fa71e558c1d3dbf80e429756797619d7010bea3800ea","engine_cda.py":"fb65b5f22bd17aa4005a9bfba938aa5270ff3fe0392e9d4933834fcc8cd9495b","recipe_cda.md":"f8bb4ce17da4ad8d2370cb51e301317abc9c8dc22935752f8c5abc7ecdafb339","report_cda.md":"8017e39f723e428b242ed5174a07336a3b6269b95e48c76a82fa4b7f86675b82","brute_cda.json":"67603ff3088d3c8099f6ca62f0e2b75533815b7cb26df769d01b696396339cf8","evidence_cda.md":"22587fbfaed50b9172e98b3f87798ad86666fa3aac6e72de60e90940165a4163","prior_art_cda.md":"1262f2689bd792a8fccd280d4dc227d0ff3d8c06b17fa642fd5de0b842192561","next_step_cda.json":"37936e55ab97874e2acab644c2ac1f4434f9cd3be5acd92699f855c20ddde02e","transcript_cda.clean.md":"01c775cca6088220ac82c1b523ab025ca589257d44fc380327109393cd206322","cert_cda_23_198_full.json":"af237e90dc3f4608892a1edc4ebf3553c92ec93bcbe55dfa2def7ac6de6e0623","cert_cda_23_204_full.json":"ce675b007b1e39a523c4e0312e895cd8e5d3183179b6bebdd69a153302288198","cert_cda_47_702_full.json":"8a7816c337fa39490db1e0a21fd373cf18140121672f20662c76716986dcc840","cert_cda_47_708_full.json":"04988c07338f6ff47d38519e5ae1cbe056c0890c6bde6b6294d27783e08cc550","cert_cda_53_864_full.json":"5f3367ecb873c777743d3385b248e485be969f38d1babcda41e7ca0b7671c728","cert_cda_53_870_full.json":"5725cd3ac9ec777c949185b2d0588980b9be207cd8e5b4c6f1809b7427db31ce","cert_cda_59_960_full.json":"159c66c1c79bb1ff569de4e8791689e2a422dde9a07288d494292c79feaca89f","cert_cda_59_966_full.json":"297d902303eb2c0fc1b1abecc986e7450bed355290f7e233ace7477aeca78ca8","cert_cda_47_702_halfq.json":"57965025c0e811a4f358fd088bf23799c246f70dccab4f97c41d481c0bdb8a47","cert_cda_47_708_halfq.json":"32fa69fcc376aa324896f4d3ee9bda4d3f2a2121b05d8c1db7ea116ef5aedeb2","cert_cda_53_864_halfq.json":"f7c665de532600f6b37a8458097add3150e3995fe98e6255d99d5b6d5e283f0e","cert_cda_53_870_halfq.json":"25be0c80e26a70abcea2127e810d784c7e34f307df3d5f920ba96b2e9419b0d1","cert_cda_61_1080_full.json":"5bbc66570f7f58eb5199ab29e0854eed2de3389e51b2d6188fb68359da12815e"},"author_rung":"measured","status":"pending","final_rung":null,"created_at":"2026-10-21T18:35:05.826Z","repo_url":null,"commit":null,"cites":{"files":[],"handles":[],"returns":[5158,5276,5139,2061,2197,5110,5120,5090],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"codebuff/freebuff CLI keeps no per-turn token record for this session: chat-meta.json and run-state.json expose no usage block, and reasoning-token counts would not identify usage. sah-tool/1.0.15 has","cache_write":0,"observed_models":[]},"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":null,"also_fix":null,"transcript_omitted":null,"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":"2026-10-21T18:36:01.781Z","file_notes":[{"sha":"fb65b5f22bd17aa4005a9bfba938aa5270ff3fe0392e9d4933834fcc8cd9495b","name":"engine_ei.py","notes":["prints what looks like progress or timing to stdout on line 261 (\"\"elapsed_s\": round(time.time() - t0, 2)}))\"), inside the statement that starts on line 259: stdout is the artifact and must reproduce byte for byte elsewhere; send progress, timing and rates to stderr. This one is a guess from the text, not a measurement: if the output is already identical from run to run, say so in your return and leave the file alone."]}],"research":{"outcome":"result","route_id":349,"next_step":{"method":"Run CERT at the ceiling length itself (G = 1284 at 67#) over the COMPLETE slot domain S = Z_19 (378675 slots, one residue class per prime 19 < q <= x, exact integer counts) with the unchanged census engine (engine_ei.py sha256 fb65b5f2...) and the cert_cd.py driver of this return. Do NOT use the axis quotient: this return measures it dropping every ceiling run (47#: full 4, half 0; 53#: full 2, half 0) because psi_G(r)+G = mu(r) is admissible, so the partner slot can never carry a run longer than G. Include the positive control CERT_1278(67#) = 2 in the same run, and add CERT_1074(61#) = 4 for 61#, so that no zero is vacuous. Price from the corrected node model of this return (61#: projected 574 s, measured 2094 s, i.e. correct the node ratio by about 3.6x). Compute as declared: the corrected model puts the run at about 10 wall hours on 16 workers (above this field's 32 CPU-hour cap, which is why it is set to the maximum); the block files make the scan resumable, so it can be split across machines or sessions without redoing finished blocks.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":32},"failure":"CERT_1284(67#) > 0 at any slot: the A144311 row is wrong at 67# and the ladder's G column must be repaired (report the slot and the reconstructed run start); or CERT_1278(67#) != 2, which invalidates the kernel at that rung; or the run cannot be completed within its compute requirement, which then becomes a capability shortfall rather than a result.","success":"CERT_1284(67#) = 0 over all 378675 slots with CERT_1278(67#) = 2 at the published mirror pair (m(67#) = 2, attaining slot 3941657, #5158 section 4) and, at 61#, CERT_1074(61#) = 4; then G2(67#) = 1284 is measured on both sides and the ladder is closed at 12 of 13 rungs (only 17-43# remain on the cited side).","question":"Is G2(67#) = 1284 (does no covered run of length > 1284 exist at x = 67), closing the last rung of the ceiling ladder on both sides, and can the 61# positive control CERT_1074 = 4 be added so that every certificate in this lane carries one?","budget_hours":4,"required_tools":["python3","numpy"],"required_sources":[]},"depends_on":[5158,5276,5139,2061,2197,5110,5120,5090],"evidence_md":"Every number below is re-derived from the attached artifacts by `check_cd.py` (no hand-typed result);\n`check_cd.out` is its run.\n\n**1. Kernel semantics, validated against a different method (`brute_cd.py`).** At `23#` a plain flag\narray over the whole period (`|Z_23| = 7,952,175 = prod_{5<=p<=23}(p-2)`, every gap a multiple of 6,\ngaps summing to `23#`) gives `Gmax = 204`, `m = 4`, starts\n`76166567 / 108991247 / 114101417 / 146926097`. The covering kernel on the same rung returns\n`CERT_198 = 4` at exactly those four residues mod `19#` and `CERT_204 = 0`.\n\n**2. `CERT_{G-6} = m`, cross-instrument (`cert_*_full.json`).** `47#`: `CERT_702 = 4` at slots\n`1531841` (2 systems) and `8167139` (2) — the published `T_19` mirror pair, `m(47#) = 4` (#2061,\n#5158 §4). `53#`: `CERT_864 = 2` at `1984889` and `7713929` — `m(53#) = 2` (#2197). `59#`:\n`CERT_960 = 8` at `3259691` (4) and `6439031 = psi_966(3259691)` (4) — reproduces #5158's\n`m(59#) = 8` and its attaining slot `3259691` with a second, independent instrument.\n\n**3. The certificates (`cert_59_966_full.json`, `cert_61_1080_full.json`, `cert_47_708_full.json`,\n`cert_53_870_full.json`).** `CERT_G = 0` over all `378,675` slots at `47#/G=708`, `53#/G=870`,\n`59#/G=966` and `61#/G=1080`; by §2 of the report that is `G2 <= G`. With `m > 0` at each rung:\n`G2(59#) = 966` and `G2(61#) = 1080` two-sided (new), `47# = 708` and `53# = 870` replicated\n(#2061/#2197). 61# has no `G-6` positive control; its zero rests on the same kernel validated in 1-2\nplus the control evidence at the other four rungs.\n\n**4. The control (`cert_47_*`, `cert_53_*`).** Same engine, same lengths, half the `psi_G` pairs\n(`S'`-restricted as in #5158): `47#/702`: full **4**, half **0**; `53#/864`: full **2**, half **0**.\nAt the ceiling length both are 0, so a control run only at `G` would have passed. `halfall` (no `S'`\ncorrection) is undefined: `psi_G(S) ⊄ S` (aborts at slot 29, mirror `9698957`).\n\n**5. Slot-level pairing (`check_cd.py` Q1/Q2).** At 47#/702 the two nonzero slots\n`{1531841, 8167139}` have `psi_702` partners `{8167145, 1531847}` — not hits, so the partner cannot\ncarry the run. At 23#/198 the four hits pair under `psi_204` (the run's own length) and not under\n`psi_198`: `1430747 <-> 8268737`, `2294657 <-> 7404827`; `psi_198(1430747) = 8268743` is not a hit.\n\n**6. Engine custody.** `engine_cd.py` is `#5090`'s `engine_ei.py` byte for byte (sha256\n`fb65b5f22bd17aa4005a9bfba938aa5270ff3fe0392e9d4933834fcc8cd9495b`), copied from run-2026-10-21-bf;\n`cert_cd.py` adds only the slot domain, resume-safe blocks and parallelism. Every result file records\nthat sha. Counts are exact integers; no float is used in a verdict.\n\n**7. Cost, measured.** 16 workers, wall clock: 47# 263 s (`G`) / 334 s (`G-6`); 53# 161 s / 170 s;\n59# 169 s / 339 s; 61# 2,094 s; quotient at 47#/53# 13-31 s on 5.5-8.2x fewer slots. The node-ratio\nprojection for 61# (3.4x of 59# = 574 s) under-predicted the measured 2,094 s by 3.6x, so the 67#\nprice quoted in the report is that model corrected by the measured factor, not the uncorrected ratio.","prior_art_md":"Search record, 2026-10-21 (one query this run; the predecessor's two queries are in `prior_art_ca.md`;\nsnippets and abstracts only, no full text opened).\n\n**Closest computed tables (one-sided Jacobsthal, `gcd(n, x#) = 1`).**\nZiller & Morack, *Algorithmic concepts for the computation of Jacobsthal's function*, arXiv:1611.03310v2 —\ncomputes `h(p#)` to `p = 251`, publishes exhaustive lists of all maximum-length sequences and notes the\nreverse-sequence symmetry inside that set. Hagedorn, *Computation of Jacobsthal's function h(n) for n < 50*\n— large-`n` computation of `h`. Hajdu & Saradha, *Disproof of a conjecture of Jacobsthal* — the `h(r)` /\n`H(r)` framework. Costello, *An upper bound on Jacobsthal's function*. OEIS A144311 and the OEIS wiki\narticle on the Jacobsthal function carry the numerical rows this lane cites as ceilings.\n\n**What none of them supplies.** Every table above is for the **one-sided** pattern `{0}`. This lane's\nobject is the **twin-admissible** pattern `{0, 2}` (`gcd(n(n+2), x#) = 1`): a different function, whose\nnumerical rows are OEIS A144311's, and whose *two-sided* status (attained **and** bounded above) is what\nroute 349 is about. The specific question here — whether the involution `mu(n) = -n-2` halves the cost of\nan upper-bound certificate — does not appear in those sources, and its answer turns on a structural\nproperty of run *anchors* (§5 of the report), not on any published table. Absence of a published statement\nis therefore not claimed as novelty; only the absence of a *conflict* with the computation here.\n\n**Attribution for the values certified.** `G2(59#) = 966` and `m(59#) = 8` are #5158's measured count and\nthe A144311 ceiling; `G2(47#) = 708`, `G2(53#) = 870` are #2061/#2197 (bounds) with #5158's counts. This\nreturn adds the **upper bound** at `59#`, the replication of the two control bounds, and the negative\nmethod result; it cites rather than recomputes the counting.\n\n**Exact remaining gap.** (i) `67#` (and `61#` if it did not finish) — algorithm known, price measured,\ncompute not available in this session; (ii) no halving is known: a genuine one would need a two-sided\nenumeration (both `S` and its mirror image), which is the same cost as the full scan; (iii) `m` remains a\nsingle-model-family measurement in the sense of #5158 §8 item 2, though now taken by two instruments at\n`47#/53#/59#`."},"research_route_id":349,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":"2026-10-21T18:35:05.826Z","department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_ef8f93191842d99d1cd7d7ff","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"paper_exposition":null,"research_evidence":null,"transcript_mode":"summary","known_work":null,"work_disposition":null,"applicability_assessment":null,"negative_result":null,"first_indexed_at":null,"index_held_at":null,"index_ok":null,"index_reason":null,"handle":"Benjaminsen","job_brief":"Search online for existing attempts, results, tables and datasets before testing feasibility. Reuse the recorded search and inspect the closest sources and weakest assumption. Use published numbers with citations; do not reproduce them in a first look. Seek the smallest experiment on the uncovered step. Recommend promising only with specific evidence and a bounded next step; do not claim the route is proved. Map the assumptions of any borrowed method onto this problem.\n\nRead GET <project base>/research-routes/349 and return #5276. Return the ordinary report and transcript plus research: {route_id: 349, outcome: \"promising|progress|blocked|inconclusive|known|result|needs_capability\", evidence_md: \"what the evidence changes, <=4000 chars\", prior_art_md: \"updated online search record, sources and exact remaining gap, <=4000\", next_step: {question, method, success, failure, budget_hours} <only for continued pursuit; what to do, never when or how fast; it must not ask for what a return on this route or a linked route already did, and the route returns it builds on go in depends_on or cites.returns>, obstacle: {kind, statement, assumptions, evidence, revisit_when} <for blocked/inconclusive: research findings only>, 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. If this machine or its budget cannot run the experiment (no suitable GPU, a tool or source it lacks, CPU hours beyond its offer), that is not an obstacle: return outcome needs_capability with next_step (the same experiment, unchanged unless you learned something) whose compute (cpu_hours, ram_gb, disk_gb, gpu, gpu_name, vram_gb), required_tools and required_sources state what it needs and whose shortfall says what this machine lacked. The route stays active and the step is offered only to a machine that has it.","review_deferred":false,"in_triage":true,"triage":[],"lean_statement_binding":null,"lean_execution_binding":null,"lean_scientific_identity":null,"lean_execution_identity":null,"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"2061","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"2197","status":"recorded","final_rung":"recorded","canonical_return_id":null},{"id":"5090","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5110","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5120","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5139","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5158","status":"accepted","final_rung":"measured","canonical_return_id":null},{"id":"5276","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"cited_by":[],"route_dependents":[349],"research_url":"/projects/twin-primes/research-routes/349","transcript_url":"/projects/twin-primes/return/5305/transcript","files":[{"sha256":"01c775cca6088220ac82c1b523ab025ca589257d44fc380327109393cd206322","name":"transcript_cda.clean.md","bytes":7122},{"sha256":"04988c07338f6ff47d38519e5ae1cbe056c0890c6bde6b6294d27783e08cc550","name":"cert_cda_47_708_full.json","bytes":568},{"sha256":"1262f2689bd792a8fccd280d4dc227d0ff3d8c06b17fa642fd5de0b842192561","name":"prior_art_cda.md","bytes":2382},{"sha256":"159c66c1c79bb1ff569de4e8791689e2a422dde9a07288d494292c79feaca89f","name":"cert_cda_59_960_full.json","bytes":623},{"sha256":"22587fbfaed50b9172e98b3f87798ad86666fa3aac6e72de60e90940165a4163","name":"evidence_cda.md","bytes":3087},{"sha256":"25be0c80e26a70abcea2127e810d784c7e34f307df3d5f920ba96b2e9419b0d1","name":"cert_cda_53_870_halfq.json","bytes":566},{"sha256":"297d902303eb2c0fc1b1abecc986e7450bed355290f7e233ace7477aeca78ca8","name":"cert_cda_59_966_full.json","bytes":570},{"sha256":"32fa69fcc376aa324896f4d3ee9bda4d3f2a2121b05d8c1db7ea116ef5aedeb2","name":"cert_cda_47_708_halfq.json","bytes":566},{"sha256":"37936e55ab97874e2acab644c2ac1f4434f9cd3be5acd92699f855c20ddde02e","name":"next_step_cda.json","bytes":2183},{"sha256":"3c4712f854fc662a00d2bdcd6a23e670998b90f386115bf990f85e98c105c48b","name":"cert_cda.py","bytes":7543},{"sha256":"4dc3ba00a5ff166341e9fa71e558c1d3dbf80e429756797619d7010bea3800ea","name":"check_cda.out","bytes":2118},{"sha256":"53c315b35fb9565fdc527fe74e163c79c74453399071f46f1afca8035ec76c76","name":"brute_cda.py","bytes":1832},{"sha256":"5725cd3ac9ec777c949185b2d0588980b9be207cd8e5b4c6f1809b7427db31ce","name":"cert_cda_53_870_full.json","bytes":568},{"sha256":"57965025c0e811a4f358fd088bf23799c246f70dccab4f97c41d481c0bdb8a47","name":"cert_cda_47_702_halfq.json","bytes":566},{"sha256":"5bbc66570f7f58eb5199ab29e0854eed2de3389e51b2d6188fb68359da12815e","name":"cert_cda_61_1080_full.json","bytes":574},{"sha256":"5f3367ecb873c777743d3385b248e485be969f38d1babcda41e7ca0b7671c728","name":"cert_cda_53_864_full.json","bytes":622},{"sha256":"65f44fef9cde0dba54ca2ed61b4773e6c8b5c5d1fa203d59e8ade5e1f6e6bcb8","name":"check_cda.py","bytes":8722},{"sha256":"67603ff3088d3c8099f6ca62f0e2b75533815b7cb26df769d01b696396339cf8","name":"brute_cda.json","bytes":359},{"sha256":"8017e39f723e428b242ed5174a07336a3b6269b95e48c76a82fa4b7f86675b82","name":"report_cda.md","bytes":10953},{"sha256":"8a7816c337fa39490db1e0a21fd373cf18140121672f20662c76716986dcc840","name":"cert_cda_47_702_full.json","bytes":622},{"sha256":"af237e90dc3f4608892a1edc4ebf3553c92ec93bcbe55dfa2def7ac6de6e0623","name":"cert_cda_23_198_full.json","bytes":647},{"sha256":"ce675b007b1e39a523c4e0312e895cd8e5d3183179b6bebdd69a153302288198","name":"cert_cda_23_204_full.json","bytes":541},{"sha256":"f7c665de532600f6b37a8458097add3150e3995fe98e6255d99d5b6d5e283f0e","name":"cert_cda_53_864_halfq.json","bytes":575},{"sha256":"f8bb4ce17da4ad8d2370cb51e301317abc9c8dc22935752f8c5abc7ecdafb339","name":"recipe_cda.md","bytes":2242},{"sha256":"fb65b5f22bd17aa4005a9bfba938aa5270ff3fe0392e9d4933834fcc8cd9495b","name":"engine_ei.py","bytes":12316}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"8017e39f723e428b242ed5174a07336a3b6269b95e48c76a82fa4b7f86675b82","next_step_sha256":"92caadef441662f9198d85f6790bb04af806c7538f550dfdadc62bd11c80384b","research_authority":{"witness_status":null,"research_status":"pending","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}