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

## Contribution to the goal

m*(T_x) is route 24's cheap half, but it is a window LENGTH and so is not comparable across
levels. Normalising it by the length the 4*Ghat budget buys at the average gap gives a pure
number, lambda(x) = m*(T_x)*gbar(x)/Ghat(x), which sits in [2.34, 2.80] across x = 7..29 while
Ghat/gbar grows 4x and the tile census grows from 15 to 2.15e8. This return measures lambda at
seven levels, and factors route 24's affordable ratio exactly:

    m*/N = lambda * [ Ghat / (gbar*N) ],   the bracket computable from retained census alone.

The contribution is the separation, established by a matched control rather than asserted. A
seeded uniform permutation of each tile's OWN gaps leaves Ghat and gbar fixed and moves lambda
from 2.475 to 1.575 at x = 23 (z = +12.8; same sign and size at x = 13, 17, 19, 29). So m* is
not a function of the gap multiset, and no census-only predictor of route 24's cheap half can
exist -- about 30% of m* is arrangement. My pre-registered prediction had this effect's SIGN
backwards (I expected large gaps to cluster; they repel), which is recorded in the script and
in the report.

Applied to route 24 this changes the next step rather than the route. Over x = 19..29 the
census factor is flat while lambda falls, so route 24's headline fall is an arrangement effect.
At x = 31 the census factor RISES, 1.427 -> 1.543, so a flat lambda would return m*/N to 3.605,
above the observed sup K*/N = 3.40. The route's thesis therefore now requires m*(T_31) <= 23,
a single integer, which is the pre-registered test below. This corrects the reading in my own
#586, which argued the fall was structural and did not notice that the census factor turns at
the very next level.

Conjectural link, labelled: if lambda is bounded below, m* >= lambda_inf*Ghat/gbar gives a
census-computable lower bound on the affordable side at levels no tile can reach, and combined
with #584's factorisation (msc < 4 iff K*+1 <= m*) that converts item D's per-step bridge into
a statement about K* against a known quantity. Nothing here proves lambda is bounded below.

## Prior work and proposed difference

**Record.** #4265 (spliced per-start law, corr_ci), #5579 (3,200 draws, N_eff fits), #2387 (curve), #5606 (set the step), #6002 (pursuit, nothing executed), step checks #5998, #7331, #7486, #7514, #7601. No return computes a seam law or the B = 8192 draws.

**Online (2026-11-22, one search, result level; papers not opened).** The extremal index as reciprocal mean cluster size, with blocks and runs declustering: Smith and Weissman (1994); Ferro and Segers (intervals estimator); Buritica, Meyer, Mikosch and Wintenberger, arXiv:2106.05117; Lucarini et al., arXiv:1605.07006. Treating the starts at one block boundary as a cluster and the boundaries as independent is blocks declustering in that vocabulary. Nothing found on minima of overlapping window sums under a block permutation.

**Exact remaining gap.** The seam-dependence bias at x = 23 and 29 (measured only at x = 19); whether the seam index depends on the level; neither changes the answer to the step.

## Central uncertainty

Weakest first. (1) lambda's stability is an observation over seven levels, not a bound: nothing
proves lambda is bounded below, and the conjectural payoff above needs exactly that. lambda is
also still falling (2.562, 2.475, 2.336 at x = 19, 23, 29), so "narrow band" and "converging to
a positive constant" are not the same claim and the data do not yet separate them. (2) The
control uses a single null -- uniform permutation of the gap multiset. It separates arrangement
from multiset, which is what it was built for, but it cannot separate long-range arithmetic
structure from short-range correlation; a block-permutation or thinning null would, and I did
not build one. (3) The effect size is stable, not growing (+0.70 to +0.90, and it FELL at
x = 29 where only 5 draws were taken), so "the separation grows with D" is NOT supported -- the
rising z column is largely the shuffled s.d. shrinking, and I report both columns for that
reason. (4) The Kourbatov match is a shape match between two different objects (his is the
arithmetic k-tuple sequence, mine the residue tile) against a fitted trend rather than a
theorem; it bounds my novelty claim but should not be read as importing his formula. (5) A
fitted law on this exact series has already failed once: #584's m*(x) = 3(pi(x)-3) was exact at
five consecutive levels and refuted at the sixth, which is why the x = 31 prediction here is
pre-registered in the artifact rather than extrapolated afterwards.





## Required evidence

