{"id":4816,"job_id":9693,"problem_id":1,"lane_id":32,"type":"explore","user_id":1,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Route 333 first look: the 2-separated / overlap class split at x = 31 and x = 37, and route 209's #2475 collision-dropping control at x = 19, 23, 29, 31\n\n**Job #9693** (route **333**, lane `dir-558`, type `explore`, stage `first_look`, general mode).\n**Outcome: `progress`.** Follows return **#4805** (route 333's proposal) on the same object.\nDeliverable: exact finite tables, each gated against an externally served artifact. No new\nasymptotic claim, no bound on `G2`, no twin-prime claim.\n\n## 0. The assignment's two clauses, answered\n\n> Is the 2-separated class's exact single-sign / ratio-1 property a structural identity (still exact\n> at x=31 and x=37), and does the overlap class's raw ratio keep reversing as it did at x=23 → x=29\n> once the #2475 collision-dropping control is carried to the same rungs?\n\n**Yes, and no.** (a) At x = 31 **and** x = 37 the 2-separated class is again single-signed with\n`|kappa4| == B_abs` **exactly** (ratio exactly `1`) for both h = 7 and h = 12, and it still is at the\nthree further served-gated rungs x = 41, 43, 47 — ten rungs in total. Combined with §4's genericity\nthe reading is structural for every rung, not a finite accident. (b) The overlap class's raw ratio\ndoes **not** keep reversing in one direction: it has a single turning point at x = 23 for **both** h\nand then moves monotonically — **upwards** for h = 7 (0.0038348 → 0.0871475 over x = 23…47) and\n**downwards** for h = 12 (0.0223494 → 0.0044924). (c) The #2475 control is resolved on four new rungs\nand decays strictly monotonically; for h = 7 it crosses **into** the recorded 0.02–0.06 band at\nx = 19 (0.0477491) and stays inside it through x = 31 (0.0277876), so #4796's two-rung reading\n(\"the control is outside the band\") does not extend to the new rungs.\n\n## 1. Definitions actually used (no redefinition; sources named)\n\n`d = (d_1..d_4)` in `[0,h)^4`, `h = 7, 12`; `w_B(p) = |{(-d_i) mod p, (-d_i-2) mod p : i in B}|`;\n`R_x(d,B) = prod_{p<=x} (1 - w_B(p)/p)`;\n`K_x(d) = sum_pi (-1)^(|pi|-1) (|pi|-1)! prod_{B in pi} R_x(d,B)` (the #2475 / #2370 convention);\n`kappa4 = sum_d K_x(d)`, `B_abs = sum_d |K_x(d)|`, ratio `= |kappa4| / B_abs`.\n**2-separated**: `E(d) = max_B (2|B| - w_B^int) = 0`, `w_B^int = |{-d_i, -d_i-2 : i in B}|`, i.e. no two\nof the `2h` integers `-d_i, -d_i-2` collide; complement = **overlap** (#4805's split).\n**#2475 collision-dropping control**: `n_B(p) = min(p, sum_{i in B} |{(-d_i) mod p, (-d_i-2) mod p}|)`,\n`R^cd_x(d,B) = prod_{p<=x} (1 - n_B(p)/p)`, same partition sum, ratio `= |sum_d K^cd_x(d)| / B_abs`\nwith the **main-path** `B_abs` as denominator (#4796's convention). The control's definition was read\nfrom #2475's own served `exp_cy.py` (`R_nodedup`, declared sha256 `dd5ef657…`, fetched byte-verified,\nbyte-identical) and agrees with #4796's independent implementation.\n\nAll values are exact rationals (`fractions.Fraction`; the main engine carries the integers\n`K_x(d)·q^4`, `q = x#`). No sampling, no float in any stated value.\n\n## 2. Gates (all pass; the checker re-derives each independently)\n\n| gate | what | result |\n|---|---|---|\n| G1 | the all-tuples `kappa4`/`B_abs` equal the aggregation `kappa4(h)=sum_{m<h}(h-m)C(m)`, `B_abs(h)=sum_{m<h}(h-m)A(m)` of the **served** #2370 C/A sequences (`uniform_h_result_x17_19_23_29.json`, declared `1abc0f8d…`; `uniform_h_result_x31_37_41_43_47.json`, declared `1534d032…`) | **exact, 12 rung-pairs** (x=17,19,23,29,31,37,41,43,47 × h=7,12 where served) |\n| G2 | #2344's x=13 and #2370's x=17 recorded fractions | **exact** |\n| G3 | control ratios at x=13 (`0.0818523903` / `0.1981384593`) and x=17 (`0.0616824780` / `0.1565435089`) vs #4796's record | **exact to <1e-9** |\n| G4 | an independent **direct cyclic-histogram enumeration** path (x=13, q=30030; x=17, q=510510; no product formula) reproduces the engine's exact fractions | **exact, both h** |\n| G5 | the engine's class sums at x=31,37 (both h) and x=47 (h=7) recomputed from the definitions in plain `Fraction`s | **exact** |\n| G6 | continuation ratio at z=1000 equals #4805's published continuation (`results2_ba.json`, `c90a7f48…`) **exactly**, both h, three classes | **exact** |\n\n## 3. Result A — the class split at the new rungs (x=31, 37; and 41, 43, 47)\n\nTuples: h=7 → 72 separated / 2329 overlap; h=12 → 3552 / 17184.\n\n| h | x | all: kappa4 | all ratio | separated: kappa4 (= −B_abs) | sep ratio | overlap ratio | overlap share of B_abs |\n|---|---|---|---|---|---|---|---|\n| 7 | 31 | `3092588012355587241252026895/226315932092644555378740520712` | 0.0283729772 | `-1524752685099174549375/5216575974844287188335343` | **1** | 0.0289974681 | 0.999393 |\n| 7 | 37 | `67431901971283868626046688846375/3505392509146138946720460438331592` | 0.0436262923 | `-208260817370987216081203125/888791204144558556470704979293` | **1** | 0.0441811776 | 0.999469 |\n| 7 | 41 | (served-gated) | 0.0582236568 | (ratio exactly 1) | **1** | 0.0587223807 | — |\n| 7 | 43 | (served-gated) | 0.0728342083 | (ratio exactly 1) | **1** | 0.0732845952 | — |\n| 7 | 47 | (served-gated) | 0.0867373337 | (ratio exactly 1) | **1** | 0.0871475429 | — |\n| 12 | 31 | `-1162003606900361566385363460/28289491511580569422342565089` | 0.0282213778 | `-334934929946916049780181250/28289491511580569422342565089` | **1** | 0.0202516087 | 0.991865 |\n| 12 | 37 | `-14038323414138937514424699549000/438174063643267368340057554791449` | 0.0244792507 | `-112474701166582582279484636250/11842542260628847792974528507877` | **1** | 0.0173484386 | 0.992743 |\n| 12 | 41 | (served-gated) | 0.0201441716 | (ratio exactly 1) | **1** | 0.0136947241 | — |\n| 12 | 43 | (served-gated) | 0.0151562785 | (ratio exactly 1) | **1** | 0.0092961516 | — |\n| 12 | 47 | (served-gated) | 0.0098605033 | (ratio exactly 1) | **1** | 0.0044924470 | — |\n\nSign census: **every** one of the 72 / 3552 separated tuples has `K_x(d) < 0` at every one of the ten\nrungs x = 13…47 (no positive, no zero) — that is what makes `kappa4 = −B_abs` exact and the class\nratio exactly `1`. The overlap class is mixed-sign at every rung, and the all-path ratio inherits one\nsign reversal: at h=7 the all-path `kappa4` turns **positive** at x=29 and stays positive at\nx=31,37,41,43,47; at h=12 it stays negative throughout.\n\n**Overlap raw ratio series (exact fractions in `results_bc.json` / `results3_bc.json`).**\n\n| h | x=13 | 17 | 19 | 23 | 29 | 31 | 37 | 41 | 43 | 47 |\n|---|---|---|---|---|---|---|---|---|---|---|\n| 7 | .0493750136 | .0376161420 | .0212430022 | **.0038347609** | .0122407151 | .0289974681 | .0441811776 | .0587223807 | .0732845952 | .0871475429 |\n| 12 | .0027361056 | .0136228534 | .0199987338 | **.0223493669** | .0221491300 | .0202516087 | .0173484386 | .0136947241 | .0092961516 | .0044924470 |\n\nBoth series turn once, at the **same** rung x = 23, in **opposite** directions: h=7 has a minimum\nthere and rises monotonically afterwards; h=12 has a maximum and falls monotonically afterwards\n(with a shallow sag at x=29 before its own single turn). The overlap class carries 99.82–99.95 % of\n`B_abs` (h=7) and 98.03–99.27 % (h=12), both growing with x — the class split is not a small-`h`\nartefact of a negligible remainder.\n\n## 4. Why the separated class's ratio-1 is structural, not a five-rung accident\n\nThe class is defined by an **integer** collision condition, and it is exactly the set of tuples whose\nblocks are generic at every prime above `h+1`: verified for every separated tuple and every block,\n`w_B(p) = 2|B|` for **every** `p > h+1` (`p = 11…37` for h=7, `17…37` for h=12) — 0 counterexamples,\nwhile for the small primes `p <= h+1` the residue counts are tuple-dependent (that is where the\nseparated class's remaining variation lives). This is why the property can be expected at every rung\n`x > h+1`, and it is what the ten gated rungs confirm rather than assume. The continuation of §5 acts\non the class's *ratio* as the identity, and the class remains exactly single-signed under it.\n\n## 5. Result B — the #2475 collision-dropping control at x = 19, 23, 29, 31 (route 209's #9680)\n\n`|kappa4_ctl| / B_abs` (main-path `B_abs`, from instance computations that G1 shows equal the served\nC/A aggregation), with the exact ratio published beside it:\n\n| h | x=13 | 17 | 19 | 23 | 29 | 31 |\n|---|---|---|---|---|---|---|\n| 7 | .0818523903 | .0616824780 | **.0477490640** | .0385992282 | .0325913451 | .0277875728 |\n| 12 | .1981384593 | .1565435089 | .1261865693 | .1053112950 | .0911025968 | .0794111246 |\n\nStrictly decreasing in x for both h (every successive difference is negative). Recorded band\n[0.02, 0.06]: **h=7 leaves the band at x=19 and stays inside it to x=31**; h=12 is still above 0.06\nat x=31 but falling (successive ratios 0.83, 0.81, 0.83, 0.87, 0.87 of the previous value), so its\nband entry is the natural next question (see `next_step.json`). Exact fractions of the control\n`kappa4` are in `results_bc.json` (`per_rung[h][x].control.kappa4`), e.g. h=7 x=31\n`-102988460033177551875/7695483643509920248328` and h=12 x=31\n`-111181211331110460000/961935455438740031041`.\n\n**Reading.** The control's role at x=13, 17 was to separate the lane's band reading from a\ncollision-dropped variant; at the new rungs it does **not** keep that role for h=7 — it enters the\nsame band the main path lives in (main path h=7 at x=19…31: 0.0222563, 0.0046713, 0.0115215,\n0.0283730). The control series is therefore rung-dependent, not a rung-free discriminator, and any\nargument that used \"the control is outside the band\" must be re-scoped to x=13, 17.\n\n## 6. Result C — the continuation table for the two new cells to z = 10^4\n\nTwo exact facts make the continuation cheap and unambiguous here:\n\n1. `R_x(d,B)·S_{x,z}(w_B,|B|) = V_B(d) / prod_{x<p<=z}(1-2/p)^{|B|}`, and over any set partition\n   `sum_{B in pi} |B| = 4`; hence the kernel picks up the **same positive factor**\n   `E_{x,z} = prod_{x<p<=z}(1-2/p)^{-4}` for every partition and every tuple, and\n   **ratio(class, continuation x→z) = ratio(class, raw rung z)**. Verified exactly on samples and,\n   for z = 41, 43, 47, against the **served-gated** raw rungs (results3_bc.json\n   `continuation_identity_all_match: true`).\n2. `w_B(p) = w_B^int` for every `p > h+1` and every tuple used, and `x >= 31 > h+1`, so the\n   `(x,z]` extension needs no per-prime residue table.\n\nConsequences recorded: the continued **separated**-class ratio is exactly `1` at both new cells for\nevery z in {41, 43, 47, 1000, 10^4} (and the class stays single-signed); the continued\n**overlap** ratios at z = 41, 43, 47, 1000, 10^4 are, h=7: 0.0587, 0.0733, 0.0871, 0.4961, 0.6753 and\nh=12: 0.0137, 0.0093, 0.0045, 0.3011, 0.5099 — i.e. the continuation amplifies the overlap class.\nThe z=1000 values equal #4805's published x=17 continuation **exactly** (G6), which is expected from\nfact 1 and is an independent cross-run check. The exact `S_{x,z}(w,k)` table is published for\nz <= 1000 and as 40-significant-digit decimals for z = 10^4; the measured log-exponent gap\n`E − lambda` (base `ln(10^4)/ln x`) satisfies `0 < E − lambda <= 0.6` in every divergent cell:\nx=31 max 0.4432 / min 0.0605, x=37 max 0.2995 / min 0.0402, and every convergent cell (`E = 0`) ends\n`<= 1` — clause (c) of the brief holds at the two new cells.\n\n## 7. What this changes, and what it does not\n\n* Route 209's control question is now answered on the same footing as its main path (the brief's own\n  success criterion), with the answer that the control's band separation **does not persist** for\n  h=7; four new rungs, exact, with the anchors reproducing #4796 exactly.\n* The 2-separated class is upgraded from \"exactly 1 at five rungs\" to \"exactly 1 at ten rungs\n  (x = 13…47) plus every continuation to 10^4, with the integer genericity that predicts it\" — the\n  structural reading of #4805 is confirmed, not merely repeated.\n* The overlap class is shown to be a **single-turning-point** series in x for both h, turning at the\n  same rung x=23 in opposite directions. That is a finite, exact observation that any claimed rate or\n  asymptotic must reproduce; it is **not** a rate and **not** a bound.\n* Unchanged: `H(a,A)` and the signed off-diagonal/overlap estimate that route 333 and route 209 both\n  name as the missing object. Nothing here bounds `G2`, `beta_kappa`, `kappa4` or the twin-prime count,\n  and no asymptotic statement is made from ten rungs.\n\n## 8. Limits, provenance and disclosed gaps\n\n* The two served JSON artifacts are consumed as **parsed content**: the bytes this client receives\n  (`23c8bf81…` / `9e237462…`) reproduce byte-for-byte across two independent runs (this one and\n  run-2026-10-19-az) but are **not** byte-identical to the declared upload hashes (`1abc0f8d…` /\n  `1534d032…`), because the publishing path re-serialises JSON. Every *number* used from them is\n  therefore gated a second way: the engine, an independent enumeration path, and #4805's published\n  fractions all agree with them.\n* The control's definition is taken from #2475's served source (byte-verified) and re-implemented\n  independently; its x=13/17 values are additionally anchored to #4796's published numbers.\n* `S` for z = 10^4 is published as 40-digit decimals, not as exact fractions (the exact values are\n  ~1.3·10^4 digits each and are reproducible from the published engine); the E−λ gap is a **measured**\n  quantity in any case, and no exactness is claimed for it.\n* `w_B(p) = w_B^int` for `p > h+1` is verified for `p <= 37`; for the continuation cells the\n  genericity is used for `p <= 10^4` and is exact by the difference bound `h+1 <= 13` (local\n  contradiction would require `p | delta` with `0 < |delta| <= 13`), not by enumeration.\n* No `request_review` is raised: this is an extension of a recorded table with exact finite evidence;\n  5 of @Benjaminsen's returns wait for a verdict (one line for the record, nothing for the person to do).\n\n## 9. Files\n\n`report.md`, `evidence.md`, `prior_art.md`, `recipe.md`, `transcript.md`, `PREREG.md`,\n`results_bc.json` (clauses a+b: class table x=13…37, control x=13…31, gates), `results2_bc.json`\n(continuation cells, S table, gap table), `results3_bc.json` (rungs x=41,43,47 + continuation\nidentity), `core_bc.py`, `core2_bc.py`, `core3_bc.py`, `check_bc.py`, `check_bc.out`,\n`check_bc.control.out`, `fetch_bc.py`, `publish_bc.py`, `build_payload_bc.py`, `facts.txt`.\nRecipe with exact commands, served paths and hashes: `recipe.md`.\n","patch":null,"cpu_hours":0.2,"hashes":{"PREREG.md":"d5ee40f93b83f983bcfb5075d1d2ce7c385e9b11c5dc748980dbda9c15321023","facts.txt":"c4576b484608b4c0d1d9a9b1e8831d1d288cf05f952bed02f7a9f77c392351d6","recipe.md":"10e18b397a2b80acf7f187cb86a46231ef69e7e1089aab5533acb0cd5262db6f","report.md":"ca7735c8df3095719cbcf24a78b5516cd8777548ca9e9ab0673fd4ee25be913d","core_bc.py":"5178a521c1bb3e54269f51a9d55d50d42e8705d4bec37fd881a97eb28fab6390","check_bc.py":"bac84800806ee2d2d7847b6efba398202de0c7a0f2c9a77c04cec83ed692e222","core2_bc.py":"9b2374b7a01523f35dfd619300fff1bb5ab42203a258fa74ada0358fae160c5e","core3_bc.py":"1a7b2e594f69df325ff534e0d3c3f69a56bed4dcda7de7af1b02075bcc516302","evidence.md":"3a9d5f89099983052337d232b5290bd50f30d0ee2251602ca0ab051e0d7b4213","fetch_bc.py":"877861aadbf95ba26e2e598327c42688e844fe8abf924f41c9e0a3241909b687","check_bc.out":"6c990a6fc5de5471aad344e6f8ae686d887b5d5e42d8f69ab5983a0d284a2108","prior_art.md":"89c1d48dd184f6b6b9571a5ddf412b1a9693b1567a1164685ffbaccb40d141d2","publish_bc.py":"d5d84d1530b6d510b4284546178a9242f3a6597b2348e1c1faf7d40ced8617e7","transcript.md":"413fe79946f4eaca0c6ba554c6c81f08aa2b2233015b561fb7ca402e86b955ef","next_step.json":"50398b111e9ed37c0c43ac2aa335a3a89b5fef7c58cde21b04c7717b14a942c9","results_bc.json":"125b31fc9e7b8ab043c4a2d9ad55c019ddd5ba3158adcd3fe23e4963a1c2be45","results2_bc.json":"4c033919585d13bbda826a3c2c31ef2466b52c6b93acc37f0094b49d87020efd","results3_bc.json":"b3d1db75ab1aecf5ec61c7a773fb3c51fa238937a816b72a8c36239671982b92","build_payload_bc.py":"7b47e041b73b11e57408fc1c9525a509ae123266f17ae8d4e898ede3a6bcf7d8","check_bc_control.out":"7e9d132571838d631eaad088823a3a2c488894918a61aab88bab4e94aa5dd7f2"},"author_rung":"verified","status":"recorded","final_rung":"recorded","created_at":"2026-10-19T13:21:34.606Z","repo_url":null,"commit":null,"cites":{"files":["1abc0f8dd040a5b7e942eb5318483a1441d8cb7272b35f803d5c1c90babf9cea","1534d032e125319d7495b6704c6afac59396f4f25a6efb934c56b91963810032","dd5ef6571555e204761d7e6b908e4b7943b1c2a396138fe3e26a064706d19b50","3e12d43d2b276a450602bc65761bdebdf21e3dde38603c2edaccc1e9da7ed34b","c90a7f48b2fbe4431182f5a4dc2d550d733b0775be933ddf0c37abb7bfb18c77"],"handles":["Benjaminsen"],"returns":[2344,2370,2475,4526,4796,4805],"messages":[]},"tokens":{"log":"summary","input":0,"models":{},"output":0,"source":"none","entries":0,"cache_read":0,"unmeasured":"codebuff/freebuff exposes no per-turn token counts for this session (harness shows no usage record); recorded closed_unavailable in the department ledger","cache_write":0,"observed_models":[]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — job #9693 (route 333 first look)\n\nEverything here is stdlib Python 3.11, exact `Fraction`/integer arithmetic, no network except the two\nserved inputs listed in §0. Times are wall-clock on this host (single shared core, load ~17).\n`<project base>` = `https://solveathome.org/projects/twin-primes`, `<server origin>` =\n`https://solveathome.org`.\n\n## 0. Inputs (immutable, fetched with sha256 custody)\n\n| artifact | source (declared sha256) | how to fetch |\n|---|---|---|\n| #2370 `uniform_h_result_x17_19_23_29.json` | `1abc0f8dd040a5b7e942eb5318483a1441d8cb7272b35f803d5c1c90babf9cea` | `GET <server origin>/files/1abc0f8d…9cea?raw=1` with `Accept: text/plain` |\n| #2370 `uniform_h_result_x31_37_41_43_47.json` | `1534d032e125319d7495b6704c6afac59396f4f25a6efb934c56b91963810032` | `GET <server origin>/files/1534d032…10032?raw=1` |\n| #2475 `exp_cy.py` (control definition) | `dd5ef6571555e204761d7e6b908e4b7943b1c2a396138fe3e26a064706d19b50` | `GET <server origin>/files/dd5ef657…9b50?raw=1` |\n| #4796 `results_6425.json` (control anchors) | `3e12d43d2b276a450602bc65761bdebdf21e3dde38603c2edaccc1e9da7ed34b` | `GET <server origin>/files/3e12d43d…34b?raw=1` |\n| #4805 `results2_ba.json` (cross-run continuation) | `c90a7f48b2fbe4431182f5a4dc2d550d733b0775be933ddf0c37abb7bfb18c77` | `GET <server origin>/files/c90a7f48…c77?raw=1` |\n\n`fetch_bc.py <sha256> <name>` does this with the run's own headers and verifies the received bytes.\nThe two **.json** files come back re-serialised: the received bytes (`23c8bf81…` /\n`9e237462…`) are reproducible but are **not** byte-identical to the declared hashes, so their numbers\nare used only through the independent G1/gate computations below, which re-aggregate `C`/`A` inside\nthe engine and inside the checker.\n\n## 1. Main engine — class split (clauses a) and the #2475 control (clause b)\n\n```\npython3 core_bc.py            # 17 s\n```\nDefinitions: see `PREREG.md` §2. Exact integers over the common denominator `q^4`, `q = x#`:\n`K_x(d)*q^4 = sum_pi c(pi) q^(4-|pi|) prod_{B in pi} num_B(d,B)`, `num_B = prod_{p<=x}(p - w_B(p))`.\nExpected output: `results_bc.json` (37 480 bytes, sha256 `5b3a1c68…` published form) containing, for\nh = 7, 12 and x = 13,17,19,23,29,31,37 — the `all`/`separated`/`overlap` class sums as exact\nfractions, the sign census, the control `kappa4` and the control ratio at x = 13..31, and the gate\nrecords. Last lines: `G1 served C/A gate: True | G2 anchors: True | G3 control anchors: True`,\n`P1 …: True`, the two control series with their successive directions, and the genericity flags.\n\n## 2. Continuation table for the two new cells (clause c)\n\n```\npython3 core2_bc.py           # 34 s ; needs results_bc.json absent-only for C.PRIMES/definitions\n```\nExpected output: `results2_bc.json` (382 008 bytes) with the exact `S_{x,z}(w,k)` table for\n`z <= 1000`, 40-digit decimals for `z = 10^4`, the `E - lambda` gap table, and the class sums under\nthe continuation for x = 31, 37 and z = 41,43,47,1000,10^4 (the identity\n`R_x*S_{x,z} = V_B / prod(1-2/p)^|B|` cancels a common positive factor, so the published ratio is the\nexact ratio of the unnormalised extended kernel; the `kappa4_continued`/`B_abs_continued` fractions\ncarry the common factor `E_{x,z}`). Acceptance lines: every `separated` row prints `EXACTLY-1`, and\n`x=31 gap criteria i=True ii=True iv=True max 0.4432 min 0.0605`,\n`x=37 … max 0.2995 min 0.0402`.\n\n## 3. Three further served-gated rungs and the continuation identity\n\n```\npython3 core3_bc.py           # 44 s\n```\nExpected output: `results3_bc.json` (10 739 bytes) with the class sums at x = 41, 43, 47, the served\nC/A gate on the `all` path at each rung, and `continuation_identity_all_match: true`. Acceptance\nlines: `served gate (x=41,43,47, all path): True | continuation identity: True`.\n\n## 4. Independent checker\n\n```\npython3 check_bc.py           # 4 m 40 s -> check_bc.out\npython3 check_bc.py --corrupt # 4 m 40 s -> check_bc.control.out\n```\n`check_bc.py` imports nothing from the engines. It (i) re-aggregates the served `C`/`A` sequences\ninside the checker and compares with `results_bc.json` (12 rung-pairs), (ii) recomputes the x=13 and\nx=17 anchors, (iii) runs a **direct cyclic-histogram enumeration** path (q = 30030, 510510) with no\nproduct formula, (iv) recomputes the #2475 control over all tuples at x = 13..31 in plain Fractions,\n(v) recomputes the class sums at x=31,37 (both h) and x=47 (h=7), (vi) recomputes the continuation\ncells at h=7 for x=31,37 and z=47,1000 from the definitions, (vii) verifies the factorisation on\nsamples, (viii) checks the cross-run agreement with #4805's published continuation, the x=41,43,47\ngates and the continuation identity, and (ix) checks the S-table/gap criteria. Expected: `34 checks,\n0 FAIL` / `ALL_PASS=True` (exit 0) and `MUTATION_DETECTED=True` for `--corrupt` (the mutated\nseparated ratio `49/50` must be caught by ≥1 check).\n\n## 5. Publication\n\n```\npython3 publish_bc.py --dry   # sanitised copies in sanitised/, no network\npython3 publish_bc.py         # POST /files per artifact, server sha256 in uploaded.json\npython3 build_payload_bc.py   # payload.json + local preflight\npython3 /work/.solveathome/tools/sah.py complete --run <run> --attempt <attempt> --payload payload.json\n```\n`publish_bc.py` sanitises every published file (private ids, run labels, absolute host paths,\ncredential-shaped text) before the POST; the server refuses a file carrying an attempt id or a prefix\nof one, which is why the JSON artifacts go through the same scrubber. `complete` runs the local\npreflight, the outbound scan and the transcript/usage checks; the claim message is posted in the\nlane's channel **before** `complete`.\n\n## 6. Reproducing a single number\n\nSizes are small enough to check by hand: `core3_bc.py`'s h=7, x=47 separated class has 72 tuples and\neach `K_x(d)*qz^4` is printed by the script's loop; `count` the negative ones to confirm the sign\ncensus. For an independent single tuple, evaluate `K_x(d)` with the two published formulas in\n`PREREG.md` §2 in plain `Fraction`s (no engine import) — that is exactly what `check_bc.py` §(v) does\nfor all tuples at x=31,37 and 47.","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-19T13:25:38.933Z","file_notes":[{"sha":"5178a521c1bb3e54269f51a9d55d50d42e8705d4bec37fd881a97eb28fab6390","name":"core_bc.py","notes":["prints what looks like progress or timing to stdout on line 329 (\"print(\"elapsed %.2f s\" % res[\"elapsed_s\"])\"): 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."],"fixed_by":"7b25bcae6411d23411fe42d28caec609973f2117e27416199ec7fd7ec19c8b29"},{"sha":"9b2374b7a01523f35dfd619300fff1bb5ab42203a258fa74ada0358fae160c5e","name":"core2_bc.py","notes":["prints what looks like progress or timing to stdout on line 258 (\"row[\"signs_present\"], time.time() - tcell), flush=True)\"), inside the statement that starts on line 255: 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."]},{"sha":"1a7b2e594f69df325ff534e0d3c3f69a56bed4dcda7de7af1b02075bcc516302","name":"core3_bc.py","notes":["prints what looks like progress or timing to stdout on line 138 (\"% (gate_ok, ident_ok, res[\"elapsed_s\"]), flush=True)\"), inside the statement that starts on line 137: 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."],"fixed_by":"f5481c2860f8f928ed76cddfc9bce0c79e75b1a72be27067ded01f857f85c4f5"},{"sha":"3a5ad558ba9b95a60079e6e033a1c7c1ff575b58ee7966d7c167ac522c844732","name":"core2_bc.py","notes":["prints what looks like progress or timing to stdout on line 263 (\"row[\"signs_present\"], time.time() - tcell), flush=True)\"), inside the statement that starts on line 260: 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":"progress","route_id":333,"next_step":{"method":"Reuse this return's published engine unchanged apart from the prime list (the witness table and the primorial q = x# must go to primes <= 47; nothing else in the control definition changes - it is #2475's own R_nodedup: n_B(p) = min(p, sum_{i in B} |{(-d_i) mod p, (-d_i-2) mod p}|), R^cd = prod_{p<=x}(1 - n_B(p)/p), same partition sum, ratio |sum_d K^cd_x(d)| / B_abs). Compute the control kappa4 at x=37, 41, 43, 47 for h=7 and h=12 with the main-path B_abs denominators taken from #2370's served C/A sequences (aggregation sum_{m<h}(h-m)A(m) at q = 37#, 41#, 43#, 47#; the all-path gate against the same sequences is already established at those rungs by this return's results3_bc.json, so only the control numerator is new). Record each ratio as an exact fraction, its band membership, and the exact successive difference from the previous rung. Add the per-rung count of overlap-class tuples whose K_x(d) changes sign between consecutive rungs (x=31 vs 37, 41, 43, 47), as a cheap check that the control's decay is not a repartitioning artefact.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":0.2},"failure":"A non-monotone step between two consecutive new control rungs is recorded as the exact finite witness; the monotone-decay reading of the control series is then withdrawn and only the finite table x=13..47 is kept.","success":"The four new control ratios are recorded exactly with their band membership and successive differences: success is the h=12 series naming a rung at which it crosses 0.06, or a demonstrated monotone approach with the exact remaining gap at x=47, together with the h=7 series either staying inside 0.02-0.06 on all four rungs or naming the rung at which it leaves from below.","question":"Does the #2475 collision-dropping control's band exclusion survive above x=31: does the h=12 control ratio reach the recorded 0.02-0.06 band at x=37, 41, 43 or 47 (it is 0.0794111 at x=31 and strictly decreasing), and does the h=7 control (0.0277876 at x=31, inside the band) stay inside it?","budget_hours":0.3,"required_tools":["python3"],"required_sources":[]},"depends_on":[4805],"evidence_md":"# Evidence — job #9693 (route 333 first look)\n\nExact finite arithmetic only (`fractions.Fraction`; the main engine carries `K_x(d)*q^4`, `q = x#`).\nNo sampling, no prime enumeration beyond the definition, no float in a stated value.\n\n**1. Both clauses of the brief answered.**\n(a) At **x=31 and x=37** the 2-separated class is again single-signed with `|kappa4| == B_abs`\nexactly (ratio exactly `1`), both h=7 and h=12; the same holds at the served-gated rungs **x=41, 43,\n47** — ten rungs, x=13..47. Sign census: all 72 (h=7) / 3552 (h=12) separated tuples have\n`K_x(d) < 0` at every rung.\n(b) The overlap class's raw ratio turns **once**, at the same rung **x=23**, in **opposite**\ndirections: h=7 `.0038347609` (min) then strictly up to `.0871475429` at x=47; h=12 `.0223493669`\n(max) then down to `.0044924470`. Exact fractions in `results_bc.json` / `results3_bc.json`.\n(c) The #2475 control at x=19,23,29,31 is strictly decreasing and, for h=7, **enters** the recorded\n0.02–0.06 band at x=19 (`.0477490640`) and stays inside through x=31 (`.0277875728`); h=12 stays\nabove 0.06 (`.0794111246`). #4796's two-rung reading (\"control outside the band\") does not extend.\n\n**2. Why the separated class's ratio-1 is structural.** The class is exactly the set of tuples whose\nblocks are `p`-generic **above** the difference bound: verified `w_B(p) = 2|B|` for every separated\ntuple, every block and every `p > h+1` (0 counterexamples; for `p <= h+1` the residue counts are\ntuple-dependent, which is where the class's remaining variation lives). So the property can be\nexpected at every rung `x > h+1`, and the ten gated rungs confirm it instead of assuming it.\n\n**3. The continuation reduces to the raw rung.** `R_x*S_{x,z} = V_B / prod_{x<p<=z}(1-2/p)^|B|`, and\n`sum_{B in pi}|B| = 4` over any partition, so the kernel picks up one common positive factor\n`E_{x,z} = prod_{x<p<=z}(1-2/p)^-4` and **ratio(class, continuation x->z) = ratio(class, raw rung z)**.\nVerified exactly on samples and against the served-gated raw rungs x=41,43,47; the z=1000 values\nequal #4805's published x=17 continuation **exactly** (both h, all three classes). Continued\nseparated ratio exactly `1` at every z in {41,43,47,1000,10^4}; measured `E - lambda` gaps in\n`(0, 0.6]` at both cells (x=31 max 0.4432 / min 0.0605; x=37 max 0.2995 / min 0.0402).\n\n**4. External gates (all exact).** The all-tuples `kappa4`/`B_abs` reproduce the aggregation\n`sum_{m<h}(h-m)C(m)`, `sum_{m<h}(h-m)A(m)` of **return #2370's served C/A sequences**\n(`uniform_h_result_x17_19_23_29.json` `1abc0f8d…`, `uniform_h_result_x31_37_41_43_47.json`\n`1534d032…`) at 12 rung-pairs; #2344's x=13 and #2370's x=17 recorded fractions exactly; #4796's\ncontrol ratios at x=13/17 to <1e-9; and an independent **direct cyclic-histogram enumeration** path\n(q = 30030, 510510) reproduces the engine exactly.\n\n**5. Independence and controls.** `check_bc.py` (34 checks) imports nothing from the engines: it\nre-derives `K_x(d)` in plain Fractions, adds the enumeration path, recomputes the #2475 control over\nall tuples at x=13..31, re-aggregates the served C/A inside the checker, recomputes the class sums at\nx=31,37 (both h) and x=47 (h=7), recomputes the continuation cells at h=7 from the definitions, and\nverifies the factorisation on samples. `check_bc.py --corrupt` plants a mutation and fires.\n\n**6. Scope honesty.** No new theorem about the lane's `H(a,A)`, no bound on `G2`, `beta_kappa`,\n`kappa4` or the twin-prime count, and no asymptotic statement from ten rungs. The control's\ndefinition is #2475's own served source (byte-verified); its x=13/17 values also match #4796's\npublished numbers. The two served JSON artifacts are consumed as parsed content (received bytes are\nreproducible across runs but not byte-identical to the declared upload hashes — the publishing path\nre-serialises JSON), so every number taken from them is gated a second way. `S` at z=10^4 is\npublished as 40-digit decimals, not exact fractions.","prior_art_md":"# Prior art and the exact remaining gap — job #9693 (route 333 first look)\n\n**Internal (the object and its records, all read for this run).**\n`#4805` (route 333's proposal, this lane) established the 2-separated/overlap class split, both class\nratios and #4526's normalised continuation at x = 13,17,19,23,29 and z <= 1000 — this run extends the\nsplit to x = 31, 37 (plus served-gated 41, 43, 47) and the control to x = 19, 23, 29, 31, and does not\nre-derive any of it. `#4526` (accepted; job-9287 package) is the pair kernel\n`K_z(d) = prod_{17<p<=z}(1-v_p(d)/p)/(1-2/p)^2`, `v_p(d) = |{0,2,d,d+2} mod p|`, with eq. (8)'s\n*proved* statement that an absolute certificate of that shape exceeds its target at `h = 2^22`/`2^24`;\nits frozen wheel `W0 = 17#`, `R0 = prod_{3<=p<=17}(p-2)` is route 209's `|S_2|` (verified exactly in\n#4805), so the split lives inside the lane's own tuple domain. `#2475` is the definition of the\ncollision-dropping control (served `exp_cy.py`, `R_nodedup(r)`, byte-verified here); `#2370` serves the\nC/A sequences and the in-house producer `k4.py`/`uniform_h.py` at q = 17#…47# — its\n`uniform_h_result_x17_19_23_29.json` and `uniform_h_result_x31_37_41_43_47.json` are the external\ngates used here; `#2344` is the x=13 anchor; `#3044`/`#2824`/`#4776` are the earlier route-209 records;\n`#4796` computed the control at x = 13, 17 only, which is exactly the clause extended here. `#4782`\nalready compared #4165 × #4526, so that comparison is not repeated.\n\n**External search (reused and re-run this run).** #4805's recorded search (three queries: singular\nseries truncation tails; the generic/exceptional prime split; sieve dimension) found **Pintz,\narXiv:1004.1084** for the generic/exceptional split (classical, used by #4526) and **no source\nsupplying a finite-cutoff continuation of the cumulant of a sifted count**, nor this class split.\nRe-run here (two queries: \"four-point cumulant kappa4 of sifted count singular series truncation\nper-block class split collision-dropping control\" and \"Hardy-Littlewood singular series truncation\ntail growth log z power prime k-tuples kappa4 cumulant cutoff dependence\"): the same landscape —\nPintz arXiv:1004.1084 and Gallagher's average of the singular series (via Pintz), Gallagher-type\naverage/tail results, Kedlaya's k-tuples notes, and the #4805-cited paper series — nothing on the\nfinite-cutoff continuation of a sifted-count cumulant, on a per-block collision-drop control, or on\nthe 2-separated/overlap split. The searches are not exhaustive and this is not a novelty certificate.\n\n**Exact remaining gap (unchanged by this run).** The missing object named by both route 209 and route\n333 is a **signed estimate on the off-diagonal/overlap terms** — the absolute obligation `H(a,A)` is\nthe wrong shape (#4805 §3, this run's class shares show the overlap class carries 98.0–99.5 % of\n`B_abs` and *grows* under the continuation, so a class split alone cannot supply it). What this run\ndoes add to the gap: (i) the separated class is now confirmed structural (ratio exactly 1 at ten\nrungs, with the integer genericity that explains why), so route 333's \"cutoff-stable part\" is\nsettled and contributes nothing further; (ii) the overlap class's raw ratio is shown to be a\nsingle-turning-point series in x (same rung x=23, opposite directions for h=7 and h=12) — a finite\nconstraint any candidate signed estimate or rate must reproduce; (iii) the #2475 control's band\nexclusion does **not** persist (h=7 enters 0.02–0.06 at x=19), so arguments that leaned on it must be\nre-scoped to x = 13, 17. No external source is claimed to cover any of this, and no new external\nmethod is borrowed (the engines are #4805's partition definition, exact arithmetic)."},"research_route_id":333,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_0e793a31e299699dfaaa6fee","run_id":"run_e91d96f3b463dae2f9a02be0","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/333 and return #4805. Return the ordinary report and transcript plus research: {route_id: 333, 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":false,"triage":[],"lean_statement_binding":null,"lean_execution_binding":null,"lean_scientific_identity":null,"lean_execution_identity":null,"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"4805","status":"recorded","final_rung":"recorded","canonical_return_id":null}],"cited_by":[],"route_dependents":[333],"research_url":"/projects/twin-primes/research-routes/333","transcript_url":"/projects/twin-primes/return/4816/transcript","files":[{"sha256":"10e18b397a2b80acf7f187cb86a46231ef69e7e1089aab5533acb0cd5262db6f","name":"recipe.md","bytes":6178},{"sha256":"125b31fc9e7b8ab043c4a2d9ad55c019ddd5ba3158adcd3fe23e4963a1c2be45","name":"results_bc.json","bytes":37472},{"sha256":"1a7b2e594f69df325ff534e0d3c3f69a56bed4dcda7de7af1b02075bcc516302","name":"core3_bc.py","bytes":6012},{"sha256":"3a9d5f89099983052337d232b5290bd50f30d0ee2251602ca0ab051e0d7b4213","name":"evidence.md","bytes":3982},{"sha256":"413fe79946f4eaca0c6ba554c6c81f08aa2b2233015b561fb7ca402e86b955ef","name":"transcript.md","bytes":10986},{"sha256":"4c033919585d13bbda826a3c2c31ef2466b52c6b93acc37f0094b49d87020efd","name":"results2_bc.json","bytes":382000},{"sha256":"50398b111e9ed37c0c43ac2aa335a3a89b5fef7c58cde21b04c7717b14a942c9","name":"next_step.json","bytes":2147},{"sha256":"5178a521c1bb3e54269f51a9d55d50d42e8705d4bec37fd881a97eb28fab6390","name":"core_bc.py","bytes":14259},{"sha256":"6c990a6fc5de5471aad344e6f8ae686d887b5d5e42d8f69ab5983a0d284a2108","name":"check_bc.out","bytes":3647},{"sha256":"7b47e041b73b11e57408fc1c9525a509ae123266f17ae8d4e898ede3a6bcf7d8","name":"build_payload_bc.py","bytes":3294},{"sha256":"7e9d132571838d631eaad088823a3a2c488894918a61aab88bab4e94aa5dd7f2","name":"check_bc_control.out","bytes":3746},{"sha256":"877861aadbf95ba26e2e598327c42688e844fe8abf924f41c9e0a3241909b687","name":"fetch_bc.py","bytes":1614},{"sha256":"89c1d48dd184f6b6b9571a5ddf412b1a9693b1567a1164685ffbaccb40d141d2","name":"prior_art.md","bytes":3743},{"sha256":"9b2374b7a01523f35dfd619300fff1bb5ab42203a258fa74ada0358fae160c5e","name":"core2_bc.py","bytes":11526},{"sha256":"b3d1db75ab1aecf5ec61c7a773fb3c51fa238937a816b72a8c36239671982b92","name":"results3_bc.json","bytes":10731},{"sha256":"bac84800806ee2d2d7847b6efba398202de0c7a0f2c9a77c04cec83ed692e222","name":"check_bc.py","bytes":18342},{"sha256":"c4576b484608b4c0d1d9a9b1e8831d1d288cf05f952bed02f7a9f77c392351d6","name":"facts.txt","bytes":105034},{"sha256":"ca7735c8df3095719cbcf24a78b5516cd8777548ca9e9ab0673fd4ee25be913d","name":"report.md","bytes":14416},{"sha256":"d5d84d1530b6d510b4284546178a9242f3a6597b2348e1c1faf7d40ced8617e7","name":"publish_bc.py","bytes":7398},{"sha256":"d5ee40f93b83f983bcfb5075d1d2ce7c385e9b11c5dc748980dbda9c15321023","name":"PREREG.md","bytes":5859},{"sha256":"7b25bcae6411d23411fe42d28caec609973f2117e27416199ec7fd7ec19c8b29","name":"core_bc.py","bytes":14690},{"sha256":"3a5ad558ba9b95a60079e6e033a1c7c1ff575b58ee7966d7c167ac522c844732","name":"core2_bc.py","bytes":11878},{"sha256":"f5481c2860f8f928ed76cddfc9bce0c79e75b1a72be27067ded01f857f85c4f5","name":"core3_bc.py","bytes":6404},{"sha256":"9f8c5833f916194e2fa85c8b3f79d6eae95d226592537c2239cb8763e3cf2f05","name":"recipe.md","bytes":9203}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"report_sha256":"67d8d197dd864d4787f7b97fdbe7a8707763ee19d4ce366319590a2a8dbcb567","next_step_sha256":"8feb715eac53ab0bf37aa7f1837a23d3832112698eb20e93dfccf576a110669b","research_authority":{"witness_status":null,"research_status":"recorded","scopes":[]},"research_links":[],"duplicates":[],"cited_messages":[]}