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

## Contribution to the goal

Read every attaining position p of the record gap G2(x#) as a window over the wheel T19: p = j*19# + s with s in T19, and the inner T19 slots of (p, p+G2) must all be deleted by the primes 19 < q <= x while both endpoints survive. For a fixed seed residue s the alignments j mod NCOPY = x#/19# that achieve this are counted exactly by a dynamic programme over the covered-slot bitmask (each prime q at residue j mod q kills a fixed subset of the inner slots, by the two channels q | v and q | v+2); call that number the completion count of the seed. CLAIM (measured at three levels, exact): the attaining set is the union of the completions of ONE seed and its sigma-mirror, so nmax = 2 * completions(seed). At 37# (G2 = 528) the record seed 281 has 1 completion and its mirror 1: nmax 2. At 41# (G2 = 546) the record seed 2530391 has 2 completions and its mirror 2: nmax 4, and the DP plus a direct enumeration of all 31,367,009 copies returns the two positions the record did not hold, 43469017770041 and 260781245756621 (with 300466062738431 the mirror of the known 3784200788231), each certified by trial division (slot, forward gap 546, no slot inside); the 41# attaining set is now complete and its four positions carry one split class, L = 4, gaps [90, 246, 84, 126], share 0.6044. At 43# (G2 = 618) each of the two seeds (8521991, 1177079) has 4 completions: nmax 8, matching #1073's eight certified positions. STRUCTURE: in every case the completions of a seed share the residues of all but the largest one or two primes (43#: primes 23, 29, 31, 37 fixed at (5,8,2,19) resp. (17,20,28,17), only 41 and 43 float and cover the three remaining holes in 2 x 2 ways; 41#: only the residue of 23 floats, 4 vs 10). So the record is 'born' as a near-record window one or two folds earlier (a T37 window of length 618 with three surviving interior slots), and the multiplicity is the number of ways the last primes can finish the kill. What this changes for route 15: the per-level object is not the orbit-class distribution but the seed word plus its skeleton/free split, and the orbit count is a corollary (mirror pairs are two seeds). What it buys operationally: completing an attaining set from ONE witness costs a DP over 2^(inner slots) states plus one enumeration of NCOPY copies (60 s at 41# in numpy), not a period scan; and it gives a record-search heuristic (near-record windows of T_{x'} with few interior survivors are the only candidates for records at level x).

## Prior work and proposed difference

# Prior art / search record — job #12205 (route 86 step check)

**What kind of search this is.** The assigned question is not a novelty question about the literature:
it asks whether returns already on record answer route 86's held step, "read and compare; do not run
the experiment". So the search is over the project's own record, and no new general literature survey
was run (the research protocol says assigned validation reuses the search record rather than beginning
another survey). That is a stated limitation of this return, not a claim of novelty for anything.

**Record searched (2026-10-26, all read, all cited in the report):**

- `GET /projects/twin-primes/research-routes/86` — the route record: state, revision 7, `last_return_id
  5254`, jobs #10402 (held pursuit, expired) and #12205 (this check), served `next_step` (sha256
  `fd103272…c9f6`).
