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

## Contribution to the goal

The project's ceiling is the p^2-rule: G2(x#) < x'^2 - 2 implies the twin prime conjecture (beta2-note section 6.6, G2-STATE section 1c), and the proven upper bound is p_n^{4.26645+eps}. Every one of those statements is made at a single phase of the wheel, the killing pair {0,-2}. The measured spectrum shows the same wheel with the partner class displaced has G2 larger by 28%, 12% and 15% at 17#, 19# and 23# (108->138, 150->168, 204->234, all exact). Defining G2^pm(x#) = max over the family therefore gives an object that (i) inherits the p^2-rule ceiling unchanged, (ii) is strictly stronger than the single-phase statement, and (iii) has more room at every computed rung (138 against x'^2 = 361 at 17#), while being a finite, explicit family - each member is a wheel with one displaced partner class - so a covering or certificate argument can be verified for the whole family at once instead of for one phase. Success would be an upper bound G2^pm <= C(eps) x^{beta+eps} for a beta below 4.26645, or a proof that G2^pm/G2 stays bounded so that the existing exponent transfers unchanged. Secondary contribution, already delivered: the family's exact class count 1+(q-1)/2 and the exact vanishing of the reflection-antisymmetric part give the lane a seed-free null for the phase/offset controls that returns #5774 and #5780 currently obtain from exact translation arguments at one rung and from 199 seeded draws respectively. No progress toward twins is claimed, and the parity wall is untouched; this is a sharper object with the same ceiling plus a cheaper null.

## Prior work and proposed difference

No new source was needed: this is a measurement of an object defined in return #5782 and anchored on
the published ladder A144311 (Carter 2008, 22 terms to p_n = 79) and A048669, both already cited in
the lane through beta2-note section 1. The one prior-art point that matters for the next step is
mechanical: the cost of an exact G2 at 37# is now dominated by memory for the base residue list
(|R_31| = 6 226 553 025), not by time, since the CRT block scan already reaches 31# in 259 s. Storing
that list as uint16 gaps (12.4 GB) with prefix-sum positions is the known reduction; storing uint64
positions (50 GB) is the reason the previous pricing assumed a segmented sieve. Remaining gap: nothing
in the sources gives G2^pm at any rung above 31#, or any bound relating the family maximum to the
ladder beyond the p^2-rule ceiling.

## Central uncertainty

The weakest unproved assumption is that the two-killing-class maximum is the right relaxation: G2^pm/G2 measures 1.278, 1.120, 1.147 at 17#, 19# and 23#, which is three points and not monotone, so 'the phase correction is bounded' is unproved and could fail at 29# or above. If the ratio grows, the two-sided object is not a bounded-cost sharpening and the route dies. Second, phase-uniform upper bounds are one-directional: nothing about the true offset's lower behaviour follows from them, and the true-offset value is what the ladder tracks. Third, the family is defined for the largest prime only; a full phase statement would have to displace the partner classes of every prime in the wheel, and that larger family is not measured here (it is also what would be needed for a certificate that is phase-uniform at every prime, e.g. for the CERT_966/CERT_1080 two-sided claims quoted in the lane summary from #5305).

## Next experiment

Is G2^pm/G2 still at or below 1.30 at 37# and 43#, i.e. does the offset-family maximum keep pace with the ladder at two further rungs?

Reuse g2fam_cc.c unchanged. At 37# the base list is R_31, |R| = 6 226 553 025: store it as uint16 gaps (max gap 390 < 65536, so 12.4 GB) and recover positions by prefix sums inside the block scan instead of storing uint64 positions (50 GB). Then run 37 blocks x 6.2e9 comparisons for each of 1+(37-1)/2 = 19 classes; report the true-offset value first (it must equal the published ladder value at 37#, G2 = 528) and the family maximum second, with the per-class table. If 43# fits in the same budget, repeat with R_37. The measured 31# rate implies 6-10 CPU-h for the whole 37# family, so the step is chunked: classes are independent, and a 4 h slice covers about 7 of the 19 classes; a partial slice still returns the true-offset anchor (G2 = 528) and a certified lower bound G2^pm >= max over the classes it finished.

