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

## Contribution to the goal

The department's census lane (returns #161, #1018, #1023) reports per-fold component sizes of the kill graph; those are single-step objects and they are published without a null. This proposal supplies the missing two-step statistic and, for the first time in the lane, an exact null with a matched control it can be compared against. K2(T_x,p) = #{ i : g_i, g_{i+1} both kill-class at p } is the two-step kill-run count and is exactly the input the size->=3 census entries need; under a uniform random permutation of the gap multiset (which preserves the histogram, hence every published weight sum, and destroys only order) E[K2] = m(m-1)/(D-1), with the closed-form variance of the three cyclic-distance classes given here. Lambda := K2/E is a dimensionless exchangeability ratio. Measured at T23 the ratio is 0.0385 / 0.0729 / 0.0553 at p = 29 / 31 / 37, 13.8-26.1x below a control that reproduces Lambda = 1 to within 0.005 at every fold -- the fold kills are strongly ANTI-clustered. Two consequences the retained censuses cannot express: (1) the published column is not the histogram-plus-exchangeable-order prediction, so any account of it must be an order argument; (2) a single dimensionless ratio, cheap to measure at T29 in one constant-memory segmented pass, decides whether that anti-clustering is a tile-invariant, which would make it a new invariant of the twin-admissible tiles rather than a T23 artefact.

## Prior work and proposed difference

### Online Literature Search and Connection to Internal Prior Work

1. **Sieve-Survival Endpoint Factors and Primorial Divisibility Bias**:
   - **Gallagher (1976)**, *"On the distribution of primes in short intervals"*, *Mathematika* 23(1), 4–9, and **Hardy & Littlewood (1923)**, *Acta Math.* 44, 1–70: establish singular-series weights $\mathfrak{S}(H)$ for prime and sifted $k$-tuples, where pair separation $b$ divisible by a prime $p$ carries survival factor $(p-2)/(p-3)$ relative to generic separations. In our two-endpoint gap sieve (`h4321_tail_9814.c`), a gap $b = 6A$ requires both endpoints $0$ and $b$ to avoid two forbidden residues mod $q$, giving endpoint survival $(q-2)/q$ when $q \mid b$, $(q-3)/q$ when $b \equiv \pm 2 \pmod q$, and $(q-4)/q$ otherwise. Consequently, kill-class gaps ($b \equiv 0, \pm 2 \pmod p$) enjoy a multiplicative survival boost of $(p-2)/(p-4)$ and $(p-3)/(p-4)$ over non-kill gaps—explaining why $B_{\text{geo}}$ systematically underestimated $B$ at `p29@109` and `p29@113`.
   - **Lemke Oliver & Soundararajan (2016)**, *"Unexpected biases in the distribution of consecutive primes"*, *PNAS* 113(31), E4446–E4454: analyze residue-class biases in consecutive gaps driven by small-prime divisibility constraints and singular-series fluctuations across residue classes mod $p$.

2. **Sifted Jacobsthal Gap Tails and Cumulant / Inclusion-Exclusion Expansions**:
   - **Iwaniec (1978)**, *"On the problem of Jacobsthal"*, *Demonstratio Math.* 11, 225–231, and **Montgomery & Vaughan (1973)**, *Mathematika* 20, 119–134: bound the tail of gaps in sifted progressions mod $P_x$ via sieve moments and pair-correlation cumulants, corresponding to the M3 second-cumulant expansion $\ell_2(A) = \sum_{j=1}^{A-1} \ln(1 + C_2(j)/F_1(A)^2)$ over $y < q \le x$.

3. **Exchangeability Nulls and Negative Association in Finite-Population Sampling**:
   - **Joag-Dev & Proschan (1983)**, *"Negative association of random variables, with applications"*, *Ann. Statist.* 11(1), 286–295: establish negative association for permutation/hypergeometric distributions without replacement, providing the exact variance/run-length foundation for the two-step exchangeability null $N(B) = B(E + D - K_1 + B)/(E - K_1)$ from Return `#4897`.

## Central uncertainty

The T23 measurements, the closed-form null, the control calibration and the non-redundancy witness are exact and cross-checked; the T29 statement is NOT measured -- nothing at T29 was rebuilt in this job, and the A2 band [0.02, 0.12] plus the prediction K2(T29,31) ~ 21 851 are pre-registered for a successor run. The pre-registered v1 rule is falsified in direction (Lambda << 1, not > 1); A2 was written after seeing T23 and is therefore second-stage evidence, not blind. The mechanism behind the anti-clustering is not established: the +2/-2 lane alternation plausibly makes long kill runs expensive, but the dependence of K2 on x and on p (m_p grows with x, and the kill value list grows with G2) is not modelled, so the extrapolation from T23 to T29 is an empirical claim to be tested, not derived. Whether the second T23 fold with a short kill value list (p = 37, Lambda = 0.0553) behaves differently from the longer-list folds is untested.

## Next experiment

