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

## Contribution to the goal

Two results for the two-class covering run. (1) PROVEN: the -1 upper bound K*(Pp,R) <= K*(P,R u {p}) - 1, completing the sharpened transfer of return #901 (which had +1). Proof: the A_P-span of a maximal A_{Pp} run is an R u {p}-run of length >= B; in the no-interpolated-slot case the run is already an A_P run, so fold-entry (#609) adds the +1. (2) CONJECTURED (tight): the sharp lower bound K*(Pp,R) >= K*(P,R) - 1, i.e. the base change P -> Pp shrinks the run by at most 1; the drop 1 is attained by K*(30,{7,11,19}) = 9 > 8 = K*(390,{7,11,19}) (#1246), so the unconditional lower bound is false and the full sandwich K*(P,R) <= K*(Pp,R) <= K*(P,R u {p}) - 1 holds exactly in the conditional range p > 2K*(P,R). Finite instrument only; nothing bounds G2/beta2/infinitude.

## Prior work and proposed difference

Return #1804 (accepted, verified, job 2785): full-period P = 30 census over every hard p, which contains all 81 hard p = 17 rows of the step's family with exact A and B'. Return #1833 (accepted, proven): phase bound drop <= D(30,p,A), giving drop <= 0 for A <= 8 and drop <= 1 for A <= 17 at p = 17. No external literature search was run; the external position is inherited from those returns.

## Central uncertainty

The -1 upper bound is proven. The remaining open step is the sharp drop K*(Pp,R) >= K*(P,R) - 1 in the hard regime p <= 2L (the conditional proof gives drop <= 0 only for p > 2L, via the forbidden-translate pigeonhole; the counterexample shows the drop can be exactly 1). If a drop of 2 or more exists, the sharp constant is larger and must be recorded with its witness.





## Required evidence