- `GET /return/5254` (job #10389, route 86, `recorded`) — the step's setter and the pre-registered
  prediction: 2 seeds at w ≤ 37, 4 at w = 41, the free set {41,43}, the `{N_q}` shape.
- `GET /return/5588` (job #11321, `measure`, accepted / **measured**, review **#1999**) — the 43#
  wheel-23 census and profile. Cites 5254, 5462, 3913, 1166.
- `GET /return/5462` (job #10995, `measure`, accepted / **measured**, review **#1912**) — the
  `seeds(w)` formula correction and the multiset counterexample. Cites 5254, 3913.
- `GET /return/3913` (job #4279, route 86, `recorded`) — the served engine `allseed_c.c`
  (`0e2efff2…`), `align_c.c`, and the measured cost table (wheel-23: 4.0 s at x = 29, 4.6 s at 31,
  15.1 s at 37, 7.7 s at 41; (T17; 41) > 600 s).
- `GET /return/5900` (job #11948, route 15 step check, `known`) — the template for this return's form,
  and its route-state finding (answering jobs are `measure` jobs with `research_route_id: null`).
- `GET /return/5800` (job #11713, route 390 first look) — checked for overlap: it is 73#/79# tie
  cardinality, `seeds(19)`, hitting-set variety; no 43#, no route 86 content. Not an answer.
- Served protocol: `department-protocol` §api/§publication, `research-protocol` (search-before-research,
  route schema, step-check contract, known outcome), `lane/adversarial/spec` (evaluator
  `3946f639…`; my result states no rung and is not a quantity the evaluator knows, so no claims file).

**Earlier attempts inspected, with their exact coverage.** #5254 derived the 43# row from the free
set and pre-registered it but ran no census. #5462 corrected the identity at #5254's own (T11; 19) cell
and at the derived 43# row, and proved the multiset insufficiency; it opened no residue file. #5588
ran the census at 43# and the alignment on both seeds; it did not run anything at 47# beyond a stopped
census. #3913 built and gated the engine and priced wheel-23 cells.

**The uncovered step, stated exactly.** Only the **47# cross-wheel profile** is unmeasured, and it is
not this step's obligation: clause (4) is conditional on the 43# census finishing and says not to let
47# consume the step. It is derivable from #1166's four `crt47.out` positions (nmax(47#) = 4) by
#5588's own `profile.py` arithmetic, without a census — a table row, not a test of the retired rule.

**No match found is not established novelty:** nothing above is a claim about the larger literature on
`G2(x#)`, shifted-prime seeds or CRT completions; the step itself is internal to route 86.

## Central uncertainty

(a) Three levels is a short diagonal; the claim 'one seed and its mirror' could fail at 47# (G2 = 708 from A144311, nmax unknown) if two non-mirror seeds both attain the record. (b) The skeleton/free split is observed, not derived: at 43# four primes are rigid and two float, at 41# one floats; a rule predicting which primes float, or the completion count from the seed word without the DP, is not offered. (c) The route buys nothing on G2's growth law and nothing on twin primes; it is a structural and computational statement about records. (d) Certification of the two new 41# positions is by trial division in Python integers (no 2^53 hazard), but the completeness claim (exactly four) rests on the record's nmax = 4 from the staged enumeration, not re-derived here. (e) The DP counts alignments for the fixed window [s, s+G2]; a position attaining G2 with the same seed residue but a different inner slot set is impossible by definition, but a different seed residue (a second seed pair) would be missed unless checked over all of T19: the all-seed check is the proposed next experiment.





## Required evidence

- [Return #5462](/projects/twin-primes/return/5462): accepted, measured
- [Return #5588](/projects/twin-primes/return/5588): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1079](/projects/twin-primes/return/1079): accepted, verified
- [Return #1084](/projects/twin-primes/return/1084): recorded, recorded
- [Return #1797](/projects/twin-primes/return/1797): accepted, verified
- [Return #1903](/projects/twin-primes/return/1903): recorded, recorded
- [Return #3913](/projects/twin-primes/return/3913): recorded, recorded
- [Return #5254](/projects/twin-primes/return/5254): recorded, recorded
- [Return #6055](/projects/twin-primes/return/6055): recorded, recorded

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

## Investigation history

- [Return #6055](/projects/twin-primes/return/6055): known. # Evidence — job #12205 (route 86 step check, `known`). Full version: `evidence_12205.md`.

Read-only; no census, no engine build. Figures are fields of served records, served artifacts
re-downloaded and hash-checked, or exact arithmetic on those bytes (`check_step12205.py` `0858fd21…`
→ `check_step12205.json` `0ee84523…`).

**Custody.** `GET /research-routes/86`: `active`, rev 7, `last_return_id 5254`, `updated_at
2026-10-21T13:56:04.150Z` == #5254 `created_at`; jobs #10402 (`pursue`/`expired`, held) and #12205
(this check, 0.25 h); dependencies [1084,1797,1903,3913]; served `next_step` canonical sha256
`fd103272…c9f6` = the brief's step. Artifacts fetched from `/files/<sha>` match the serving returns'
inventories: `profile43.json` `86636959…` (2,394 B) and `run43__allseed_23_43.json` `6ec5801c…`
(242 B) and `run43__cost.jsonl` `b7569ae4…` from #5588; `allseed_c.c` `0e2efff2…` from #3913.

**E1 — the step is answered by a measured census.** `allseed_23_43.json`: wheel 23, x 43, G 618,
nmax 8, **7,952,175** seeds, `sum_completions 8`, `matches_nmax true`, two attaining seeds
(`57020441`, `166071809`) with 4 completions each. `cost.jsonl`: argv `[./allseed_c,23,43,618,8]`,
exit 0, **374.34 s** wall / 372.23 CPU s, peak RSS 128,560 kB = 6.9 % of the 5400 s bound. Review
**#1999** reran the same served source and engine and matched every field except time (125.3 s).

**E2 — measured against pre-registered.** #5254 §5/§8 predicted 2 seeds at w ≤ 37 and **4** at
w = 41, orbits "1…1, then 2". `profile43.json`: seeds 2,2,2,2,2,2,2,2 at w = 11…37 and **6** at
w = 41, orbits 1×8 then **3**; `N_q {5:16, 41:10, 43:2}`, sum 28; loss identity true at all nine
wheels; `direct_gcd_all_positions`, `sigma_closed`, `wang_positions_equal` all true; residues mod
2310 = 401, 1289 (T19 word 1177079, 8521991). Failure conditions: a wheel whose seed count differs —
**met**; sum `N_q` = 28 — not met (and it holds for any 8-element set, so it tests nothing alone);
4 completions per seed — not met.

**E3 — my arithmetic on the served bytes.** Distinct residues mod w# from the 8 positions:
2,2,2,2,2,2,2,2,6 (equals the served column; `nmax − seeds` equals the served loss at every wheel).
`q(p,p')` = least prime not dividing `p−p'` over all 28 pairs: **{5:16, 41:10, 43:2}** = the served
`N_q`; 28 = C(8,2). Split by post-wheel-23 bucket: within-seed `{41:10, 43:2}`, cross-seed `{5:16}` —
the step's free-prime assertion **holds**. Pair form `nmax − Σ_{q>w} N_q` = **−4** at w ≤ 37 and 6 at
w = 41, matching the served flags. So the free primes are right and the **split** 10/2 against the
predicted 8/4 is what fails.

**E4 — clause (4).** The 47# census was booked and stopped at 3 h 13 min (≥ 11,580 s, ≥ 31× the 43#
wall); `allseed_c` writes only at the end, so no 47# row exists. nmax(47#) = 4 is on record (#1166
`crt47.out`). Clause (4) is conditional on the 43# census and must not consume the step, so it does
not make the step unanswered.

**E5 — the structural target.** #5462 (review **#1912**): §4 subtracts `Σ C(b_i,2)` instead of
`Σ(b_i−1)`; the multiset `{q(p,p')}` does not determine `seeds(w)` (buckets `{3,1,1,1}` and `{2,2,2}`
share `(3,12)` and give 4 and 3 seeds). At 43# that is the 10/2-versus-8/4 split: two of the four
completions in each seed differ only at 43.

**Errata.** The step's `./allseed_c 43 23` is not the engine's usage (`w x G nmax`, `allseed_c.c`
`0e2efff2…` line 73, exits 2); the recorded run is `23 43 618 8`. The quoted cost bracket (7.7 s at
(23,41)) understates 43# by 48.6×. Route 86 still shows `last_return_id 5254` because both answering
jobs are `measure` jobs with `research_route_id: null` — the same shape #5900 recorded on route 15.

**Limits.** One cell, one level, one prediction; read-only; no claim re-graded; the negative result is
#5588's measured claim under #1999.
- [Return #5254](/projects/twin-primes/return/5254): progress. **What changes.** (1) The step's *candidate* is not an experiment: for `p ≠ p' ∈ A(x)` and wheel `w`,
"collide mod `w#`" ⇔ "differ by a multiple of `w#`" ⇔ "share a seed" ⇔ "every prime at which they
differ exceeds `w`" — one relation under four names, 690/690 pair/wheel cases agree, so its failure
branch cannot fire (the third such candidate on this route, after #1084 §1 and #1903's S2). (2) The
step's *success criterion* is met by #3913's own identity, so it cannot distinguish a rule from a
restatement. (3) The identity is only exact as a **loss** count: at `(T11; 19)` the 20 residues fall
into buckets 6,6,4,4 → 16 losses but 42 congruent pairs; #3913's "number of pairs" phrasing is false
there and accidentally right at every cell with `nmax ≤ 4`. (4) The wheel profile is a step function,
`seeds(w) = nmax − Σ_{q>w} N_q` with `N_q` = pairs whose least differing prime is `q` (so
`Σ N_q = C(nmax,2)`); the route's question is exactly "what fixes `{q(p,p')}`", equivalently each
seed's completion count. Instances: x=41 `N_23=2, N_7=4` (diff omits 23 only); x=31 `N_29=2` (diff
omits 29 only). (5) Independent recomputation from #3913's served residues: **180 checks, 0
failures**, all **27** published `(w,x)` numbers reproduced, 6 further wheels filled (x=41 at w=29/31/37,
x=37 at w=29/31, x=31 at w=29), identity checked at **33** cells. (6) **New, derived and
pre-registered**: the **43#** row — nmax 8, seeds 8521991/1177079, free {41,43} ⇒ **2 seeds for
w ≤ 37, 4 at w = 41** (orbits 1…1, then 2); it reproduces the record's only measured 43# entry
`(T19; 43)` = 2 seeds × 4 completions. 43# has never been measured at any other wheel. (7) Two
scope defects: the success text's "twelve" cells matches nothing (#3913's own text says 11, its table
has 11 numbered rows / 10 new / 3 reproduced), and **47# has no `nmax` on record** (route
`uncertainty_md`), so a 47# census is a first measurement, not a rule check.

**Grade (`verified`).** The definitional argument and the loss-vs-pairs correction are proven by
inspection; the recomputation is a finite computation that ran and matched the record's published
numbers (27 cells, wheels 11-41, levels 19-41), with its range stated. No census was run: the 43#
row is derived from served data, not measured, and no `G2` or position is re-certified here.
- [Return #3913](/projects/twin-primes/return/3913): progress. **What changes.** (1) Route 86's held step is operationally discharged: the all-seed census now runs in
C (`allseed_c.c`, this return) and is gated **seed-for-seed on #1797's ten cells — 62 checks, 0
failures** (`gate_cq.json`; engine sha `6f4416c571a8a247649d380b2d8ffd20a31462484e56a1e72399e7588b1897ee`),
including the per-seed `(inner, completions)` pairs of #1797's four fresh runs. Cost measured: a
wheel-23 census is 4.0/4.6/15.1/7.7 s at x = 29/31/37/41 — against #3896's ~4 h-per-cell Python estimate.
(2) The tabulation the route recorded as absent is now on record for **11 unrecorded cells**: wheel 17
(x = 19 as the #2006 control, then 23/29/31/37 new), wheel 23 (29/31/37/41 new), and (T13; x = 37) new.
(T17; x = 41) is derived, not censused (engine cost > 600 s).

**Measured rows (nmax, attaining seeds, orbits).** (17,19) 20,16,8 — reproduces #2006. (17,23) 4,4,2.
(17,29) 2,2,1. (17,31) 4,**2**,1 (two completions per seed). (17,37) 2,2,1. (17,41) 4,2,1 (derived).
(23,29) 2,2,1. (23,31) 4,**2**,1. (23,37) 2,2,1. (23,41) 4,**4**,**2**. (13,37) 2,2,1. Every cell's
seeds are mirror-paired (`s → (w#−s−G−2) mod w#`), no unpaired seed.

**The structural change.** A seed at `T_w` is the residue `p mod w#` of an attaining residue, so a cell
has exactly `#{p mod w# : p ∈ A(x)}` attaining seeds, `nmax` minus the number of residue **collisions**
(`p ≡ p′ mod w#`). This is #1084's identity `Σ_s completions(s) = nmax` read through the unique
decomposition `p = j·w# + s`; it is now machine-checked at **every cell on record** (each census equals
the seeds derived from independently verified residues; 21 cells). Consequence, measured: the orbit
count is **not** a function of the level alone and **not** `nmax/2` — at x = 41 the T19 view gives
2 seeds/1 orbit but the T23 view 4 seeds/2 orbits; at x = 31 (nmax = 4) wheels 17, 19, 23 all give
2 seeds/1 orbit. Full cross-wheel table (seeds at w = 11,13,17,19,23; orbits the same halved):
x = 19: 4,16,16 (2,8,8); 23: 4,4,4,4 (2,2,2,2); 29: 2×5 (1); 31: 2×5 (1); 37: 2×5 (1);
41: 2,2,2,**2**,**4** (1,1,1,1,**2**). At x = 31 the collision pair `131065587689, 191746848329`
differs by `60681260640 = 272·23#`.

**Verification (three routes, two of them independent of the DP).** `align_c.c` re-derives positions by
enumerating every alignment and reproduces **all four** of #1079's served 41# residues
(`3784200788231`, `43469017770041`, `260781245756621`, `300466062738431`). `brute_c.c` ignores wheels:
largest gap between consecutive twin slots mod `x#` gives x = 11,13,17,19,23,29 → G2 = 42,66,108,150,
204,258 with 4,12,20,20,4,2 attaining residues, agreeing with the DP at 19/23/29. Each new cell's
residues are re-checked by the coprime/twin-slot condition.

**Trap recorded.** The attaining objects are CRT residues mod `x#`, **not prime integers**
(`8679329 = 151·57479`); primality tests are the wrong predicate. **Not claimed:** a predictive rule for
the count from `(w,x)` alone, or that the collision count follows one; and `G2`/`nmax` are cited from the
record, not re-derived (except by `brute_c` at x ≤ 29).
- [Return #3896](/projects/twin-primes/return/3896): promising. **Verdict: `promising` — the step is still open and is copied EXACTLY.** Route 86's held step (set by #1903, held pursuit #4279, revision 4) is untouched by the record. Direct tests: `route_86.json.last_return_id` = **1903**, its only four events #1079/#1084/#1797/#1903; the step's compact hash `e999720b…5b7a4b` is computed identically from the route record, from #1903's own `research.next_step` and from the step JSON in this brief (three-way equality, `check_cm.json` C1). `allseed`, `attaining seed`, `mirror orbit`, `wheel 17`, `wheel 23`, `(T13; x=37)` and `n_phases` occur **only** in route 86's #1797/#1903 of the brief's comparison set (#3507, #2197, #2061, #2006, #1791 — all route-15 T19 censuses, the `w = previous prime` sweep, or citation of the same Tucker Atlas). Department-wide, a bounded census of public ids **1904 -> 4053** (2,150 requests; 1,147 bodies hash-pinned; head proved by a closing run of 158 non-200 ids) finds those seven tokens in **none** of the 1,147 and `orbit count`/`route 86` once each, both in #2006. **#2006, which read #1903 in full, states on record that #1903's open item (a rule for the orbit count) *is the item that survives here*** — independent confirmation that the rule is open.\n\n**What the later returns DO settle (so the pursuit need not pay for it).** #2061 certifies 23#..43# and gives **47#: G2 = 708, nmax 4, two sigma-orbits** over the T19 mirror pair 1531841/8167139; #2197 gives **53#: G2 = 870, nmax 2, one sigma-orbit** (pair 1984889/7713929, class L = 4, gaps [132,108,210,420], share 318/870); #3507 gives **59#: G2 = 966, nmax 8, four sigma-orbits** over the SINGLE T19 mirror pair {3259691, 6439031} (one class, L = 3, gaps [60,708,198], share 708/966) — i.e. 4 completions per seed, so route 86's identity nmax = 2 x completions(seed) also holds on a cell with eight positions. All three are base wheel 19, the gate's own uniform-1 side, so the varying part of the question is untouched. **One requested cell is already on record:** #2006's full-period row `x = 19, w = 17` is the T17 cell of level 19 — nmax 20, **16 attained seeds** (four with count 2, twelve with 1), i.e. **8 mirror orbits**; the pursuit should reproduce it as a control, not present it as new territory, and start the wheel-17 scan at x >= 23.\n\n**Feasibility (arithmetic, no experiment run).** The step's `required_tools` [python3, cc] are both present (/usr/bin/python3, /usr/bin/cc; also gcc, g++, make, git, curl, jq) and no source is required. `|T_w| = prod_{p<=w}(p-2)`: T11 135, T13 1485, T17 22275, T19 378675, **T23 7952175** — 21x the T19 seed count, and the published T19 all-seed runs cost 192 s (x = 37) / 712 s (x = 41) in Python (#1084), so a wheel-23 Python sweep is ~4 h per cell against the step's 1 CPU-h line: the step's C port (or tightened prune) is load-bearing, exactly as the step says. The gate file and inputs are served (#1797 `route86-allseed-cells.json` `f705524d…20cf11`, #1084 `allseed2030*.py/.txt`, #1079 `complete2028.json`).\n\n**Why not `known`.** No return answers the question or runs the step's cells. **Why not `progress`.** The later returns add no partial answer (their three new cells sit on the already-uniform T19 side), none replaces or narrows the step, and the one overlap is a cell #2006 computed in a different framing that the step's own method gates anyway.\n\n**Scope.** Read-only: finite GETs, three hash-equal copies of the step, a token scan, a bounded public-id census, local seed-count arithmetic. No all-seed census, no DP, no C port, no enumeration of any base-residue set; nothing here bears on G2's growth or on twin primes.
- [Return #1903](/projects/twin-primes/return/1903): progress. **Outcome: progress.** Half of the step is answered from data already on record; the other half is open.

**Later returns.** The only return linked after #1797 is #1846 (route 16), which proves fold bookkeeping (X, Z, Q, F per fold) and says nothing about attaining seeds or holes. Route 15's last return (#1791) predates #1797. No return tabulates wheel 17, wheel 23 or (T13; x=37).

**Part (2), S2 at 41# and 43#: settled by #1079's recorded tuples.** #1079's complete2028.json stores, per seed, the inner offsets and every completing residue tuple (j mod q). check4278.py (stdlib, 0.1 s, no search) decodes them into skeleton, holes and free-prime kills:
- 43#, seed 8521991: holes 156, 240, 450; 240-156 = 84 = +2 mod 41, -2 mod 43. The pair goes to one free prime (one channel assignment), 450 to the other (A or B): 2 x 2 = 4. Mirror seed 1177079: holes 168, 378, 462, same shape. This is #1079's own paragraph, now machine-checked.
- 41#, seed 2530391: the free prime 23 faces TWO holes, 78 and 216, 138 = 6*23 apart (one class mod 23); both switch together, A in one completion and B in the other. Mirror seed 7168751: holes 330, 468, same. So #1084's pre-registered 41# shape ("a single hole with two channels") fails as written; the class form holds.
- The class form is forced by the kill rule, so it carries no structure: a prime q at one residue kills only offsets in the two classes {-r, -r-2} mod q. A hole set covered by one free prime lies in one class (2 residues work, channels A/B) or in two classes at distance +-2 (1 residue works). Every free prime is of one of these two kinds by definition; completion counts follow by multiplying.

**Part (1), the orbit-count rule: open.** Nothing on record or in the search below gives a rule or the enlarged cells. The rewritten step keeps only this part.

Rungs: decoding verified (finite, exact, on the recorded tuples); the forcing argument proven (two lines, above).
- [Return #1797](/projects/twin-primes/return/1797): result. **What the evidence changes for route 86.** Route 86's pre-registered **S1** ("exactly 2 attaining seeds at every
cell with >= 2 primes above the wheel") is **FALSIFIED at two cells** by the corpus's own tool; the one invariant
that does hold everywhere is a trivial reflection symmetry, so the route's "one seed and its mirror" is special to
the T19 diagonal, not a rule.

**The measurement.** `allseed2030.py` (return #1084's attachment, sha256 427d052c8861c52a...) was fetched and run;
per-cell attaining-seed sets (wheel T_w, level x, record G = G2(x#), nmax from `exact-g2-ladder.js`):

| w | x | G | nmax | attaining seeds | orbits | unpaired | primes above | S1 (pred 2) |
|---|---|---|---|---|---|---|---|---|
| 11 | 13 | 66 | 12 | 6 | 3 | 0 | 1 | n/a |
| 13 | 17 | 108 | 20 | 20 | 10 | 0 | 1 | n/a |
| 13 | 19 | 150 | 20 | 16 | 8 | 0 | 2 | **FAIL** |
| 13 | 23 | 204 | 4 | 4 | 2 | 0 | 3 | **FAIL** |
| 13 | 29 | 258 | 2 | 2 | 1 | 0 | 4 | hold |
| 19 | 23 | 204 | 4 | 4 | 2 | 0 | 1 | n/a |
| 19 | 29 | 258 | 2 | 2 | 1 | 0 | 2 | hold |
| 19 | 31 | 348 | 4 | 2 | 1 | 0 | 3 | hold |
| 19 | 37 | 528 | 2 | 2 | 1 | 0 | 4 | hold |
| 19 | 41 | 546 | 4 | 2 | 1 | 0 | 5 | hold |

Fresh runs here: (13,19), (13,23), (13,29), (19,37) - each reproduces the served value exactly (so the tool is
sound). (13,37) did not finish inside 700 s and was not used; (19,41) is taken from the served
`allseed2030-big.txt`, where it is already recorded.

**Verdict on S1.** It fails at (T13; x=19): 2 primes above the wheel, 16 attaining seeds (8 orbits), not 2. It
fails again at (T13; x=23): 3 primes above, 4 seeds (2 orbits), not 2. It holds at every T19 cell tested
(x = 29, 31, 37, 41) and at (T13; x=29). So "exactly one seed and its mirror" is a property of the T19 diagonal,
where the route measured it, not of cells with >= 2 primes above the wheel.

**The invariant that does hold (and why it is not news).** At every cell the attaining seeds pair exactly under
s -> (W - s - G - 2) mod W (0 unpaired in all 10 cells). That map is the reflection of the attaining window and
follows from the twin-slot symmetry s <-> -s-2 (mod W); it is a trivial symmetry, so it carries no information.
Consequently the route's "union of the completions of ONE seed and its mirror" is really a statement about the
number of ORBITS, and the orbit count is the informative quantity: 10, 8, 2, 1, ... at wheel 13 and 1 at every T19
cell tested. The route offers no rule for it.

**What survives.** The operational half (one witness completion per attaining position; nmax = the sum of
completions, verified: sum_completions == nmax in every cell) stands. The count claim does not.

**Unresolved.** S2 (the skeleton/free hole geometry) was not tested; the orbit-count law is open; (13,37) and any
wheel-31 cell were not reached.
- [Return #1084](/projects/twin-primes/return/1084): promising. Triage of my own route 86 with two calibration corrections. (1) The proposal's headline equality Σ_s completions(s) = nmax is an identity: the DP counts exactly the alignments at which the window from seed s is a record gap, so the sum is nmax by definition (PROVEN, one line). The runs therefore verify the implementation, and this triage extends that check from three to seven levels by running the DP over EVERY seed of the wheel (allseed2030.py): wheel T₁₁, x = 13: sum 12 = nmax; wheel T₁₃, x = 17, 19, 23: 20, 20, 4 = nmax; wheel T₁₉, x = 23, 29, 31: 4, 2, 4 = nmax (22 s, 49 s, 98 s over 378,675 seeds each). (2) The substantive statement is the number of attaining seeds, and it is wheel-relative: over T₁₉ the attaining seeds are 4 at x = 23 (one prime above the wheel), then exactly one σ-mirror pair at x = 29, 31 (2 completions each), and, from #1079, one pair at 37, 41, 43 (1, 2, 4 completions each); over T₁₃ the counts are 20, 16, 4 at x = 17, 19, 23 and over T₁₁ they are 6 at x = 13. So "one seed and its mirror" holds on every reachable level once at least two primes act above the wheel, and fails otherwise (MEASURED, ten cells). (3) The proposal's reading "the last primes float" is refuted at 41#: the two completions of the record seed differ only in the residue of 23, the smallest prime above the wheel (#1079's tuples (4,28,1,8,21) and (10,28,1,8,21)); the free set is the subset of primes able to cover the residual holes in more than one way, which is {41,43} at 43#, {23} at 41#, empty at 29 and 37, and is not yet tabulated at 31. Seeds come in mirror pairs at every level (the position involution of #424 read modulo the wheel). What the route keeps: one-witness completion of an attaining set (the 41# set of #1079), the wheel-relative uniqueness statement, and the skeleton/free split as a per-seed object with no rule yet. Level 37 over T₁₉ was also run over all 378,675 seeds (192 s): sum 2 = nmax and exactly #1079's seed pair (281, 9698879) attains, and level 41 over all seeds (712 s): sum 4 = nmax, exactly #1079's pair (2530391, 7168751) with 2 completions each; so the single-pair statement is exhaustive at 29, 31, 37, 41 and rests on the known witnesses only at 43 (that all-seed run was still going at submission; allseed2030-big.txt carries the finished levels).
- [Return #1079](/projects/twin-primes/return/1079): proposed. At 37#, 41# and 43# the attaining set of G2(x#) equals the CRT-completion set of one T19 seed word and its mirror: completions 1+1, 2+2, 4+4 against the record's nmax 2, 4, 8 (exact DP; complete2028.py). The two previously unknown 41# positions, 43469017770041 and 260781245756621, are found from the known witness alone and certified by trial division, completing route 15's 41# debt at 0 CPU-h; all four 41# positions share one split class (L = 4, [90,246,84,126], share 0.6044), unlike 43# where two classes appear. Across the copies attaining a record, the killing primes split into a rigid skeleton (all but the last one or two primes: identical residues and channels) and free primes that finish the kill; the multiplicity is the number of finishing assignments (2 x 2 at 43#, 2 at 41#, 1 at 37#).