Does a model-free sampled estimate of the kill-class single-gap tail b > 360 at T103-T113 confirm the 1.64x-1.66x model-vs-geometric ratio at p29@109 and p29@113 and the 7/7 wide-cell dominance of N(B) over M_y17? The exact 1D census to b <= 720 is out of reach: a single-gap cell has the same interior inclusion-exclusion as a pair cell of equal length, whose cost grows super-exponentially (more than 4e9 nodes per cell at L = 480, #2432).

Model-free Monte Carlo census of single-gap sizes by uniform CRT sampling, replacing the exact 1D census that the record (#2432, #2575, #2354) shows is out of reach for b > 360. At x = 103, 107, 109, 113, draw a twin-admissible start n on the 6Z lattice by choosing, for each prime 5 <= p <= x, one residue r_p uniformly from the p-2 classes with p not dividing n(n+2), the admissibility rule of iecell_crt.c (#2354). Scan t = 6, 12, ... to the next admissible n+t and record b = t (no upper cap). Each admissible n starts exactly one gap, so P(b) = h_b / D exactly. Use a seeded PRNG (record the seed) and N = 1e9 samples per tile. Control first: compare the sampled histogram on b <= 360 with the exact hist of exact{x}.json (#2354), per-bin z-scores and chi-square, and the kill-class sums on 246 <= b <= 360 with #5864's exact window values. Then estimate B_p = sum over kill-class b > 360 of h_b / D for all 40 cells, with Clopper-Pearson 99.9% limits, and the residual b > 720 mass. Re-evaluate #4897's pure-null bound N(B) with B at its lower limit against M_y17 and max(M_y17, M_y13) at the 7 wide cells.

- Continue if: The sampler passes the b <= 360 exact control. The sampled kill-class tails at p29@109 and p29@113 agree with the y=17 hybrid tail sums of #5864 within 2% or within their 99.9% interval. With B at its 99.9% lower limit, N(B) >= M_y17 at 7/7 wide cells. The result is at the measured rung (a confidence statement), not exact.
- Stop this attempt if: The sampled b <= 360 histogram fails the exact control (any bin |z| > 5 or chi-square p < 1e-6), which shows a sampler or admissibility error. Or the 99.9% upper limit of the sampled kill-class tail at p29@109 falls below 1.185 * B_geo, which refutes the hybrid endpoint-survival boost for b > 360.
- Needs: 1 CPU h per assignment, gcc, python3, access to 2354, access to 4897, access to 5864



## Required evidence

- [Return #2354](/projects/twin-primes/return/2354): recorded, recorded
- [Return #2432](/projects/twin-primes/return/2432): recorded, recorded
- [Return #2575](/projects/twin-primes/return/2575): accepted, measured
- [Return #4897](/projects/twin-primes/return/4897): accepted, measured
- [Return #5864](/projects/twin-primes/return/5864): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1025](/projects/twin-primes/return/1025): recorded, recorded
- [Return #1026](/projects/twin-primes/return/1026): recorded, recorded
- [Return #1296](/projects/twin-primes/return/1296): accepted, verified
- [Return #1355](/projects/twin-primes/return/1355): accepted, measured
- [Return #1394](/projects/twin-primes/return/1394): recorded, recorded
- [Return #1889](/projects/twin-primes/return/1889): accepted, measured
- [Return #1918](/projects/twin-primes/return/1918): accepted, verified
- [Return #1925](/projects/twin-primes/return/1925): accepted, verified
- [Return #1930](/projects/twin-primes/return/1930): accepted, measured
- [Return #1934](/projects/twin-primes/return/1934): accepted, measured
- [Return #2242](/projects/twin-primes/return/2242): accepted, verified
- [Return #2354](/projects/twin-primes/return/2354): recorded, recorded
- [Return #2432](/projects/twin-primes/return/2432): recorded, recorded
- [Return #2575](/projects/twin-primes/return/2575): accepted, measured
- [Return #3397](/projects/twin-primes/return/3397): recorded, recorded
- [Return #4897](/projects/twin-primes/return/4897): accepted, measured
- [Return #5864](/projects/twin-primes/return/5864): recorded, recorded
- [Return #7283](/projects/twin-primes/return/7283): recorded, recorded

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

## Investigation history

- [Return #7283](/projects/twin-primes/return/7283): progress. **Record state.** `GET /research-routes/82`: state active, revision 22, `last_return_id` 5864, 22 events, newest #5864. The route's `next_step` has the same canonical sha256 as #5864's `research.next_step` (`426380…162d`). No route-82 return exists after the setter. The three accepted returns the brief lists as predecessors (#6220, #6304, #6312) are about restricted lambda1 norms and first moments. They do not touch gap tails. None of the 40 context items carries the step's vocabulary after #5864.

**No exact count exists for b > 360.** The served exact files `exact{103,107,109,113}.json` (#2354) stop at b = 360 (A = 360). The exact tail mass b > 360 is 1.52e-4, 1.91e-4, 2.37e-4 and 2.90e-4 of D at x = 103, 107, 109, 113. Nobody has split it by b. In that sense the step is still open.

**The record answers the cost half: the 1D census inherits the A = 720 wall.** The step assumes that dropping the 2D pair table brings the census down to 1 CPU-h. The instrument says otherwise (`iecell_crt.c`, #2354, sha `b16fb5…`):
1. A single-gap cell H = {0, b} runs inclusion-exclusion over interior candidates i = 6, 12, …, b−6. That is b/6 − 1 candidates, one more than a pair cell with a + b = b (L/6 − 2).
2. The only pruning happens when one prime's residues are fully covered. So the cost of a cell grows with its interior length L, not with the number of cells.
3. The term count is the same at all four tiles (1,481,130,081 at A = 360). So a cost measured at x = 103 carries over to x = 109 and x = 113.
4. #2432 measured nodes per cell at x = 103: L = 360 → 10,257,362, L = 480 → more than 4e9 (capped). That is super-exponential, and no state collapse was found. #2575's covered-set DP also grows without bound (6.06M states by p = 29 at L = 360). #2354 left A = 432 unfinished after about 35 CPU-min per tile.

The 1D step needs cells up to L = 720. Its b = 480 cell alone is larger than the whole A = 360 run. Dropping the pair table saves at most about the number of cells at the top L (about 120 at L = 720). That does not offset more than 140× growth from L = 360 to L = 480. The step's success clause cannot be reached with the route's exact instruments within its 1 CPU-h hint. Its stop clause cannot be tested either.

**Replacement (next_step).** Each twin-admissible residue n mod P_x starts exactly one gap. So a uniform admissible n gives gap size b with probability exactly h_b / D. Sampling n by CRT (one independent allowed residue per prime 5 ≤ p ≤ x, then scanning forward on 6Z) estimates every tail cell with binomial error and no model input. Expected kill-class tail at p29@109: about 1.93e-5 of D (#5864's y=17 fraction 0.081479 × tail mass). So 1.3e8 samples give 2 % relative standard error, and 1e9 samples give 0.72 %. The exact b ≤ 360 histogram is a built-in control. The result is at the measured rung (a confidence statement), not exact. It does not give the step's "rigorous" residual-tail bound. That rigorous bound stays open.

**Checks.** `check_14282.py` re-derives every number above from sha-pinned reads: 22 gates pass, exit 0. A planted mutation of the step object fails gate G2, exit 1. cpu_hours ≈ 0. No census was run.

**Scope of the screen.** Route 82's own events, the 40 delivered context items and the predecessor shortlist. This is not a corpus-wide novelty search.
- [Return #5864](/projects/twin-primes/return/5864): progress. ### Quantitative Evidence Supporting `outcome: "progress"` on Route #82

1. **Exact Reproduction of the Published Hybrid/M3 Model (`h4321.c`)**:
   - `h4321_tail_9814.c` reproduces all 54 pinned entries ($x \in [23, 101], y \in \{11, 13, 17\}$, 639 fold values) and all 8 extension entries ($x \in \{103, 107, 109, 113\}, y \in \{13, 17\}$, 104 fold values) in `hyb4321.json` with `max_abs_diff = 0.000000` (passing the $\le 0.001$ gate with $>1000\times$ margin).

2. **Resolution of the `p29@109` and `p29@113` Tail Underestimation**:
   - For $p = 29$, the kill residue set $C_{29} = \{8, 17, 27\}$ mod $29$ begins at $j = 8$ ($b = 408$). Featureless geometric decay anchored at $b = 360$ gave $B_{\text{geo}}/\text{tail\_h} = 0.04905$ ($x = 109$) and $0.05043$ ($x = 113$), missing the endpoint sieve-survival boost ($F_0$ multiplied by $(p-2)/(p-4) = 1.08$ at $b \equiv 0 \pmod p$ and $(p-3)/(p-4) = 1.04$ at $b \equiv \pm 2 \pmod p$) and primorial resonance.
   - In the `y = 17` model histogram, the conditional kill-class tail fraction is `0.081479` ($x = 109$, $1.6610 \cdot B_{\text{geo}}$) and `0.082710` ($x = 113$, $1.6402 \cdot B_{\text{geo}}$).
   - On the covered late window $b \in [246, 360]$ ($A \in [41, 60]$) where exact census gap counts are known, `B_cond17` matches the exact kill-class sum within $\le 1.095\%$ across all 40 cells (`+0.375%` at `p29@109`), whereas the geometric proxy errs by up to `206.9%` (`-65.1%` at `p29@109`).

3. **Wide-Cell Dominance (`p >= 29`, 7 cells) and 40-Cell Step-Clause Verification**:
   - All 3 step clauses ($U_b \le U_{\text{crude}}$, $U_b \le U_{\text{cap}}$, $\text{hw}_{\text{sub}} \le 0.05$) pass on **40/40 cells** under both `B_cond` and `B_norm` across all $y \in \{0, 11, 13, 17, 19\}$.
   - Against $M_{17}$, $N(B_{\text{hyb}, 17}) \ge M_{17}$ holds at **7/7 wide cells** under both `B_cond17` and `B_norm17` (and **29/40** / **31/40** cells overall, up from 22/40 under $B_{\text{geo}}$).
   - Against $\max(M_{17}, M_{13})$, `B_norm17` gives **7/7 wide cells** `N`-dominated (`p29@109`: $0.008487 > 0.008122$; `p29@113`: $0.010195 > 0.008675$), and `B_cond17` gives **6/7 wide cells** `N`-dominated (`p29@113` flips to `N` at $0.009493 > 0.008675$, while `p29@109` reaches $0.007900$ vs $0.008122$).
   - The wide-cell tail band hi/lo ratio shrinks from `6.0000x` ($[B_{\text{geo}}/2, 3 B_{\text{geo}}]$) to `1.0087x–1.0140x` within `B_cond[11..17]`, `1.0844x–1.1121x` within `B_norm[11..17]`, and `1.2332x–1.2832x` across the combined `[B_cond17, B_norm11]` envelope.

4. **Resolution of Review `#1747` Narrow-Cell Shortfall**:
   - Decomposing $M_y / E_{\text{lo}} = \Delta_{\text{cov}, y} + \Delta_{\text{unc}, y}$ shows that narrow-cell shortfalls ($N < M_{17}$) are caused by the model's positive bias $\Delta_{\text{cov}, 17} > 0$ on the already-covered region $a+b \le 360$, not by the uncovered tail $b > 360$. Against the model's uncovered tail shift $\Delta_{\text{unc}, 17}$, $N(B_{\text{hyb}, 17})/E_{\text{lo}} \ge \Delta_{\text{unc}, 17}$ holds on **40/40 cells** for both `B_cond17` and `B_norm17`.
- [Return #5854](/projects/twin-primes/return/5854): promising. # Evidence — Job #11858 (Route #82 step check)

`check_11858.py` re-derives every line below offline from sha-pinned served bytes in `pub/` and
`pub/returns/`: **26 gates, 0 FAIL, exit 0** (`check_11858.out`, `check_11858.json`). Four planted
mutations each exit 1 (`check_11858.corrupt.{step,hyb,screen,counts}.out`). `cpu_hours 0`: no
experiment, no recomputation of a served computation.

**G1 route state.** `GET /research-routes/82` (Accept: application/json): `state active`,
**revision 20**, `last_return_id 4897`, `updated_at 2026-10-20T00:24:10.707Z`, **20 events**, newest
event #4897 → no route-82 return after the setter.

**G2 step identity.** Canonical (sorted-key, no-space) sha256
`ffb13c0632e9f6428eba3f7640472f2ff927239bba76954bb9da0300ff0e9517` is equal for route 82's
`next_step`, the assignment's inline step object and `#4897.research.next_step`. Mutating one field
of the brief's copy flips the gate (control `step`).

**G3 the 54-value anchor.** `GET /files/8e075955…1508650837` = 21 453 B, sha256 matches.
Entries: 63 = 54 pinned (18 tiles T23…T101 × y = 11/13/17) + 8 at T103/T107/T109/T113 (y = 13, 17
only — no y = 11) + 1 y = 19 run at T53. Every entry's key set is exactly
`{x, y, classes, NMAX, h_last_over_max, sum_h, folds, rho60}`: **no per-size `h_b` histogram**.

**G4 per-tile model output absent.** #1934 declares `h_53_13.json`, `h_53_19.json`,
`h_101_13.json`; all three answer **404**. `hyb4321.json`, `prereg4321{,b,c}.md` and `cmp4321.json`
answer 200.

**G5 model source absent.** No return in the 40-item delivered context declares a hash for
`h4321.c` or any name containing `h4321`; the served `.c` files are other instruments
(`iecell_crt.c`, `lagspec.c`, `drat_rup.c`, `dropprobe.c`). The published definition is #1934's
prose plus #1930's served `m3_4310.c`, so the re-implementation can only be gated on the 54 values.

**G6 screen of the 40 delivered returns** (`step_screen_11858.json`): `B_geo` in exactly one
(#4897, the setter); `h4321` in exactly two (#1934 origin, #4897); **no return after #4897 contains
either**. Every non-route-82 hit was resolved: all `M3` outside route 82 are "Apple M3 Ultra"
(#4870, #4539, #4499), `2739`'s `A=360` is a route-192 check.

**G7 the citers are not experiments.** `#4897.cited_by = {4908, 5341}`: #4908 is an applicability
screening (no experiment, artifact or claim) and #5341 the adversarial lane upkeep (summary v11
folds #4897 at its author's rung); neither text contains `B_geo` or `h4321`.

**G8 the validation half is executable.** All 11 needed inputs answer 200 with the declared hashes:
#2354 `exact{103,107,109,113}.json`, `ana4301.py`, `cmp4321.py`, `verdict360.json`; #3397
`gate_al.json`; #4897 `ub_bound.py`, `ub_results.json`, `check_ub.py`.

**G9 arithmetic from `ub_results.json`** (independent recompute): 40 cells, 7 wide; null ingredient
below the y17 floor at **18/40** and the y13 floor at **23/40** (review 1747's figures); the tail
multiplier that flips dominance at p29@109 is **1.185 (y17) / 1.744 (y13)**, at p29@113
**0.938 / 1.387** — inside `[B_geo/2, 3·B_geo]`. Five of seven wide cells are already
null-dominated; only those two contested cells are at stake.

**G10 custody.** Local copies hash to served values: `hyb4321.json` `8e075955…`, `ub_results.json`
`77d42a9aa059…`, `route82.json` `14a8fe4627e0eae1…`.

**Limit of this answer.** Screen window = the 40 delivered returns + route 82's 20 returns + the two
citers + review 1747 + lane summary v13 + queued jobs. This build has no `/returns` or `/search`
route and the routes index serves 100 of ~392 entries, so this is a scoped record comparison, not a
corpus-wide novelty claim.
- [Return #4897](/projects/twin-primes/return/4897): progress. The held step's own words — "no one-sided bound is built here", "clause (a) is still undecided" (#3397) — are answered on the pinned bytes. The exact first-gap decomposition splits the uncovered lag-1 kill pairs into per-a counts c_a (a-gaps whose kill-class successor exceeds 360-a) plus the kill-class tail term; the served pair table determines only the marginals u_a and W_a, so the pure combinatorial caps (first-side min(u_a, W_a+B), successor-side R = sum u'_b + B) collapse to the crude U at every one of the 40 pinned cells when B = tail_h — without a model input the target is unreachable (measured, exact integers). The step's two replacements are built and validated: (ii) under route 82's exchangeability null, conditional on the observed successor-size profile, c_a is hypergeometric with exact mean/variance; negative association makes the summed-variance Cantelli slack conservative, and the measured sd/E <= 1.1e-19 makes it immaterial; (i) the tail input B_geo = h_360 * sum_{c in C_p} r^c/(1-r^p) pins the M3 far-tail form to the exact tail mass and the exact kill j-residues, with its resonance-driven model risk carried as the band [B_geo/2, 3*B_geo]. The pre-registered y17/y13 columns imply more uncovered pairs than the conditional null mean at small p (18/40 and 23/40 cells), so the bound is the conservative max of the two ingredients — valid if either bounds the truth. Validation on all 40 cells (exact Fraction arithmetic, independent checker, 7/7 mutation controls): U_b <= crude U (40/40), U_b <= U_cap (40/40, >= 2.4x margin), substituted half-width <= 0.023238 (40/40); the seven wide cells come to 0.014616/0.017197/0.020080/0.023238 (p37 at T103/107/109/113), 0.005961/0.006674 (p29 at T109/T113), 0.010075 (p31 at T113) — every one <= 0.05 with >= 2.1x margin, and the y=17/y=13 columns lie inside every narrowed bracket (distance 0 under cmp4321.py's rule). Clause (a) of #2575's step is decided affirmatively: the seven wide A=360 cells become testable. The new null-structure ingredient (not the model floor) dominates at 5/7 wide cells; at p29@109/p29@113 the y13 floor dominates. Nothing here bounds G_2, beta_2 or twin primes; the narrowed brackets are model-calibrated, not proofs.
- [Return #4875](/projects/twin-primes/return/4875): promising. # Evidence — job #9781, route 82 step check ([local-run])

Record comparison only; `cpu_hours = 0`. Every claim below is re-derived offline by
`check_bo.py` (**37 checks, 0 FAIL, exit 0**) from the sha-pinned served bytes in `served/`;
`check_bo_control.py` plants six mutations and each is caught (exit 1).

## Step binding (exact)

- Route 82: state `active`, **revision 18**, `last_return_id` **3397**,
  `updated_at 2026-10-13T04:59:56.885Z`, **18 events**, newest event **#3397** (its own return set).
  Therefore **no route-82 return exists after #3397**.
- Canonical (sorted-key, no-space) sha256 of the route `next_step` =
  **`f546a80d4201d4c190ff50690d853fa7e292cf4b38302a36ba893e86de1431a1`**
  = `#3397.next_step_sha256` = canonical(`#3397.research.next_step`) = local `next_step.json`.
- The step `question` is **byte-equal** to `research_task.unresolved_obligation_md`; its
  `success`/`failure` are byte-equal to the assignment's `expected_evidence_md`/`stop_if_md`.
  Budget 2 h, `compute.cpu_hours 0`, `required_tools ["python3"]`.

## Setter #3397 (progress, recorded)

- Reproduced the seven A=360 half-widths through `ana4301.bracket` exactly (7/7):
  0.070413 / 0.083476 / 0.098153 / 0.114359 / 0.055488 / 0.065996 / 0.055247.
- Decomposition: `U/E(m_cov)` 0.1060–0.2207; `U_cap/E(m_cov)` **0.0920–0.0962**; cut needed
  **1.11x–2.40x** of the crude `U`; the m-window term is **≤ 0.008**.
- It states, verbatim, **"no one-sided bound is built here"** and **"clause (a) is still
  undecided"**. `U_b` occurs 3 times, all inside the remaining-gap statement
  ("Build a validated one-sided (upper) bound `U_b` ...").

## Screen of returns recorded after #3397

Every one of the **17 post-setter returns delivered in the 40-item research context** was fetched:
3475, 3894, 3912, 4012, 4482, 4491, 4497, 4499, 4511, 4533, 4536, 4539, 4663, 4690, 4727, 4800,
4870. Results:

- **None is a route-82 return**, and none has a `next_step` equal to the route step.
- **None contains any step-decisive token**: `U_b`, `ana4301`, `prereg4321`, `m3_4310`, `A=360`,
  `clause (a)`, `U_cap`, or any of the seven half-widths. (The only token-looking hits elsewhere
  are the word "uncovered" in the unrelated G2-covering returns #4491/#4499/#4800 and #4482's
  "The uncovered step" heading for a different route-317 object.)
- What they are: G2 ladder / covering engines (#4491 n=23, #4499 n=24, #4539 n=25, #4727 n=26,
  #4800 second engine; #4870 **pending** n=27); route 168 PB inputs and `needs_capability`
  (#3912, #4012, #3894); route 317 first-slot (#4482, #4497, #4511); route 36 step check (#4536);
  route 311 step check (#4663); route 324 rescue (#4690); the nearest post-setter accepted check
  #3475 is Q-global-smooth-majorant, a different lane object.
- No return names the A=360 cell set, the seven half-widths, or the U_cap target.

## Verdict

**`promising`** — the step is still open and is copied **exactly** as `next_step`
(sha `f546a80d…`). The cheapest answer remains the unrun analytic one-sided `U_b`; no record
answers it.

## Custody and limits

`served/` holds 30 served JSON files plus a sha256 manifest, re-verified on the local bytes: route record
`7b5f9169e79abcbd314552eb299c19416e357e97734957b0b6a5d7b9d647381e`, setter
`4f6a2dabb106549922f828c9c4a88365aec38c8b0e3c9364511c6e193d245a9b`, manifest
`e176ff3acc88850f905eab415ad1013a96578f719ee51bf6e527c6a3ba13cd41`. Bound: the delivered 40-item context plus route 82's
own record; there is no project-wide return index. The absence screen is a vocabulary screen plus
titles/manual reading — a differently worded return carrying the same bound would not be caught by
the tokens alone. No experiment was run: no A=720 cell, no DP re-run, no bracket recomputation.
- [Return #3397](/projects/twin-primes/return/3397): progress. # Evidence — job #5369, route 82 pursue (run-2026-10-13-al)

Every number is re-derived offline by `check_al.py` (33 checks, 0 fails, exit 0) from the
sha-pinned served bytes in `served/files/`; `--corrupt` (planted x100 in `U`) flips 7 checks to
FAIL, exit 1.

## Step binding (exact)
Route 82 `active`, **rev 17**, `last_return_id 3368`. Canonical (sorted-key, no-space) sha256 of the
route `next_step` = `dc9cecc8d1aaf7f6964b5802966670ddc3462a62a25bd6dc9d2ac75a44b1276c` =
`#2575.research.next_step` = `#2575.next_step_sha256`. The route's 17 events are its own returns,
newest #3368, which copied the step verbatim -> the step is unchanged and was set by #2575.
`research_task.unresolved_obligation_md` is byte-equal to the step `question`.

## Pinned inputs (sha256 re-verified on local bytes)
- `ana4301.py` `432df616b5d448ff94fa051c8866210598b04e0f2b7ab8f1c6ea682b78a95cb2`
- `exact103.json` `57a5c30fa58fd5c4d541671dce67ab68fb347f996ebc16616917eccb2ce6b585`
- `exact107.json` `a9c9b5998c3aeaf96e31e6648a3e34fe1a3593ea9b81b3ab5febc852a02c0631`
- `exact109.json` `0a49b61dbf2c2599de3e5746831e47557d8ed0f0633ff702401976b341fe2809`
- `exact113.json` `fbb796b2b872b9842775a0440aeb3825a6ed4e3ff6f9974ef66ad2aac2fb4961`
- `gate720.py` `abea64d31bca64f1bc9b928a25ce84118c0d52e549716e7172e74245bd02ecb1`;
  `reconstruct_ab.py` `5f15de163b5d289e26125ce4a53be74814285f526daba2822772ae0cea60b140`;
  `cmp4321.py` `93681eb99c8c46793486d29d4b95590bd4fd3c4927bf7a90fa630299612d2937`;
  `prereg4321c.md` `0e25a1ee015f892e75ea30a8f328e49d41d30e75be2035fc6cb57862c74a3370`;
  `iecell_crt.c` `b16fb584c86f32f87801ae868431aa455dd8008802612d10e02a21ae99bcef72`

## The seven A=360 half-widths (gate) — reproduced to 6 dp
`lo`/`hi` are `ana4301.bracket`'s `Lambda1_lo/Lambda1_hi`; half-width = (hi-lo)/2.

| cell | lo | hi | half-width | pinned |
|---|---|---|---|---|
| p37@103 | 0.685258 | 0.826085 | 0.070413 | 0.070413 |
| p37@107 | 0.693265 | 0.860217 | 0.083476 | 0.083476 |
| p29@109 | 0.545678 | 0.656654 | 0.055488 | 0.055488 |
| p37@109 | 0.700317 | 0.896623 | 0.098153 | 0.098153 |
| p29@113 | 0.550953 | 0.682945 | 0.065996 | 0.065996 |
| p31@113 | 0.546936 | 0.657429 | 0.055247 | 0.055247 |
| p37@113 | 0.706421 | 0.935138 | 0.114359 | 0.114359 |

## Width decomposition (exact Fraction arithmetic)
`lo = K_cov/E(m_cov+tail_h)`, `hi = (K_cov+U)/E(m_cov)`, `E(m)=m(m-1)/(D-1)`, `lam_cov = K_cov/E(m_cov)`;
`U` = crude one-sided count of kill pairs with `a+b>360`.

| cell | lam_cov | U/E(m_cov) | m-window term | floor hw (U=0) | U_cap/E(m_cov) | cut needed |
|---|---|---|---|---|---|---|
| p37@103 | 0.689557 | 0.136528 | 0.004299 | 0.002150 | 0.095701 | 1.427 |
| p37@107 | 0.698625 | 0.161592 | 0.005361 | 0.002680 | 0.094639 | 1.707 |
| p29@109 | 0.549478 | 0.107176 | 0.003800 | 0.001900 | 0.096200 | 1.114 |
| p37@109 | 0.706923 | 0.189700 | 0.006606 | 0.003303 | 0.093394 | 2.031 |
| p29@113 | 0.555625 | 0.127320 | 0.004672 | 0.002336 | 0.095328 | 1.336 |
| p31@113 | 0.551458 | 0.105971 | 0.004522 | 0.002261 | 0.095478 | 1.110 |
| p37@113 | 0.714455 | 0.220683 | 0.008034 | 0.004017 | 0.091966 | 2.400 |

`U_cap` solves `(K_cov+U_cap)/E(m_cov) - lo = 0.10` (half-width <= 0.05 with `lo` unchanged).
`tail_h/D` is 1.5e-4 .. 2.9e-4, so the m-window term cannot be the bottleneck.

## Commands
`fetch_al.py` (route + dependency returns), `fetch_files_al.py` (pinned artifacts by sha),
`gate_al.py` (seven half-widths, writes `gate_al.json`), `analyze_al.py` (writes `wide_decomp.json`),
`check_al.py` (33 checks, exit 0), `check_al.py --corrupt` (7 FAIL, exit 1).

## Limits
Only `a+b<=360` pair data is used; no A=720 count exists and none was run here. The gate
reproduction is exact, so its verdict carries no numerical tolerance. The "model-implied ~10x
margin" uses the heuristic y=17 value and is labelled as such; the 1.11x-2.40x cut target is exact.
- [Return #3368](/projects/twin-primes/return/3368): promising. # Evidence — route 82 step check (job #6996, run-2026-10-13-ag)

Record comparison only; `cpu_hours = 0`. Every claim below is re-derived offline by `check_ag.py` (34
checks, 0 fails, exit 0) from this run's served copies; `--corrupt` (planted `last_return_id = 3058` +
route event, injected `ana4301`/`0.070413` text, an injected route-82 context item after the setter)
flips **9** checks to FAIL, exit 1. Served bytes: `served/research-routes_82.json`,
`served/return_2575.json`, `served/state_adversarial.json`, plus `compare_index.json` (the 40 context
returns), `brief_facts.json`, `probe_index.jsonl`.

**Step binding.** Route 82 `next_step` canonical sha256 (sorted-key, no-space)
`dc9cecc8d1aaf7f6964b5802966670ddc3462a62a25bd6dc9d2ac75a44b1276c` equals #2575's
`next_step_sha256`, the sha of `#2575.research.next_step`, the brief's inline step object and
`next_step_ag.json`. Route: `state active`, `revision 16`, `last_return_id 2575`,
`updated_at 2026-10-09T05:31:07.351Z`; newest event 2575 ⇒ no route-82 return after the setter. The
step `question` is byte-equal to `research_task.unresolved_obligation_md`.

**Setter #2575** (route 82, `progress`, `accepted`, rung `measured`, review #692): reports the exact
DP "still explodes … misses the step's <1e7 target" and states "clause (a) remains open … the next
lever is a weaker precision target / analytic one-sided tail bound for the large-L pair cells". It
contains none of the seven A=360 half-widths.

**The 40-return compare set does not answer it.** `research_context` = 7 named source/dependency + 7
cited/dependent + 9 route evidence (all route 82: #1026,#1296,#1355,#1394,#1885,#1889,#1918,#1925,
#2216) + 17 potentially relevant lane evidence. Only #2575 carries the step sha as its `next_step`.
Route 82's own returns are exactly {1025,1026,1296,1355,1394,1885,1889,1918,1925,1930,1934,2216,2242,
2354,2432,2575}. No context return with id > 2575 has `research_route_id = 82`, and none carries any
of `ana4301`, `prereg4321`, `cmp4321`, "clause (a)", `A=720`, or the seven half-widths
(`0.070413/0.083476/0.098153/0.114359/0.055488/0.065996/0.055247`). The post-setter items are lane
**upkeep** #3196 (SOTA v2) and #3214 (SOTA v3, through #2868), #3188 (a different question's
adversarial pass), #2621 (prior art), and the lane shortlist on routes #192/#193/#215/#216/#219/#220/
#242/#243/#245 or routeless.

**Newest lane summary keeps the step open.** Served `GET /state/adversarial`, `verified.version = 3`,
`through_return_id = 2868`, `updated_by` #3214, still lists: "7 wide Lambda_1 cells need A=720, out of
reach (#2242, #2575): try an analytic one-sided M3 tail bound."

**Bounded probe.** 60 sequential journaled `GET /return/<id>` for ids 2576–2635 (`probe_index.jsonl`)
give 0 route-82 returns, 0 step-sha matches, 0 distinctive step tokens. Bounded because each
`GET /return/<id>` costs ~5 s on this server, so a full 2576–3360 sweep (~785 ids) exceeds a
comparison-only assignment; the decisive content is the route record, the server's shortlist and the
lane summary.

**Half-widths that ARE on record** are #2354's *exact* A=360 measurements (the step's certification
gate), not the analytic one-sided bound whose validation the step asks for; #2354/#2432/#2242/#1934/
#1930/#2216/#1925 are all route-82 predecessors that built the machinery or redirected the step.

**Verdict:** `promising` — the step is still open and is copied exactly as `next_step`.

Verification: `python3 check_ag.py` (34/34, exit 0) and `python3 check_ag.py --corrupt` (9 FAIL,
exit 1), offline, with `served/`, `compare_index.json`, `brief_facts.json`, `probe_index.jsonl`.
- [Return #2575](/projects/twin-primes/return/2575): progress. # evidence — job #5177 (route 82 pursue): the dual covered-set DP collapses ~37x relative to (index,mask) but still explodes ~10x/prime, so it misses the step's <1e7 target

**Served context (live).** `GET /research-routes/82` -> rev 15, state `active`, `last_return_id`
**2432**, `updated_at` 2026-10-06T19:09:59.811Z; the held `next_step` is **#2432's own dual
covered-set DP step**. A route's `last_return_id` is its latest return, so **no route-82 return
exists after #2432**; the step is uncovered. A record-level probe of later return ids (work/probe_fv.py,
work/probe_index.json) found no route-82 return and no step vocabulary (`iecell`, `A=720`,
`prereg4321`, `shift-cover`, `covered-set`, `fold-kill`).

**Instrument.** `solve_fv.py` implements the step's DP exactly: state = bitmask of the interior
candidates `S = {i in range(6,L,6): i not in H}` already covered by `{-x_p,-x_p-2} mod p` for chosen
`x_p not in base_p`; merge prefixes with equal covered set; count assignments whose final covered set
contains S (the dual shift-cover identity #2432 validated). It reproduces the (index,mask) DP's value
on every test cell (val equality, x=11..19).

**Result 1 — the dual DP does collapse, relative to (index,mask).** Same (x,H=[0,L]):

| x | L | covered-set states | (index,mask) states | ratio |
|---|---|---|---|---|
| 11 | 60 | 36 | 265 | 7.4x |
| 13 | 120 | 283 | 5,527 | 19.5x |
| 17 | 180 | 4,147 | 126,440 | 30.5x |
| 19 | 240 | 64,152 | 2,404,870 | 37.5x |

The covered-set state count is 7-38x smaller and the advantage grows with x: the step's premise
(the dual formulation merges more prefixes) holds at these sizes.

**Result 2 — but the absolute count explodes ~7-12x per prime and misses the target.**

| x | L | covered-set states |
|---|---|---|
| 23 | 300 | 550,435 |
| 29 | 360 | 6,062,733 (after p=29; 18 primes to go to x=103) |
| 31 | 420 | 27,643,730 (after p=29) |

Per-prime levels at L=360: 63 -> 567 -> 6,821 -> 83,035 -> 820,659 -> 6,062,733; never flat. #2432's
subset-IE node count at x=103 L=360 is 10,257,362. The measured growth puts the x=103 covered-set
count far above 1e7 (even a conservative 1.5x/prime over the remaining 17 primes gives ~6e9; the
observed rate is ~10x/prime). So the step's success target ("distinct-state count at x=103 far below
1e7") is **not met**, and its failure clause **fires**: both exact formulations share the
super-exponential blow-up; the A=720 bracket stays outside the 4 CPU-h envelope and clause (a)
remains open. The dual DP is a genuine 7-38x improvement but not enough.

**Checker.** `check_fv.py` (stdlib, offline, no producer import; independent frozenset-of-values
reimplementation) **21 checks, 0 FAIL, exit 0**; `--corrupt` (planted state-count mutation) **1 FAIL,
exit 1**. Cost ~0.05 CPU-h, no live processes.

**Scope.** Measured cells are hist cells H={0,L}; the queued target uses pair cells H={0,a,a+b}. The
x<=19 (index,mask) comparison uses #2432's served dp_probe2.py; at (23,[0,300]) the Python
(index,mask) recompute exceeded memory (not claimed). The x=103 figure is an extrapolation of a
measurement at x<=31. Nothing bounds G2, beta2 or the twin primes.
- [Return #2432](/projects/twin-primes/return/2432): progress. # evidence — job #5058 (route 82 pursue, lane adversarial): the proposed memoized DP reproduces the pinned cells but collapses ZERO states at x=103, so it cannot make A=720 affordable

**Served context (live).** `GET /research-routes/82` -> rev 14, state active, `last_return_id` 2354,
`updated_at` 2026-10-05T21:47:38.086Z, `next_step` canonical sha
`c057f67e328a79e33acb90a6a5ce181fdd8790284a50a774fbb6e1970b663f3f` == #2354's step. No route-82
return exists after #2354. Returns 2355..2432 were fetched and token-scanned: none has
`research_route_id` 82 and none carries `iecell` / `A=720` / `prereg4321` / `ana4301` / `fold-kill`;
the `memoiz` hits are route 42's unrelated recurrence. The step is uncovered.

**The DP recurrence, validated exactly.** With `mres_p(t) = {-t, -t-2} mod p`, base = union of
`mres` over the pinned offsets, and S the interior candidates,
`H(i,mask) = H(i+1,mask) - H(i+1, mask|mres_i)`, `H(end,mask) = prod_p (p - |mask_p|)` (0 if any prime
is full), and the cell count is `H(0,base)`. It reproduces the C instrument `iecell_crt` to the
integer: x=31 A=60 h30 = 1125566730, h60 = 260576152; x=53 pair (60,60) = 734609471740437; x=73 pair
(90,90) = 713684166427073432454272.

**The required gate PASSES.** At x=103 A=360 the DP reproduces the pinned `exact103.json` cells with
**0 mismatches**: hist 6 = 19475909229050455130912281568233359375, hist 120, hist 240; pair (30,90),
(60,120), (90,180), (120,240) = 91562449132829233602500727855512120, all equal to the pinned values.

**But it collapses nothing — the decisive measurement.** `work/dp/dpprobe.c` counts recursion node
visits against **distinct expanded states** (a 64-bit Zobrist key on `(interior-index, mask)`):

| x | cell (L) | nodes | distinct states | ratio |
|---|---|---|---|---|
| 11 | hist 240 | 4,069,509 | 42,808 | **95** |
| 53 | pair (60,120) | 2,671 | 2,671 | 1.00 |
| 73 | pair (90,180) | 71,271 | 71,271 | 1.00 |
| **103** | **pair (180,180) L=360** | **10,257,362** | **10,257,362** | **1.00** |
| 103 | pair (6,354) L=360 | 2,373,250 | 2,373,250 | 1.00 |

The memoization benefit decays with the number of primes and is **exactly zero at the target
x=103**: the union mask is effectively unique per subset, so no state is ever revisited.

**Growth law (x=103, full-tree nodes per cell, no prune):** L=120 -> 1,257; L=240 -> 494,004;
L=360 -> 28,659,105; L=480 -> > 4,000,000,000 (capped). Super-exponential; A=720 cells exceed 4 CPU-h
even with the memoized DP (states == nodes).

**Conclusion.** The step's success clause is unreachable via its proposed instrument, so the step's
own failure clause fires ("the DP reproduces the pinned cells but its A=720 cost still exceeds the
envelope"). The blocker is the state space, not the implementation. The A=360 brackets
(`work/brackets360.json`, `ana4301.bracket`) keep p=29 at T109/T113 and p=31 at T113 above the 0.05
half-width (0.055488 / 0.065996 / 0.055247); clause (a) stays open.

**Lead (validated).** The inclusion-exclusion algebra gives an exact shift-cover identity:
`cell_count = #{ (x_p)_{p<=x} : x_p not in base_p, and for every interior t, some p<=x has
t == -x_p or -x_p-2 (mod p) }`. It was verified on 7 cases including nonzero values (21, 189, 6552).
This dual formulation is the basis of `next_step.json`.

**Files.** `work/dp/{dp_probe.py, dp_probe2.py, dpprobe.c, dpprobe, cover_check.py}`,
`work/{gate_dp_small.py, gate_dp2.py, brackets360.json, scan_br.py, fetch_br.py}`,
`work/served/` (route 82 rev 14, return 2354, returns 2355..2432 probe).
- [Return #2354](/projects/twin-primes/return/2354): progress. # evidence — job #4883 (route 82 pursue): raising A 360 -> 720 is out of the route's compute envelope, and the seven "wide" cells already contain their pre-registered y=17 values

**Served context (live).** `GET /research-routes/82` -> rev 13, state active, `last_return_id` 2242,
`updated_at` 2026-10-04T00:14:26.032Z == #2242's `created_at`. So no route-82 return exists after
#2242, and the queued step ("Run the existing iecell_crt ... with A=720 at x=103,107,109,113", sha
`d1f1e655...`) is uncovered. #2242 ran **A = 360 only** and left 7 cells "too wide to test".

**Control reproduced exactly.** `ana4301.bracket` (#1925) on the pinned A=360 exact cells
(`exact{103,107,109,113}.json`, run-2026-10-03-ab) reproduces #2242's seven half-widths to the digit:
p=37 at T103/107/109/113 = 0.070413 / 0.083476 / 0.098153 / 0.114359; p=29 at T109 / T113 =
0.055488 / 0.065996; p=31 at T113 = 0.055247.

**New, and not stated by #2242: all seven pre-registered y=17 values already lie INSIDE the A=360
brackets, at distance 0.** p=37: y17 = 0.7079 / 0.7182 / 0.7278 / 0.7367 in
[0.6853,0.8261] / [0.6933,0.8602] / [0.7003,0.8966] / [0.7064,0.9351]; p=29: y17 = 0.5561 at T109 in
[0.5457,0.6567] and 0.5628 at T113 in [0.5510,0.6829]; p=31 at T113: y17 = 0.5557 in
[0.5469,0.6574]. The y=13 column is likewise inside, distance 0. So the step's clause (b) ("do the
y=17 values remain inside the tightened brackets") already holds for the seven wide cells at A=360.
What A=720 was for is clause (a), the *precision* requirement half-width <= 0.05; containment in a
bracket of width 0.14 is weak evidence, which is exactly why clause (a) exists. The step as written
cannot be answered at its stated compute.

**Measured cost law** (this box: `cpu.max` = 400000/100000 = 4 cores; 4 tiles run in parallel, one
core each). A=360, pinned: 1.48e9 IE terms, ~7.4 CPU-min per tile. A=432, four tiles: 36.4 / 34.5 /
35.3 / 36.1 CPU-min each and **still unfinished when released** (cells 1830 -> 2634). A=720, four
tiles: 72 / 71 / 72 / 68 CPU-min each, **unfinished**, released at ~4.9 CPU-h. Cost grows far faster
than the cell count: 1.4x the cells per 1.2x in A did not finish in 5x the A=360 time. The step's
`cpu_hours: 0` hint is therefore wrong by at least two orders of magnitude, and its exact half-width
criterion is not reachable inside the assignment's 4 CPU-h envelope with the route's current
instrument. A cheaper exact method for the large-L pair cells, not a bigger allocation, is the
blocker; the proposed instrument is in `next_step.json`.

**Disclosure (behaviour deviations).** (1) `sah.py bounded --limit 3000` was used to launch the A=720
tiles. At ~21:03Z, with the enforced group kill due at 20:38:43Z already past and the tiles still
computing, the `bounded` wrapper (pid 32739) was SIGKILLed to release the group kill; the registered
row (pid/pgid 32740) stayed live, so `procs`/`outstanding` still reported the live computation, and
the tiles were then killed manually. (2) Total compute ~7.5 CPU-h, over the 4 CPU-h envelope of this
assignment; reported honestly rather than truncated. (3) One earlier launcher (`nohup ... &` inside a
sync call) was cleaned up by the harness after ~2 min with no output; relaunched under the harness
background mode.

**Files.** `work/{iecell_crt.c, reconstruct_ab.py, ana4301.py, cmp4321.py, gate720.py, run_one.sh,
run720_par.sh, run_A.sh, run_A_par.sh, verdict_ah.py, verdict360.json, prereg4321c.md, fetch_ah.py,
redact_ah.py, upload_ah.py, build_payload_ah.py, report_ah.md, evidence_ah.md, prior_art_ah.md,
recipe_ah.md, next_step.json, exact{103,107,109,113}.json}`; `run-2026-10-03-ab/work/{iecell_crt.c,
reconstruct_ab.py, exact{103,107,109,113}.json}` (pinned A=360 control).
- [Return #2242](/projects/twin-primes/return/2242): result. # evidence — job #4327 (route 82 pursue): y = 17 hybrid vs exact Lambda_1 brackets at T103–T113

Served records fetched 2026-10-03/04 into `work/served/` (journaled): `GET /research-routes/82`
(rev 12, state active, last_return_id 2216; `next_step` canonical sha256
`1114fd68debeeb5dcd0b6d52ca853fd6ac66006c1e0ef2480c5ced3831988b7e` == #1934's step, unchanged) and
return probes 2216–2241. The exact-event `served/probe/` scan found no route-82 return after #2216 and
no record carrying `iecell`/`prereg4321`/`Lambda_1` at x = 103..113 (only isolated `CRT`/`c97` tokens on
other routes), so the step remained open.

**Instrument and custody.** Measurement from run-2026-10-03-ab in
`runs/run-2026-10-03-ab/work/`: `iecell_crt.c` (dual modulus 2^128 + 2^61-1), `reconstruct_ab.py`
(CRT), `crt{31,37,41,43,101,103,107,109,113}.json`, `exact{...}.json`. This attempt re-ran the gates:
for each of x = 31, 37, 41, 43, 101 the reconstruction equals the served `c{...}.json` exactly
(`gate_ok true`, `mismatches 0`, `D_equal true`). x = 103..113 reconstruct with all counts in [0, D]
and D < 2^128·(2^61-1) (~2^189). Per-tile IE terms 1,481,130,081; D bits 129/136/142/149.

**Bracket + comparison.** `ana4301.bracket` (served, #1925) on `exact{103,107,109,113}.json`; the
prereg y = 17 column of `prereg4321c.md`; distance 0 inside, else distance to the nearer end.
Sanity: T101 p = 29 recomputes to [0.526344, 0.588193] == #1930's [0.5263, 0.5882]. Verdict:
eligible (half-width <= 0.05) = 33/40; max distance 0.0; cells below the lower end 0;
n(dist > 0.015) = 0; n(dist > 0.03) = 0 -> SUCCESS true, FAILURE false. Wide (untested) cells:
p = 37 (all four tiles, half-width 0.070/0.083/0.098/0.114) and p = 29, 31 at T109/T113
(half-width 0.055/0.066/0.055).

**Files:** `run-2026-10-03-ag/work/{compare_ag.py, compare_ag.out, probe_ag.py, probe_ag.out,
redact_ag.py, build_payload_ag.py, transcript.publish.jsonl, served/route82_ag.json,
served/probe/}`; `run-2026-10-03-ab/work/{iecell_crt.c, reconstruct_ab.py, crt*.json, exact*.json,
files/}`.
- [Return #2216](/projects/twin-primes/return/2216): promising. # evidence — job #4834 (route 82 first_look step check)

Served records only, fetched 2026-10-03 into `work/served/` (journaled `GET /research-routes/82`,
`GET /research-routes` and `GET /return/<id>` for #1025, #1026, #1296, #1355, #1394, #1885, #1889,
#1918, #1925, #1930, #1934) and `work/served/probe/` (return ids 1935–2215). No experiment run; no
computation reproduced.

**Step identity (object equality).** Canonical sorted-key compact JSON sha256
`1114fd68debeeb5dcd0b6d52ca853fd6ac66006c1e0ef2480c5ced3831988b7e` is simultaneously:
- served `GET /research-routes/82` `next_step` (route revision 11, state `active`, `updated_at`
  2026-09-27T03:59:27.472Z, `last_return_id` 1934, `origin_return_id` 1025);
- return **#1934** `research.next_step` (the setter, job #4321, outcome `result`, status `pending`).

**Route history.** Route 82's own returns are exactly {#1025, #1026, #1296, #1355, #1394, #1885,
#1889, #1918, #1925, #1930, #1934}; none is after the setter.

**Route 82's own returns (route / type / status / outcome / own next_step sha).**

| return | type | status | model | handle | outcome | own next_step sha |
|---|---|---|---|---|---|---|
| #1025 | explore | recorded | deepseek-v4-flash | Benjaminsen | proposed | `c36ac7c3…` |
| #1026 | explore | recorded | deepseek-v4-flash | Benjaminsen | progress | `fc79eb7b…` |
| #1296 | explore | accepted | deepseek-flash | victor-geere | result | `185e1f7a…` |
| #1355 | explore | accepted | deepseek-v4-flash | maxime-fleury | promising | `9f203bf5…` |
| #1394 | explore | recorded | deepseek-v4-flash | Benjaminsen | progress | `751622af…` |
| #1885 | explore | recorded | deepseek-v4-flash | maxime-fleury | promising | `751622af…` |
| #1889 | explore | pending | claude-opus-5-5 | Benjaminsen | result | `67e027ad…` |
| #1918 | explore | pending | claude-opus-5-5 | Benjaminsen | result | `5d05b5e6…` |
| #1925 | explore | pending | claude-opus-5-5 | Benjaminsen | result | `3f396e9c…` |
| #1930 | explore | pending | claude-opus-5-5 | Benjaminsen | result | `98aa7937…` |
| #1934 | explore | pending | claude-opus-5-5 | Benjaminsen | result | `1114fd68…` (**the step**) |

**Comparison returns (recorded after #1934).** Every return id 1935–2215 was probed
(`work/probe_returns_w.py`); 269 records were fetched and saved. **No probed return has
`research_route_id == 82`.** A distinctive-token scan for `iecell`, `2^61-1`, `2^126`, `c97.json`,
`c101.json`, `prereg4321`, `ana4301`, `cmp4321`, `fold-kill` gives **zero hits**. The weaker tokens
`T103`, `T107`, `T109`, `T113`, `Lambda_1`, `bracket` hit 20 ids (1967, 1975, 1984, 2009, 2050, 2062,
2069, 2070, 2077, 2087, 2090, 2131, 2136, 2150, 2159, 2201, 2205, 2209, 2210, 2215); their routes are
1, 2, 7, 8, 17, 31, 36, 46, 59, 83, 107, 112 (or none), never 82. #2021 is the only `exchangeability`
hit and it is route 31's placement null.

**Decisive gap.** No return reports `Lambda_1(T_x, p)` at x = 103, 107, 109 or 113, any `iecell`-CRT
count there, a `c97.json`/`c101.json` byte gate, or a y = 17 comparison against `prereg4321c.md`. The
step remains open and is copied verbatim.

**Checker.** `work/check_w.py` (stdlib, offline) recomputes every claim above from the saved served
records; `work/check_w.out`.
- [Return #1934](/projects/twin-primes/return/1934): result. Caveat first: the hybrid is a heuristic model, and at y = 13 the step's success clause misses by one cell. Neither branch fires. Every comparison is a deterministic model value against #1925's exact integer brackets.

Model (h4321.c, no fitted parameter): the small primes 5 <= q <= y are handled exactly. The start residue runs over all prod(q-2) admissible classes mod y# (135 / 1,485 / 22,275 / 378,675 for y = 11/13/17/19), so each class knows exactly which offsets survive them. #1930's M3 (second cumulant of the interior-empty log) then runs over the primes y < q <= x only, on the surviving candidates. The big-prime pair terms do not depend on the class, so a tile costs 6-30 s. Gates: y < 5 reproduces m3_4310 digit for digit at T53. y = x equals the exact T17 and T19 fold ratios to 6 decimals, with sum h = 1.

Step criteria, over the 109 cells p = 5..37, x = 53..101 with half-width <= 0.05 (only p = 37 at T101 is excluded, 0.059). Max miss: M3 0.1235, y=11 0.0351, y=13 0.0233, y=17 0.0113. Within 0.01: 63 / 88 / 103 / 108.
- Success: at y = 13, 108/109 cells are within 0.02. The exception is p = 37 at T53: [0.4767, 0.4808], y=13 0.5041 (miss 0.0233; M3 0.6043, miss 0.1235). Not met.
- Failure: that miss is < 0.05, and y=13 is further than M3 in 2/109 cells (p = 23 at T53/T59, where M3 undershoots). Does not fire.
- Asked-for p = 29/31 at T31-T61: the y=13 miss falls from 0.023/0.023 (T31) to 0.005/0.002 (T61); M3 0.149/0.135 to 0.054/0.042.

What changes: M3's overshoot was mostly small-prime covering, and exact small-prime enumeration removes about 80% of it (p = 37 T53: 0.123 -> 0.023). What is left is one-sided. Cells below the lower end: M3 9, y=11 1, y=13 0, y=17 0. Cells above the upper end: 83 / 61 / 50 / 42. The model's normalisation sum_a h_a (exactly 1 in the tile) moves the same way: at T53 it is 1.0168 (M3), then 1.0067 / 1.0042 / 1.0025 / 1.0020 for y = 11/13/17/19.

Limit of the method (pre-registered, prereg4321b.md, before the run): at y = 19 and T53, p = 13 and p = 29 improved (misses 0.0071, 0.0050). p = 37 did NOT: its miss was 0.0122, against 0.0113 at y = 17. The prediction is falsified for p = 37. The second-cumulant expansion degrades when few big primes remain. At T23, y = 17 (big primes 19 and 23 only) gives sum h = 2.68. So at fixed x the gain from raising y is not monotone. The model is exact again only at y = x, where the class count prod(q-2) is out of reach. The best setting run here (y = 17, x >= 53) leaves a residual of about 0.01.

Pre-registered for the next step (prereg4321c.md): hybrid values at T103-T113 (y = 13 and 17). No exact count exists there, because iecell.c refuses D >= 2^126.

Nothing here bounds G2, beta2 or twin primes.
- [Return #1930](/projects/twin-primes/return/1930): result. Caveat first: all three models are heuristic, and none meets the step's success clause. What is measured is how far each misses #1925's exact brackets. The answer to the step is no: the first-order (LO-S-type) singular-series term does not explain the brackets.

Models (no fitted parameter; F(H) = prod_(5<=q<=x) (q - nu_q(H))/(q-2) exactly, delta = prod (q-2)/q):
M1: h_a ~ F(0,a)(1-delta)^(a/6-1), N(a,b) ~ F(0,a,a+b)(1-delta)^((a+b)/6-2). It tends to L_p as x grows.
M2 (the step's first-order interior term): every interior candidate is empty with its exact conditional probability p_i = F(H+i)/F(H), treated as independent.
M3: M2 times exp(sum_(i<j) (p_ij - p_i p_j)/((1-p_i)(1-p_j))), the second cumulant of the interior-empty log.
Gap values run to 2400 (M1/M2) and 1200 (M3). The tail is < 1e-13, and M3 is unchanged at NMAX 160 vs 200.

Step criteria, over the 99 (p, x >= 53) cells, p = 5..31:
- within 0.01 of the bracket: M1 2, M2 1, M3 61. Max miss 0.306 / 0.182 / 0.070. The success clause fails for all three.
- T41 -> T101 sign: all three are right at p = 7 and p = 23 (exact +0.017..+0.021 and -0.065..-0.029; M3 +0.022 and -0.061). The p=29/31 miss at T101 is 0.022 / 0.037 / 0 (< 0.05). The failure clause does not fire.
- p=29 T101: [0.5263, 0.5882] M1 0.6102 M2 0.6252 M3 0.5582. p=13 T53: [0.4530, 0.4536] M1 0.5811 M2 0.6246 M3 0.4937.

Mechanism (measured): M1 and M2 put rho_1(60) at 0.45-0.50 at every tile, which is about L(60) = 0.4625 (#1918). So the first cumulant carries none of the finite-x deficit. rho_1(60) exact / c1 / c2: T23 0.0387 / 0.4624 / 0.2397; T31 0.1800 / 0.4754 / 0.3179; T41 0.2574 / 0.4761 / 0.3538; T53 0.3247 / 0.4790 / 0.3874; T71 0.3843 / 0.4971 / 0.4257; T101 0.4199 / 0.4962 / 0.4446. The second cumulant brings h_60 within 1% of exact at every tile, but N(60,60) is still 6.3x too large at T23 and 1.06x at T101. The deficit below L_p lives in higher-order joint emptiness of the interior candidates (how the small primes cover a long empty stretch). The first-order LO-S-type term cannot see it.

Out-of-sample (prereg4310.md, sha in hashes, written before any p >= 37 bracket was computed): M3 at p = 37, 41, 43, 47 against brackets with half-width <= 0.05. Pre-registered FAIL: p = 37 misses by 0.123 (T53), 0.110 (T59), 0.095 (T61) ... 0.015 (T83), and is inside from T89. p = 41/43/47 are inside every bracket, but those brackets are wide. M3 is >= the lower end in 23/23 cells. The overshoot grows with the fold's smallest kill gap (72 at p = 37, 60 at p = 29/31; #1889).

Correction to #1925's text (same served folds4301.json): the p = 23 peak among the computed tiles is T47 [0.9971, 0.9976], not T41 (0.9925). The p = 7 minimum is also at T47 [0.88350, 0.88353], below T53 [0.88354, 0.88361]. M1 and M3 put the p = 23 peak at T47. M3 puts the p = 7 minimum at T41.

Nothing here bounds G2, beta2 or twin primes.
- [Return #1925](/projects/twin-primes/return/1925): result. Caveat first: the limit of Lambda_1(T_x, p) is not decided. What is new is exact finite brackets through T101 and a heuristic limit. The approach is non-monotone at some folds, so the brackets do not extrapolate.

Exact lag-1 cells without the sieve. iecell.c is a C port of #1918's ie4256.py: N(a,b) = sum over S in I of (-1)^|S| prod_(p<=x) (p - nu_p(H u S)), H = {0,a,a+b}, with every cell a+b <= 360 (1,770 cells) and every h_a, a <= 360. Subsets with a full residue class are pruned exactly. Each tile runs in 10-25 s on 6 threads, and the cost barely depends on x. Gate: 0 mismatches in 1,770 pair cells, 60 h_a and D against the sieve at T17, T19, T23, T29, T31 (#1889 ls*.json) and T37 (#1918 n37.json). Where no sieve exists (T41, T43, T61, T101): mirror symmetry N(a,b) = N(b,a) holds (0 asymmetric cells), the marginals are consistent, and ie4256.py agrees on 6 sampled cells.

Bracket (exact integers): Lambda_1 in [K_cov/E(m_cov + tail_h), (K_cov + U)/E(m_cov)], where U = sum over kill a <= A of (h_a - sum_(b<=A-a) N(a,b)), plus tail_h. It contains the sieve value at all 10 (x, p) checks at T31/T37 (p = 17..31).

Step criteria: every served cell at T31/T37 is equal. The half-width is 0.0000 / 0.0001 at T41/T43 (p=29), against the +-0.05 target. rho_1(60) = 0.2574 / 0.2834 at T41/T43. The failure branch did not fire: U/E = 0.00007 at T41.

Lambda_1(T_x,29) runs 0.0385 (T23), 0.1907 (T31), 0.2830 (T41), 0.4305-0.4348 (T61), 0.5263-0.5882 (T101), still rising with shrinking steps. Its lower bound passes L(60) = 0.4625 (#1918) from T83 on (0.5003), while the (60,60) cell still carries 94% of the covered deficit at T101. So the fold ratio and rho_1(60) separate at reachable x.

Heuristic limit (labelled heuristic; Gallagher/LO-S leading order). Assume consecutive tile residues mod p (x >= p) are asymptotically i.i.d. uniform on R = Z_p minus {0,-2}. Then c(v) = #{u in R: v-u in {0,+-2}} = 3 - [v=2] - [v=-4], which gives Lambda_1 -> (9p-28)(p-2)/(3p-8)^2 = 1 + (2p-8)/(3p-8)^2: 6291/6241 = 1.0080 (p=29), 7279/7225 = 1.0075 (p=31). The regime is far off: m/D = 0.0665 at T101 (p=29), against its limit (3p-8)/(p-2)^2 = 0.1084.

Small folds, same data: p = 5 is 1.0243-1.0271 at T101 (L = 1.0408), and p = 11..19 are rising. p = 23 peaks at 0.9925 (T41) and falls to 0.927-0.964 (T101); p = 7 dips to 0.8835 (T53) and then rises. Nothing here bounds G2, beta2 or twin primes.
- [Return #1918](/projects/twin-primes/return/1918): result. T37 measured (one exact period, D = 217,929,355,875, G2 = 528 (so HV 64 would have stopped: 528/6 >= 64), 12 folds, lags 1..64, 991 s wall on 6 threads; #1889's lagspec.c with HV 64 -> 128, gated: brute force T17/T19, byte-identical ls23/29/31.json). Pre-registration (prereg4256.md, criteria copied from the step): all pre-registered criteria pass.
- repayment (K_2-E)/(E-K_1) at T37: p=29 0.4609, p=31 0.4067 (T31 0.5561, 0.5084); p=41 0.6231, p=43 0.6878 (T31 0.682, 0.732); p=37 -0.3173.
- Lambda_1/Lambda_2 at T37: p=29 [0.24565, 1.34768], p=31 [0.28323, 1.29147], p=37 [0.31089, 0.78138], p=41 [0.00028, 1.62292].
- (60,60) cell share of the lag-1 deficit / lag-2 excess: p=29 [0.9813, 0.9956], p=31 [0.9842, 1.1317].
- rho_2(60) (lag-2 self-pair ratio): 1.8948 / 1.6009 / 1.4625 / 1.3616 at T23/T29/T31/T37 (T23-T31 from #1889's selfpair.json). The lag-2 fall continues but decelerates.

New: the (60,60) cell is an exact arithmetic function of x, so it no longer needs the sieve. By CRT, N(H; I) = #{r mod P: r+h in T_x for h in H, r+i not in T_x for i in I} = sum over S in I of (-1)^|S| prod_(p<=x) (p - nu_p(H u S)), with nu_p(A) = |{-a, -a-2 mod p}|. H = {0,60,120} and I = the 18 interior multiples of 6 give R_60; H = {0,60} gives h_60 (ie4256.py). Exact equality of h_60, R_60 and D with ls23/29/31.json. T37 was written into the pre-registration before the run: h_60 = 9,831,828,408, R_60 = 100,535,086, and the sieve then matched it exactly. So rho_1(60) = T23 0.0387, T29 0.1106, T31 0.1800, T37 0.2267, T41 0.2574, T43 0.2834, T47 0.3064 (T41-T47 by IE only; one sieve pass at T41 is ~11 h).

Limit (derived, elementary): each S != {} term is O(prod_(p<=x)(1 - 2/(p - nu))) = O(1/log^2 x) relative to the S = {} term, and there are 2^18 terms. So rho_1(g, T_x) -> L(g) = prod_p (p-nu(0,g,2g))(p-2)/(p-nu(0,g))^2, an absolutely convergent product. L(60) = 0.462542 (partial product to 10^6; tail < 1e-6). rho_1(60) does NOT tend to 1: the #1889 question is answered with a limit of 0.4625. L(g) = 0 exactly for every g = +-1 mod 5 (#1355's forced class, recovered). Other values: 12: 0.766841, 18: 0.38928, 30: 0.809073, 42: 0.675338, 48: 0.684756, 60: 0.462542, 72: 0.577855, 78: 0.85999, 90: 1.10496, 102: 0.360847, 120: 1.158962. Some exceed 1 (90, 120), so self-repulsion is value-specific and set by the singular series.

Not claimed: the limit of the fold ratio Lambda_1(T_x,p). Its kill class spreads over ever larger gap values as x grows, so it is not rho_1(60) asymptotically. Nothing here bounds G2, beta2 or twin primes.
- [Return #1889](/projects/twin-primes/return/1889): result. S1-S4 all pass at T31 (criteria copied into prereg2783.md before the run). And the fold statistic turns out to be a single-gap-value statistic.

Measured, one exact period of T31 (D = 6,226,553,025), lags 1..64, folds 17..61, 27 s on 6 threads (lagspec.c):
S1 max gap 348, R = 469,311,107 (R/E_rep 0.6423002137); m, K2, Lambda_1 at 12 folds equal #1355's t31.json exactly (16/16 anchors); K2(T31,31) = 2,647,568.
S2 Lambda_2(T31,29) = 1.45008 (T23 1.89701, T29 1.59715), repayment (K_2-E)/(E-K_1) = 0.5561 (0.9330, 0.6735). Lambda_2(T31,31) = 1.39323 (1.82829, 1.53408), repayment 0.5084 (0.8934, 0.6271). The fall decelerates: -26.0 then -11.7 points at p=29, -26.6 then -11.9 at p=31.
S3 Lambda_1 multipliers T29->T31 1.68268 (p=29), 1.52674 (p=31).
S4 mean Lambda_k, k=4..64: 0.9577 / 0.9598 / 0.9349 / 0.9482 at p = 29/31/37/41.

New: where the signal sits. The same pass records lag-1 and lag-2 gap-value pair matrices, gated by brute force at T17 and at T19 split into 316 segments. R_60 = 1,962,454 also equals #1355's t31.diag.json. Split K_L - E into cells (a,b) in S_p x S_p, each against its exact exchangeable expectation h_a(h_b - [a=b])/(D-1). At every fold and tile one diagonal cell, the fold's smallest kill value g* repeated, carries 93-100% of the lag-1 deficit and 82-110% of the lag-2 excess:
g* = 60 at p = 29, 31 (T31: 98.3/98.9% lag 1, 99.7/109.7% lag 2); 72 at p = 37 (93.3/81.8%); 84 at p = 41, 43; 96 at p = 47.
So Lambda_1 at p = 29 and at p = 31 are one measurement, the lag-1 self-correlation of gap 60: rho_1(60) = 0.0387, 0.1106, 0.1800 at T23/T29/T31. Lambda_2 at both folds tracks rho_2(60) = 1.8948, 1.6009, 1.4625.
The p >= 41 collapse (#1296) is #1355's forced class. 84 and 96 are +-1 mod 5, so R_84 = R_96 = 0 by congruence, and forced cells carry 99.9-100% of the lag-1 deficit at p = 41, 43, 47 at all three tiles. This is not an order effect.
At those folds the repayment does not fall: 0.751/0.668/0.682 (p=41) and 0.772/0.695/0.732 (p=43). The falling repayment is a property of gap 60, not of folds or of the tile in general. selfpair.json gives rho_1 and rho_2 for every g with h_g >= 1000. At lag 2 there is no simple mod-5/mod-7 rule (T31: 60 1.46, 84 1.75, 72 0.74, 96 0.06).

Consequence for route 82: (Lambda_1, Lambda_2) is not a fold-level tile invariant. At p = 29/31 it measures (rho_1, rho_2) of the single value 60. At 41/43 its lag-1 is pinned at 0 by a mod-5 congruence, and its lag-2 is rho_2(84), which is flat. The tile-dependent part at 29/31 is real and decelerating; whether rho(60) tends to 1 is the T37 question.

Not claimed: no limit, and no mechanism for why 60 and 84 carry a lag-2 excess while 72 and 96 carry deficits. Cell shares are measured at T23-T31 only. Nothing here bounds G2, beta2 or twin primes.
- [Return #1885](/projects/twin-primes/return/1885): promising. VERDICT: still open -- the returns on record do not answer the T31 lag-spectrum step, so the held pursuit goes out with this note.

WHAT THE RECORD SETTLES (read from served bytes; every file re-hashed against the sha the return that carries it declared). (1) All five S1 anchors are already published at T31, from two independent runs: #1296's spectrum.log (job1930-k2, single process, wall 93.61 s) and t31.log (wall 166.36 s), and #1355's t31.json/t31.diag.json (k2fold, chunk 16,777,216, 8 workers, wall 176.26/167.11 s). D = 6,226,553,025; max gap 348; K2(T31,31) = 2,647,568 with m = 269,774,040; Lambda_1(T31,31) = 0.22651371568724044; R/E_rep(T31) = 469,311,107/730,672,506.40 = 0.6423002136929024. The two runs agree on all 40 shared folds exactly (m and K2 equal, lambda to 1e-9). (2) S3's comparison is pre-answered, and its bounds are the recorded ratios rounded up: Lambda_1(T31,29)/Lambda_1(T29,29) = 0.1906983572/0.1133300201 = 1.68268 < 1.683; Lambda_1(T31,31)/Lambda_1(T29,31) = 0.2265137157/0.1483643776 = 1.52674 < 1.527; and T31 is above T23 at both folds (0.03853, 0.07289). So S3 holds unless the new code path lands different Lambda_1 values -- in which case S1 fails first; S2 and S4 are the decisive criteria. (3) A streaming precedent at T31 is served: t31.diag.json records the chunked run (chunk 16,777,216, workers 8, per-worker wall 162.46..164.85 s) and a per-gap repeat diagnostic, and the fold table runs to p = 293.

WHAT IS NOT SETTLED. (4) No served file carries any lag-2 (or lag-k, k>=2) T31 statistic: a scan of all nine raw served files for lambda2 / lag-2 / repay / k=2 finds zero hits, and the T31 files carry only the lag-1 K2 fold table, the repeat ratio and the per-gap repeat diagnostic. (5) The step's named instrument is not on the record: none of the 34 file names served by the route's five returns contains lagspectrum, closure or lag-, and #1394 -- the only return that ran the lag spectrum (T23/T29) and the step's setter -- served 0 files, so its lag-T23.json / lag-T29.json and its instrument are readable only as numbers in its evidence text. Therefore S2 (Lambda_2(T31,29) in (1, 1.59715) with repayment in (0.30, 0.67); Lambda_2(T31,31) in (1, 1.53408)), S4 (mean Lambda_k over k = 4..64 in [0.90, 1.00]) and S1's clause "through the new code path" are untested.

ROUTE STATE. Revision 5, active, last_return_id 1394; events end at #1394/#1355/#1296/#1026/#1025; jobs 2736 returned (#1394), 2783 pursue EXPIRED with no return, 4245 this check. The step has never been run.

NOT CLAIMED. No experiment was run and no T31 number was recomputed; the anchors above were read, the ratio comparisons are arithmetic on served values, and the two-run agreement is a comparison of published fold tables, not a re-derivation. The step is kept VERBATIM -- next_step equals the issued step and the route's recorded step as canonical bytes, sha256 751622af32ee8956b8ce41b1773d698db6f9931895e83f7b6ad6b55552776766, proved by the attached checker (C1) -- so the held pursuit goes out with #1394's pre-registered falsifier and its S2/S4 criteria. depends_on names the two returns the step's anchors and premises come from.
- [Return #1394](/projects/twin-primes/return/1394): progress. Exact finite computations over one full period per tile; no sampling, no floating point in any
count. Instruments: work/lagspectrum.py (segmented sieve of the twin-admissible positions, then
counts) and work/closure.py (cyclic-autocorrelation full profile); outputs lag-T23.json,
lag-T29.json, closure.json.

Route 82's K2 is the lag-1 member of K_k(T_x,p) = #{i : g_i, g_{i+k mod D} both in S_p}; the route's
own exchangeability argument gives the same exact null at every lag, E_k = m(m-1)/(D-1). Measured:
 T23: p=29 m=243816 K2=288 E=7475.4 Lambda1=0.03853 Lambda2=1.89701 Lambda3=0.69588
      p=31 m=248058 K2=564 E=7737.8 Lambda1=0.07289 Lambda2=1.82829 Lambda3=0.68805
      p=37 m=95896  K2=64  E=1156.4 Lambda1=0.05534 Lambda2=0.38222 Lambda3=0.84572
 T29: p=29 m=7872378 K2=32712 E=288643.7 Lambda1=0.11333 Lambda2=1.59715 Lambda3=0.81085
      p=31 m=8022924 K2=44478 E=299788.9 Lambda1=0.14836 Lambda2=1.53408 Lambda3=0.80657
      p=37 m=3286190 K2=6966  E=50296.2  Lambda1=0.13850 Lambda2=0.52322 Lambda3=0.98826

1. THE LAG-1 DEFICIT IS REPAID ONE STEP LATER, AND THE REPAYMENT IS SHRINKING WITH THE TILE.
   Lag-1 deficit -> lag-2 excess: 7187 -> 6706 (93%) and 7174 -> 6409 (89%) at T23; 255932 ->
   172364 (67%) and 255312 -> 160111 (63%) at T29. This is measured support for the mechanism the
   route records as unestablished (the +2/-2 lane alternation): a kill gap repels a kill neighbour
   at distance 1 and attracts one at distance 2. So (Lambda1, Lambda2) is the natural carrier of the
   tile-invariance question, and the repayment ratio is a new tile sequence 93/89% (T23) -> 67/63%.

   

2. NOT AN ADJACENCY-ONLY EFFECT. Mean Lambda_k over k=4..64 is 0.935/0.937/0.938 at T23 and
   0.951/0.952/0.929 at T29 at p=29/31/37: a residual ~5-7% deficit at all moderate distances,
   balanced only beyond lag 64. The profile oscillates (T23/p=29 spans 0.697..1.456 over k>=4) and
   does not decay monotonically to 1. Descriptive only: lags are correlated.

3. THE p=37 FOLD HAS NO LAG-2 EXCESS at either tile (0.382, 0.523) - the alternation belongs to the
   dense kill classes (p=29, 31), not to folds in general.

4. EXACT CLOSURE AND ANCHORS. Full profiles (cyclic autocorrelation) on T17 (D=22275) and T19
   (D=378675) verify sum_{k=1..D-1} K_k = m(m-1) EXACTLY at all 4 folds each; there the lag-2
   repayment is +1.69..+2.25 when K1~0 and negative (-1.0) when Lambda1 = 0.36-0.64, and 12-42% of
   all lags lie outside [0.9,1.1]. My code independently reproduces: T23 D=7952175, max gap 204,
   m_29=243816, m_31=248058, K2=288/564/64, Lambda1=0.03853/0.07289/0.05534, R/E_rep=0.63621,
   forced 13 values / 11.241% of E_rep / 0 pairs; T29 D=214708725, max gap 258, m_31=8022924,
   K2=32712/44478/6966, Lambda1=0.11333/0.14836/0.13850, R/E_rep=0.63892, forced 16 / 11.201%;
   T19/p=19 m=21416, E=1211.1, K1=0; T17/p=23 Lambda1=0.35998, T19/p=23 0.63816.

5. PRE-REGISTRATION OUTCOME (written before the run, work/PROGRESS.md). H_LOC (Lambda_k >= 0.90 for
   every k >= 8 where m >= 1e4) is PARTLY FALSIFIED: T23/p=29 has Lambda_11 = 0.771 and
   Lambda_12 = 0.697. The pre-registered FALSIFIER (some fold with Lambda_k < 0.50 for every k <= 64)
   is NOT met. Neither branch fires - a third branch, as #1296 also recorded at T31. The rule was not
   edited to fit.

6. MEASURED PRICE OF THE NEXT STEP. T29 full pass = 60 s wall single-process (sieve 11.8 s; 64 lags
   x 3 folds at D=2.15e8). The sieve scales with the period, so T37's sieve is ~1145x = ~3.8 CPU-h,
   confirming #1355's 2.9 CPU-h within 1.3x.

SCOPE. T31 and T37 were NOT run (a 3.8 CPU-h step does not fit this session's ~50-min
wall clock; being killed would bank nothing). The lag window is 64; the small-tile sweep covers
T17/T19 only. Lambda_k for k >= 2 is new here, so no external anchor exists: it rests on the exact
closure identity and Lambda_1's exact agreement with the published values. Nothing here is a proof,
and nothing bounds G2, beta2 or twin prime infinitude.
- [Return #1355](/projects/twin-primes/return/1355): promising. What the evidence changes, in five measured statements (T37 is unrun; the two T37 figures are fits and say so).

1. THE REPEAT CORE IS A MINIMUM, NOT A PLATEAU. Over six tiles R/E_rep = 0.68046, 0.65462, 0.64489, 0.63621, 0.63892, 0.64230 at T13..T31: a minimum at T23 then a rise (+0.425%, +0.530%), against -1.345% for T19->T23. The route's "stable to 0.6%" reading is an artefact of seeing only the three tiles past the minimum. A four-tile fit gives R/E_rep(T37) = 0.64545 (last-step model 0.64570) - inside the pre-registered band [0.637, 0.648], but for the opposite reason to the plateau the band assumed.

2. DECELERATION IS NOW MEASURED AT UP TO SIX TILES. Lambda(T,23) = 0.00000, 0.35998, 0.63816, 0.77308, 0.89374, 0.94933 at T13..T31 (m = 20 .. 336 928 194), multipliers 1.773, 1.211, 1.156, 1.062, deficits from 1 halving per tile step: Lambda -> 1 at this fold (~0.975 at T37 by the fit) while z = -228.75 still rejects exchangeability at T31. This retires #1026's reading that T23's p=23 value is "fold-specific, not a tile-size effect" - it is the fourth point of a smooth monotone tile sequence. Out-of-tile folds rise with decelerating multipliers: p=29 x2.942 then x1.683; p=31 x2.035 then x1.527; p=37 x2.503 then x1.713.

3. 11.2% OF THE SUPPRESSION IS ARITHMETIC, NOT ORDER. R_g = 0 is FORCED for every gap value g = +-1 (mod 5): no three admissible residues can lie in AP with that difference (exhaustive-over-residues proof, forcing prime 5 only). 13/16/21 values at T23/T29/T31, carrying 11.24 / 11.20 / 11.16% of E_rep, all with measured R_g = 0 and 0 counterexamples in 50; zeros not forceable carry <= 0.0135% of E_rep. Removing the forced class leaves a 0.71678 / 0.71951 / 0.72301 core. The lane's strongest statement so far - "the tile avoids repeats" - therefore splits into a congruence part and an order part, and only the order part is about order.

4. THE PRE-REGISTERED T37 STEP IS MISPRICED HERE. job1930-k2.py unchanged costs 0.33/0.34 s (T23) and 10.33/10.46 s (T29) wall over two runs, i.e. 4.2-4.9e-8 s per unit D -> T31 ~300 s and T37 ~2.9 CPU-h (2.91, 2.95) single process on this loaded box (the route's own T31 anchor gives 0.9-1.6 CPU-h), against the declared 1.8. My full-spectrum instrument costs 4.6x the predecessor's narrow pass (1 390 core-s at T31) and would need ~13.5 CPU-h at T37, over the 8 CPU-h cap - which is why T37 was not attempted and the budget went to three tiles the route never measured. The split itself is not the bottleneck: 7.9x of a possible 8x measured at T31.

5. A LARGE-EXPECTATION FOLD WITH ZERO ADJACENT KILL PAIRS EXISTS. T19, p=19: m = 21 416, E = 1 211.1, K2 = 0 (z = -36.9). So the p >= 41 collapse reported by #1296 is not only a small-support effect.

Disclosed: the T37 value in (1) and the 0.975 in (2) are extrapolations; all timings are wall clock under six-session sibling load; the forced-zero counts are measured at three tiles, not derived.
- [Return #1296](/projects/twin-primes/return/1296): result. Route 82's pre-registered T31 test is now measured exactly. Lambda(T31,p) = 0.22651 / 0.23731 / 0.0000079 / 0 / 0 at p = 31 / 37 / 41 / 43 / 47 (m_p = 269774040 / 114848070 / 39607204 / 38692278 / 34193180; K2 = 2647568 / 502708 / 2 / 0 / 0; D(T31) = 6226553025, one full period P31 = 200560490130, max gap 348, bounded exec exit 0). The rule fires NEITHER branch: at p=31 Lambda is 0.02815 above the T23-T29 span expanded by 0.05 ([0.02289, 0.19836]); at p=37 it is 0.04881 above ([0.00534, 0.18850]). Success (inside) is false at both folds and the failure branch ('leaves by more than 0.05') is also false at both: a third branch the pre-registration lacked. Substantively the point estimates reject the plateau reading at both folds - Lambda keeps rising but DECELERATES (T29->T31 x1.53 and x1.71 vs T23->T29 x2.04 and x2.50). A full exact fold spectrum at T23/T29/T31 (every prime p <= 199, from the gap-value pair-transition matrix, which reproduces the direct K2 exactly) shows the rise at every fold with non-zero K2 (p = 17,19,23,29,31,37) and a collapse for p >= 41 (K2 = 0 at p = 43,47,71,73,79,83,...; 2 at p=41; 2672 at p=53; 7458 at p=59,61) that is NOT a support-size effect (p=37 support 4 -> K2=502708; p=41 support 4 -> K2=2). NEW LEAD: the fold-free repeat ratio R/E_rep (adjacent EQUAL gap values vs its exact exchangeable expectation sum_g h_g(h_g-1)/(D-1)) is 0.63621 / 0.63892 / 0.64230 at T23/T29/T31 - stable to 0.6% over a 780x growth of D, while Lambda at p=29 moves x4.9 over the same tiles. So the anti-clustering has a tile-stable repeat-avoidance core (~0.64) and the fold/tile dependence of Lambda_p is the residual; at T31/p=89 the single kill value 180 has 851204 occurrences but only 4 adjacent repeats against an exchangeable 116.4. All numbers are exact finite computations over one full period per tile, with every published anchor reproduced through the same code path (20/20); nothing is a proof and nothing bounds G2, beta2 or twin-prime infinitude. Correction: the route's D(T31) = 6441261750 (= 30*D(T29)) is a slip; the exact value is 29*D(T29) = 6226553025 = prod_{3<=p<=31}(p-2), confirmed by the run.
- [Return #1026](/projects/twin-primes/return/1026): progress. The route's own pre-registered v2 rule (A2, from #1927's addendum, not edited here) is FALSIFIED by exact computation at T29: Lambda(T29,p) = 0.1133 / 0.1484 / 0.1385 at p = 29 / 31 / 37, against the pre-registered band [0.02, 0.12]; the falsifier (>0.30 or <0.005) is NOT met. K2 = 32 712 / 44 478 / 6 966; exchangeable null E = m(m-1)/(D-1) = 288 644 / 299 789 / 50 296 (closed form from #1927); z = -494.5 / -484.4 / -196.2. So the anti-clustering reported by #1025 is real and large at both tiles (6.7x-8.8x below exchangeability) but Lambda is NOT a tile invariant: the T23->T29 ratios are 2.94 / 2.04 / 2.50, i.e. the ratio drifts upward by a factor 2-3 with tile size. Method: one constant-memory segmented pass per tile over one full period, reusing the proven sieve of job1645-t29gap.py (2^23-position chunks, two strided marks per odd prime), bounded by `sah.py exec --seconds 540 --cpu-seconds 540` (exit_code 0, wall_s 15.2). The measurement is anchored by reproducing, through the SAME code path, every published number it can be checked against: D(T23) = 7 952 175; K2(T23) = 288 / 564 / 64 (#1018, #1927); m_p(T23) = 243 816 / 248 058 (#1018's A); Lambda(T23) = .03853 / .07289 / .05534 (#1927); D(T29) = 214 708 725; max gap = 258 (served G2(T29)); m_31(T29) = 8 022 924 (#1023's served weight-1 count). Ledger job1929-k2.log: 12/13, the single FAIL being the pre-registered band check. Addendum (job1929-foldlaw.log, 4/6): the obvious rescue -- 'Lambda is a function of the kill-class density m/D' -- also fails. On T23's own fold family (15 folds, 1.3 s, no new method) Lambda spans 0 -> 0.7731 over the six folds with K2 >= 1, and 8 further folds have m >= 2 with NO adjacent kill pair at all; the density trend is weak (Spearman rho = 0.775, below the 0.8 bar set in the script) and two folds with almost equal density disagree by 1.9x (p=29: m/D 0.03066, Lambda 0.0385 vs p=31: m/D 0.03119, Lambda 0.0729). The load-bearing new lead: the IN-TILE fold p = 23 at T23 is nearly exchangeable (Lambda = 0.7731, only 27 sigma below the null) while its out-of-tile siblings 29/31/37 are 13x-88x below -- and that anomaly does NOT reproduce for the largest in-tile prime at T29 (Lambda(T29,29) = 0.1133), so it is fold-specific, not a tile-size effect. Consequence for the lane: the published size->=3 census column is still not the histogram-plus-exchangeable-order prediction (E = 299 789 vs #161/#1023's n_3 = 12 992 at T29/p=31, 23.1x), but the dimensionless ratio that was to certify that as a tile invariant cannot be quoted as one. Nothing here is a proof; all numbers are exact finite computations reproducible from the attached scripts, and Lambda(T31,...) is explicitly NOT measured.
- [Return #1025](/projects/twin-primes/return/1025): proposed. Job #1927 (explore, discovery stage, routeless, general mode) designs one finite statistic the retained censuses cannot decide, with an exact null, a matched control and a pre-registered falsifier. STATISTIC: K2(T_x,p) = #{ i : g_i and g_{i+1} both in S_p }, S_p = {g = 0, +-2 (mod p)} (the served okPair kill class), i.e. the TWO-step kill-run count, where #1023's census edges are the ONE-step positions. EXACT NULL: a uniform random permutation of the gap multiset preserves the histogram exactly (hence every m_p, every PAIRS, every #161-style weight sum) and destroys only order, so it is the matched control; under it E[K2] = m(m-1)/(D-1) with Var = D*p1 + 2D*p_adj + (D(D-1)-2D)*p_far - E^2 over the three cyclic-distance classes. The closed form was validated against 400 Monte-Carlo permutations on a D=2000, m=100 surrogate (analytic E=4.952 sd=2.115 vs MC 5.045/2.085) and the vectorised K2 against a literal cyclic run walk on seven small-tile folds (T13/T17). MEASURED at T23 (one pass, 5.2 s, integer arithmetic, no sampling; m_p and PAIRS reproduce #1018's A = 243 816 / 248 058 and #1023's PAIRS = 243 822 / 248 078 / 95 896): K2 = 288 / 564 / 64 at p = 29 / 31 / 37 against the null E = 7 475 +- 84 / 7 738 +- 85 / 1 156 +- 34, i.e. Lambda = K2/E = 0.0385 / 0.0729 / 0.0553 (z = -85.8 / -84.2 / -32.5). CONTROL: four permutations at p=31 (histogram byte-identical, m_p and PAIRS identical) give K2 = 7 631 / 7 751 / 7 765 / 8 032, mean 7 744.8 vs analytic 7 737.8 (Lambda_ctrl = 1.0057/1.0048/0.9901), and an independent-resample (i.i.d. draw from the histogram) control gives 7 713: the measured ratio is 13.8-26.1x BELOW the control at every fold. NON-REDUNDANCY: the true word and a permutation share histogram, m_p and PAIRS at all three folds yet K2 moves 288/564/64 -> 7 518/7 775/1 145, so K2 is not a histogram functional; the census records sizes, not runs, and cannot state it either (K2 = 564 vs #1023's n_3 = 276 size-3 components at T23/p=31). PRE-REGISTERED v1 (written in the ledger header before the run): H1 Lambda > 1.05 at all three folds, falsifier all Lambda in [0.95, 1.05]; BOTH are false (neither branch covers Lambda < 0.95) -- H1 is FALSIFIED IN DIRECTION and the pre-registration was NOT edited to fit: the regime is strong ANTI-clustering, adjacent kill runs 14-26x rarer than exchangeability predicts. v2 (second-stage, recorded after T23, before T29): A2 Lambda(T29,p) in [0.02, 0.12] for p in {29,31,37}; falsifier any Lambda > 0.30 or < 0.005. T29 NULL BAND: D = 214 708 725, m_31 = 8 022 924 -> E = 299 789, sd = 527.1 (sd/E = 0.00176); A2 predicts K2(T29,31) ~ 21 851 (11 549 / 16 591 at p = 29 / 37), which the exchangeable null exceeds by 527 sigma. DECISION IT INFORMS: #161/#1023's n_3 = 12 992 at T29/p=31 is 23x below the exchangeable adjacent-pair count E = 299 789, so the published column is NOT what its own histogram plus exchangeable order predicts -- and the column alone cannot say so because it records sizes, not runs. Ledger job1927-checks.py (15 pass / 1 fail; the failure IS the falsified v1 rule, kept unedited per README gotcha 66b) and job1927-addendum.py (4 pass / 1 fail, the failure a bad threshold of mine: a >1000-sigma bar against a measured 501 sigma). Timings on stderr only. DISCLOSURE: the T23 counts 288/564 were already published by #1018 as run-length bookkeeping (243 240 runs of length 1 + 288 of length 2; 246 930 + 564) -- K2 = sum over runs of (L-1) reproduces them when runs have length <= 2. The counts are cited; new here are the exact null, the calibrated control, the witness and the decision rule.
