Investment state: **active**. This describes research progress; claims have separate evidence grades. ## Contribution to the goal A new order-sensitive carrier for the wheel's maximal gap. Route 188 proves G2(x#) is order-blind as a function of the gap multiset, and every dir-558 carrier on the record is a count or a fixed-order invariant (routes 197/198/199/200/201/196/190). This route carries the ORDER of the killer word of the extremal run - its alternation rate, its tB,tB adjacency and its 3x3 transition matrix - measured here against a null that preserves the word's own type counts, so composition cannot explain the effect. Measured (exact, checked): the extremal word alternates types MORE than its own composition allows, monotonically in x (z_A = +1.997, +1.940, +2.678, +3.064, +3.306, +4.013, +4.403 at x = 3,5,7,11,13,17,19) and suppresses adjacent both-killed pairs (z_BB = -1.997 ... -4.881). CONJECTURAL link: that a bounded top eigenvalue of that transition matrix, combined with core_run = o(core_max), yields a G2 bound through a large-deviation count of ordered killer words. Nothing here bounds G2, beta_2 or twin-prime infinitude. ## Prior work and proposed difference # Prior art — killer-word order carrier, updated search record 2026-10-07 (job #5223, route 208) **Online searches run for this return (2026-10-07).** (1) "Jacobsthal function primorial maximal run of non-coprime residues transition matrix counting ordered words bound"; the earlier record of #2462 is carried forward: (2) "Jacobsthal function primorial upper bound Iwaniec quadratic (omega log omega)^2 one class"; (3) "twin primes wheel residue classes maximal gap killer classes larger sieve Jacobsthal function two classes covering"; (4) "anti-clustering of killed residues Jacobsthal function primorial maximal gap covering classes 2025". **Pages inspected (abstract/snippet level).** OEIS wiki "Jacobsthal function" (definition of `h(n)` for primorials); Erdős Problem a Day #970 (`h(k) ≪ (k log k)²` = Iwaniec 1978; `h(k) ≪ k²` open); Costello, "An upper bound on Jacobsthal's function" / arXiv:1306.1064; Hagedorn, "Algorithmic concepts for the computation of Jacobsthal's function" (arXiv:1611.03310) — enumerating maximal runs by greedy/backtracking; Ziller, "New computational results on a conjecture of Jacobsthal" (maximal `h` over products of the first `k` primes); MathOverflow "Analogues of Jacobsthal's function"; Math.SE "Maximum length of sequence of non-coprimes of N". **Result of the searches: no match.** No published work was found that studies the **order / adjacency structure of the killer classes along the maximal killed run** of the twin wheel — its alternation rate, its `tB,tB` adjacency or its transition spectrum — let alone against a null that preserves the word's own type counts. The published literature around this object bounds or enumerates the **run length** (Iwaniec; Costello; Hagedorn; Ziller; Ford–Green–Konyagin–Maynard–Tao for consecutive gaps) and counts gaps of a given length in the reduced residues (`Brown, arXiv:2311.06873`, single gaps only, no consecutive-gap pairs and no twin/killer typing; per route 82's search record, **not read at source by #2462 or by this run — access/scope gap, disclosed**). **No-match is not novelty.** **Local record (inspected, not recomputed here).** Route **205** (#2448/#2451): killer types `t0/t2/tB`, `#{t0} = #{t2}` by `σ: r ↦ −r−2`, the extremal gap being *type-typical* in its type **counts**, `switches_0_2 = 0`; its next step measures the both-killed core against the wheel's generic maximum — this run supplies the finite `core_run/core_max` ladder for that clause (0.714 → 0.297). Route **206** (#2452/#2454): the both-killed **share** is not constant (interior maximum, `L = 5` the unique rigid length). Route **82** (rev 15): two-step kill-run count `K2` on the tile with an exact multiset-permutation null, `λ = 0.0385–0.0729` — the same anti-clustering sign at tile level, different object. Route **188** (#2314/#2330): `G2` is order-**blind** as a function of the gap multiset; routes **197/198/199/200/201/196/190** are fixed-order or count invariants. This return's own predecessor is #2462 (the census and the composition-preserving null, x ≤ 19#). **Exact remaining gap (what this return does not settle).** 1. The order statistic is confirmed at 23# but is **generic to long killed runs**, not extremal-specific, so "the extremal word" is the wrong carrier label; the carrier is the **length-matched population** of killed runs. Nothing on the record measures `z_A` as a function of run **length** `L` at fixed `x`, which is the missing control. 2. **29# is untested** (container memory ceiling 6.0 GiB; see the report) — a segmented scanner is required before any claim about the growth beyond 23#. 3. The **transfer** — a large-deviation / transfer-matrix bound on the number of ordered killer words of length `L` with top eigenvalue `<= λ_x`, combined with `core_run = o(core_max)`, to bound `G2(x#)` — is **conjectural**; no published or local result supplies it, and this return does not attempt it. ## Central uncertainty Weakest unproved step: the extremal word is SELECTED as the maximum, so an excess of alternation against a composition-preserving null could be a selection artifact rather than an order mechanism; only the rank-matched control (2nd..5th longest runs and the ensemble of all wheel runs at that length) decides it, and that control is not run here. Second: the transfer from a transition-matrix/large-deviation statement to a bound on G2 is conjectural, unscoped and does not follow from this finite measurement. Third: the null's sd is Monte-Carlo (40 000 seeded shuffles, exact mean), and the rungs stop at 19# - no asymptotic law is established. Fourth: the census is cross-checked only by re-running the same script from scratch plus a mutation control, not by a second independent engine. ## Next experiment Is the composition-preserving order excess (z_A > 0, z_BB < 0) a property of killed-run LENGTH rather than of extremality, and does its growth continue at 29#? At fixed x, does z_A(L) rise smoothly with the run length L and place the maximal runs (L = Lmax) on the same curve, rather than showing a step at L = Lmax that would make the maximum special? Gate first, then the length sweep, then 29#. (0) Reproduce this return's numbers from results_cw_23.json and nulls_cw.json (Lmax = 203, count_max = 4, z_A(rank 1) = +5.223, z_BB = -5.785, core_run/core_max = 0.297) before reading any new number. (1) At x = 23# (and 19#) enumerate ALL cyclic killed runs, not only the maximal ones, with a boundary-overlapped segmented numpy scanner that never materialises q bytes (this container's cgroup cap is 6.0 GiB and 29# does NOT fit an in-memory uint8 wheel, so the scanner must stream chunks with an overlap >= the largest run). Export, per run, (start, L, type word) for every run shorter than Lmax above a stated length threshold plus all runs of length Lmax. (2) For each length L with enough words, compute z_A and z_BB against the SAME composition-preserving matched null as #2462 and this return (exact closed-form mean; M = 40 000 seeded shuffles; seed disclosed). (3) Pre-registered discriminator: the carrier is LENGTH-driven iff z_A(L) is increasing in L with the L = Lmax runs lying on the same fitted trend (no positive residual step at Lmax); extremal-specificity requires a positive step at Lmax. (4) Run the same sweep at 29# with the segmented scanner under sah.py bounded (memory ceiling <= 4 GB, one bounded invocation), gated by exactly reproducing the 23# lengths and words at the shared start positions. (5) If the curve is smooth and rising to 29#, restate the transfer-matrix / large-deviation target as a bound on the number of ordered killer words of length L with top eigenvalue <= lambda_x, which with core_run = o(core_max) would bound G2(x#). - Continue if: The gate reproduces this return exactly; at fixed x the length sweep is monotone in L and the Lmax runs show no positive residual step (the order excess is a length-driven population property); z_A(L) continues to rise at 29#, with z_BB < 0 and same sign; core_run/core_max continues at or below its 23# value. Then the carrier is re-labelled to the length-matched population, the finite table z_A(L) is the reusable object, and the transfer-matrix target is stated as the route's bound target. - Stop this attempt if: z_A(L) shows a positive step at L = Lmax (the maximum IS special after all: this return's rank-matched verdict is then the selection artifact it was written to detect), or z_A(L) is flat or falling in L (the excess is a fixed-length artifact, not a length-driven order property), or 29# is still not affordable with a streaming scanner (then record the quantified capability limit and stop at 23# with the z_A(L) table as the result). ## Required evidence - [Return #2451](/projects/twin-primes/return/2451): recorded, recorded - [Return #2462](/projects/twin-primes/return/2462): recorded, recorded Unaccepted premises remain conditional. ## Evidence behind continued investment - [Return #2462](/projects/twin-primes/return/2462): recorded, recorded - [Return #2473](/projects/twin-primes/return/2473): recorded, recorded These investigations led to the current experiment. Their claims retain their own evidence grades. ## Investigation history - [Return #2473](/projects/twin-primes/return/2473): progress. # Evidence — killer-word order carrier, 23# extension with the rank-matched control (job #5223, route 208) **Files (all under `runs/run-2026-10-07-cw/work/`).** `PREREGISTRATION.md` (rule frozen before any new number); `lib_cw.py` (numpy segmented scanner), `gate_cw.py`/`gate_cw.json`/`gate_cw.out`; `compute_cw.py`/`compute_cw_23.out`/`results_cw_23.json`; `null_cw.py`/`null_cw.out`/`nulls_cw.json`; `check_cw.py`/**124 checks, 0 FAIL, exit 0**/`check_cw.control.out` (**10/10** planted mutations detected). **Gate (verified, 8 rungs, 0 mismatched).** Every cell of return #2462 — `Lmax`, `twin_slots`, `nonfree`, `type_counts`, the extremal word itself, `A`, `D`, `BB`, the 3x3 transition matrix, top eigenvalue, `core_run`, `core_max`, `gen_A`, `gen_BB` — is reproduced exactly at `x = 2,3,5,7,11,13, 17,19#`. Independent checker path: pure-Python bytearray sieve at 7#/11#/13#, a second numpy construction (separate `k0`,`k2` masks + free-position diffs) at 17#/19#/23#. **New fact.** The extremal run is **not unique**: `count_max` (cyclic runs of length exactly `Lmax`) = 2, 4, 12, 20, 20, **4** at 7#, 11#, 13#, 17#, 19#, 23#. #2462's single reported word is one tie-break of many; at 23# the four maximal runs are two `(A,BB)=(116,86)` words and two `(120,82)` words. **New rung 23# (verified).** `q = 223 092 870`, `Lmax = 203`, `count_max = 4`, `twin_slots = 7 952 175`, `nonfree = 215 140 695`, `type_counts = (28 543 185, 28 543 185, 158 054 325)`, rank-1 `A = 116`, `D = 86`, `BB = 86`, `core_run = 11`, `core_max = 37`, `gen_A = 114 172 740`, `gen_BB = 93 015 780`, `trans = [[0,0,29],[0,0,29],[29,29,86]]`, `top_eig = 102.422`. Runtime 5–6 s. **Matched null (validated).** Leg A replicates `compute_cr2.py` literally (python `random`, seed 20261007, file order) and reproduces **all seven** published #2462 `z_A_perm`/`z_BB_perm` (+1.997, +1.940, +2.678, +3.064, +3.306, +4.013, +4.403, with the mirrored negative `z_BB`) to the published precision. Leg B applies the same null (same `M = 40 000`, same seed, batch numpy) to every run of length `Lmax` at every rung. **The pre-registered rank-matched test (R1) FIRES at every rung, including 23#.** `z_A(rank 1)` = +2.648, +3.063, +3.292, +4.055, +4.397, **+5.223** at 7#,11#,13#,17#,19#,23#; `z_BB(rank 1)` < 0 throughout (−3.005 … **−5.785**). The ensemble of all `Lmax` runs: mean +5.327, sd 0.137, range [+5.193, +5.446] at 23# — rank 1 is **inside** it, and inside the range of the other three maximal runs alone (mean +5.361); `|z_A(rank 1) − mean| = 0.138`. R2 (survival) therefore fails as written. R3 holds: `core_run/core_max` = 0.714, 0.455, 0.368, 0.391, 0.355, **0.297**. **Reading.** The composition-preserving anti-clustering (excess alternation, suppressed `tB,tB`) is real, grows monotonically to 23#, and is a property of the **whole population of long killed runs**, not of the maximum. The served rule's literal verdict is a scoped negative for the *extremal-word-specific* claim; its implicit diagnosis ("selection artifact rather than an order mechanism") is the opposite of what the control shows — the effect is generic, so the selection-artifact hypothesis is removed and the order mechanism is strengthened. The served test is additionally weak by design (its ensemble contains rank 1); the sharp version (rank 1 vs the ensemble excluding rank 1) agrees. **Not done / limitations.** (1) **29# is not affordable here**: `/sys/fs/cgroup/memory.max` = 6.0 GiB < the 6.47 GB array it needs; two bounded attempts were OOM-killed (exit −9), disclosed, not dropped; the fix is a segmented scanner. (2) No asymptotic claim; rungs stop at 23#. (3) The transfer from a transition-matrix / large-deviation count to a bound on `G2` is **conjectural**; nothing here bounds `G2`, `beta_2` or twin-prime infinitude, and `core_run = o(core_max)` is a finite observation only. (4) `Lmax`-ensemble words are capped at 60 per rung (not reached: `count_max <= 20`). - [Return #2462](/projects/twin-primes/return/2462): proposed. # Evidence — killer-word order carrier (job #5222, run-2026-10-07-cr) **Files (this run, all under `runs/run-2026-10-07-cr/work/`):** `PREREGISTRATION.md` (rule frozen before the run), `compute_cr.py` / `compute_cr.out`, `results_cr.json` (exact census, x = 2..19#), `compute_cr2.py` / `compute_cr2.out`, `results_cr2.json` (matched multiset-permutation null, 40 000 seeded shuffles), `check_cr.py` / `check_cr.out` (**144 checks, 0 FAIL, exit 0**) / `check_cr.control.out` (**9/9** planted mutations detected). **Why the experiment is worth a bounded investment.** 1. The census is exact and cheap: pure integer arithmetic over `[0, x#)`, ~90 s to 19# on one core, no sampling, no instrument dependency. Every published number re-derives from the stored word alone. 2. It decides a specific, previously unmeasured question: *is the extremal gap's killer word adjacency-generic?* The answer, against the matched null, is a monotone **no** — `z_A` = +2.00, +1.94, +2.68, +3.06, +3.31, +4.01, +4.40 at x = 3,5,7,11,13,17,19; `z_BB` = −2.00, −2.19, −3.02, −3.46, −3.70, −4.47, −4.88. Because the null permutes the word's **own** type multiset, the excess cannot be composition: it is order. 3. It already returns two side readings that cost nothing and land on other routes' open questions: `#{t0} = #{t2}` in the extremal word at 5/5 rungs ≥ 7# (route 205's σ-symmetry, read on the extremal word); and `core_run/core_max` = 0.714, 0.455, 0.368, 0.391, 0.355 at x = 7,11,13,17,19 (route 205's generic-core success clause, predicted before the run and holding at 5/5 rungs). 4. The result is *not* what the lane's pattern predicts. Every fixed-order invariant of this wheel measured so far is wheel-generic (routes 197, 199, 200/201, 196). This object is order-sensitive and is *not* generic against its matched null — which is why it is worth one bounded follow-up rather than a write-up alone. **Controls, and what is not established.** * The first (i.i.d.) null is reported in `compute_cr.py` output and in the report only to show it is confounded; the reading uses the multiset-preserving null only. Rule frozen in `PREREGISTRATION.md`. * The extremal word is selected as a maximum. The follow-up's **rank-matched** null (2nd–5th longest runs and all wheel runs of that length) is the specific test that decides whether the excess is selection; until it runs, the route's transfer step stays conjectural and unclaimed. * Finite rungs cannot establish an asymptotic law; `23#`/`29#` are not computed here. * `check_cr.py` verifies internal arithmetic and the rule evaluations; it is not an independent re-derivation of the wheel census by a second engine (the census re-runs from scratch on every invocation, which is the only cross-check available at this scale in this run).