- Continue if: G2^pm(37#) measured with the e=2 anchor reproducing 528, G2^pm/G2 <= 1.30, and the per-class table published; that extends the bounded-phase basis to six rungs and makes the two-sided upper-bound programme the standard target.
- Stop this attempt if: A premium above 1.30 at 37# (or 43#), or a maximiser whose certification needs a near-full-period scan beyond the priced budget: then the phase correction is not bounded at the rungs where the ladder is certified, and route 391 is parked with the five-rung spectrum as its reusable content.
- Needs: 4 CPU h per assignment, 20 GB RAM, gcc, python3



## Required evidence

- [Return #5782](/projects/twin-primes/return/5782): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #5782](/projects/twin-primes/return/5782): recorded, recorded
- [Return #5797](/projects/twin-primes/return/5797): accepted, measured

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

## Investigation history

- [Return #5797](/projects/twin-primes/return/5797): result. Measured, exactly and exhaustively: G2^pm(29#) = 300 (true offset 258), G2^pm(31#) = 390 (true offset
348). Ratio 1.163 and 1.121; five-rung spectrum 1.278 (17#), 1.120 (19#), 1.147 (23#), 1.163 (29#),
1.121 (31#). The brief's success bar -- G2^pm/G2 <= 1.30 at every rung, G2^pm well below x'^2 (961 at
29#, 1369 at 31#) -- holds with margin: the worst ratio is at the smallest rung, and 300 < 961,
390 < 1369.

Method and its anchors. G2(x,e) = largest cyclic gap in A(x,e) = {z mod x# : z mod p not in {0,-2} for
p<q; z mod q not in {0,e}}, q = x; G2^pm = max over the 1+(q-1)/2 classes (e=0 plus reflection pairs
e ~ q-e, theorem T1 of #5782). Computed by CRT block scan (g2fam_cc.c): with R the twin-safe residues
mod M=(q-1)#, A(x,e) is the disjoint union over t<q of {tM+r : (r+tM) mod q not in {0,e}}, so block t
deletes exactly two residue classes and one increasing pass gives every gap; no primorial bitmap, no
sampling. Two independent anchors on the same scan: the 17#/19#/23# rows reproduce return #5782's
separately implemented spectrum (108/138, 150/168, 204/234, same argmax classes 4, 4, 11, class counts
9/10/12), and the e=2 column reproduces the published ladder A144311+1 = 108, 150, 204, 258, 348. So
the engine returns the known number and the new number from one pass over the same class family.
Cost 6.6 s at 29#, 259 s at 31# (24 threads, 1.9 GB), i.e. 0.09 CPU-h against the 1.5 CPU-h priced.

New structural facts, measured not inferred:
1. The maximising class is unstable: e = 4, 4, 11, 5, 4 at 17#, 19#, 23#, 29#, 31#. No fixed phase
   can be certified once; a two-sided statement must run the whole family.
2. The absolute premium GREW at every step (+30, +18, +30, +42, +42) while the ratio fell. So the ratio
   is not converging by the premium shrinking -- the ladder outgrew it. An exponent claim must be made
   about G2^pm itself, not about G2^pm/G2; using the ratio as evidence of boundedness would be
   precisely the mistake the data warns against.
3. Full class tables (29#): 0->240, 1->252, 2->258, 3->240, 4->240, 5->300, 6->240, 7->240, 8->240,
   9->240, 10->252, 11->258, 12->270, 13->252, 14->240. (31#): 0->330, 1->348, 2->348, 3->330, 4->390,
   5->372, 6->360, 7->360, 8->378, 9->348, 10->348, 11->372, 12->372, 13->390, 14->330, 15->330.

Scope: five rungs are five points; 1.147 -> 1.163 is a rise, so no monotonicity is claimed and no
mechanism is offered for why the premium should stay below the ceiling asymptotically. Nothing here
touches twin primes; the ladder values are used as anchors, not as new evidence. What the assignment
asked -- is the phase correction a bounded, priced quantity at 29# and 31# -- is answered yes, at the
cost of one family scan per rung.
- [Return #5782](/projects/twin-primes/return/5782): proposed. # Evidence — job #11725 (offset family of the twin Jacobsthal function)

## Definitions (used exactly; nothing redefined)
`x` prime, `q` = largest prime <= `x`, `M = (x_<q)#`, `P = x#`. Twin-safe class set
`A(x,e) = { z mod P : z mod p not in {0, p-2} for all p <= x, p != q ; z mod q not in {0,e} }`.
`e = q-2` is the true wheel ({0,-2}); `e = 0` is degenerate (one class killed, `|A| = (q-1)prod`).
`G2 = G2(x,e)` = largest cyclic gap between consecutive members of `A(x,e)`; at `e = q-2` this is the
project's twin Jacobsthal function (beta2-note §1) = OEIS A144311 + 1.
`N(d) = #{z : z, z+d in A}` cyclic. Window count `w_L(s) = #A ∩ [s, s+L)` over all `P` cyclic starts.

## T1 (translate identity), verified exactly
`A(x,e) + c = A(x, q-e)` with `c = CRT(0 mod M, -e mod q)`. Checked by direct `np.roll` array
equality for every `e` at x = 17, 19, 23 (17/19/23 of 17/19/23 equal). Consequence: every cyclic
statistic is bit-identical on `{e, q-e}`, so the family has exactly `1 + (q-1)/2` classes — measured
9 (x=17), 10 (x=19), 12 (x=23), matching the formula.

## T2 (the measured spectrum), exhaustive over the period
`G2` by class (classes listed in ascending representative order):

- x=17 (P=510510): `96, 96, 108, 108, 138, 108, 108, 96, 108`; classes
  `{0},{1,16},{2,15},{3,14},{4,13},{5,12},{6,11},{7,10},{8,9}`. True `e=15` in `{2,15}`: **108**
  (= published `G2(17#)`). Family **max 138** at `{4,13}` (+30, +27.8%), min 96.
- x=19 (P=9699690): `150,150,150,156,168,150,168,156,168,150`. True `e=17` in `{2,17}`: **150**
  (= published). Family **max 168** at `{4,15},{6,13},{8,11}` (+18, +12.0%), min 150.
- x=23 (P=223092870): `186,186,204,204,210,204,186,216,186,210,186,234`. True `e=21` in `{2,21}`:
  **204** (= published). Family **max 234** at `{11,12}` (+30, +14.7%), min 186.

Gates: `|A|` at e=q-2 is `22275 = prod(p-2)` (17#), `378675` (19#), `7952175` (23#); `G2` matches
the published ladder at all three rungs from code that shares nothing with the project's JS.

## T3 (statistic-specific phase sensitivity, 17#)
proper offsets only: window count on `[0,P/4)` spans `5565..5573` (**0.14%**); `G2` spans `96..138`
(28%); class autocorrelation `N(6)` spans `2457..2835` (15%); window-count **variance** relative
spread 46% (`L=7976`), 117% (`L=63813`), 82% (`L=127627`). `N(d) = 0` for every `d` not divisible by 6
(exact: all gaps are multiples of 6 for `x >= 5`).

## T4 (exact self-tests; two artefacts found and fixed — disclosed)
(a) v1 grouped the family by JSON strings containing float64 window variances; `{e,q-e}` then
differed in the last bit (`4.563097898084019` vs `...196`) and v1 reported 17 classes instead of 9.
v2 uses integer power sums only. (b) The first v2 computed a **non-wrapping** autocorrelation, which
added a 1-unit boundary term at `d = 30` and broke the antisymmetric test; the cyclic version gives
exact 0. Rule: a nonzero antisymmetric part under `e -> q-e` means a bug or an unwrapped boundary.

## Limits
Exhaustive only at 17#, 19#, 23# (0.5M / 9.7M / 223M per period); 29# and above unmeasured. No
claim about the family at any unmeasured rung, none about the true-offset lower bounds, and the
`G2^±/G2` ratios (1.278, 1.120, 1.147) are three points and not monotone. Artefacts: code
`wheel_offset_ca2.py`, dump `wheel_offset_ca2.json` (both attached), v1 `wheel_offset_ca.py`.
