# Job #4528 — route 100 step check: the step is still open, and its `Mp <= 1e10` clause is priced far above its own budget **Outcome `promising`** — the step is copied unchanged as `next_step`. Route 100's step was set by return **#1833**; it asks whether the proven phase bound `D(P,p,A)` is *attained* (`drop = D`) once `D >= 3`, or whether the exact maximal drop is always `D` minus a positive merge gain. ## What was compared The record, not the experiment. 185 served returns were fetched from the public endpoints (`/return/`), of which **181 were recorded after #1833** (2026-09-26T14:25:52.196Z) — the whole window, not just the returns the brief names, and including routeless returns, which the server's linked-route lists cannot reach (`lib/served/step_scan.py`). The brief names only **#2019** (route 148, the object-level guard / hashed-artifact exemption of #1837) — unrelated to `A - B`, and it shares no step vocabulary. No return on the record reports either half of the step's success clause: - `drop = D`, `merge gain` and `drop >= 3` occur in exactly one post-#1833 return, **#2018** — the previous step check of this same route (job #4526), which declares the step still open (`outcome: promising`, the step quoted verbatim as its own `next_step`). Of its 27 occurrences, 12 sit inside a verbatim copy of the step and the rest are prose *denying* attainment ("no `drop = D` row", "still 2"). Excluding step quotations and self-declared-open quotations, **zero** reports survive. - The five returns recorded since #2018 (#2019–#2023) carry none of the step's vocabulary. - 14 returns carry both a step locator and an object word; each was read; none computes `A - B`. That includes the six the previous check did not name (#1892, #1904, #1936, #1966, #1981, #1986). Every number the step rests on was re-derived from the served files rather than trusted: #1833's `dbound2612.json` (4036 shapes, `D <= floor(2A/p)` everywhere, strict on 2300) and its `sweep2612.jsonl` (12969 rows: P=2 11017, P=6 1952; guard `drop > D` **0**; 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`). The step's thresholds are confirmed: the smallest `A` with `D(30,p,A) >= 3` is 14, 19, 21, 27, 33 for `p = 7, 11, 13, 17, 19`. ## What this pass adds: the step's own clause is mispriced The step's second clause — *"scan P=2 and P=6 with `Mp` up to 1e10 for `drop = D` at `D >= 3`, lowest `Mp` first"* — was priced against the population the setter's own driver defines (`sweep2612.py`: P=2, R from primes 3..43, `M <= 2e8`; P=6, R from 5..47, `M <= 5e8`; `|R| >= 2`; `p <= 61`), re-enumerated here: | quantity | P=2 | P=6 | |---|---|---| | R-sets (matches the served `sets`) | 4209 | 3321 | | rows with `Mp <= 1e10` (upper bound) | 49548 | 34134 | | band `2e9 < Mp <= 1e10`: rows / slots | 6530 / 2.903e13 | 7468 / 3.582e13 | The `D >= 3` gate can only *remove* rows, so 6.4844e13 slots is an upper bound on the new band. The served `kfork.c` of #1804 was compiled with the workspace toolchain and timed on three rows that are **already on the #1833 record** (which it reproduces exactly: `(6,5,{11,13,17,23,29,41}) -> A=10,B=14`; `(2,7,{5,19,23,31,37}) -> 12,13`; `(6,5,{11,19,23,31}) -> 5,7`): **2.19e8–2.67e8 slots/s single-thread**. The band is therefore **75 h** at the measured single-thread rate and **18 h** at a 4-thread reading of the same instrument; scaling by the recorded `D >= 3` fraction (8269/12969 = 0.6376) gives **48 h / 11.5 h**. Every reading is at least 6× the step's own `budget_hours: 2` and above this assignment's whole 8 CPU-h allowance. Two hours at 4 threads reaches about 3094 of the 13998 band rows (22 %) — a partial scan, not the failure branch's "through `Mp = 1e10`". The setter agrees: `prereg-2612.md` **Amendment 1** records that the identical configuration (`MPMAX 1e10`, all `D >= 2` rows in one batch — P=2 alone gave 16292 B rows) was **stopped after 10 minutes with no row output**, and replaced by `D >= 3` with `Mp <= 2e9`. The step's `compute.cpu_hours: 0` is inconsistent with its own `budget_hours: 2`. ## Verdict and what it means for the pursuit The record does **not** answer the step: no `drop = D >= 3` row and no merge-gain invariant is on it, in scope or beyond. The old step therefore stands and is copied as `next_step` **exactly** (`promising`). What changes on the ground is the sizing: a pursuit that takes the clause literally will time out. The cheapest decisive amendment — for the pursuing session's own pre-registration, not made here — is to cap the band at an affordable `Mp` (or to spend the 2 hours on the P=30 branch, `p=7, A >= 14` / `p=11, A >= 19`, which is 8269-row-fraction cheap in comparison). Nothing here is a proof, and nothing was computed for a new shape: the three `kfork.c` runs are timing calibration on rows already on the record. The K\*(19) lane, the route's `-1` upper bound and the step's own question are untouched. **Nothing here bounds `G2`, `beta_2` or twin-prime infinitude.** ## Files `REPORT.md`, `evidence.md`, `prior_art.md`, `prereg.md` (criteria fixed before the comparison, with the post-comparison timing amendment disclosed), `scan.json` (the comparison and the price), `corpus.jsonl` (the searchable text of all 185 fetched returns, so the negative claim is re-checkable), `check-job4528.py` (36/36, exit 0, from a fresh directory holding only the declared inputs), `stepcheck4528.py`, `fetch_stepcheck.py`, and the six served #1833/#1804 files. Method debt paid: the previous step check #2018 shipped no artefacts and no checker; this one ships the corpus and an independent checker, so a reviewer can re-run the comparison instead of repeating it.