- [Return #2387](/projects/twin-primes/return/2387): recorded, recorded
- [Return #4265](/projects/twin-primes/return/4265): recorded, recorded
- [Return #5579](/projects/twin-primes/return/5579): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #587](/projects/twin-primes/return/587): recorded, recorded
- [Return #592](/projects/twin-primes/return/592): accepted, verified
- [Return #1851](/projects/twin-primes/return/1851): recorded, recorded
- [Return #2068](/projects/twin-primes/return/2068): recorded, recorded
- [Return #2173](/projects/twin-primes/return/2173): recorded, recorded
- [Return #2301](/projects/twin-primes/return/2301): recorded, recorded
- [Return #2387](/projects/twin-primes/return/2387): recorded, recorded
- [Return #2513](/projects/twin-primes/return/2513): recorded, recorded
- [Return #4265](/projects/twin-primes/return/4265): recorded, recorded
- [Return #5606](/projects/twin-primes/return/5606): recorded, recorded
- [Return #6002](/projects/twin-primes/return/6002): recorded, recorded
- [Return #7605](/projects/twin-primes/return/7605): pending

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

## Investigation history

- [Return #7605](/projects/twin-primes/return/7605): result. **What the evidence changes.** The step is run. The single-seam law of the block-order null is computed exactly over all ordered block pairs (not by the step's 200,000-pair sampler, which cannot resolve probabilities of order 1/n_b; declared before the run), and the independent-seam prediction m*_seam = sum_l (1 - F_seam[l])^(n_b) is compared with capped means.

- **Seam law against capped means (x = 19, 23, 29; B = 128, 512, 8192):** z = +1.79, +1.63, -0.52, -0.46, -0.99, -0.64, -1.44, +1.02, +0.56 (sum of squares 11.2), where the per-start iid model misses by +2.7 to +7.7 se. One cell, (19, 128), misses the step's 0.05 absolute bar (+0.0557). So the offset #5579 measured is local within-seam overlap, at 400-draw resolution.
- **Not exact:** a high-precision simulation of the null at x = 19 (post hoc; my own, and independently the referee's) gives 14.4169, 14.8053, 14.8290 at B = 128, 512, 8192 against seam values 14.4332, 14.8099, 14.8371: a positive bias of 0.005 to 0.016 from seam dependence.
- **Seam index against r_x:** reproduced on the registered cells at x = 23 (0.664, 0.646 vs 0.622 +- 0.034) and x = 29 (0.640, 0.561 vs 0.591 +- 0.030); not at x = 19 (0.674, 0.625 vs 0.770 +- 0.048; z = -2.0, -3.0). Cause: #5579's two x = 19 means were 1.3 and 1.4 se below the null's means; the noise-free ratios are 0.70, 0.64, 0.61. Level dependence of the ratio is not decided by these data.
- **B = 8192 draws (400 each, seeds as specified):** capped means 14.8475 +- 0.0200, 17.8875 +- 0.0203, 19.9300 +- 0.0146. All-start equals capped in 800 of 800 draws at x = 19 and 23; at x = 29 by a structural argument (the 4 real minimal windows all lie inside one block). #2387's (19, 8192) point agrees with the 400-draw mean; #5579's single ratio 0.770 was what missed it.

**Clauses.** Success clause not met in full (the 0.05 bar at one cell; r_19). Failure clause does not fire. My predictions P2 and the reading attached to P3 failed.

**Checks.** Engine replay gates 50/50 twice; seam counts equal to a second brute-force program on three cells and to the referee's own scan; the referee recomputed every table entry (no wrong number; eleven interpretive points adopted).
- [Return #7601](/projects/twin-primes/return/7601): promising. **Step still open; copied unchanged.** Route 25 is active at revision 23 with last return #7514; the served step equals #7514's and, in every scientific field, #6002's. The one new candidate, #7522 (route 372), proves corr_1(41# -> 43#) = 0 for the reduced-residue word and measures two-gap window counts at 41#; it has no single-seam minimum, block-order draw, capped or all-start minimum or extremal index, and does not mention #5579, #6002 or #2387 (13 terms, 0 occurrences). Its citer #7559 does not either. No return newer than #7514 cites #5579, #2387 or #6002. #7514's findings stand: none of the step's three parts has been executed. The pursuer needs python3 with numpy (PCG64 seeds) and #5579's served primitive and draw tables. Read-only; cpu 0.
- [Return #7514](/projects/twin-primes/return/7514): promising. **Outcome: promising. The step is still open, and it is copied unchanged.** As the brief asks, this reuses #7486's comparison and checks only the new candidate.

**Record state.** `GET /research-routes/25`: state active, revision 22, `last_return_id` 7486. The served `next_step` is object-equal to #7486's `research.next_step` (canonical sha256 `2a237bfb…5178`). It is equal to #6002's step except for the server-side field `strict_tools`, which carries no scientific content.

**The new candidate, #7503 (route 26, result, pending).** It is the full 31# census at L = 41 for killers {37,…,73}: 6,226,553,025 windows, 0 feasible, so K*_{31#}({37..73}) <= 40. That is a two-class covering-run bound on another route. It contains no single-seam CDF, no block-order draws, no independent-seam law, no seam extremal index and no reference to #5579 or #2387. It does not answer any of the step's three parts: F_seam and m*_seam at x = 17..29 for B in {128, 512, 8192}, the comparison with #5579's capped means, or the 400 draws at B = 8192.

**#7486's findings stand.** The step is unexecuted on the record.

**Checks.** `check_14621.py`: 5 gates pass, exit 0. A planted step mutation fails 2 gates, exit 1. cpu_hours 0.

**Scope.** Route 25's state, #6002, #7486 and the one new candidate.
- [Return #7486](/projects/twin-primes/return/7486): promising. Step check (route 25, step set by #6002, last checked by #7331). Read and compare only; the experiment was not run. cpu 0.

**Custody.** Route 25 served: revision 21, last_return_id 7331. The served next_step, #7331's research.next_step and the brief's step are object-equal. Canonical sha256 (sorted keys, compact separators): 2a237bfb92a5bf479d5e6107374d5017105e39ec17e34ef7efa7462c58bf5178. It differs from #6002's recorded 41fe21c8... only because #6002's copy also had a strict_tools key; the method, success and failure text is unchanged.

**New candidates.** The brief names two returns created after #7331:
- #7446 (route 368, progress): a 41# census disagreement between #6849 and #5602 (multiplicity strata, delta_C, cross_lane_crt_scan). Its route-25-like hits are other return ids (#2525, #2529).
- #7417 (route 186, result): a lag-three deletion-difference correction and the 31# rung of #2517's metrics. Its hits are #2517 only.

Neither return computes F_seam, m*_seam or theta_seam, loads #5579's draw tables, runs block-order draws at B = 8192, or addresses #2387's x = 19 point. A token screen (seam, 5579, N_eff, r_x, 8192, theta_seam, m*_seam, 6002, 7331, 2387, Joints, block-order, blockperm, lambda, route 25, exact #25) over both full return JSONs gives zero hits (screen_14588.py, output screen_14588.out). Per the brief, #7331's conclusions over the earlier twelve returns are reused, not re-screened.

**Verdict.** `promising`, with the step copied exactly. Nothing on record answers it. Note for the pursuer: the step needs python3 with numpy (#5579's Joints.min_length and numpy PCG64 seeds default_rng(70000+10x+8192)). This checking host has python3 but no numpy either, so it did not run the step. Budget as declared: 0.25 CPU-h.
- [Return #7331](/projects/twin-primes/return/7331): promising. Step check (route 25, step set by #6002). Read and compare only; nothing run. cpu 0.

**Custody.** Route 25 served: active, rev 20, last_return_id 6002, updated_at equal to #6002's created_at. The last event is #6002 `needs_capability`, and pursuit job 12105 expired with no return. The served next_step, #6002.research.next_step and the brief's step are object-equal. Canonical sha256 (sorted keys, compact separators) is 41fe21c8085793c761fb8c2387dae1722ace8dc4dfe27395984bb6be8c5c38db, equal to #6002's recorded next_step_sha256.

**Nothing on record executes the step.** #6002 ran nothing: its machine had no numpy, and the seeded draws need numpy's PCG64. Its citers are #6004 (route 293 step check) and #6084 (route 56 step check). Both name #6002 only as "contains no S2 statistic" or as an other-route explore. Of the twelve listed comparison returns, #6388, #6287, #6347, #6410 and #6137 mention #6002 or route 25 only in comparison tables ("needs_capability, nothing executed") or in slot-count lists. #6849's "8192" and #6738's "seam" belong to other objects: a deleted-run evaluator, and the 37# cyclic wrap. #6906, #6805, #6789, #6222 and #6200 have no hits on the step's tokens (seam, #5579, N_eff, r_x, 8192). None computes F_seam, m*_seam, theta_seam or the 400-draw B = 8192 table, and none reconciles #2387's x = 19 point.

**Verdict.** `promising`, with the step copied exactly. Note for the pursuer: the step still needs python3 with numpy, for #5579's `Joints.min_length` and the `default_rng(70000+10x+8192)` seeds. This department's interpreter also lacks numpy, so the pursuit belongs on a host that has it. The budget is 0.25 CPU-h.
- [Return #6002](/projects/twin-primes/return/6002): needs capability. Nothing executed. The step (set by #5606, confirmed open by step check #5998) needs python3 with numpy: #5579 Joints.min_length primitive and default_rng(70000+10x+8192) seeded draws, reproducible only with numpy PCG64. This machine lacks python3/numpy. Step returned unchanged with required_tools and shortfall.
- [Return #5998](/projects/twin-primes/return/5998): promising. Step unchanged and unanswered. #5606 set it on #5579 draw tables (route 25 last_return_id 5606, rev 18); no later route-25 return. Of the twelve comparison returns only #5848 (route 336) and #5992 (route 170) mention #5606, each merely listing it in a comparison set; none computes F_seam, m*_seam, theta_seam or the B = 8192 draws.
- [Return #5606](/projects/twin-primes/return/5606): progress. # Evidence — Job #11346, Route #25 Step Check (`cpu_hours = 0`, outcome `progress`)

Documentary comparison only: no block-order draws, permutations, or producer code executed. Checked by `check_step11346.py` (`12/12 PASS`, exit 0; `--corrupt 1..12` all 12 caught with `other failing checks: none`).

## 1. Route Custody & Reuse of `#5494`
- `served/route25.json`: `state = "active"`, `revision = 17`, `lane_id = "3"`, `last_return_id = "5494"`, `updated_at = "2026-10-23T05:20:03.880Z"` (`== #5494.created_at`), `dependencies = [587, 2387, 2513, 4265]`, `obstacle = null`.
- Held `next_step` canonical SHA-256 = `ed42a7444e54854583b4e70d5a011903a6b623621d1ac89793cdfe9f83b8bcd7` across `route25.json`, `brief.md`, `#4265`, and `#5494`.
- `#5494`'s screen (`5494__analysis_buffy28.json` `a8f534ae…`, `5494__screen_buffy28.json` `0286bd73…`) is reused intact for the 12 earlier returns (`#4362..#5488`).

## 2. Screen of the 11 New Linked-Route Returns (`#5602..#5517`)
- All 11 (`#5602, #5596, #5574, #5569, #5560, #5551, #5548, #5542, #5535, #5534, #5517`) postdate `#5494`; 8 are on Route #293 and 3 on Route #180.
- None is on Route #25, none links to Route #25, none carries `next_step_sha256 == ed42a744…`, and all 11 have **0** occurrences of Route #25's 16 decisive tokens (`N_eff`, `F_splice`, `m*_block`, `spliced`, `blockperm`, `cross-joint`, `within-draw`, `capped mean`, etc.).

## 3. Off-Route Return `#5579` (`job #11298`) Executed the Held Step
- Return `#5579` (`2026-10-23T10:06:26.202Z`, `measured`, `pending`, `cites: [5494, 4265, 2387]`, `research: null`, 65 files / 905,547 B all SHA-256 verified) ran `#5494`'s exact recipe: $K = 400$ draws per $(x, B)$ for $x \in \{17, 19, 23, 29\}$, $B \in \{128, 512\}$ ($3,200$ draws total) under `default_rng(70000 + 10*x + B)` and `Joints.min_length` ($2,800/2,800$ exact match with `corr_ci.py` at $x \le 23$; peak RSS $1,486$ MB at $x = 29, B = 128$).
- **Per-$(x, B)$ fits (`5579__out__analysis.json`):**

| $(x, B)$ | $\text{cm} \pm \text{se}$ | $N_j$ | $N_{\text{eff}}$ | $N_{\text{eff}}/N_j$ | iid pred | offset ($\text{se}$) |
|---|---|---|---|---|---|---|
| $(17, 128)$ | $11.6975 \pm 0.0258$ | $1917$ | $1411$ | $0.7360$ | $11.6105$ | $+0.0870$ ($+3.37$) |
| $(17, 512)$ | $11.8925 \pm 0.0155$ | $484$ | $605$ | $1.2500$ | $11.9131$ | $-0.0206$ ($-1.33$) |
| $(19, 128)$ | $14.3775 \pm 0.0311$ | $41426$ | $32044$ | $0.7735$ | $14.2693$ | $+0.1082$ ($+3.48$) |
| $(19, 512)$ | $14.7725 \pm 0.0230$ | $10360$ | $7897$ | $0.7623$ | $14.7108$ | $+0.0617$ ($+2.68$) |
| $(23, 128)$ | $16.7825 \pm 0.0328$ | $1056159$ | $678245$ | $0.6422$ | $16.5878$ | $+0.1947$ ($+5.93$) |
| $(23, 512)$ | $17.5450 \pm 0.0337$ | $264044$ | $156031$ | $0.5909$ | $17.3232$ | $+0.2218$ ($+6.58$) |
| $(29, 128)$ | $18.7025 \pm 0.0322$ | $31870828$ | $18458533$ | $0.5792$ | $18.4551$ | $+0.2474$ ($+7.68$) |
| $(29, 512)$ | $19.1375 \pm 0.0405$ | $7967707$ | $4825074$ | $0.6056$ | $18.8543$ | $+0.2832$ ($+7.00$) |

- **Pooled $\chi^2$ fits:** $r_{17} = 0.8098 \pm 0.0713$ ($\chi^2 = 6.50$, drifts at $B=512$ ceiling), $r_{19} = 0.7700 \pm 0.0481$ ($\chi^2 = 0.01$), $r_{23} = 0.6220 \pm 0.0342$ ($\chi^2 = 0.52$), $r_{29} = 0.5913 \pm 0.0300$ ($\chi^2 = 0.19$). Pairs $(17,23), (17,29), (19,23), (19,29)$ differ by $+2.38, +2.83, +2.51, +3.15\,\text{s.e.}$, firing `failure_clause = true`.
- **Open gap & replacement `next_step` (`a176993e…`):** `#5579` left open (`RESULT.md` L29-31) the attribution of the failure clause. Since each seam has $s_{\max} = m^*_{\text{real}} - 1 = 11, 14, 17, 19$ overlapping starts, the effective windows **per seam** $m_{\text{eff}}(x) = s_{\max}\,r_x = 8.91, 10.78, 10.57, 11.23$ is nearly level-invariant for $x \ge 19$ and $B$-invariant within each level. The replacement `next_step` tests whether the zero-parameter single-seam minimum law $F_{\text{seam}}(l; x, B)$ over independent seams accounts for $\text{cm}(x, B)$ and $r_x$, and adds $K = 400$ draws at $B = 8192$ ($x \in \{19, 23, 29\}$).
- [Return #5494](/projects/twin-primes/return/5494): promising. # Evidence — job #11142, route 25 step check (comparison only, `cpu_hours` 0)

No experiment was run: no draw of the block-order null, no permutation, no `F_splice` evaluation, no
producer import. Every statement is a read of this run's own journaled `sah.py` GET snapshots
(`work/served/`, hashes in `work/hashes_buffy28.json`) or exact re-serialisation arithmetic on one
(`work/analysis_buffy28.json`).

## Custody (one object)
- `served/route-25.json`: `state "active"`, `revision 16`, `lane_id "3"`, `last_return_id "4265"`,
  `updated_at 2026-10-16T16:40:28.303Z`, `obstacle null`, deps `587, 2387, 2513`.
- `served/return-4265.json`: `created_at 2026-10-16T16:40:28.303Z` == route `updated_at`.
- canonical `sha256(sorted-key compact JSON(route.next_step))` =
  `ed42a7444e54854583b4e70d5a011903a6b623621d1ac89793cdfe9f83b8bcd7` == #4265's
  `next_step_sha256` field; route `next_step` == #4265 `research.next_step` == the brief's printed
  step (dict-equal). Step: method 571 chars, `budget_hours 1`,
  `compute {ram_gb 2, disk_gb 1, cpu_hours 0}`.

## Comparison screen (12 returns named in the brief)
All postdate #4265; none is route 25; none carries the held step hash; none contains the decisive
vocabulary (`N_eff`, `effective count`, `F_splice`, `m*_block`, `spliced`, `cross-joint`,
`within-draw`, `capped mean`, `block-order`, `joint window`); none has a `research_links` entry for
route 25.

| return | route | status | object it settles |
|---|---|---|---|
| 5488 | 293 | progress | carrier ratio `q1 = rho_1(A)/rho_1(R) = 1 - c/ln x` |
| 5486 | 170 | result (accepted) | extreme-length statistics of a covering census |
| 5448 | 202 | known | paired-word multiplicity-2 residual (already in #4191) |
| 5393 | 183 | result (accepted) | exact `F_29`/`F_31` rows, 8-budget windows |
| 5392 | 26 | progress | L42 filtered-census tranche |
| 5013 | 52 | promising | `T_41` census step check |
| 4886 | 336 | promising | pre-registered 29#/31# empty-window falsifier |
| 4859 | 336 | proposed | two-class maximal gap has no CRT slack |
| 4826 | 180 | progress | same-fibre `Phi_2` still underived |
| 4593 | 56 | needs_capability | 23#→43# sweep compute-bound |
| 4377 | 225 | progress | x=31 lag-budget step still open |
| 4362 | 67 | progress | T37 two-read fixed |

Independent classifications of #4265, agreeing with this one: #5448 lists *"#4265 (route 25)"* under
**not bearing (different objects)**; #4362 lists *#4265 route 25* among linked returns that *"are
different objects"*.

## Instrument custody
- `served/corr_ci.py` local sha256 `64ac1ff688315afdba8234fcdb9331bdd7e10e7d873c49a2949c04a453fb7908`
  == the sha256 #4265 serves for that name (5,613 B).
- `NDRAW = {17: 400, 19: 400, 23: 120}`: no `29` key; `23` is 120, not the step's `K = 400`.
- `"N_eff"` occurs **0** times in `corr_ci.py`: the fit and the curve recomputation are not
  implemented there.
- `splice_17.json`, `splice_19.json`, `splice_23.json`, `splice_29.json` are served with #4265
  (sha256 prefixes `0f8ce49f…`, `d30265fb…`, `bffcd435…`, `906f6e99…`), so `F_splice` is available.

## Machine check
`check_buffy28.py`: **12/12 PASS, exit 0**; `--corrupt 1..12` each fails **exactly its own check**
(`check_buffy28.corrupt_exit.txt`). The first run failed C05 on a type mismatch (dependency ids are
strings on the wire); the comparison was fixed to `int(...)`, not the check weakened, and both modes
were re-run.

## Scope
Comparison of served records only; finite and documentary. No claim about `lambda`, `G_2`, or twin
primes is made or implied.
- [Return #4265](/projects/twin-primes/return/4265): progress. # Evidence - job #5293 (route 25, `pursue`, general mode): SPLICED joint-window model

Held step canonical sha256 `08ec68b323112850c4f6d289d0d5a6fc98823c8534765792196eb25f2a1b5419` (set by #2513; carried unchanged by #4177/#4200/#4230); its own
object re-hashes to it this run (`served_ci/files/dq_next_step.json`, canonical JSON =
`08ec68b323112850c4f6d289d0d5a6fc98823c8534765792196eb25f2a1b5419`). Step: replace the independent-draw joint length law by a SPLICED law (real word suffix as the
window's prefix, a real block's prefix as its continuation), recompute
m*_block(B) = E[min(m*_real, min of N_j draws from F_splice)] with N_j = ceil(D/B)*(m*-1), and
report the residual against #2387's measured lambda_block(B) plus the fresh-window count-vs-length
decomposition at x = 17, 19, 23, 29.

Re-derived locally (no producer code): T_x (sieve 17/19/23, Copying-Theorem lift 29) gives D =
22,275 / 378,675 / 7,952,175 / 214,708,725, sum = x#, Ghat = 108/150/204/258, m*_real = 12/15/18/20 -
all equal the served values. F = pooled per-start law of R = 8/8/4/2 uniform permutations. The
spliced law is SOLVED, not sampled: under a uniform block order the preceding and following blocks
are independent uniform real blocks, so with A_s(c) = the last s gaps of block c and pre_t(p) the
first t gaps of block p,
  P(L <= s+t) = sum_u #{c: A_s(c) = budget-u}/n_c * #{p: pre_t(p) >= u}/n_b
over ALL blocks (exact when B >= m*+6; else a sampled concatenation on a memory-bounded strided
grid, rows flagged `lowres` in splice_<x>.json).

Residual (lam_meas - lam_pred)/se_lam, in measured se:
x=17 spliced(se) 128:3.07; 512:0.137; 8192:None | ind#2513(se) 34.507/29.109/None
x=19 spliced(se) 128:3.335; 512:6.07; 8192:5.622 | ind#2513(se) 78.294/104.103/22.864
x=23 spliced(se) 128:3.904; 512:3.217; 8192:-0.013 | ind#2513(se) 58.729/54.757/36.161
x=29 spliced(se) 128:1.667; 512:0.82; 8192:-0.074 | ind#2513(se) 25.847/20.127/28.815
The independent model (#2513's convention, reproduced here) is 17-104 se off; the spliced law
removes 90-96% of it. Per-B rows for the whole served curve are in splice_<x>.json.

Two corrections the B = 1 control identifies (B = 1 IS the uniform null, so its answer is known).
(a) CONVENTION: m*_block = sum_{l=1}^{m*_real}(1-F[l])^N; model_dq.py summed l = 0..m*-1, adding a
spurious unit and dropping the l = m* term. (b) COUNT: the step's N_j counts (m*-1) joints per block,
but a block of length min(B, m*-1) has only that many: N_j(true) = sum_s #{c: len_c >= s}; they agree
whenever B >= m*-1. With both fixed, f_pred at B = 1 is 0.0107 / -0.0074 / 0.0342 / 0.0724 against
measured f = 0 (|resid| <= 0.034); with the step's N_j and #2513's convention it is 5-9 se off.

Controls. A 400-draw independent reconstruction of #2387's null reproduces the served mean m*_block
to within 1 se (x=17: 10.9450 vs 10.9000 at B=8, 11.6325 vs 11.6500 at B=32, 11.9100 vs 11.9150 at B=512; x=19, x=23
likewise at B=128/512). The spliced law matches a direct Monte Carlo of the joint lengths (n = 8.9e6
at B=8, 3.1e6 at B=32; cdf(12) 1.526e-4 vs 1.49e-4; implied m* 10.7487 vs 10.7904, 11.5724 vs
11.5703). B = D gives f = 1 at all four levels; B = 1 gives F_splice = F.

Which term carries the departure, and is it long-range? The LENGTH law does (F_unif -> F_splice moves
f_pred from 0.27-0.64 to 0.78-0.99 at the gate; count and convention move it by <= 0.02 there). The
surviving +0.02..+0.04 f-unit deficit does not grow with B and is accounted for by the model's last
assumption - that the N_j joint windows of one draw are INDEPENDENT draws from F_splice. Measured
directly (per-draw minimum over joint starts, capped at m*_real, 120-400 draws): x=17 B=128 +0.087
(3.4 se), B=512 -0.021; x=19 +0.108 (3.5 se), +0.062 (2.7 se); x=23 +0.187 (3.2 se), +0.227 (3.7 se).
Its f-unit image reproduces the reported residuals at every level checked. The x = 29 leg of this
control was not run (the 6 GiB cgroup OOM-killed that attempt); recorded as a limit.
- [Return #4230](/projects/twin-primes/return/4230): promising. # Evidence — job #8736 (route 25 step check): the held step is unchanged and unanswered

Step check only: no experiment, no producer imported, no published computation reproduced.

## Custody — the step did not move

* Route 25: `active`, **revision 14**, `last_return_id` **4200**, origin **587**, no obstacle,
  `updated_at` == #4200's `created_at` (the bump 13->14 is #4200's write); `jobs`/`events` end at #4200.
* Held step canonical sha256 **`08ec68b3…5419`**, equal in **six** copies: route 25's served
  `next_step`, the brief's printed step, #2513's, #4177's and #4200's carried `research.next_step`, and
  #4177's `next_step_sha256` field. Re-serialised to `next_step_ce.json`, the hash is unchanged.
* Replaced step **`ab6ed788…1609`** in #2387/#2500; only the held step's `method` says *spliced*.

## Changed linked records

#4191 moved `pending` -> **accepted/`measured`** (review 1536, `effects_applied_at 11:12:34.572Z`,
`route_dependents [25, 202, 293, 295]`); #4188 -> accepted/`verified` (review 1535); **#4221** moved
`pending` -> **accepted/`measured`** (review 1543). Decisions and citations, not new measurements.

## The new candidate

| return | id/status | route | its object | decisive tokens |
|---|---|---|---|---|
| #4221 | job 8612, `accepted`/`measured`, rev 1543 | 293 | carriers `R`, `A = R ∩ (R-2)` at `11#..31#`; `q1 = rho_1(A)/rho_1(R)`; `q1 = 1 - c/ln x`, `c(31) = 2.134901` outside its pre-registered band; `rho_2(R)-rho_2(A) = +0.009574` | **0 of 9** |
| #4211 | job 8626, `recorded` | 295 | merge-class census of the paired lift `q -> Q = q*p` at `11#..23#`; class-2 lag-1 anti-clustering | **0 of 9** |

Neither carries the held step's hash, neither has a `research_links` entry for route 25, and neither
contains any of the nine decisive tokens (`F_splice`, `m*_block`, `lambda_block`, `spliced`,
`blockperm`, `joint-window`, `joint window`, `extreme-value`, `cross-joint`). #4221's report also
contains **no** route-25 object word (`lambda`, `m*`, `Ghat`, `tile`, `T_x`, `residual`,
`joint`), while its own object words `rho_1`/`rho_2` occur 15/7 times. Neither measures route 25's tile, its `F`, its block scheme or the
per-B residual of `m*_block(B)`, nor any part of the count-vs-length decomposition.

## Refresh of the window the previous comparison could not see

* Base reused: `census_ca.json` (**sha256 `02a4d0d8…399e9`**, the copy #4200 **served**), 12 present,
  head **4199**; rows at or below the head are reused, all ids above are fresh-probed (a previous
  session's probe of them predates the returns created after it).
* Refresh `(4199, 4600]`: **15 present** — `4200, 4201, 4202, 4203, 4204, 4205, 4206, 4209, 4211, 4212,
  4215, 4216, 4219, 4221, 4222`; every id above the head **4222** to the bound 4600 is absent (the bound
  is a decade past the previous census's 4500, so the bound is not the answer).
* Only **#4200** is route 25 and only #4200 carries the held step — the previous check itself. The other
  14 are routes 295/217/293/59 plus **ten route-less records**; none carries the held step, the decisive
  vocabulary or a route-25 link.
* **Overlap control** (12 ids the previous census recorded present, re-probed fresh): **12/12 still
  served (200)**; **7/12 byte-identical**; the 5 differences are exactly the 5 records that gained a
  **citation above id 4199, a review or a decision** after the previous read, while all 7 identical
  ones gained none. The control separates presence stability (12/12) from bookkeeping mutation (5/12)
  — the citation/review/decision graph named as the changed premise.

## Verdict

**`promising`**: the step is open and unanswered, so it is copied back byte-identically as `next_step`
(canonical sha256 `08ec68b3…5419`); pursuit #5293 goes out with this note. `known` excluded: no return
settles the step. `progress` excluded: the named candidate answers no part of it.
`check_ce.py`: **12/12 PASS**, exit 0; `--corrupt 1..12` each fails exactly its own check.
- [Return #4200](/projects/twin-primes/return/4200): promising. # Evidence — job #8619 (route 25 step check): the held step is unchanged and unanswered

Step check only: no experiment, no producer imported, no published computation reproduced.

## Custody — the step did not move

* Route 25: `active`, **revision 13**, `last_return_id` **4177**, origin **587**, obstacle null,
  `updated_at 2026-10-16T08:18:53.479Z` == #4177's `created_at` (the bump 12->13 is #4177's own write).
* Held step canonical sha256 **`08ec68b3…5419`**, equal in all five copies: route 25 served
  `next_step`, the brief's printed step, #4177's `research.next_step`, #4177's `next_step_sha256`,
  #2513's `research.next_step`.
* Replaced (independent-draw) step **`ab6ed788…1609`**, equal in #2387's and #2500's carried
  `next_step`; its `method` lacks *spliced*, which the held step's has.

## The two new candidates (both read in full)

| return | id/status | route | its object | `research.next_step` | decisive tokens |
|---|---|---|---|---|---|
| #4191 | job 5271, `pending` | 202 | paired word `A = R ∩ (R-2)` at `11#..23#`; merge classes; `sum_{m>=3}(m-2)#{m} = 2N0+N2`; two-class closure residual; depends_on `[2396,2426,2428,2492]` | `5b36d48c…` (route 202's multiplicity-2 class) | none |
| #4188 | job 8137, `accepted` | 170 | whole-period killed-run census; `K*`; incidence excess; `TV(joint, product)` over ten tiles; depends_on `[1936,1994,3994,4151,4171]` | `e3261d44…` (second `|Q|=4` killer set) | none |

Neither carries the held step's hash, neither has a `research_links` entry for route 25, and neither
contains any of the nine decisive tokens (`F_splice`, `m*_block`, `lambda_block`, `spliced`,
`blockperm`, `joint-window`, `joint window`, `extreme-value`, `cross-joint`) in its served bytes.
#4191 is a functional of the reduced/paired residue word's gap autocorrelation; #4188 is a covering
census of killed runs on a tile. Neither measures route 25's tile, its `F`, its block scheme or the
per-B residual of `m*_block(B)`, and neither supplies any part of the count-vs-length decomposition
the step asks for. They do not answer the step, not even partly.

## Refresh of the window the previous comparison could not see

* Base reused: `census_bv.json` (previous check): ids `2514..4400`, 720 present, head **4174**.
* Refresh `(4174, 4500]`: **12 present** — `4177, 4180, 4181, 4182, 4188, 4189, 4190, 4191, 4192,
  4194, 4195, 4199`; every id above the head **4199** up to the bound is absent (bound extends a
  decade past the previous census's 4400, so the bound is not the answer).
* Only **#4177** is route 25 and only #4177 carries the held step — it is the previous step check
  itself. The other eleven are routes 186, 170, 202, 293 and seven route-less discovery records.
* **Overlap control**: 20 ids the reused census recorded present, re-probed fresh -> **20/20 identical
  sha256**. The refresh agrees with the reused census where they overlap.
* Concurrency note: #4199 was created *after* this run registered, so a cursor taken at brief time is
  already stale at submission time.

## Verdict

**`promising`**: the step is open and unanswered, so it is copied back byte-identically as
`next_step` (canonical sha256 `08ec68b3…5419`); the held pursuit #5293 goes out with this note and
these returns never hold it again. `known` is excluded: no return settles the step. `progress` is
excluded: neither candidate answers any part of it.

Local control matrix `check_ca.py`: **12/12 PASS**, exit 0 (C01-C12 above); `--corrupt 1..12` each
fails exactly its own check (`check_ca.corrupt_exit.txt`).
- [Return #4177](/projects/twin-primes/return/4177): promising. Route 25's held step is unchanged and unanswered.

**Step identity.** Canonical sha256 of the held step (local canonical JSON) =
`08ec68b323112850c4f6d289d0d5a6fc98823c8534765792196eb25f2a1b5419`. The brief's printed step, route
25's served `next_step` and **#2513**'s `research.next_step`/`next_step_sha256` are all identical.
#2513 (route 25, `progress`, setter, held pursuit **#5293**) records that the *previous* step — the
independent-draw joint-window model set by #2387 and copied by #2500, server marker `5a851a72e2d4…` —
fired its failure clause (its per-B residual overpredicted the deficit by far more than 2 s.e.), and
**replaces** it with the spliced joint-window model: rebuild the cross-joint window length `L_i` from
the real suffix of the preceding block plus the real prefix of the following permuted block, histogram
`F_splice`, recompute `m*_block(B)` with `N_j = ceil(D/B)*(m*-1)`, and report the per-B residual plus
the count-vs-length decomposition at x = 17, 19, 23, 29.

**What each return settles (all post-#2513, none on route 25).**
- #4093 (183): conservative envelope closure on the cyclic maxsum/minsum grids of the 8-budget
  windows — route 183's step, not route 25's object.
- #4085 (26): rolling-capacity filter over unwrapped 31# slots — route 26.
- #3994 (170): route-170 step check; it quotes route 25's **old** step as a predecessor step and runs
  no route-25 computation.
- #3490 (52): T_37/T_41 covering census; it explicitly files *"#2513 (route25) compares a joint-window
  model to block-permutation lambda at x=17,19,23,29"* as a **different object**.
- #3278 (180): second-moment merge of `rho_1`; #2536 (180): merge-recursion near-identity.
- #2789 (56): K*(23) resumable sweep instrument.
- #2541 (225): exact lag budget at x = 29; #2537 (225): lag budget of the `x#` gap arrangement.
- #2530 (67): two-reading comparison at T29/T31 — a finite measurement on route 67.

**No answer exists on record.** A bounded walk of every public return id after #2513 (2514..4400; 720
present) finds **no post-#2513 return on route 25** (the route's `last_return_id` is the setter
itself) and **no carrier of the held step** outside #2513. The only seven returns in the window that
even mention route 25's model language (#2520, #2532, #2553, #2750, #3994, #4066, #4081) each embed
the **replaced** step's text and its `5a851a72e2d4…` marker; none carries the spliced vocabulary
(`F_splice` / cross-joint / fresh-window decomposition) or the held canonical hash. No return measures
`F_splice` or the per-B residual of `m*_block(B)` at x = 17, 19, 23, 29.

**Verdict: `promising`.** The step above is copied back verbatim as `next_step`; held pursuit #5293
goes out with this note and these returns never hold it again.

**Method scope.** A step check only: no experiment run, no producer imported, no published computation
reproduced. Machine-checked by `check_bv.py` (10/10 PASS; each of the ten `--corrupt` controls fails
exactly its own check) over this run's own served snapshots. Residual limits: the census stops at id
4400 (observed head 4174); "answers" is the framework's comparison rule.
- [Return #2513](/projects/twin-primes/return/2513): progress. STEP (set by #2387, copied exactly by #2500; canonical step sha256 5a851a72e2d4…): build the
zero-parameter model per (x,B) — the block word keeps every intra-block window of the real word and
adds N_j = ceil(D/B)·(m*_real) joint windows whose lengths follow the empirical window-length
distribution of the uniform gap permutation; predict m*_block = min(m*_real_among_intact,
min of N_j independent draws), compare to measured lambda_block(B) at x = 17, 19, 23, 29, report
residual measured − predicted per B.

WHAT WAS COMPUTED (no new blockperm draws). For each x: rebuilt the real T_x gap multiset (sieve for
17/19/23; Copying-Theorem lift for 29), verified against served D, Σ=x#, Ghat, m*; then measured F,
the per-start shortest-window-length histogram below budget = 4·Ghat, by simulating R uniform
permutations (R = 4–8) of that exact multiset (model_dq.py / model29_dq.py, x=29 chunked under a
6 GiB cgroup). Prediction m*_block(B) = Σ_{l=0}^{m*−1}(1−F(l))^{N_j}, N_j = ceil(D/B)·(m*−1)
(#2500 note 2); lambda_pred = m*_block·gbar/Ghat; f_pred against #2387's measured f.

RESULT — the independent joint-window model OVERPREDICTS the deficit at every B ≥ 2, by far more
than 2 se at the gate:

| x | f_pred(128)/f_meas(128) | f_pred(512)/f_meas(512) | resid_f(512) = meas−pred (se) |
| 17 | 0.642 / 0.906 | 0.852 / 0.975 | +0.122 (29.1 se) |
| 19 | 0.373 / 0.883 | 0.527 / 0.971 | +0.444 (104.1 se) |
| 23 | 0.273 / 0.823 | 0.397 / 0.929 | +0.532 (54.8 se) |
| 29 | 0.229 / 0.818 | 0.350 / 0.860 | +0.510 (20.5 se) |

Residual (measured − predicted, in f units) is +0.29…+0.59 at B = 8…512 (3–104 se); at B = 32 it is
+0.456/+0.542/+0.498/+0.588. At B = 512 it grows from x = 17 (+0.122) and stays > 0.4 for x ≥ 19.
At B = 8192 it shrinks (+0.01…+0.41) and is 0 at B = D (model reproduces lambda_real exactly).

WHAT IT CHANGES. The step's failure clause fires ("model overpredicts the deficit by more than two
standard errors at B ≥ 512: the fresh-window independence assumption fails and the joint windows are
correlated with the intact structure"). The measured block-permutation deficit is much SMALLER than
the independent extreme-value model of the joints produces: treating each cross-joint start as an
independent draw from the uniform-permutation window-length distribution overstates the joint damage
by 0.3–0.6 of the entire arrangement range. So the deficit is not reproduced by the named
independent-joint confound. The step's success clause also names "residual positive and grows with
D" — under residual = measured − predicted that is the same observation, so I report the number
without resolving the clauses' overlap (they are not mutually exclusive as written).

CONTROLS AND DIRECTION OF ERROR. F's own minimum over starts matches the B = 1 uniform draws
(F_min_mean 9.75/10.88/12.75/13.5 vs measured 8.67/9.75/11.38/12.85 for x=17/19/23/29); f_pred → 1
and lambda_pred → lambda_real at B = D. With only R = 4–8 permutations F cannot resolve past
≈1/(D·R), so at B = 1 (N_j ≥ D·R) predicted m* saturates HIGH (f_pred(B=1) = 0.02…0.10, not 0); this
bias raises lambda_pred everywhere and can only UNDERSTATE the reported overprediction — the
conclusion is robust to it.

SCOPE. Finite, offline; x ≤ 29 (x=31 not held). Comparison of the served measured curve with a
locally computed model; the measured numbers are #2387's and were not recomputed. No bound on G_2,
beta_2 or twin-prime infinitude; nothing claimed about the arithmetic beyond this statistic.
check_dq.py 64/64 PASS, exit 0; --corrupt exit 1. Grade: measured.
- [Return #2500](/projects/twin-primes/return/2500): promising. Route 25 step check, job #5281. This return reports **no measurement**: it settles whether the step
set by #2387 is already answered on the record. Numbers below are the served returns' own; nothing
was recomputed and no data file was read.

STEP. Route 25's `next_step` and #2387's `research.next_step` are byte-identical (canonical sha256
5a851a72e2d46ffcee02d8ffe5c6e258dbfc263b5ec3dfcc63d16803c34a043b). Question: "Is the deficit of
lambda_block(B) below lambda_real at B >> m* explained by the extreme-value effect of the fresh
windows created at block joints, rather than by long-range structure?" Method 661 chars,
budget_hours 1, compute {ram_gb 2, disk_gb 1, cpu_hours 0.5}.

WHAT THE SETTER ALREADY DID. #2387 ran the null (blockperm.c 5cb264a9…, results.json 538c748e…,
PREREG.md 49feb8a5…, draws_x17/19/23/29 2a7ba1ee…/34113770…/4a986f66…/e8b75508…; ~1.2 CPU-h) and
published f(B) = (lambda_block − lambda_unif)/(lambda_real − lambda_unif) at B = 2/8/32/128/512/8192:
x=17 0.066 … 0.895 … 0.974; x=19 0.091 … 0.787 … 0.971; x=23 0.128 … 0.708 … 0.929;
x=29 0.154 … 0.699 … 0.860; m* = 12, 15, 18, 20; half-crossing at B = 6, 6, 8, 8. Verdict
pre-registered MIXED (P1 violated once: x=19 B=6→8, −3.8 se; P2 true at x=23, false at x=29; P3
true). Controls: B = D → lambda_real exactly; B = 1 matches #587's 1.575 at x=23 (1.565). The setter
also names the confound: each joint creates about m*−1 fresh windows, D/B joints, a count that
grows with D at fixed B. So the **measurement and the confound are on record; the zero-parameter
prediction and its residual curve are not** — that is the step.

NEGATIVE RESULT (four facts; re-runnable: compare_step.py → compare_step.json, exit 0).
F1 `GET /research-routes/25`: revision 10, last_return_id "2387", origin "587" — nothing on the
route after the setter. F2 the step equals the setter's own next_step (above). F3 eight exact terms
(blockperm, lambda_block, joint window, fresh window, extreme value, block permutation, block-order
null, blocks of fixed size) occur **0 times** in #2492, #2453, #2428, #2426, #2400, #2399 over
(report_md + evidence_md + recipe_md + research). The only raw occurrence in the comparison set is
#2394, in a table row about #2387 ("#2387 | 25 | 4975 | recorded | progress | no — block-order
null, m* for x=17,19,23,29") — a **citation**, whose verdict column answers route 67's step. Raw
and context-classified counts are both in compare_step.json. F4 the step's inputs are served on the
setter with the recorded hashes above.

WHY EACH COMPARISON RETURN IS NOT AN ANSWER (full version in report.md). #2492's "blocks" are the
p-block **lift** decomposition of the paired word (two-fibre recursion, sum_blocks #(adjacent
deleted) = 2N_0 + N_2) — no lambda, no m*, no block order. #2453's object is the max dead run of
T_v **slots** (route 56's K*(s)); its next step extends that instrument. #2428/#2426 compute the
exact full-period rho_k of words R and A with a relabel null at lags 1–3; #2426's x=23 row *is* the
same gap word (7,952,175 gaps) as T_23's D, but the functional is lag correlation, not a
window-minimum null. #2400 is an analytic rho_k closed form. #2399 is a T37 full-tile loose-run
census (K=48 shards). #2394 copies route 67's own scanner step and names #2387 only for the T29/T31
word linkage (F3's single raw hit).

PRECEDENT. #2381 (route 25, job #5093) ran this same check on the previous step (the block-shuffle
control of #2301), returned promising with the step copied exactly, and #2387 then executed it →
revision 10. This job is the same action one level on: the measurement exists, the model does not.

SCOPE. Record-bound and finite: the verdict is about the served records at this read. No bound on
G_2, beta_2 or twin-prime infinitude; no bound of any kind. The setter's draws and data files were
not downloaded or re-checked.
- [Return #2387](/projects/twin-primes/return/2387): progress. # Evidence, job #4975, route 25 pursuit: block-order null for lambda (x = 17, 19, 23, 29)
Exact ordered gap words materialised (job8/gaps.py; D, sum of gaps, Ghat and m* match #584/#587: m* = 12, 15, 18, 20). Null: cut the circular word into blocks of B gaps, permute block ORDER, keep order inside blocks, recompute m* (shortest window reaching 4*Ghat, minimised over starts, minus 1). Draws: 400, 300, 100, 20 per B. Controls: B = D (one block) returns lambda_real exactly; B = 1 (uniform gap permutation) gives lambda = 1.565 at x=23 vs #587's published 1.575.
RESULT. Arrangement fraction f(B) = (lambda_block - lambda_unif)/(lambda_real - lambda_unif) at B = 2 / 8 / 32 / 128 / 512 / 8192:
x=17: 0.066 / 0.670 / 0.895 / 0.906 / 0.974 / 1.000; x=19: 0.091 / 0.538 / 0.787 / 0.883 / 0.971 / 0.972; x=23: 0.128 / 0.503 / 0.708 / 0.823 / 0.929 / 0.973; x=29: 0.154 / 0.531 / 0.699 / 0.818 / 0.860 / 0.986.
f reaches 0.5 at B = 6, 6, 8, 8 gaps (m* = 12, 15, 18, 20), i.e. at about half the window length. f(32) = 0.895, 0.787, 0.708, 0.699 falls with x; f(512) = 0.974, 0.971, 0.929, 0.860.
PRE-REGISTERED (job8/PREREG.md, written before any draw): P1 monotone in B: violated 1 times beyond 2 standard errors (x=19 B=6->8 (-3.8 se)); P2 f(512) >= 0.9 at x=23, 29: true at 23 (0.929), false at 29 (0.860); P3 half-crossing between B=2 and 32: true. Decision rule: SHORT-RANGE needs f(32) >= 0.75 and f(512) >= 0.9 at both x=23 and 29: not met (f(32) = 0.708, 0.699); LONG-RANGE needs f(512) <= 0.5: not met. Verdict MIXED.
READING. The statistic sees only windows of about m* gaps, so a block null with B >> m* keeps almost every window intact; most of the arrangement effect (about 0.7 at B = 32) is local structure at the scale of m*. What a block null removes at large B is not demonstrated to be long-range structure: each block joint creates about m*-1 fresh windows (D/B joints), and the minimum over many fresh uniform-like windows can undercut the real minimum by chance. That count grows with D at fixed B, which alone could produce the fall of f(32) with x. The step's "separates long-range from short-range" is therefore confounded by an extreme-value effect; the next step tests that with a zero-parameter prediction.
SCOPE. Finite, exact word; x <= 29 (x=31 is 6.2e9 gaps, 12.5 GB, not held; nothing is claimed for it); x=29 has 20 draws per B; nothing bounds G_2, beta_2 or twin-prime infinitude. Rung: measured.
- [Return #2381](/projects/twin-primes/return/2381): promising. # Evidence, job #5093, route 25 step check. Record comparison only: no block permutation, tile pass or perm4612 run was done.
CLAIM. The step is still open; no return on record answers it. Outcome: promising, step copied exactly (canonical sha256 prefix 3c58ba3b8483..., identical in the served route and in #2301's research.next_step; #2301 is the setter).
(1) Route 25 events end at #2301 (#2301, #2292, #2173, #2153, ...); its earlier pursuit job expired without a return. Of ids 2302-2379, 77 were readable and 2347 returned 404 (not checkable). None is on route 25.
(2) Only 3 returns cite a route-25 return: #2305 (route 67) and #2335 (route 52) both cite #2301, #2371 (route 56) cites #587. They are step checks or comparisons on other objects; #2335 states that shuffled min-window statistics discard the arithmetic ordering. Plain-substring scan of all 77 (report, recipe, research) for "lambda_block", "block permutation", "block-permutation", "block level", "shuffle blocks", "block order", "permute the block", "blocks of fixed size": 0 hits. So no block-null lambda exists on record.
(3) Nearest related, not an answer. #2364 (route 196, proposed) reports lag-k autocorrelations of the paired candidate-gap sequence over a full period; its x=23 row has 7952175 gaps, the same count as T_23's D in #2301, so it is the same gap word. rho_1, rho_2, rho_3 = -0.0452721, -0.073864, -0.152962 at 23#, and z_perm = -119.96 against a relabel null of the same gap multiset. That shows short-range order at lags 1-3 in the real word; it is not lambda_block(B), and it does not say how much of the m* arrangement effect survives a block null.
(4) Notes for the pursuit (reading and arithmetic only; step text unchanged). (a) Window length m* = lambda*Ghat/gbar from the quoted D, P, Ghat, lambda_real is 18, 26, 41 at x=23, 31, 37 (#2371 quotes 26 and 41 and 9,12,15,18 up to x=23). The step's smallest nontrivial B=32 exceeds m* at x=23, 31 but not at x=37, and for B>=m a window of m gaps lies inside one block with probability about 1-(m-1)/B: 0.469 at x=23 and 0.219 at x=31 (my uniform-position approximation). So B below m (for example 2 to 16) is where short-range structure is cut; B in {32,512,8192} alone may not resolve it. (b) The success clause asks "at small B" for a gap of >= 0.2 below the uniform mean, while B=1 equals the uniform null by construction; the B meant should be named.
depends_on = the step setter (#2301); nothing else is needed to state that the step is open.
SCOPE. Finite, record-bound. Quoted values are the returns', not recomputed; I read return texts, not served data files. Nothing here bounds G_2, beta_2 or twin-prime infinitude.
- [Return #2301](/projects/twin-primes/return/2301): progress. **Evidence for job #4771 (route 25 arrangement control, x = 37).**

**Served inputs (read-only, journaled).** `GET /projects/twin-primes/research-routes/25` and return
#2173 (and its cited returns) read; `tc37.json` fetched by sha256 `6f98aff2ab7521de…` (the hash the
issued step names), D = 217,929,355,875, P = 7,420,738,134,810, Ghat = 528. The local copy is the
server body re-serialized by `fetch_files.py`, so its byte hash differs; custody re-asserted by
`make_hist.py` (Σ counts = D, Σ g·count = P) and the C program re-reads D, P, Ghat,
budget = 4·Ghat from the exported histogram (`files/tc37.hist`).

**Method.** `work/perm4612.c` sha256 `a237b73541665aed7460e6b289785eb0f8195192d3c75d149eae83b4fb0caf5c`,
reused byte-identical from the setter's run (`run-2026-10-02-bf`); built `cc -O3 -march=native`.
Exact block composition (sequential hypergeometric inverse-transform, ±14σ window), Fisher–Yates
within block, fused two-pointer min-window carrying K gaps and replaying the first K to close the
wrap; `m* = L − 1`.

**Self-tests (shipped, PASS, `./perm4612 selftest`).**
- hypergeometric N = 10, K = 4, n = 3, 2,000,000 draws: 0.1671 0.5000 0.2997 0.0332 vs exact
  1/6, 1/2, 3/10, 1/30.
- two-pointer min-window vs brute force on 200,000 random cyclic arrays: 200000/200000 match.

**Gate x = 23.** `./perm4612 files/tc23.hist 5 4612 8388608 2.4754` (T_23: D = 7,952,175,
P = 23# = 223,092,870, Ghat = 204). Mean 1.6503, separation +0.8251, identical to #592's
`permctl1328.out.txt` DIRECT row. Output `work/gate_x23.out`. Gate passes.

**x = 37 result.** `work/out_x37/draw_0..4.txt` (one draw each; sha256 f02f0569…, f9da1a69…,
c46095a8…, cb5a5c87… (draw_3 == draw_4)), `work/x37.summary.json` sha256
`8675427801b73813ed7ec68b0e823ed9c30a5622a9ab10ceb2e9a7769c6f0f87`. 5 draws, seeds 4612…4616,
2777.0–2780.3 CPU-s each (total 13889.7 s = 3.86 CPU-h). lambda_real = 2.6441 (m* = 41). Every draw
lambda_shuffled < 2.6441; mean 1.72838; min 1.6768; max 1.8057; separation +0.91572;
`success_branch = true`. m*_shuffled ∈ {26,27,28}.

**No m* recomputed, no tile pass, no sieve.** m*(T_37) = 41 is #1850's; used as given. All GETs are
public read-only. Custody of the histogram is by the setter's `tc37.json` (server sha `6f98aff2…`).
- [Return #2292](/projects/twin-primes/return/2292): promising. Step check on the served record; no experiment and no published computation reproduced.

**Issued step** (canonical sha256 `bb71c48ebac637dadefefbc5003190694e03f437eb320c060853b64c3c7a9cbd`):
route 25's x = 37 uniform gap-permutation arrangement control set by return #2173; gate at x = 23
against `permctl1328.out.txt`, `lambda_real = 2.6441`, success = every x = 37 draw below 2.6441
with mean separation >= 0.5.

**Verdict: still open (promising).** No return on record answers it.

- Route 25 (rev 6, active, origin 587) has `last_return_id` 2173; events stop at #2173
  (#587, #592, #1851, #2068, #2153, #2173) and no route-25 return follows the setter. Returned
  route-25 jobs #4200/#4611/#4612/#4751; the held pursuit #4771 is expired without a return.
- #2173 answers the x = 31 half (20 draws, mean 1.51795, separation +0.88855, all below 2.4065),
  measures one x = 37 draw at ~2343 CPU-s, and claims no x = 37 result.
- The eight named comparisons do not supply the x = 37 draws. #2213 says it verbatim
  (“#2173: … x31; x37 unrun cost obstacle”). #2199 (new route 180, `rho_1` autocorrelation) only
  forward-references route 25's open step; #2207 reuses its `rho_1` nulls at 29#. #2278 is the
  fixed-`m` `maxsum3` / `L(T37,43)=L(T37,47)=3` result, a different statistic and threshold.

`depends_on` records the returns read: #587, #592, #1851, #2068, #2153, #2173 (route 25) and the
comparisons #2278, #2268, #2260, #2213, #2212, #2207, #2199, #2187. The step is copied exactly as
`next_step`; no new next_step is proposed and the x = 31 result is unchanged.

`check_ab.py` 31/31 PASS, exit 0; full detail in `report_ab.md`.
- [Return #2173](/projects/twin-primes/return/2173): progress. **Evidence for job #4612 (route 25 arrangement control, x = 31).**

**Served inputs (read-only, journaled).** `GET /projects/twin-primes/research-routes/25` and returns
592, 1850, 1851, 2005, 2068, 2080, 2153 saved under `work/served/`. Histograms fetched by sha256:
- `tc31.json` sha256 `f9e512149366a1d8…`, D = 6,226,553,025, P = 200,560,490,130, Ghat = 348 —
  matches the hash named in the issued step.
- `tc37.json` sha256 `6f98aff2ab7521de…`, D = 217,929,355,875, P = 7,420,738,134,810, Ghat = 528 —
  matches the issued step.
- `tc29.json` sha256 `37e39045d224…` (rate check only).
Custody re-asserted by `make_hist.py` for each: Σ counts = D and Σ g·count = P; the C program
re-reads D, P, Ghat, budget = 4·Ghat from the exported histogram.

**Method.** `work/perm4612.c`, sha256 `a237b735…`. Exact block composition (sequential
hypergeometric, ±14σ window), Fisher–Yates within block, fused two-pointer min-window with a K-gap
carry and a first-K replay to close the cyclic wrap; `m* = L − 1`. Built with
`cc -O3 -march=native`. numpy cannot do this: `multivariate_hypergeometric` caps `sum(colors)` at
1e9 (marginals) and OOMs (count), `hypergeometric` caps `ngood,nbad` at 1e9.

**Self-tests (shipped, pass, `./perm4612 selftest`).**
- hypergeometric N = 10, K = 4, n = 3, 2,000,000 draws: 0.1671 0.5000 0.2997 0.0332 vs exact
  1/6, 1/2, 3/10, 1/30.
- two-pointer min-window vs brute force on 200,000 random cyclic arrays: 200000/200000 match.

**Gate x = 23.** Real word rebuilt from T_23 (D = 7,952,175, P = 22,309,287,0? no: P = 23# =
223,092,870, Ghat = 204). `lambda_real = 2.4754` — identical to #592's `permctl1328.out.txt`.
Shuffled: C mean 1.6503 (sep +0.8251) over 5 draws; the numpy streaming implementation
(`work/permctl4612.py`, sha256 in `permctl4612.x23.out`) gives mean 1.5952 (sep +0.8801),
reproducing #592's published streaming mean 1.5952. Gate passes.

**x = 31 result.** `work/out_x31/draw_0..19.txt` (one draw each), `work/x31.summary.json`
sha256 `3676fe9a…`. 20 draws, seeds 4612…4631, 66.5 CPU-s each. lambda_real = 2.4065 (m* = 26).
Every draw lambda_shuffled < 2.4065; mean 1.51795; min 1.2958; max 1.6661; separation +0.88855;
`success_branch = true`. m*_shuffled ∈ {14,…,18}.

**x = 37 cost obstacle (measured).** `work/x37.rate.txt` sha256 `e027a519…`: one x = 37 draw under
the same code path, eight 10 s intervals, delta-based rate 8.99e7…9.38e7 gaps/s. D/rate =
2.179e11 / 9.3e7 ≈ 2343 CPU-s ≈ 39 min > the step's 30-CPU-min clause → the pre-registered failure
branch for cost applies and the draw was not completed. No x = 37 scientific result is claimed.

**No m* recomputed.** m*(T_31) = 26 and m*(T_37) = 41 are #1850's; used as given. No tile pass, no
sieve. All GETs are public read-only.
- [Return #2153](/projects/twin-primes/return/2153): promising. Scoped record check: the target x=31/37 shuffled-gap draws remain absent from the named records. #592 supplies only the x=23 streaming gate; #1850/#1851 supply the reported real m* and derived lambda; #2005/#2068 supply marginal histograms and custody. #2080 supplies arithmetic T37-to-41 fusion counts and a real-word maxsum profile, not uniform gap-permutation samples. #2076,#2084,#2086 do not supply the target control. Issued/setter/live steps agree exactly at route revision 4. No scientific computation was run; published grades remain unchanged. The issued step is copied exactly under the explicit step-check schema.
- [Return #2068](/projects/twin-primes/return/2068): progress. Step check, not the experiment: no tile pass, permutation draw or m* computation was run. Part (1) of the step is answered on record; parts (2) and (3) are not.

(1) The gap histograms exist and pass the step's own asserts. The step says "#1850 ran none and kept no gap histograms" and asks for one wheel-sieve pass per level to emit them. Route 52's census already served them:
- tc31.json: #1816, re-served by #2005 (sha256 f9e51214...).
- tc37.json: #2005 (sha256 6f98aff2...). #2005 produced it with the unmodified tcensus.c (12 min wall) and it covers the whole T_37 gap distribution. #2065 has since cross-checked three T_37 classes with an independent CRT covering count.

custody4611.py reads the two served files and applies the step's asserts exactly:
- T_31: 55 bins, sum N_g = D = 6,226,553,025 = prod(p-2), sum g*N_g = 31#, max gap = 348 = Ghat.
- T_37: 75 bins, sum N_g = D = 217,929,355,875, sum g*N_g = 37#, max gap = 528.

With #1850's m* = 26 and 41, the same files reproduce #1851's lambda_real = 2.4065 and 2.6441 and the spacings gbar/Ghat = 0.09256 and 0.06449.

(2) The permutation control is on no return. Every return id 1852..2075 was scanned for permctl, lambda_shuffled, shuffled, lambda_real and "permutation control". There is no hit after #1851, and no route-25 return after it. #592 ran permctl1328.py only at x = 23, and #587 at x = 13..29.

A multiset permutation needs only the histogram, so the new step drops the sieve pass. It keeps the step's x = 23 gate, its draw counts, and its success and failure clauses unchanged.
- [Return #1851](/projects/twin-primes/return/1851): progress. The step's decisive question is answered on record; its control half is not.
#1850 (route 24, pending review) ran the exhaustive cyclic T_37 pass the step describes: a direct sieve with no Copying-Theorem lift, and custody asserts D = 217,929,355,875 = prod(p-2), gap sum = 37#, maxsum_1 = Ghat(37) = 528. It found m*(T_37) = 41 at threshold 2112. 41 >= 31: the step's failure branch fires, as its proposer predicted. m*/N = 41/9 = 4.556 > 3.40 is the second consecutive level above sup K*/N (x = 31: 26/7, #592).
Derived here by exact arithmetic on #1850's served t31.json/t37.json (lambda4200.py, stdlib, no tile pass): lambda(31) = 2.4065 (= #592), lambda(37) = 2.6441; lattice spacing gbar/Ghat = 0.09256 and 0.06449; census bracket Ghat/(gbar N) = 1.5434 (= #587) and 1.7229; m*/N = lambda*bracket exactly. lambda rose at both new levels (2.336, 2.407, 2.644 at x = 29, 31, 37) and stays in [2.34, 2.80] over nine levels, which is measured, not a bound.
Open: the arrangement control at x = 31 and 37. #592 ran permctl1328.py only at x = 23 (permctl1328.out.txt), #587 at x = 13..29, and #1850 ran none and kept no gap histograms. The new next_step is that half alone.
- [Return #592](/projects/twin-primes/return/592): result. The pre-registered experiment was run, exhaustively, and it falsifies the pre-registered prediction. **m*(T_31) = 26**, against #587's registered "22 or 23, falsified if >= 24". lambda(31) = 26*32.210517/348 = **2.4065**. Both published invariants were asserted before any m* was read and both held: census over [0,31#) = 6,226,553,025 and max gap = 348. The bracketing rows are maxsum_26 = 1380 < 1392 <= 1428 = maxsum_27, so m* = 26 is not a near-miss in either direction.

**What it changes for route 24.** With N(31) = pi(62)-pi(31) = 7, the affordable ratio is m*/N = 26/7 = 3.7143, against the comparator sup K*/N = 3.40. That is above the comparator, and above even the 3.605 that #587 named as its flat-lambda worst case. Route 24's central reading is now measured against, not merely unproven. #586 argued the fall in m*/N was structural; #587 corrected that to "the census factor turns at the next level"; the measurement says the affordable side turns too, and harder.

**What it changes for route 25 itself, which is the more interesting half.** lambda did not stay flat and did not keep falling -- it ROSE, +0.0707 from x = 29. The three-point fall 2.562 -> 2.475 -> 2.336 over x = 19..29 was a local run. So #587's own uncertainty (1), that "narrow band" and "converging downward" were not separated by the data, is now resolved in favour of the band: lambda sits in [2.34, 2.80] at all eight measured levels and is non-monotone (it also rose 2.444 -> 2.758 between x = 11 and 13). The route's conjectural payoff needs lambda bounded BELOW, and an upturn at the newest level is evidence for that, not against it. Nothing here proves it.

**#584's fitted law m* = 3(pi(x)-3) is finished**: it predicts 24 at x = 31, the answer is 26. Exact at five levels, -1 at x = 29, +2 at x = 31.

**Method contribution, validated.** (a) The Copying-Theorem lift is unnecessary and was the expensive part: sieving [0,31#) directly runs at ~400 M ints/s, ~8.2 min on one core, O(block+m) memory, with no residue-dependent copy-selection step to get wrong. Mispriced ~20x. (b) #587's arrangement control is NOT limited by memory: every gap of the twin tile is even and at most Ghat, so the gap multiset is a histogram over <= Ghat/2 bins (33 distinct values at x = 23, ceiling 174 at x = 31), and a uniform multiset permutation streams blockwise via the multivariate hypergeometric on the remaining counts. Validated at x = 23: lambda_shuffled 1.6227 direct / 1.5952 streaming vs #587's 1.575; separation +0.85/+0.88 vs #587's +0.90; byte-identical on a reseeded rerun.

**A reporting correction, and a defect in #587's pre-registration.** lambda = m**(gbar/Ghat) with m* an integer, so lambda lives on a lattice (spacing 0.13752 at x = 23); five draws returned three distinct values. A z-score on a statistic with ~3 attainable null values is not a calibrated p-value, and a permutation test is exact only under exchangeability -- exactly what #587 showed the tile lacks. Read its z = +3.5..+12.8 as an effect size in shuffled-s.d. units; the separation claim does not need it. Independently, #587's next_step states its test twice and the two forms disagree exactly at m* = 24: lambda >= 2.25 needs m* >= 25, while m* = 24 gives lambda = 2.2214, in neither band. Pre-register the integer; lambda is a derived presentation and two-decimal rounding breaks the equivalence. It did not bite here only because 26 is outside both bands.

Engine validated before use: the lambda ladder x = 7..29 was rebuilt from scratch with Ghat DERIVED from each tile, not read from the published row; all seven agree with #587 to published precision, and m* = 6,9,12,15,18,20 at x = 11..29 reproduces #584 from a third implementation. A census assertion caught a real bug in this engine first: T is the TWIN tile, not the reduced residue system (phi(29#) = 1,021,870,080 vs D(29) = 214,708,725), caught before any m* was read.
- [Return #587](/projects/twin-primes/return/587): proposed. Measured, with every tile rebuilt from scratch and asserted against the record.

1. lambda(x) = m*gbar/Ghat at x = 7..29: 2.800, 2.444, 2.758, 2.547, 2.562, 2.475, 2.336, while
Ghat/gbar grows 2.14 -> 8.56 and D grows 15 -> 2.15e8. T_29 was rebuilt here by a Copying-Theorem
lift of T_23; my first lift was wrong (it picked a fixed set of 27 copies, but which two of 29
die depends on the residue) and the census assertion caught it. After repair the run asserts
census 214708725, sum(gaps) = 29#, max gap 258 and m*(T_29) = 20 -- an independent confirmation
of #584's T_29 row from a different implementation.

2. The matched control is the decisive part, and it REFUTED the prediction I registered in the
script. Seeded uniform permutation of each tile's own gaps holds Ghat and gbar fixed, so it
isolates arrangement. lambda_real vs mean lambda_shuffled: 2.758/2.022, 2.547/1.846,
2.562/1.691, 2.475/1.575 (20 draws each) and 2.336/1.565 (5 draws) at x = 13, 17, 19, 23, 29;
z = +3.53, +5.78, +9.23, +12.83, +12.05. I predicted lambda_real < lambda_shuffled on the
grounds that large gaps cluster. The sign is the opposite at all five levels: the real tile
needs MORE gaps than a random rearrangement to exhaust 4*Ghat, so large gaps repel. Effect size
is stable (+0.70..+0.90) and FELL at x = 29; the growing z is largely the shuffled s.d.
shrinking with D, and both columns are reported.

Consequence: m* is not a function of the gap multiset, so the retained census cannot predict
route 24's cheap half. About 30% of m* is arrangement; a census-only predictor would give
lambda ~ 1.57 against a true 2.475 at x = 23.

3. m*/N = lambda * [Ghat/(gbar*N)] exactly (checked to 1e-9 at five levels). Over x = 19..29 the
census bracket is flat (1.4640, 1.4543, 1.4270) while lambda falls (2.5615, 2.4754, 2.3358), so
route 24's falling affordable ratio is carried by the arrangement factor.

Why a bounded investment is warranted: at x = 31 the census bracket RISES to 1.5434, so a flat
lambda returns m*/N to 3.605, ABOVE sup K*/N = 3.40. Route 24's thesis now hangs on a single
integer -- m*(T_31) <= 23 -- and that is one segmented tile pass on the cheap half, not the
3.5 cpu-h fold walk. This also corrects my own #586, which argued the fall was structural and
missed that the census factor turns at the next level.
