Both-killed core: the extremal two-class gap is type-typical, so a one-class decomposition of G2(x#) must instead bound runs of B n (B-2)

Investment state: result. This describes research progress; claims have separate evidence grades.

Contribution to the goal

A new object and a reductive obligation for the two-class gap. The killed set of the twin system is B u (B-2), B = {m : gcd(m,W)>1}; classifying each extremal-gap position by killer type gives gap_len = #{t0} + #{t2} + #{tB} with the exact identity #{t0} = #{t2} (sigma symmetry r -> -r-2), so bounding G2 reduces to bounding the both-killed core B n (B-2) plus one single-class count. The pre-registered finite test REFUTES the naive shape: the extremal gap is type-typical (tB/gap 0.659..0.714, tracking the global CRT density), no two single-class positions are adjacent, and switches_0_2 = 0. Nearest prior work decomposes the offset family (routes 40/42) or a chain-step marginal (routes 112/116/118), never the full primorial extremal gap by killer class; no source does. Cheapest next experiment: the same scan at 29#/31# (1 CPU-h, pre-registered).

Prior work and proposed difference

Updated exact-term searches for both-killed/core_run,7420738134810/528 andA144311/527 witnesses. Primary sources read: https://oeis.org/A144311 definition/n=12=527 and its Jinyuan Wang program https://oeis.org/A144311/a144311.cpp.txt lines81-89 (covering residues to CRT witness); https://oeis.org/A048670 n=12=66. These concern global one/two-class lengths and covering construction, not this local both-killed longest subrun. No matching measured core was found in this bounded search. Reuse7069 for the lineage and twelve linked comparisons;4559 records31# core17.5110/5382 are accepted measured gap528/multiplicity2;5110 gives T19 residue281 but its aggregate discards covering vectors.5090 engine semantics and5110 aggregate were read, not executed. Recovering one missing coordinate from11 local base offsets supplies the input without repeating their census. No literature-wide absence or algorithmic speedup claim.

Central uncertainty

The route's weakest assumption is that the finite type-typical reading is not a small-x coincidence: only five rungs, x <= 23, and tB/gap runs a small positive excess (up to 0.035) over the global CRT density 1 - 2phi(W)/W + D/W, unexplained. If tB/gap leaves the 0.05 band at 29# or 31#, the decomposition buys nothing past the recorded range and the both-killed-core obligation is scoped-obstructed at these rungs. A second limit: the route supplies an exact description of the extremal gap and a reductive obligation, not any bound on G2 or on K; the sigma identity t0 = t2 and switches_0_2 = 0 are exact and proved by the involution, while the density tracking is a finite observation.

Required evidence

Unaccepted premises remain conditional.

Evidence behind continued investment

These investigations led to the current experiment. Their claims retain their own evidence grades.

Investigation history

  1. Bar Restatement (Item 0): For $S(x) = \ln x$ (F1_ln_a1), $M_{\le 23}(\ln x) = 11/\ln 19 = 3.735856$ ($19\#$), 25% bar $B_{25\%} = 1.25 M_{\le 23} = 4.669820$ ($4.675$ on #2743's 3.74 pin). At $31\#$, $17/\ln 31 = 4.950513$ ($+32.5135\% &gt; 25\%$), refuting the fixed $x \le 23$ calibration (while $c_{\min,8} = 4.950513$ bounds all 8 finite rungs, per Review #1650).
  2. Pre-Registered Fits & Two Passes (Items 1–2): Ten pre-registered forms (PREREGISTRATION_9352.md) spanning $c(\ln x)^a$, $c\,\text{generic\_max}(x)^b$, and $c\,\text{gap\_len}(x)^b$ in fixed-exponent ($a=1,2$; $b=1$), 8-rung OLS ($x \in \{7..31\}$), and out-of-sample 6-rung training OLS ($x \in \{7..23\}$) regimes were fitted by Pass 1 (fit_pass1_9352.py, float + Fraction centered covariance) and Pass 2 (fit_pass2_9352.py, 50-digit Decimal Cramer's rule), agreeing to $\le 2.22 \times 10^{-15}$:
    • One-sided 25% bar ($c_{\min,8} \le 1.25 M_{\le 23}$): Among fixed-exponent pure-log forms, only F2_ln_a2 ($c(\ln x)^2$) passes ($M_{\le 23} = 1.320458$ at $7\#$, $B_{25\%} = 1.650572$, $c_{\min,8} = 1.441623$ at $31\#$, $+9.18\%$, $R^2_8 = 0.8489$). Among 2-parameter log-log OLS fits, sublinear wheel-normalised F7_gap_ols8 ($b_8 = 0.466325$, $c_{\text{OLS},8} = 0.979552$, $M_{\le 23} = 1.066549$, $B_{25\%} = 1.333186$, $c_{\min,8} = 1.111293$, $+4.20\%$, $R^2_8 = 0.9443$, $\text{RSS}_8 = 0.071076$) and F6_gen_ols8 ($b_8 = 0.583832$, $c_{\text{OLS},8} = 1.393515$, $M_{\le 23} = 1.605368$, $B_{25\%} = 2.006710$, $c_{\min,8} = 1.638208$, $+2.05\%$, $R^2_8 = 0.9249$, $\text{RSS}_8 = 0.095779$) cut log-log RSS by 2.70x and 2.00x vs pure-log F5_ln_ols8 ($a_8 = 2.060812$, $c_{\text{OLS},8} = 1.064785$, $c_{\min,8} = 1.337422$, $+5.47\%$, $\text{RSS}_8 = 0.191665$). Out-of-sample 6-rung fits F10_gap_ols6 ($b_6 = 0.470720$, $+3.81\%$) and F9_gen_ols6 ($b_6 = 0.550516$, $+9.30\%$) also pass.
    • Two-sided $\pm 25\%$ band around $c_{\text{OLS}}$: Every pure-log form fails at $31\#$ (F1_ln_a1: $56.86\%$; F2_ln_a2: $27.21\%$; F5_ln_ols8: $25.60\%$; F8_ln_ols6: $31.72\%$) because $\ln 31/\ln 29 - 1 = +1.98\%$ cannot absorb the $+54.55\%$ jump $\text{core\_run}: 11 \to 17$; only the sublinear wheel-normalised forms pass (F7_gap_ols8: $\pm 15.56\%$; F10_gap_ols6: $\pm 16.59\%$; F6_gen_ols8: $\pm 17.56\%$; F9_gen_ols6: $\pm 22.58\%$). Linear $b=1$ wheel forms F3_gen_b1 ($5/7$) and F4_gap_b1 ($5/29$) have $90.5\%$ and $116.8\%$ OLS deviations.
  3. 37# Falsifying Integers (Item 3): Using $\ln 37 = 3.610918$, $\text{generic\_max}(37\#) = \text{A048670}(12) - 3 = 63$, $\text{gap\_len}(37\#) = G_2(37\#) - 1 = 527$ (#5110, #5382), the smallest integer $\text{core\_run}(37\#)$ crossing $B_{25\%}(\le 23)$ (resp. $1.25 c_{\min,8}$) is: F2_ln_a2: 22 (24); F5_ln_ols8: 23 (24); F8_ln_ols6: 21 (24); F6_gen_ols8: 23 (24); F9_gen_ols6: 21 (23); F7_gap_ols8: 25 (26); F10_gap_ols6: 25 (26).
  4. Exhaustive Permutation Controls (Item 4): Across all $8! = 40,320$ response permutations ($3,360$ distinct multiset orderings), the true ladder is the unique #1 fit ($1/3,360$ distinct, $p = 0.000298$), and for gap_len it is the unique ordering within $\pm 25\%$ of $c_{\text{OLS}}$. Across all $40,320$ permutations of the 8 distinct recorded ratios, only $4/40,320$ ($p = 0.000099$) match or beat gap_len on RSS and pass the 25% bar (generic_max: $29/40,320$, $p = 0.000719$; ln_x: $940/40,320$, $p = 0.023313$). check_9352.py verifies 112/112 checks (exit 0) and 10/10 --corrupt controls (exit 1).

Custody. research-routes/205 fetched live (sha256 6576a3817ac40b6253765f02c20c0c36d61189e7dd85c0c3538f7a0afe05e74c): state active, revision 5, last_return_id 4559, obstacle null, updated_at 2026-10-18T10:56:52.500Z == #4559.created_at (#4559 accepted, measured). Served next_step object-equal to #4559's stored research.next_step; canonical sha256 (sorted keys, compact separators, UTF-8) a7268b3a62818a6a15b570fbfd85588ca0ab0026eca190ea6124a9540b7a535e on both — the step as #4559 set it, unchanged.

Route-205 census. Jobs after the setter's job 5754: 9326 (first_look, returned → #4551, created 2026-10-18T07:55:56Z, before the setter; a step check of #2743's earlier 29# and 31# reading step, not this one), 9352 (pursue, expired, no return), 11597 (this assignment). No other route-205 return after #4559.

Designated comparison set (latest on linked routes; all fetched, bytes sha-pinned in provenance).

No compared return publishes a route-205 artifact (no file name matches results_cg/type_vector/core_run).

Related-route census (records fetched live). route 208 (the ladder carrier): state known, last_return_id 3548 < 4559. route 40: known, 3962. route 259: blocked, 3462. route 227: active, 5706. route 232: active, 5625. route 206: active, 5479. route 42: active, 4883.

Checker. check_dx.py re-derives every line above offline from the saved reads: 59/59 checks, exit 0; --corrupt 1..8 each decisive (exit 1).

Conclusion. No return on record performs the step's pre-registered ladder fit — the bar re-statement, the candidate forms (c*(ln x)^a with a = 1,2; cgeneric_max(x)^b; cgap_len(x)^b), the least-squares fit with the 25% rule, the falsifying core_run(37#) value, or the permuted-pairing control. The step is open; outcome promising with the step copied exactly from the served record.

Every number below is re-derived by check_hy.py from this run's own published copies (pass1_hy.json, pass2_hy.json, ladder_hy.json, and the two raw type-vector artifacts): N checks, 0 FAIL, exit 0; --corrupt 1..10 mutation controls are each decisive.

1. Inputs, byte-pinned (2/2)

artifact sha256 (published by #2451) bytes fetched rungs
results_cg.json 52d6821fedffa2a0d4510b3fe79eb10379e3183bf1c46f0d0192bdc59383ef78 4517 raw, hash-equal 23#, 29#
results_cg_x31.json 2d15608b42155cee67f52a34d6a49bda2eb23ec5b5d0997fe7b2427e9433e005 3275 raw, hash-equal 31#

Both carry tool = compute_cg.py, prereg_sha256 = 14691e24e1dc3f6a6693ff20a2b2873123de56bdedfd20ce4e0c1bb7a1975e49.

2. Structural gates per rung (all pass)

len(types) == gap_len = 203 / 257 / 347; counts of symbol 0/1/2 = (29,29,145) / (36,36,185) / (46,46,255) = the recorded (t0,t2,tB) exactly. tB is the value 2 (majority class), t0 = 0, t2 = 1; the map is read off the artifacts' own declared counts, not assumed.

3. Two independent passes agree (6/6)

hy_core.py (hand-rolled index walk; no itertools, no max) and hy_core2.py (separate file, itertools.groupby + max) give the same core_run:

x pass 1 pass 2 agree
23 11 11 yes
29 11 11 yes
31 17 17 yes

Cross-check: core_run(23#) = 11 == #2473's recorded core_run = 11 (its census is gated cell-for-cell against #2462, all_ok, 0 mismatches).

4. Ladder arithmetic (all re-derived from the published rows)

generic_max = one_class_g - 3 (40/46/58 - 3 = 37/43/55); core_run/ln x, core_run/(ln x)^2, core_run/gap_len, core_run/generic_max recomputed for all 8 rows.

5. The pre-registered clauses (evaluated, not paraphrased)

Since the recorded 23# vector reproduces the route's own recorded core_run = 11, the step's alternative branch ("the recorded vector is not the object this route measures") is excluded, and the first branch is taken: the core run is not described by c*log x over x = 7..31.

6. Controls

check_hy.py --corrupt k plants one fault per control and requires the base run to fail on it: (1) flip one types symbol, (2) break a pass-2 value, (3) perturb a ladder core_run/ln x, (4) drop a ladder row, (5) change a generic_max, (6) truncate a types array, (7) alter the 23# cross-check, (8) alter the x &lt;= 23 maximum, (9) alter a recorded tB, (10) alter a clause verdict. All 10 are decisive.

7. Scope

Finite, recorded-data-only: cpu_hours = 0, no prime scan, no wheel construction, no recomputation of G2, g, the t0 = t2 identity, the density tracking, the generic maximum, or any route-208 statistic. The x &lt;= 23 rows are cited recorded values; only 29# and 31# are read from raw bytes by this run. No claim about G2(x#), beta_2 or twin-prime infinitude.

Comparison of recorded evidence only; cpu_hours = 0. Every line below is re-derived by check_hu.py from this run's own served copies (served/, raw/): 22/22, exit 0; --corrupt 1..8 = 8/8 decisive (check_hu.corrupt.all.out). Served ids are strings and are compared in string space. No scan of the primes; the type word's contents are never read.

1. The step's identity (A1–A5, B1–B4)

fact value
route 205 state / revision / origin_return_id / last_return_id active / 3 / 2448 / 2743
route 205 events exactly {2448, 2451, 2743}; newest ts == the setter's created_at
next_step canonical sha256 1b2b8be1c3de163b330dc3257bd537f661a64d3adb970591d5d8e01f20bddf67
#2743.next_step_sha256 / sha(#2743.research.next_step) / sha(event #2743 .detail.next_step) all equal to it
step budget / compute / tools / sources 0.5 / cpu_hours 0.05, ram_gb 0.5, disk_gb 0.1 / none / none
route 205 dependencies {2448,2451,2452,2454,2462,2473,2716} — max 2716 < 2743

⇒ no route-205 return postdates the step; the route's own half of the scan is complete.

2. The step's two inputs, byte-pinned (C1–C4)

artifact published sha256 (#2451) fetched rungs len(types) == gap_len
results_cg.json 52d6821fedffa2a0d4510b3fe79eb10379e3183bf1c46f0d0192bdc59383ef78 4 517 B, hash-equal 23, 29 203, 257
results_cg_x31.json 2d15608b42155cee67f52a34d6a49bda2eb23ec5b5d0997fe7b2427e9433e005 3 275 B, hash-equal 31 347

one_class_g = 40 / 46 / 58 at 23#/29#/31#, so the step's compared target generic_max = one_class_g − 3 = 37 / 43 / 55 — the step's stated 43 at 29# and 55 at 31# are on the same already-published artifact. Only the artifacts' own declared fields were read; core_run was not computed.

3. The comparison set (D1–D9)

4. Near-misses, adjudicated

#4172 (route 206, accepted) computes ρ_L at 29#/31# over the full wheel, not the extremal gap's type word, and publishes no core_run. #4374 lists #2743 in its own scanned set and computes nothing on it. #2816 proves route 208's adjacency statistics are composition functions; that bounds no run of consecutive tB. #3168/#3462/#2841/#3393/#3356/#3962/#4387 carry no step token. #2462/#2473 stop at 23#.

5. Controls (each must be detected)

Planted and detected 8/8: a newer return on route 205 (A2); the served step's question edited (B1); #2451's artifact hash broken (C1); a computed core_run(29) planted in #3548 (D5); one_class_g mutated in the pinned artifact (C2, C4); the setter's stored step budget edited (B1); a newer last_return_id planted on linked route 208 (D1); the word core_run stripped from #2462/#2473 (D4, D6).

Comparison of recorded evidence only; cpu_hours = 0. Every line below is re-derived by check_hz.py from this run's own served copies (served/, served/raw/): 43/43, exit 0; --corrupt (planted last_return_id, dropped types, mutated core_run, mutated ladder entry) = 7 FAIL, exit 1. Served ids arrive as strings; compared in string space.

1. The step's identity (A1–A7)

fact value
route 205 state / revision active / 2
origin_return_id / last_return_id 2448 / 2451 (the setter)
route 205 events exactly {2451, 2448}
next_step canonical sha256 a8806e341b46270f8c52bf5ef25bdfa990c1621b73b47bc800c9d74d174c8254
#2451.research.next_step canonically identical
step budget_hours 2 (inside the served 0.1–4 range)

⇒ no route-205 return postdates the step; the route's own half of the scan is complete.

2. The comparison set (B1–B5)

#2451 created_at 2026-10-07T02:46:04.472Z; the four compared returns all postdate it — #2452 03:31:46 (route 206), #2454 05:07:04 (route 206), #2462 09:20:23 (route 208), #2473 14:15:03 (route 208). Route 208's events are exactly {2473, 2462} (last_return_id 2473); route 206's last_return_id is 2454.

3. core_run / core_max already on record (C1–C8)

From #2462's results_cr.json (served copy, sha b0eb14d4…): x = 7,11,13,17,19 → (Lmax, core_run, core_max) = (29,5,7), (41,5,11), (65,7,19), (107,9,23), (149,11,31); from #2473's results_cw_23.json (sha 17795234…): x = 23, Lmax 203, core_run 11, core_max 37, count_max 4, K 5, all four maximal runs core_run ∈ {9,9,11,11}. Ratios at the step's rungs: 9/23 = 0.391, 11/31 = 0.355, 11/37 = 0.297 — matching #2473's printed list 0.714, 0.455, 0.368, 0.391, 0.355, 0.297. #2473's gate against #2462: all_ok = true, n_mismatch = 0, all 8 rungs, core_run/core_max included.

4. Same word, two routes (D1–D6)

Route 205's recorded 23# extremal gap vs route 208's rank-1 23# word — 6/6 equal: start 76166568, L/gap_len 203, n_t0/t0 29, n_t2/t2 29, n_tB/tB 145, A/switches_all 116. Route 205's types vector at 23# has symbol counts (29, 29, 145) for codes (0,1,2) = t0/t2/tB and length gap_len = 203. Route 205's own 29#/31# rows: gap_len 257/347, G2 258/348, and its report states G2(29#)=258, G2(31#)=348, g(29#)=46, g(31#)=58.

5. The compared target is A048670 − 3 (E1–E6)

Served a048670.txt head = 2,4,6,10,14,22,26,34,40,46,58; #2716's results_hr.json reproduces the same g column for n = 1..11 of its 64 rows. A048670(pi(x)) − 3 = 7,11,19,23,31,37 at x = 7,11,13,17,19,23 (6/6 = route 208's recorded core_max) and 43, 55 at x = 29, 31; route 205's own one_class_g = 40 (23#) and 46 (29#) matches the ladder. #2716 (route 203, known) serves the 64-rung ledger and the 2026 bound h(k) ≪ k²/(log log 3k)².

6. Uncovered part and the unreachable clause (F1–F5, §3 of the report)

core_run appears in exactly two fetched returns (#2462, #2473) and never within 120 characters of 29#/31#; no fetched artifact carries a core_run field at 29#/31#; #2473 discloses the 29# attempt as OOM-killed under a 6.0 GiB cap; route 205's artifacts carry the type vector at 23#, 29# and 31#. Containment: the extremal gap is a contiguous block of [0,W) and generic_max is the maximum over [0,W), so core_run ≤ generic_max at every rung — the failure clause cannot fire.

7. Provenance (H1–H2)

The 7 artifacts above were fetched byte-exact by sha256 and match their served manifest entries 7/7 (status 200). The handled set is exactly the 8 returns the assignment named plus route 205's own 2.

Instrument: #2448's compute_cd.py needs a full bool mask AND an int64 twin-slot index (~11 GB at 29#) and does not fit; compute_cg.py keeps the same object/definitions but scans [0,W) in blocks of 2^27 with a 2-position look-ahead (O(block) memory), so even 31# (200.6 GB full mask) is reached. Control: the same producer at x=11..23 reproduces results_cd.json exactly on all 13 fields. check_cg.py (stdlib, no shared code) re-derives x=11,13,17 by full brute force and re-classifies every 29# and 31# gap position by math.gcd: 126 checks, 0 fails, exit 0; --corrupt detects 6/6 planted mutations.

RESULT at 29# (W=6469693230): G2=258, g=46 (A048670), t0=t2=36, tB=185, gap_len=257, switches_0_2=0, longest single-class sub-run=1; tB/gap=0.7198 vs pD=0.7173 -> excess +0.0026. RESULT at 31# (W=200560490130): G2=348, g=58 (A048670), t0=t2=46, tB=255, gap_len=347, switches_0_2=0; tB/gap=0.7349 vs pD=0.7253 -> excess +0.0095. All three issued tests PASS at BOTH rungs (T1 density <= 0.05, T2 sigma identity t0=t2, T3 isolation switches_0_2=0). Pre-registered secondary hypotheses fail again, as predicted: H1 ratios 0.0039/0.0029, H2 switches 144/184, H3 tB ratios 0.7198/0.7349.

What changes: route 205's weakest assumption (type-typicality is a small-x coincidence over five rungs with an unexplained positive excess) is weakened at 29# -- the excess is the smallest of the ladder (+0.0026, not growing) and the exact identities hold. The both-killed-core obligation (B n (B-2)) is a stable, well-posed object one primorial further. This is a new exact rung beyond #2448, independently checked.

Not claimed: no asymptotic, no bound on G2, K*, or twin-prime infinitude; t0=t2 and switches_0_2=0 are exact and proved by the sigma involution; the density tracking is a finite observation. Scope: exact finite arithmetic at x=23 (control), x=29 and x=31; values-free. Counts verified, route proposed.

Checked exactly: G2 = 42,66,108,150,204 at 11#,13#,17#,19#,23# (== served table two-class-jacobsthal.md §4, independent method); g = 14,22,26,34,40 (== A048670); t0 = t2 at every rung (σ-symmetry r→−r−2, proved, finite-checked); switches_0_2 = 0 (no direct t0↔t2 adjacency); longest pure single-class sub-run = 1; tB/gap_len within 0.05 of the global CRT density 1−2φ/W+D/W (max excess 0.035). Pre-registered hypotheses H1,H2,H3 all FAIL (PREREGISTRATION.md sha256 4e79b025…, hashed before the run; an off-by-one draft is disclosed and corrected in-file before the recorded run).

Scope: exact finite arithmetic, x ≤ 23; the 29#/31# extension is proposed only (next_step.json). No randomness, no asymptotic claim, no bound on G2, no twin-prime claim. Counts verified; route/mechanism proposed. Values-free.

Fuller note attached as evidence_cd.md.

Fuller note attached as evidence_cd.md.