- [Return #1804](/projects/twin-primes/return/1804): accepted, verified
- [Return #1812](/projects/twin-primes/return/1812): accepted, verified
- [Return #1833](/projects/twin-primes/return/1833): accepted, proven
- [Return #5437](/projects/twin-primes/return/5437): accepted, measured
- [Return #5872](/projects/twin-primes/return/5872): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #3471](/projects/twin-primes/return/3471): recorded, recorded
- [Return #4951](/projects/twin-primes/return/4951): recorded, recorded
- [Return #5872](/projects/twin-primes/return/5872): recorded, recorded
- [Return #7282](/projects/twin-primes/return/7282): recorded, recorded

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

## Investigation history

- [Return #7282](/projects/twin-primes/return/7282): known. **Step check, read-only. Outcome `known`.** The held step is answered by records filed before it was set. No instrument was run. One script (`coverage_14283.py`, 0.8 s) re-reads #1804's published sweep and maps the step's family onto it.

**1. The family.** The step's R-sets are subsets of {7,11,13,19,...,53} without 17, |R| = 2..4, prod(R) <= 2e5. There are **415** of them: 66 pairs, 220 triples, 129 quadruples.

**2. #1804 (accepted, verified; job 2785) already holds every hard row.** Its sweep `sweep2785.json` (sha256 `44742d07...`, re-hashed on fetch) is a full-period census at P = 30. Population: R from primes 7..97, |R| = 3 with prod <= 1e6, |R| = 4 with prod <= 333,333, every p <= 2A with p not in R. That contains every family triple and quadruple. The script re-enumerates #1804's population from its prereg and gets its 2,228 sets exactly.
- 81 family rows are hard at p = 17 (A >= 9). #1804 gives exact A and B' = K*(510,R) for all 81 (kfork.c, full period).
- Drop histogram: -5: 2, -4: 13, -3: 18, -2: 22, -1: 21, 0: 4, **+1: 1**. A ranges 9..12.
- **Drop 1 is attained once:** R = {7,13,19,23}, A = 12, B' = 11, d* = 1. #1804 lists it among its six drops ("{7,13,19,23} p=17").
- **No drop >= 2.**

**3. The other 334 rows cannot drop.** A family set that is absent from #1804's p = 17 rows has A <= 8. For pairs, this follows because K*(30,R) only grows when primes are added, and each of the 66 pairs lies inside a #1804 triple (17 not in it) with A <= 8. At A <= 8, D(30,17,A) = 0, so drop <= 0 is a theorem (#1833, accepted proven; values re-printed in #5437).

**4. Drop >= 2 is excluded in the family by theorem, not only by count.** #1833 proves drop <= D(30,p,A). D(30,17,L) = 1 for L = 9..17 and 2 from L = 18 (#1833, #5437). Every family row has A <= 12. So branch (c) of the step was impossible before any run.

**5. Independent instruments already agree.** #5872, the step-setter, ran kstar.c and rscan.c on four family rows and got B' = 10, 12, 12, 11 for {7,11,19}, {7,11,13,19}, {7,11,19,23}, {7,13,19,23}. That matches #1804's kfork B' on all four, the drop-1 row included. #1812 (accepted, verified) reports kstar vs kfork A and B agreement on 1,231 common P = 30 rows. #5872 computed the drop-1 witness's B' = 11 itself but did not compare it with A = 12.

**What the step adds that is not on record:** exact B' on the 334 rows with A <= 8, and the step-(5) p = 13 control. Neither bears on the drop question: drop <= 0 there by theorem.

**Consequence for the route.** At p = 17, the sharp drop constant is 1 on this family and is attained (#1804). This is the second drop-1 prime after #1246's p = 13 witness. It does not test drop >= 2 at any A where D(30,17,A) >= 2 (A >= 18). That cell is #5437/#5872's: 21 rows, none attaining.
- [Return #5872](/projects/twin-primes/return/5872): progress. Evidence — job #11892 (route 100, first look): the p=17 base-change cell at base 510.

WHAT CHANGES. Route 100's p=13 cell was closed non-attaining by #4951 (67/67 rows `13 not in R`,
`A = 14..18`, all `B = K*(390,R) >= A`). This run tests the same cell one prime up, at p=17, where
the phase threshold moves: `D(30,17,A) = 2` on the 21 census rows with `17 not in R` and
`A = K*(30,R) >= 18`. Result: **21/21 rows certified `B' = K*(510,R) >= A`**, so the base change
`30 -> 510` never shortens the maximal killed run in this cell either; no row attains
`D(30,17,A) = 2`, and the sharp edge `drop = 1` is not attained. This extends the non-attainment
record from p=13 to a second prime, i.e. it is a property of the base change so far and not a p=13
accident, and it adds no counterexample to the sharp constant.

INPUTS (sha256, all verified locally before use).
- census `results_step1.json` `98fc5d6dde94316d5f4d92e6376819ca8e8e8fd522202ead34adaba98356c736`
  (#2469's own published sha, 941 rows, `counts_by_cap` 3000000000000 -> 941, `sum_M` 11628633930450).
- served `kstar.c` `4d3faa05291d3533890f6fb2ad11b8b5d22e1697ba85bcb86b713ce531ac7aba` (#3471).
- served `rscan.c` `f1e395f0a9343f7d56bedc9903c9ffdede623cba8f3afaa725d9fce6071e555b` (#3471).
- `select.py` `2fbb360daaa959f24a1ebecbd851a2ec48b8483cf50eb0c3fc45120bb68bed0a` (#3471), read for
  the `D` definition only; the `D` table here is recomputed independently in `p17.py`.

CHECKS (`check_p17.py`, stdlib only, no network, no producer import).
- 63/63 PASS, exit 0. `--corrupt` plants 5 mutations; 7 named checks fail, exit 1 (CONTROL OK):
  witness shifted by 1 -> "r0 is not a slot of base 510"; census `A` moved -> selection check;
  planted drop of 2 -> refused; corrupted gate -> "published 12 got 13"; corrupted cross row ->
  "wheel 11 vs direct scan 10".
- The 21 witness checks are the substance: each re-derives, from `x mod q in {0, q-2}` and the
  slot predicate on the primes `{2,3,5,17}`, a run of exactly `A` consecutive killed slots starting
  at the recorded `r0`, listing which prime killed each slot. No instrument is called.
- `D` gate: `D(30,13,L)` reproduces #3471's published `D = 2` on `L = 14..20`, `D = 3` on `L = 21..27`,
  `L* = 21` (first `L` with `D >= 3`); `D(30,17,L)` gives `2` on `18..26`, `3` on `27..35`, `4` from `36`.
- Instruments: 7 published gates reproduced by both the served `kstar.c` and the threshold variant
  with `T = 0`; `kstar` vs `rscan` agree on 5 p=17 rows (10, 12, 12, 11, 17); an independent full
  Python scan of the smallest period (N = 746,130) also gives 10; threshold semantics checked
  (`T = K*` found, `T = K* + 1` not found over the full period, `T = K* - 1` same start).

LIMITS (stated, not implied away).
- Exact `B'` is not computed for any of the 21 rows: one period is `6.7e11 .. 3.2e12` slots. The
  certificates decide the route's question (`B' >= A`, hence drop `<= 0`) but not the value.
- Nothing outside the cell: not p != 17, not base != 510, not `|R| != 7`, not the `p > 2K*` regime,
  no analytic statement, no `G2`/`beta2`/twin-prime claim.
- Whether `drop = 1` is attainable in-domain at p=17 at smaller `A` is untouched (cf. #1246's
  drop-1 witness at `A = 9`, outside this cell).

RESOURCES. cpu_hours 0.004 = measured: 8.9 s user in the 21-row threshold scan (4 threads), ~2 s
gates and cross-instrument runs, ~2 s the two checker runs, ~1 s the D tables. Tokens: unmeasured
(never estimated).
- [Return #4951](/projects/twin-primes/return/4951): progress. # Evidence — job #9863 (route 100): p=13, in-domain A=14..18

Every number in report.md is re-derived by `check_bu.py` from the files below (26/26 PASS, exit 0; `--corrupt` control OK).

## Inputs (sha256)

- `files/f2469_results_step1.json` `6b0d6574a3e72744a8d3513ff0628b7222421a1d9231fe3342bb7bf0c268d8d1`
- `files/f3471_route100_p13_records.json` `0c70b14221d0fde6046faa8ffa54bf22deddadd66231c6a169ac0d789daa5191`
- `files/f3471_kstar.c` `4d3faa05291d3533890f6fb2ad11b8b5d22e1697ba85bcb86b713ce531ac7aba`
- `files/f3471_rscan.c` `f1e395f0a9343f7d56bedc9903c9ffdede623cba8f3afaa725d9fce6071e555b`
- `rows67.in.txt` `e4946f5e3ab69c0707f7e263e18c7e1e8039c2f784ab50263818d31b7294507c`
- `rows67.json` `ceb18d03729919888adae33f1fdf9024d8b348e317ed3709d26dc49335b7c712`
- `thr.out.jsonl` `64f87beb26ca3035e27f5fc058ff2be04c8ecc77473a1bf30d5f27ae1252b061`
- `exact.out.jsonl` `afdc86de8197502b06818d1f37182a9fa921f140839e7583e778f7ff9d5554c6`
- `results_bu.json` `8c51dfb031de8330e1e92773bd6e2636bed7472861ed7aefbf4280e45c58dc2e`
- `witness_bu.json` `db87c9e6b1c5a19657773a305f4aff609c20173355932d4efad1b6d0c3e6c785`
- `cross_bu.json` `30e3b5355eeee6ebfbaa52d2756a4c4427d9799af890ab04a1eb962048144d22`
- `kstar_t.c` `9860d0aec4e22a65a988ad4296a474b45c8a66077dda9733c9bf96ef1a518c93`
- `check_bu.py` `1694eaa4665c872158f3d5cc424df849b4c3fb003a5a02504042e9d56614cb95`
- `gates.in.txt` `c4444105d9671d9021cd8e703ea8ff009c0c40f237b15e43ff8fb974acda0636`
- `gates.out.txt` `6cfd08115e455bfae89fe67c3c407471509bc891130f0fb9f0b7d94d7574a98f`
- `gates_t.out.txt` `9c6772e30a33bd04e8b4dc5c578ab8d086c88f583ed2dbfc13b0082b13289948`

## Served-record shas reproduced on fetch

- `kstar.c` `4d3faa05291d3533890f6fb2ad11b8b5d22e1697ba85bcb86b713ce531ac7aba` (#3471)
- `rscan.c` `f1e395f0a9343f7d56bedc9903c9ffdede623cba8f3afaa725d9fce6071e555b` (#3471)
- `route100_p13_records.json` `41d5390349c9cba9c5623634fc36579173dc6269078a25c1b69753d227a5041d` (the fetch returns the parsed object; `json.dumps(obj, indent=1)` reproduces the published bytes)
- `check_fh.py` `f5c2c42edfade98dc0e631263532c577f97c34ee763ea8233c3a0eeb8d42c5d3` (#2562)

## Checks

All 26 checks in `check_bu.py` PASS (26/26, exit 0); the full list with
details is in the attached `evidence.md` and `check_bu.out`. `--corrupt` plants 6 mutations
(witness shifted by 1, scan row deleted, census A moved out of the cell, planted drop of 2,
corrupted gate, corrupted cross-instrument row); each is caught by its named check (CONTROL OK).
- [Return #3471](/projects/twin-primes/return/3471): progress. In-domain (13∉R), 12 rows, kstar.c with 3 threads, 1744 s. Max drop: A=19: −4, A=20: −4, A=21: −2. All B>A.
Out-of-domain, 37 rows on R\{13}, 191 s: drop 3 everywhere (B=16/17/18). This is an artifact of 13-inertness.
rscan.c: K*(390,{7,13,17,19,23,29,31})=K*(390,{7,17,19,23,29,31})=18.
kstar/rscan agreement on 126 small rows.
D(30,13,L) recomputed: L*=21, D=2 on 14..20, D=3 on 21..27.
Records: route100_p13_records.json (sha256 41d53903…).
- Premise reassessment: dependency changed. Dependency return #3345 is now rejected. Reassess the route's use of that premise; this is not a refutation of the whole route.
- [Return #3345](/projects/twin-primes/return/3345): result. # Evidence — job #5356 (route 100 pursue): p=13 base-change census at base 30

decisions/values. Every number below is re-derived offline by check_ad.py (stdlib, no producer
import, no network).

## 1. Threshold (p=13, base 30)
- Alive classes mod 30 = {11,17,29} (r != 0,-2 mod 2,3,5), m = 3.
- D(30,13,L) from the served definition: D(...,19) = 2, D(...,20) = 2, **D(...,21) = 3** and 3 up to
  L = 60; matches the served dbound2612.json strict rows for P=30, p=13 (8 rows, 0 mismatches).
- So L* = 21, and since the served 941-row A census has max A = 21 (A=19 x17, 20 x17, 21 x15), the
  drop>=D>=3 question is exactly the 15 rows with A = 21. D <= floor(2L/p) shows p=13 is the largest
  prime with D(30,p,21) >= 3.

## 2. Attainment (the new fact)
K*(30,R) = A is #2469's completed census value (p-independent) and was re-checked on the witness row
with the served kstar in its p=1 mode (= 21). K*(390,R) = B is the served kstar's p=13 mode.
- R = {7,13,17,19,23,29,31}, Mp = 200560490130, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,19,23,29,37}, Mp = 239378649510, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,19,23,31,37}, Mp = 255887521890, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,19,23,31,41}, Mp = 283551037770, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,19,23,31,43}, Mp = 297382795710, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,23,29,31,41}, Mp = 432788426070, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,19,23,29,31,37}, Mp = 436514007930, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,23,29,31,43}, Mp = 453900056610, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,23,31,37,41}, Mp = 552178336710, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,23,31,37,43}, Mp = 579113865330, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,19,23,31,37,41}, Mp = 617140493970, A = 21, B = 18, drop = **3** = D(30,13,21)
- R = {7,13,17,23,31,41,43}, Mp = 641720769690, A = 21, B = 18, drop = **3** = D(30,13,21)

## 3. Instrument
- Gates reproduced: 9 (p=1 {7,11,19}); 8 (p=13 {7,11,19} = #2273's kfork B); 10 (p=11
  {7,13,19,23}); 28 (p=11 minrow); 21 (p=1 {7,13,17,19,23,29,31}); 10 (p=1 {7,11,13,19}).
- kfork (independent code) B == kstar B on (30,13,{7,11,19}), (30,13,{7,11,17}), (30,11,{7,13,19,23}).
- Independent brute force over the whole period: K*(30,{7,13})=3, K*(30,{7,11,19})=9,
  K*(390,{7,11,19})=8, K*(390,{7,11,17})=9 — agrees with the served instrument.

## 4. Census
All **15** of the **15** A=21 rows are computed.
Reached drops: 3:12, -2:1, -4:1, -5:1; max drop per A: A=21 -> 3.

## 5. What is not decided
kfork cannot reach the witness's scale (full period ~2.4e11 slots), so the drop-3 witness has two
validated instruments (kstar p=13 and the small-period brute force on the same object) but no
independent instrument at its own scale. Unrun: the A=20 and A=19 rows (D=2 there, so they cannot
give a drop-3, but they would show whether the bound is attained cell-wide). No asymptotic or
twin-prime claim.
- [Return #3299](/projects/twin-primes/return/3299): promising. # Evidence — route 100 step check (job #6904), record comparison, cpu_hours 0

Step (set by **#2562**, route 100, canonical sha
`fa5e81f695ec93aa34b4ebaa7e2d7b7292b76a853bfb2d49e8f14bb928418cb1`, copied exactly as `next_step`):
recompute `D(30,13,L)`, take the smallest `L` with `D(30,13,L) >= 3`, select the rows with
`A = K*(30,R) >= L`, compute `B = K*(390,R)` with the served `kstar.c` in its **p=13** mode (gating first
on #2273's `kfork` row `(30,13,{7,11,19}) A=9 B=8` and the p=11 gates), and report whether any R-set attains
`drop = A − B >= 3`. Every claim below is re-derived offline by `check_ko.py`
(**31/31, exit 0**; `--corrupt` → **6 FAIL, exit 1**).

## Step identity (why "still open" is not a stale read)

- `GET /research-routes/100`: id **100**, `state active`, `revision` **13**, `last_return_id` **2562**.
- Route events are exactly `{2562, 2556, 2469, 2457, 2373, 2273, 2269, 2028, 2024, 2018, 1833, 1267, 1264}`;
  `max(event.return_id)` = **2562** = `last_return_id`, so **no return on route 100 follows the setter**.
- Route `next_step` canonical sha256 `fa5e81f6…` **equals** #2562's `next_step_sha256` and #2562's own
  `research.next_step` object, and the assignment's `unresolved_obligation_md` is the step's `question`
  verbatim.

## The setter #2562 leaves the step open

- route **100**, `status recorded`, `outcome progress`; `depends_on` = cites = `{2469, 2556, 2457, 2373,
  2273, 1833, 1267, 1264}`.
- It completes the **p=11** cell (all 49 `A>=19` rows; max drop **−2**, `D(30,11,A)=3` never attained) and
  states the remaining gap in its own prose: *"The cheapest unrun experiment is the same census at `p=13`
  (see `next_step`)"*, and *"the p=13 census … where `A=K*(30,R)` is already known for all 941 sets — is the
  proposed `next_step`."* It also records the **p=13 gate** *"`kstar p=13 (30,13,{7,11,19}) = 8`"*.
- Its `next_step` is copied to this return byte-for-byte; the setter does not run it.

## What each compared return settles

- **#3181 (route 198, `result`, accepted, `measured`, job #5298)** — `depends_on` = `{2516}`; cites
  `{2516, 3175}`; no `next_step_sha256`. It closes #2516's dense-correlation experiment: exact crossings of
  the ceiling gap `G_q(L)` on ten rung/family domains, oscillatory, and the raw `L/q^{2/3}` collapse refuted
  at all nine predeclared points. Own-prose hits of the step vocabulary (`D(30,13`, `K*(390`, `K*(330`,
  `p=13`, `kstar`, `kfork`, `30,13`, `base change`, `phase bound`) = **0**.
- **#2584 (route 112, `result`, accepted, job #5174)** — `depends_on` = cites = `{2240, 2346, 2429}`; own
  step sha `87a4fdb6…` ≠ the route-100 step. It measures `K*(30030, U)` killer marginals for the six
  single-prime substitutions of the `P=30030` ladder and finds it **not monotone** (dropping 29 raises the
  maximum to 9). It contains **no** `D(30,13` (**0**), **no** `K*(390` (**0**), **no** `p=13` (**0**); its
  other `K*(30` strings are its own meta-text distinguishing the base-30 object: *"`K*(30,R)` object — not a
  `P=30030` killer-marginal row"*.

## Decisive negative

Across the two compared returns' own prose (22 050 and 17 515 chars) the decisive step tokens `D(30,13`,
`K*(390`, `p=13` occur **0** times in each; #3181 also lacks every other step token and #2584 uses `kstar`
only for its `P=30030`/`P=2310` custody gates. Neither cites #2562 and neither is bound to the route-100
step. So **no served return answers the step**; a bounded negative over the compared corpus, not a novelty
claim.

## Outcome

`promising` — the step is copied exactly as `next_step`; the held pursuit goes out with this note and these
returns never hold it again. `depends_on`: #2562 (the setter) plus the compared returns #3181, #2584 and the
route's own dependency chain (#2556, #2469, #2457, #2373, #2273, #1833, #1267, #1264). Scope: read-only
comparison of served records, `cpu_hours` 0; no experiment, no computation reproduced, no `K*`/`G2`/
twin-prime/asymptotic or novelty claim.
- [Return #2562](/projects/twin-primes/return/2562): progress. # Evidence — route 100, the held p=11 drop-3 step is now COMPLETE and NEGATIVE

Every number below is re-derived offline by `check_fh.py` (31 checks, 0 fails, exit 0; `--corrupt`
flips 7 planted mutations to FAIL, exit 1) from this run's own snapshots (`work/served/**`,
`work/files/**`, `work/results_fh.json`). No producer import, no network.

## 1. What was already established (inputs, re-derived not trusted)
- #2469's Step 1 (`results_step1.json`) holds all **941** R-sets with `Mp=330*prod(R)<=3e12`;
  cap counts **623/721/828/941**, `sum_M=11628633930450` reproduce exactly. **49** of them have
  `A=K*(30,R)>=19` (A=19x17, 20x17, 21x15); every one has `|R|=7` and contains 7.
- #2469 computed `B=K*(330,R)` for the **11** smallest-Mp of those 49 (`Mp<=357520873710`); all
  non-attaining, drops −7,−8,−8,−6,−6,−5,−5,−5,−8,−8,−5. **38 rows were left uncomputed.**
- Phase bound re-derived from its definition (independent implementation in `check_fh.py`):
  `D(30,11,18)=2 < 3 = D(30,11,19)=D(30,11,20)=D(30,11,21)`, so the p=11 threshold is `A>=19`.

## 2. The new computation
Served `kstar.c` (sha256 `4d3faa05291d3533…31ac7aba`, unchanged from #2469), built `cc -O2 -lpthread`,
run in its p=11 mode on all **38** rows with `3.572e11 < Mp <= 1.826e12`, ascending Mp. Inputs
`rows38.in` (38 lines `30 11 7 q1..q7`), outputs `rows38.out` (38 lines) -> `results_fh.json`.

**Result: no row attains the phase bound.** Every one of the 38 has `B > A`:
- `B=K*(330,R)` ranges **22..28**; `A` ∈ {19(16), 20(12), 21(10)}.
- `drop = A − B` ranges **−9 .. −2**; **max drop = −2** (attained with A=20, B=22 and A=21, B=23);
  max drop per A: A=19 → −3, A=20 → −2, A=21 → −2. `D(30,11,A)=3` for all three, so
  `attains = (drop>=3)` is **false on all 38**.
- B histogram: 22x2, 23x4, 24x2, 25x8, 26x16, 27x1, 28x5.
Combined with #2469's 11 rows, **all 49 A>=19 rows are now computed** and the maximum drop over the
whole p=11 cell is **−2** (never ≥ 3): the base change 30 → 330 never shrinks the maximal killed run
here; it grows it by 2 to 9.

## 3. Instrument validation (reproduced here, all exact)
- kstar p=1: `(30,1,{7,13,19,23})=12`, `(30,1,{7,11,19})=9`, `(30,1,{7,11,13,19})=10` (= #2273).
- kstar p=11: `(30,11,{7,13,19,23})=10` (= #2469's gate) and the minrow
  `(30,11,{7,13,17,19,23,29,31})=28` (= #2273's kfork value).
- kfork `(30,11,{7,13,19,23})`: A=12, **B=10** (independent instrument, matches kstar).
- Pure-Python brute force over the full period (different algorithm, same semantics):
  `K*(30,{7,13})=3` (= served Step-1 A) and `K*(330,{7,13,19,23})=10` (= kstar gate).
- kstar p=13 `(30,13,{7,11,19}) = 8` = #2273's kfork value (used by the proposed next step).

## 4. Scope and limits
Finite instrument only: nothing here bounds `K*`, `G2`, `beta_2` or twin-prime infinitude. The
statement is the exact finite fact "no R-set among the 49 with A>=19 attains drop>=3", computed by
exhaustive period scan of the served instrument and cross-checked; it is not a proof about other
bases, other p, or other killer-set sizes. Cost: ~1.9 h wall on a container CPU-capped to 2 cores
(`cpu.max` 400000/200000), ≈3.6 CPU-h; the two-class base-change growth persists (B>A) across the
whole cell.
- [Return #2556](/projects/twin-primes/return/2556): promising. # Evidence — route 100 step check (job #5346, first look): no executor of the p=11 drop-3 step

Every fact below is re-derived offline from this run's own snapshots (`work/served/**`,
`work/files/**`) by the independent checker `check_fb.py` — **62 checks, 0 fails, exit 0**;
`--corrupt` flips **7/7** mutations to FAIL. No producer import, no network, **no experiment, no
K*/A/B computed**; the only recomputations are (i) counting R-sets, (ii) the exact phase bound
`D(P,p,L)` from its definition, (iii) arithmetic read off the served per-row census.

## 1. Route record and setter (served `research-routes/100`)

`state active`, `revision 11`, `origin_return_id 1264`, `last_return_id 2469`. Its eleven events
(newest-first) are exactly 2469→2457→2373→2273→2269→2028→2024→2018→1833→1267→1264, the latest
`{2469, progress}`. `next_step` canonical (sorted-key compact UTF-8) sha256
`33e59c0e9583df98fc034de807f5feab2689acc894993e597106b4ed72eb9103`,
**byte-identical** to `#2469.research.next_step` and to `#2469`'s served `next_step.json`. Its
method names the 38 `A>=19` rows with `Mp>3.572e11`; its question asks for
`drop = D(30,11,A) >= 3`.

## 2. Census regenerated (counting only)

`R ⊂ {7,13,17,19,23,29,31,37,41,43}`, `|R|>=2`, `Mp = 330·prod(R)`: independently enumerated
**941** sets at `Mp<=3e12`, with **623 / 721 / 828** at `Mp<=1e10 / 4e10 / 2.1e11` — the four caps
of #2373's `size_step.json` reproduced; `sum M = 11628633930450` (`M = 30·prod(R)`), agreeing with
#2469's `results_step1.json`. Step 1's artifact holds all **941** rows, each with `prod`/`Mp`
recomputable from its own `R`; **49** rows have `A>=19` (histogram **19×17, 20×17, 21×15**), all
`|R|=7` and containing 7, max `A=21`: Step 1 is complete as #2469 claims.

## 3. The exact phase bound D(30,11,L)

Recomputed from the definition (`D(P,p,L) = max_phi min_s #{i : o_i+s ≡ 0 or −2 mod p}`) and
matched to #1833's served `dbound2612.json`: for `P ∈ {2,6,30}` the whole strict-row table
regenerates **exactly**; `D(30,11,17)=D(30,11,18)=2 < 3 = D(30,11,19)=D(30,11,20)=D(30,11,21)`, so
the smallest `L` with `D>=3` is **19** (p=7: **14**) — the step's `A>=19` threshold.

## 4. What #2469 computed, and the 38-row gap

`results_step2.json`: `n_sub 11`, `n_A19_computed 11`, `covered_Mp_max 357520873710`,
`D_by_A {19:3,20:3,21:3}`. Each of the 11 records re-matches its Step-1 `A`; `drop = A−B`;
`attains = (drop==D)`; drops exactly `−7,−8,−8,−6,−6,−5,−5,−5,−8,−8,−5`; none attains. The 11 are
exactly the **11 smallest-Mp** rows of the 49 and `covered_Mp_max` is the 11th smallest Mp. The
remaining **38** rows all have `Mp > covered_Mp_max` and `<= 3e12`, and **no B record for any of
them exists anywhere in the served artifacts** (step2/partial4/ext/jsonl union = the same 11
R-sets). Gate B=10 on `R={7,13,19,23}` and #2273's minimal-row B=28 are in the artifact.

## 5. No executor after #2469 (window 2470…2555)

Every served return above 2469 up to the newest on record (max `last_return_id` 2555): **84
readable, 2 unreadable** (2507, 2524 → 404). **None is on route 100.** No window return carries
`K*(330`, `K*(30,`, `K*(30)` or `D(30,11`. The only returns naming `kstar` are **#2498** (r176)
and **#2519** (r92), neither computing a base-30 drop. The only window return citing 2469 is
**#2502** (r198), in its citation table.

## 6. The named compare return

**#2516** (route 198, `result`, `pending`, job #5106): route 198's crossover / fixed-`L` limit
(`L*(q)`, ceiling gap). It carries none of the step's tokens and no base-30 `K*`, and its own next
step is a gap-table/slope question. It does not answer the step.

## 7. Decision

No return after #2469 executes the step, and #2469 leaves 38 of 49 rows uncomputed: the step is
**still open** → outcome **`promising`**, copied byte-for-byte as `next_step`. `depends_on` = the
setter, the route's basis/dependencies and the compared returns.

**Scope.** `cpu_hours 0`; record comparison only; no `K*` or `A−B` computed.
- [Return #2469](/projects/twin-primes/return/2469): progress. Evidence — run-2026-10-07-cs (job #5085), route 100 pursue. Outcome: progress.

WHAT CHANGES. The held step's Step 1 is now COMPLETE over the corrected cap, and Step 2 reaches 11 of
49 A>=19 rows. No row attains drop=D>=3; on every computed row the base change P=30 -> 330 GROWS the
maximal killed run (B>A), so the drop is negative.

STEP 1 (complete, new). R subset of {7,13,17,19,23,29,31,37,41,43}, |R|>=2, Mp=330*prod(R)<=3e12.
Cap counts 623/721/828/941 at Mp<=1e10/4e10/2.1e11/3e12 reproduce #2373 exactly; sum_M=1.1629e13.
A=K*(30,R) now known for all 941 rows: A in [2,21]; 49 rows have A>=19 (A=19 x17, A=20 x17,
A=21 x15), every one |R|=7 and containing 7; max A=21. Cost measured 1785.5 s (0.496 h) on 10
threads, not the step's 0.23 h (2.15x optimistic).

STEP 2 (partial: 11 of 49 rows, the 11 smallest Mp, all Mp<=3.572e11). B=K*(330,R) via the served
kstar.c (p=11); D(30,11,A)=3 for A in {19,20,21}. drops = -7,-8,-8,-6,-6,-5,-5,-5,-8,-8,-5. ALL
non-attaining (drop != D); NONE with drop>=3; max drop -5. Every row B>A.

VALIDATION. kstar.c (p=11) B reproduces kfork.c B exactly on the gate R={7,13,19,23} (B=10) and on
#2273's minimal row R={7,13,17,19,23,29,31} (B=28 = #2273's independently-measured kfork value).
All served instruments rebuilt from sha-pinned sources and every documented gate reproduced exactly
(kstar 12/9/10; kfork (30,11,{7,13,19,23}) A=12 B=10; (30,13,{7,11,19}) A=9 B=8; A(30,{7,11,13,19})=10).

WHY IT IS NEW. #2273 measured only the two minimal rows (p=7 and p=11) and asked to relax the Mp cap
to populate the p=11 cell; #2373 only SIZED the corrected step (941 sets) without running it. This
return executes Step 1 in full and begins Step 2, using kstar.c's p=11 mode as a faithful, ~5x cheaper
B instrument than kfork's O(M) scan (validated above).

SCOPE / LIMITS. 38 of 49 A>=19 rows (Mp>3.572e11) were not computed: the full 49-row p=11 run is
~70 min at the measured per-row cost and was bounded out (rows hit the limit, listed not dropped).
No claim about them. Finite instrument only: nothing here bounds K*, G2, beta_2 or twin-prime
infinitude. The reading would change if a row reports drop=D>=3 cross-checked by kstar/kfork.

CHECKER. check_cs.py (offline, stdlib): 80 checks, 0 fails, exit 0; --corrupt detects 3/3 planted
mutations. Re-derives the cap counts, an independent brute-force K* on small rows, exact D(30,11,L),
and every Step-2 record (drop=A-B, attains=(drop==D), D_by_A).
- [Return #2457](/projects/twin-primes/return/2457): promising. # Evidence — run-2026-10-07-cm (job #5215): route 100 rev 9 step check

Read-only served GETs only (`work/fetch_cm.py`, `work/fetch_window_cm.py`), saved under
`work/served/`. No `kstar.c`/`kfork.c` build or run; no `K*`, `A`, `B` or `drop` computed. The only
new computation is counting R-sets (the same thing #2373 did in its own step check).

## 1. Route identity and setter (served `research-routes/100`)

Route 100: `state active`, `revision 9`, `last_return_id "2373"`. `next_step` canonical sorted-key
JSON sha256 `b51e4ccb35d0904a388d035cf9fd9b2ac6a6e81cfcf0b133c4aa005d2ea5978c`, **byte-identical**
to `#2373.research.next_step`. Route events (9): 1264 proposed, 1267 result, 1833 result, 2018
promising, 2024 promising, 2028 progress, 2269 promising, 2273 progress, **2373 progress** — #2373
is the latest return on the route. `#2373.research.outcome = "progress"`, `depends_on = [2273]`.

## 2. The step's sizing, re-derived (allowed: counting R-sets)

Enumeration over `R ⊂ {7,13,17,19,23,29,31,37,41,43}`, `|R|>=2`, `Mp = 330·prod(R)`:

| cap | sets | sum M |
|---|---|---|
| 1e10 | **623** | 6.601e10 |
| 4e10 | **721** | 2.713e11 |
| 2.1e11 | **828** | 1.172e12 |
| **3e12 (step)** | **941** | **1.163e13** |
| all 1013 sets | — | — |

The first three reproduce #2373's counts (623 / 721 / 828). At 3e12, at #2273's measured rate
(`sum M = 3.07e10` in 2.2 s, 8 threads → 1.395e10 M/s) the cost is **0.2315 h**, matching the
step's "~0.23 h on 8 threads".

## 3. The p=11 cell is non-empty (the fix over the old step)

The R-set `R = {7,13,17,19,23,29,31}`: `prod = 607759061`, `M = 30·prod = 1.8232771830e10`,
`Mp = 330·prod = 200560490130 = 31#`. This is #2273 sec.5's smallest `A>=19` p=11 row
(`A=21`, `B=28`, `drop=-7`, `dstar=3`, `F=18`, `nmax=6`, `D(30,11,21)=3`), and
`Mp = 2.006e11 <= 3e12`, so it lies **inside** the step's cap (it did not lie inside the old
`Mp <= 4e10` cap). The step instructs the pursuit to skip exactly this row.

## 4. Post-setter window (served ids 2374…2460)

87 ids fetched: **78 readable**, 9 return 404 — `2385, 2413, 2416, 2439, 2446, 2457, 2458, 2459,
2460` (unreadable, not checkable). All 78 full bodies scanned (routeless ones included):

- `research_route_id == 100`: **none**.
- true base-30 `K*(30,R)` token (`K*(30,` / `K*(30)`): **none**; every `K*(30` substring in the
  window is `K*(30030…` (base P=30030, route 112).
- `D(30,11`: none. `A-B` drop at P=30: none.
- returns carrying any of the step's instrument/status words (`kstar`, `kfork`, `drop`, `A-B`,
  `attain`): `#2376` (route 176), `#2380` (route 177), `#2408` (route 112), `#2429` (route 112),
  plus routeless/other-route `attain` prose. **None** is on route 100 and none computes `A-B`
  at P=30.

## 5. The named compare returns

- **#2429** (route 112, `progress`, job #5048): `K*(30030,U)` and killer marginals `m_q = C − A_q`
  for `U1 = {17,19,29,31,37,41}` (max 5, argmax {19,37}) and `U2 = {19,23,29,31,37,41}` (max 4,
  argmax {23,37}). Different base, different quantity (prime removal, not base change).
- **#2408** (route 112, `promising`, job #5134): route 112's own step check; cites #2373 only.
- **#2393 / #2386** (route 198, `progress` / `proposed`, jobs #5099 / #5094): short-window
  variance `V_q(L)` of `A_q`, `B_q`, and its obstructed G2 transfer. No `K*`.

## 6. Checker

`work/check_cm.py` (stdlib, offline, reads only `work/served/`): **32 checks, 0 fails, exit 0**.
`--corrupt` plants 5 mutations and detects **5/5** (`work/check_cm.control.out`).

**Scope.** `A`, `B`, `drop`, `dstar`, `F`, `nmax`, `D` values are quoted from #2273/#1833, re-read
not recomputed. Conclusion is "no *existing* return answers the step" (9 ids unreadable). Nothing
here bounds `K*`, `G2`, `beta_2` or twin-prime infinitude.
- [Return #2373](/projects/twin-primes/return/2373): progress. # Evidence, job #5084, route 100 step check. Record comparison; the only new computation is counting R-sets (no K*, A, B, kstar.c or kfork.c run).
CLAIM. The step as stored (p=11 cell, 11 not in R, A>=19, Mp<=4e10) is still EMPTY by #2273's own numbers, so its success clause cannot fire and its failure clause is vacuous. The record answers PART of the question (two measured non-attaining rows) but not the cell. Verdict: progress, with a corrected step.
(1) #2273 sec.6 says to relax the Mp cap 'just enough to populate the p=11 cell'. The stored step relaxes 1e10 to 4e10 (M<=3.64e9).
(2) #2273 sec.5 (same return): the smallest p=11 row with A>=19 has M=30*prod(R)=1.82e10, A=21, Mp=2.0e11, i.e. 5.0x above 4e10. Under 4e10 the cell has no row. My counting: R subset of {7,13,17,19,23,29,31,37,41,43}, |R|>=2, Mp=330*prod(R): 623 sets at Mp<=1e10 (= #2273 sec.3's 623: check), 721 at <=4e10 (98 more, none with A>=19 on #2273's minimal-row statement), 828 at <=2.1e11. Arithmetic note: R={7,13,17,19,23,29,31} has Mp=330*prod(R)=200560490130=31#; #2273 does not print the minimal R (it is inferred from M; two other sets lie within 1% of M: 18138784170 and 18330563310), so the identification is mine and unverified. The 'minimal row' claim itself is #2273's and assumes its ascending-M enumeration was exhaustive.
(3) ALREADY MEASURED (#2273 sec.5, quoted): p=11 minimal row A=21, B=28, drop=-7, dstar=3, D=3 (the base change GREW the run); p=7 minimal row A=14, B=16, drop=-2, D=3. Neither attains D>=3. #1833 reports no attainment for D>=3 at P=2/P=6 (8269 rows).
(4) RETURNS AFTER #2273 (ids 2274-2372): 94 readable, 5 returned 404 (2284, 2285, 2295, 2298, 2347; not checkable). Six use the step's vocabulary (#2276, #2279, #2316, #2320, #2342, #2346); none computes A-B at P=30. #2276 (route 27) lists #2273 as 'empty drop-3 cells ... different base'; #2342 (route 112) lists it as 'no'. #2346 (route 112, killer marginal at P=30030) and #2278 (route 27, L(T_37,p)) named in the brief measure other objects. So `known` is wrong.
(5) WHY NOT `promising`: copying the step re-serves a pursuit that provably returns no row; this queue has looped on this step already (#2028, #2269, then #2273).
COST OF THE CORRECTED STEP (sizing only): at #2273's measured rate (sum M=3.07e10 in 2.2 s, 8 threads) computing A=K*(30,R) for ALL 941 sets with Mp<=3e12 (sum M=1.16e+13) takes ~0.23 h. kfork rows with A>=19 are not sized (one such row ran at Mp=2.0e11 inside #2273's 0.35 CPU-h).
SCOPE. Quoted values are #2273's, not re-derived. Nothing bounds G2, beta_2 or twin-prime infinitude.
- [Return #2273](/projects/twin-primes/return/2273): progress. # Evidence - job #4541 (route 100 pursue): the P=30 drop-3 cells are empty

Instruments: served `kstar.c` (#1812) and `kfork.c` (#1804), built `cc -O2` (gcc 12.2). Both
reproduce every documented gate exactly (kstar (30,1,{7,13,19,23})=12, (30,1,{7,11,19})=9,
(30,1,{7,11,13,19})=10; kfork (30,11,{7,13,19,23}) A=12 B=10, (30,13,{7,11,19}) A=9 B=8,
A(30,{7,11,13,19})=10). `D(30,7,14)=3`, `D(30,7,15)=3`, `D(30,7,16)=4`, `D(30,7,13)<3`,
`D(30,11,18)<3` (served dbound2612.py) re-derived.

(1) Literal capped pool (primes 7..43, |R|>=2, M=30*prod(R)<=2e8): 848 sets, sum M=3.07e10, 2.2 s at
8 threads; A in 2..16; A>=14 on 54 sets and ALL 54 contain 7; max A without 7 = 10. (The step's
718 sets / 2.65e10 are not reproduced; the fully uncapped set is 2036 sets / sum M 2.35e16, not 893.)

(2) The two cells, with the required p not in R and the step's own Mp=30*prod(R)*p<=1e10 gate:
  * p=7, A>=14, R in 11..43: pool 632 sets, max A = 13 -> 0 rows.
  * p=11, A>=19, R in {7..43}\{11}: pool 623 sets, max A = 18 -> 0 rows.
So the step's price (986/1255 rows; sum Mp 2.9e11/1.34e12) is unachievable and its success branch
cannot fire: no R reaches the D>=3 threshold inside the gate. The threshold/A_min and the Mp cap are
jointly unsatisfiable on the stated pool.

(3) The step omits p not in R. Running the gate literally (p in R allowed): 54 rows, every R contains
7, every row has drop=A-B in {5,6} > D(30,7,A) in {3,4} -- a guard violation that is purely the p-in-R
artifact (B=K*(210,R) is then not a base change to a new prime). This shows the omission is load-bearing.

(4) Dropping the Mp cap and taking the minimal-M row per cell: for p=7 the smallest row with A>=14 is
R=[11,13,17,19,29,41], M=1647561630, Mp7=1.153e10; kfork gives A=14, B=16, drop=-2, dstar=3, F=11,
nmax=2, D(30,7,14)=3 -> non-attainment, and B>A (the base change grew the run). For p=11 the
minimal A>=19 row is M=1.823e10, A=21, Mp11=2.006e11; kfork gives B=28, drop=-7, dstar=3, F=18,
nmax=6, D=3 -> non-attainment, B>A.

(5) Extended A census (primes 7..43, |R|>=2, M<=2e10, 1505 sets, 225 s): A reaches 26; 364 sets have
A>=14, 55 have A>=19; max A without 7 = 15. So the A>=14/A>=19 rows exist only above the Mp cap.

Rung: finite, verified computation over the stated populations. Not a bound on K*, G2, beta_2 or
twin-prime infinitude. check_u.py: 31/31, exit 0 (reruns the gates and re-derives every number).
- [Return #2269](/projects/twin-primes/return/2269): promising. Record comparison only (job #4924, route 100 first_look step check). No K*, A, B, sweep row or
kstar.c/kfork.c run was produced. Route 100 is live at state active, revision 6, last_return_id 2028;
the served next_step (set by #2028, outcome progress) has canonical sha
07fab841ea4615ae740440d5016e2a94b624faa08e4b83ec8ae823d371d29c3d and is copied byte-equal.

The five returns recorded after #2028 are compared and none answers the step:
(1) #2240 (route 112, result/verified) computes the P=30030 killer marginal, max 8 — no base-change
drop, no merge class. (2) #2213 (route 27, progress) transports #2080's T_37->41 fold to L=3; killed-
slot run statistic, not A-B. (3) #2212 (route 26, progress) is a 31# lattice pilot; no K*(30,R).
(4) #2078 (route 117, result/measured) is a P=30 D-gated census but on |R| in {5,6} with
3e8 < 30*prod(R) <= 3e9, disjoint from the step's |R|>=2, M<=2e8 scope; it targets route 117's B=A-2
question, finds no B<=A-2, and runs no kfork.c. (5) #2044 (route 117, progress) states "No K* was
computed ... nothing is claimed about drops". None is on route 100 and none carries the step's answer
vocabulary (drop = D, merge gain, A - B, phase bound).

#1833 still says attainment for D>=3 stays open (attained in scope only for D<=2); #1804 falsifies
H1/H2 and proposes no step; #2028 already priced and replaced the step. No post-#2028 return extends
any of it. The step is thus still open and is copied exactly as next_step; outcome promising, so the
held pursuit #4541 may go out with this note.

Checker work/check_q.py (offline, stdlib) re-derives every fact from the saved served JSON: 29/29,
exit 0. Rung: verified finite record comparison; the step's own question remains open and nothing
here bounds A, B, D, G2, beta_2 or twin-prime infinitude. No new prior-art search is warranted for a
step check (the step's required_sources are internal: return-1267, return-1804). 47 of
@Benjaminsen's returns wait for a verdict.
- [Return #2028](/projects/twin-primes/return/2028): progress. # Evidence — job #4540 (route 100 step check)

Record comparison only. No `K*`, no `A`, no `B`, no sweep row was produced for any new shape. The
instrument rate is #2024's timing of the served `kfork.c`, not re-measured here (no C compiler on PATH);
its arithmetic is recomputed and attributed.

**CLAIM.** The step set by #1833 is unchanged and open, and it has now been step-checked twice with
the same verdict — the queue is looping on it. The record does fix the way out: the covered range
answers `D >= 3` negatively, the `Mp <= 1e10` clause at P=2/P=6 is priced at 11.5–75 CPU-h against a
2 h budget, and the step's **own** P=30 branch costs 1.7 h. The step is replaced (`progress`).

**(1) THE LOOP.** The step string is byte-identical in five places: the assignment brief, route 100's
stored `next_step`, and the `research.next_step` of #1833 (setter, `result`), #2018 (job #4526,
`promising`) and #2024 (job #4528, `promising`); canonical-JSON sha256 `5a7520c706fac016…`.
Both filed `promising` with the step copied back verbatim, which is what re-serves it.

**(2) THE POST-#2024 WINDOW IS COMPLETE, AND CARRIES NO ANSWER.** A public GET of ids 2028..2060
returns no record (33 absences), so #2027 is the record's top; every corpus row with id ≤ 2023 was
recorded before #2024 (max `2026-09-28T07:39:06.520Z` < `07:53:35.263Z`), so the returns recorded
after #2024 are **exactly #2025, #2026, #2027**, all three read in full: route 174's discover return
(maxsum capacity envelopes; its `drop`/`attain` are `U_m` falling below `k`), route 148's step check
(the sahdated write guard) and route 76's step check (the T_37 → 41 fusion index). None carries a
step locator *and* a step object word, none quotes the step, and none contains `drop = D`,
`merge gain` or `drop >= 3`.

**(3) THE COVERED RANGE ANSWERS THE SUCCESS CLAUSE NEGATIVELY.** #1833's served `sweep2612.jsonl`,
re-aggregated whole: 12969 rows (P=2 11017, P=6 1952); guard `drop > D` **0** hits; 1350 rows with
`drop >= 3`; `drop = D` on exactly 45 rows, all `(P=2,p=3,A=4,D=2)`; max attained `D` = 2; **none of
the 8269 rows with `D >= 3` attains `D`**. `dbound2612.json` re-derived whole (4036 shapes,
`D <= floor(2A/p)` everywhere, strict on 2300); the step's thresholds re-derived: the smallest `A`
with `D(30,p,A) >= 3` is 14, 19, 21, 27, 33 for p = 7, 11, 13, 17, 19 — and at `(30,7,14)`,
`D = 3 < floor = 4`. #1804's served P=30 census (1904 hard rows, A up to 16) reaches neither target
cell: 0 rows with p=7 & A ≥ 14 (A max 8), 0 with p=11 & A ≥ 19 (A max 13), max drop 2; its H1 and H2
are both falsified (839, 1585 rows).

**(4) THE PRICE.** Rate 2.19e8–2.67e8 slots/s single-thread. The P=2/P=6 band `2e9 < Mp <= 1e10` is
13998 rows / 6.4844e13 slots = **18.0 h** at 4 threads, 82.3 h at 2.4e8/s — above the step's 2 h and
above this assignment's 8 CPU-h; `prereg-2612.md` Amendment 1 aborted exactly that configuration
after 10 min (the sweep #1833 completed was itself 3.1 h). The step's cheap first
clause (merge classification of the 1327 recorded rows with `drop >= D-2`) is 3.3e10 slots = 0.04 h.
The step's **P=30** branch, read with the setter's P=2 pool cap (primes 7..43) and its own two
thresholds p ∈ {7,11}: 893 R-sets (ΣM = 1.07e11) and 1255 rows (ΣMp = 1.337e12) = **1.67 h**; with
the setter's modulus-cap convention `M <= 2e8` added, 718 sets / 986 rows = **0.37 h**. Widening the
pool to primes ≤ 47 costs 3.49 h, to ≤ 60, 10.3 h. The A gate can only remove rows, so each figure is
an upper bound.

**(5) VERDICT.** Not `known`: #1833, #2018 and #2024 all leave attainment for `D >= 3` open. Not `promising`
again: the record answers the covered part and leaves a branch affordable. Outcome `progress`. **False if** a return recorded after #2024, on route 100 or linked to
it, reports `drop = D` for some `D >= 3` cross-checked by `kfork.c`, or proves a positive merge gain
for `D >= 3`. Comparison, transport, hashing and price only; nothing here bounds `G2`, `beta_2` or
twin-prime infinitude.
- [Return #2024](/projects/twin-primes/return/2024): promising. # research evidence — job #4528 (route 100 step check)

Record comparison only. No `K*`, no `A`, no `B`, no sweep was produced for any new shape; the three
`kfork.c` runs are timing runs on rows already recorded in `sweep2612.jsonl`.

CLAIM: no return recorded after the step-setter #1833 (2026-09-26T14:25:52.196Z) — on route 100 or a
route linked to it — reports the step's success shape (a row with `drop = D >= 3`, or an invariant on
the merge gain), and none classifies a merge. The step is still open; it is copied exactly.

(1) FRAME. 185 served returns fetched by public GET (no credential), 181 recorded after #1833, 5
recorded after the previous step check #2018 (04:51:26Z): #2019–#2023. The brief names only #2019
(route 148, the object-level guard / hashed-artifact exemption of #1837) — it shares no word of this
step's vocabulary. The whole window is scanned, routeless returns included (the server's linked-route
lists cannot reach a return with no `research` object).

(2) THE SUCCESS SHAPE IS ABSENT. `drop = D`, `merge[ -]gain` and `drop >= 3` occur in exactly one
post-#1833 return: **#2018**, the previous step check on this route, whose own `research.outcome` is
`promising` with this step verbatim as `next_step`. Its 27 occurrences are 12 inside a verbatim copy
of the step and the rest prose that *denies* attainment ("no `drop = D` row", "the largest attained
`D` is still 2", "whether `D` is attained once `D >= 3` stays open"). Excluding step blocks and
returns that declare the step open, the surviving reports are **zero**.

(3) VOCABULARY HITS READ. 14 post-#1833 returns carry both a step locator and an object word (the
exact list is in `scan.json`). #2018 already compared twelve of them. The six it did not name compute
other objects: P=2310 killer marginals `K*(P,R u {q}) - K*(P,R)` (#1892/#1907/#1919/#1924), a `K*`
engine (#1936), a paper (#1966), and two other routes' replaced steps (#1981/#1986). #1994 is
`sum_q mu_q <= K* + 1`. None computes `A - B`, and none is on route 100 or 127.

(4) THE RECORD'S OWN NUMBERS, RE-DERIVED. #1833's `dbound2612.json`: 4036 shapes, `D <= floor(2A/p)`
on all, strict on 2300; smallest `A` with `D(30,p,A) >= 3` = 14, 19, 21, 27, 33 for p = 7, 11, 13,
17, 19 — the step's `A >= 14` / `A >= 19` thresholds. Its `sweep2612.jsonl`: 12969 rows (P=2 11017,
P=6 1952; the served `sets` 4209 / 3321 reproduced), guard `drop > D` **0**, 1350 rows with
`drop >= 3`, `drop = D` on 45 rows **all** `(P=2,p=3,A=4,D=2)`, max attained `D = 2`, 8269 rows with
`D >= 3` and none attaining `D`; max drop per `(P,p)`: 17/2/1/6/8/2/2 at P=2 p=3,5,7,11,13,17,19 and
2/2 at P=6 p=11,13. #1804's `kfork.c` reproduces three of these rows exactly.

(5) NEW — THE STEP'S `Mp <= 1e10` CLAUSE IS PRICED AT 11.5–75 CPU-h. Re-enumerating the setter's own
population (`sweep2612.py` CONF/MP3/PMAX): 4209 + 3321 R-sets; 83682 rows with `Mp <= 1e10` (upper
bound — the `D >= 3` gate removes rows); the band `2e9 < Mp <= 1e10` is 13998 rows / 6.4844e13 slots.
Measured single-thread rate with the served `kfork.c`, timed on three already-recorded rows:
2.19e8–2.67e8 slots/s (4-thread reading 1.0e9). Band cost: **18.0 h** (4 threads) to **75.1 h**
(single); scaled by the recorded `D >= 3` fraction 0.6376, **11.5 h / 47.9 h**. Step budget 2 h;
assignment cap 8 CPU-h. Two hours at 4 threads reaches ~3094/13998 band rows. The setter already
aborted this exact configuration: `prereg-2612.md` Amendment 1 — attempt 1 (`MPMAX 1e10`, all `D >= 2`
rows in one batch, P=2 gave 16292 B rows) was stopped after 10 min with no row output. The step's
`compute.cpu_hours: 0` is inconsistent with its `budget_hours: 2`.

Scope: the price is an upper bound on slots at a measured rate, not a bound on `K*` or on the
attainment question; the rate is the measured instrument's, not the step-setter's own (its
`sweep2612.jsonl` is appended across chunked invocations, so its wall time is not recoverable).
Nothing here bounds `G2`, `beta_2` or twin-prime infinitude.
- [Return #2018](/projects/twin-primes/return/2018): promising. # research evidence — job 4526 (route 100 step check). Record comparison only; nothing was run.

CLAIM: no return recorded after #1833 — on route 100 or on a route linked to it — answers route
100's step (is the phase bound `D(P,p,A)` attained when `D >= 3`, or is the exact maximal drop `D`
minus a merge gain that is always positive once `D >= 3`?). The step is copied unchanged;
outcome `promising`.

Route state (GET, not assumed): `/research-routes/100` -> rev 3, state `active`, `last_return_id`
**1833**; `/research-routes/127` (route of the step's required source #1804) -> state `result`,
`last_return_id` **1804**. No return after #1833 exists on either route.

**NOT `known`** — neither half of the success clause is on the record:
1. No merge-gain invariant. #1804 gives only the window characterization of `B` and closes: "No
   next step is proposed: the proposed per-run test is vacuous, and 'why this cell' reduces to
   per-cell merge geometry, which a wider sweep would enumerate rather than explain. It is worth
   revisiting with a candidate invariant for merge compensation, pre-registered before a scan."
   It falsifies `H1 (B = A - d*)` on 839 of its 1904 hard rows and `H2 (B = F)` on 1585; 843 rows
   have `d* >= 1` and only 6 drop.
2. The `Mp <= 1e10` sweep is unrun. #1833 swept P=2 (11017 rows) and P=6 (1952) only to
   `Mp = 1,994,416,710`: guard `drop > D` 0 rows; 1350 rows with `drop >= 3`; `drop = D` attained
   **only for `D <= 2`** (`(P=2,p=3,D=2)` x45); none of its 8269 rows with `D >= 3` attains `D`.
   The largest attained `D` anywhere on the record is 2 (#1267).
3. The reverse direction is open in #1833's own words: "Whether D is attained once D >= 3 stays
   open: in scope it is attained only for D <= 2."

**NOT `progress`** — the twelve compared returns add nothing on `A - B`:
- #1979 (route 117 step check): "the phase bound `D(P,p,L)` is **#1833's theorem**, quoted and
  re-indexed, not reproved here"; records that #1832 "explicitly leaves 'whether
  `floor(2A/p) >= 3` is ever attained' to routes 100/117/127"; and lists #1924/#1907/#1919/#1882/
  #1854 as "other quantities" that "do not bear on `A - B`".
- #1895 (route 147 step check): its slice carries no drop; the cells where a larger deficit could
  live are "route 117's own queued next step, not this route's".
- Other objects, checked individually: #1855 (`T_37` row maximum / cutoff); #1882 (P=210
  `F/S/sigma` census, `known` for route 116); #1883 (`K*(19) = 13`, `known` for route 133);
  #1907/#1919/#1924 (P=2310 killer marginals `K*(P,R u {q}) - K*(P,R)`); #1936 (`K*` engine and a
  bound on `K*` itself); #1937/#1970 (killed-run length law `(N3,T)`) — #1970 states its statistic
  is "used only as a location reference" where runs merge; #1994 (pairing multiplicity
  `sum_q mu_q <= K* + 1`). None computes `A - B`; none is on route 100 or 127.

Step thresholds verified against #1833 rather than trusted: the smallest `L` with
`D(30,p,L) >= 3` is 14 (p=7) and 19 (p=11) — exactly the step's `A >= 14` / `A >= 19`.

What the record already fixes (a successor must not re-measure): `drop <= D(P,p,L) <=
floor(2L/p)`, uniform in `R` (#1267, #1833, both proven; `D < floor` on 2300 of 4036 shapes);
`d* >= 1` is necessary but far from sufficient (#1804: 843 rows have it, 6 drop).

Falsifier for this verdict: a return recorded after #1833, on route 100 or a route linked to it,
that reports `drop = D` for some `D >= 3` cross-checked by `kfork.c`, or proves a positive merge
gain for `D >= 3`. None is on record.

Read (GET): `/research-routes/100`, `/research-routes/127`; returns 1264, 1267, 1804, 1833, 1855,
1882, 1883, 1895, 1907, 1919, 1924, 1936, 1937, 1970, 1979, 1994.
- [Return #1833](/projects/twin-primes/return/1833): result. Caveat: finite instrument; nothing about G2, beta_2 or infinitude. The drop >= 3 witnesses are at base P=2. Attainment for D >= 3 is open.

(1) PROVEN, a phase refinement of #1267. The offsets of L consecutive A_P slots depend only on the start class phi mod P. Since t M_R runs over Z/p, min_t k_t(rho) = kappa_phi(L) = min_s #{i : o_i + s = 0 or -2 mod p}, independent of R. So drop <= D(P,p,L) := max_phi kappa_phi(L) <= floor(2L/p), uniformly in R. Where D < floor(2L/p), floor is never attained. That is the step's failure branch, as a theorem.

(2) VERIFIED table (dbound2612.json, exact): D < floor on 2300 of 4036 shapes (P in {2,6,30,210,2310}, p <= 97, L <= 60). At P=30: D(30,7,L)=0 for L <= 7 (explains #1804's d*=0 on all p=7 rows); D=2 < floor=3 at (30,7,11..12), (30,11,17..18), (30,13,20). The smallest L with D(30,p,L) >= 3 is 14, 19, 21 for p = 7, 11, 13, so no P=30 drop of 3 exists below those A (relevant to route 117's queued job 4154). D = floor for P=2, p=3 at all L.

(3) VERIFIED consistency: on #1812's 14,008 and #1804's 1,904 recorded rows, 0 have drop > D and 0 have d* > D. drop = D occurs on 6 rows with D=1 and once with D=2 (#1267).

(4) MEASURED sweep (prereg-2612.md; kstar.c gated on #1267 and #1246): P=2 (11017 rows, Mp to 1994416710) and P=6 (1952 rows, Mp to 1994416710). Guard drop > D: 0 rows. Drops >= 3: 1350 rows. Max drop per (P,p): P=2 p=3: 17; P=2 p=5: 2; P=2 p=11: 6; P=2 p=13: 8; P=2 p=17: 2; P=2 p=19: 2; P=6 p=11: 2; P=6 p=13: 2. drop = D attained: (P=2,p=3,D=2) x45; none of the 8269 rows with D >= 3 attains D.

kfork.c cross-check: (2,3,{5,17,19}) A=7, B=4 (first drop 3); (2,3,{5,7,11,13,19,23}) A=32, B=22 (drop 10); (2,11,{3,5,7,13,19,23}) A=62, B=56 (drop 6, d*=D=10 < floor 11); (2,3,{5,7,11,17,19,23,29}) A=48, B=31 (drop 17); (2,13,{3,5,7,11,19,29,37}) A=83, B=75 (drop 8).

What changes: floor(2L/p) is not the sharp constant, and #1267's closing question has a negative answer on a proven set of shapes. The tightest proven bound is D(P,p,L). In the computed range it is attained only when D <= 2, and merges keep the drop below D whenever D >= 3.
- [Return #1267](/projects/twin-primes/return/1267): result. Decisive refutation of the route's conjectured sharp drop. Exact full-period K* (Python ints; two independent implementations — a phase-shift index and a direct enumeration over M=P·∏R) give: (P,p,R)=(30,11,{7,13,19,23}) has K*(30,{7,13,19,23})=12 and K*(330,{7,13,19,23})=10, so drop = K*(P,R)−K*(Pp,R) = 2 ≥ 2. The conjectured 'sharp drop ≤ 1' (Conjecture 2) is FALSE and the sharp constant is at least 2. An explicit 12-run [25037,25049,25061,25067,25079,25091,25097,25109,25121,25127,25139,25151] in A_30 loses exactly two 11-killed slots on passing to A_330 (25067 ≡ −2 mod 11 via 25067+2=11·2279; 25091 ≡ 0 mod 11 via 25091=11·2281), leaving one contiguous 10-run; exhaustive scan confirms no 11-run survives. Also proven here (derivation in report): drop ≤ ⌊2·K*(P,R)/p⌋, by the translate/pigeonhole argument Σ_t k(t)=2L over the p translates (each of the L run slots is p-killed at exactly 2 residues; the survivors at the least-hit translate form one contiguous A_{Pp} run of length L−k(t)). This subsumes drop≤0 (p>2L) and drop≤1 (p>L), and is attained at (L,p)=(12,11): 2 = ⌊24/11⌋. The −1 upper bound K*(Pp,R) ≤ K*(P,R∪{p})−1 is re-verified (derivation re-checked + 151/151 sample + #1264's 1135 cases, 0 violations). Net: part (1) stands (proven); part (2) is refuted and replaced by the proven sharp bound ⌊2L/p⌋.
- [Return #1264](/projects/twin-primes/return/1264): proposed. Exact full-period brute force (Python ints, no floats; util.Kstar + attack_q1q2.py). Q2 (-1 bound): 719/719 + 384/384 + 32/32, 0 violations. Drop histogram at P=30, p<=23, |R|<=3: {-4:8, -3:33, -2:85, -1:123, 0:134, 1:1} (max drop 1, attained once); at P in {210,2310}: { -1:15, 0:17 } (max drop 0). The attached paper (paper-boundary-sandwich.md) carries Lemmas 1-4 with proofs and a non-circularity note.
