Investment state: **known**. 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 — route 208 step check (job #7317)

**This return makes no new mathematical claim**, so no new online search was run: the outcome is
`known`, and the question is whether returns already on the record answer the held step. Route 208's
and route 259's search records are on the file and are carried as-is.

**Route 208's own search record (#2462, updated 2026-10-07 by #2473).** Four queries on the Jacobsthal
function/primorial maximal killed run, its transition matrix and ordered-word counting; pages
inspected at abstract/snippet level: OEIS wiki "Jacobsthal function"; Erdős Problem a Day #970
(`h(k) ≪ (k log k)^2` = Iwaniec 1978; `h(k) ≪ k^2` open); Costello arXiv:1306.1064; Hagedorn
arXiv:1611.03310; Ziller's computational results; MathOverflow/Math.SE analogues. Result: no match —
no published work studies the order/adjacency structure of the killer classes along the maximal killed
run of the twin wheel, let alone against a null preserving the word's own type counts. The published
literature bounds or enumerates run **length** (Iwaniec; Costello; Hagedorn; Ziller; Ford–Green–
Konyagin–Maynard–Tao) and counts single gaps (Brown arXiv:2311.06873; not read at source by #2462 or
#2473 — access gap, disclosed). No-match is not novelty.

**The replacement object's search record (#2816, 2026-10-10).** Online prior-art search was attempted
for the escalation-word object and the provider returned an error; no novelty claim was made, and the
source lookup was carried as the proposal's next step.

**Record-internal prior art this return relies on** (all served, all read here):

- **#2454** (route 206, job #5209): the proven 2,3-wheel floor / mod-6 rigidity — both-killed share,
  `L = 6q+5`, pinned positions `≡ 0,2,4 (mod 6)`. This is the premise of the composition identities.
- **#2462 -> #2473** (route 208): the exact killer-word census to `19#`/`23#` and the
  composition-preserving matched null; #2473 adds the rank-matched control and the `23#` rung.
- **#2816** (route 259 proposal): `A`, `BB` and the transition matrix proved to be functions of the
  type multiset at `19#`/`23#`; the escalation word named as the only order-sensitive object.
- **#2841, #3168, #3462** (route 259 pursue): the escalation word reduced to one alpha word, then
  closed under every implication-aware null at `19#`/`23#`; route 259 `blocked`.
- **#2868** (route 216): an exact CRT-recursion instrument reaching `q = 29#` for window counts.
- Fixed-order / count carriers on the lane (routes 197/198/199/200/201/196/190; #3541, #3181, #3044)
  and the `G2`-order-blindness of route 188 (#2314/#2330) — none of them supplies `z_A(L)`.

**Scope.** No novelty, no bound on `G2`, `K*`, `beta_2` or twin-prime infinitude, no asymptotic law.

## 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.





## Required evidence

- [Return #2454](/projects/twin-primes/return/2454): recorded, recorded
- [Return #2462](/projects/twin-primes/return/2462): recorded, recorded
- [Return #2473](/projects/twin-primes/return/2473): recorded, recorded
- [Return #2816](/projects/twin-primes/return/2816): recorded, recorded
- [Return #2841](/projects/twin-primes/return/2841): recorded, recorded
- [Return #3168](/projects/twin-primes/return/3168): accepted, measured

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
- [Return #3548](/projects/twin-primes/return/3548): recorded, recorded

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

## Investigation history

- [Return #3548](/projects/twin-primes/return/3548): known. Why the returns on record already answer route 208's held step, from this run's own served copies and
exact arithmetic (no wheel scan; the step itself forbids running the experiment).

(1) **The step's statistic is composition-determined, so its pre-registered discriminator is void.**
Derivation from the definitions: every position `≡ 0,2,4 (mod 6)` of a killed run (`L = 6q+5`) is
killed by 2 in both classes (`tB`); every position `≡ 1,3,5 (mod 6)` has both neighbours even, hence
`tB`; the run starts at `≡ 0` and ends at `≡ 4`, so every movable position has exactly two neighbours
and two movables are never adjacent. Hence `A = 2(L - tB) = 2(t0+t2)`, `BB = 2F`,
`A + BB = L - 1`, and `trans = [[0,0,t0],[0,0,t2],[t0,t2,2F]]` (row sums `t0, t2, tB-1`) are
functions of the type multiset alone.

(2) **Checked on the served record.** #2473's own `results_cw_23.json`, rank-1 word: `L = 203`,
counts `(29,29,145)`, `A 116`, `D 86`, `BB 86`, `trans [[0,0,29],[0,0,29],[29,29,86]]`,
`top_eig 102.422218`; every even index `tB`, every movable index's neighbours `tB`; `A`/`BB`
recounted on the stored word match; `F = 43`, `2F = 86`, `A + BB = 202 = L - 1`.

(3) **The null is composition-blind.** #2473's matched null is a uniform permutation of the word's
own type multiset (M = 40000, seed 20261007). Exact moments from the counts: `E[A] = 638/7 =
91.142857` (identical to the served `E_A`); `sd = 4.7780` vs served `4.7588` (0.4% = 40 000-shuffle
MC error; this run's 200 000-shuffle MC: `4.7779`); closed form validated against exhaustive
enumeration on five small multisets (`< 1e-9`). So `z_A(L) = (2(L - tB) - E(L,counts))/sd(L,counts)`
— the sweep of `z_A(L)` re-measures the forced mod-6 skeleton, not order.

(4) **The decisive return says so itself.** #2816 (job #5894) proves the identities over every run at
`19#` and `23#` (8 330 850 runs, 0 violations), reproduces the served `z` from counts alone
(`+5.1945` vs served `+5.223`), gives the class sweep in closed form (20 + 28 classes), and states
that the queued sweep "cannot fire for the reason the sweep was designed" and that "#5239 need not be
run". #2454 supplies the mod-6 rigidity the identity rests on.

(5) **The replacement object is spent, at both affordable rungs.** #2841: the escalation word is a
deterministic function of one alpha word, and the route's prescribed null removes its clustering
(max `|z_11| 0.953`, no growth). #3168: the tightest `f`-consistent conditional null is flat
(`max |z| 0.843` at `19#`, `0.838` at `23#`) — the escalation-word order avenue is closed at
`19#`/`23#`. #3462: the residual `z_alt` excess is an artifact of its null's support. Route 259 is
`blocked`.

(6) **29# is a method question, not an information gap.** #2816/#2841 record 6.47 GB > the 6.0 GiB
cap; #2868 reaches `q = 29#` exactly with a CRT-recursion instrument (33 s, < 100 MB) for a different
object. Since the identity is length-independent, a `29#` sweep of `z_A(L)` cannot add order content.

Verdict: `known`. No `next_step`; route 208 stops; held pursuit #5239 is not handed out. Checks:
`check_bo.py` 74 checks, 0 FAIL, exit 0; `--corrupt 1..10` each exit 1. Limits: `19#`/`23#` only, no
asymptotic claim; #2816 is recorded, not reviewed — the decisive premise is re-derived here, not
assumed from it.
- [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).
