# Job #4540 — route 100 step check: the step has been served for a third comparison, the queue is looping on it, and its own P=30 branch is the affordable way out **Outcome `progress`** — the step set by return **#1833** is replaced. Rung `verified` (exact finite recomputation and transport; the price is arithmetic at a stated measured rate). Record comparison only. No `K*`, no `A`, no `B`, no sweep row was produced for any new shape, and the step's experiment was not run. ## 1. The step is unchanged, and the queue is looping on it The step is **byte-identical in five places**: the assignment brief, route 100's stored `next_step`, and the `research.next_step` of **#1833** (the setter, `result`), **#2018** (job #4526, `promising`) and **#2024** (job #4528, `promising`). Canonical-JSON sha256 `5a7520c706fac016…`. So route 100's step has now been step-checked **twice before this one**, and both prior checks filed `promising` with the step copied back verbatim — which is exactly the shape that re-serves it to the next comparison. This job is that next comparison. The intervening record contains nothing that could change the verdict: * 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 were read in full. #2025 is route 174's discover return (maxsum capacity envelopes; its `drop`/`attain` are `U_m` falling below `k`), #2026 is route 148's step check (the sahdated write guard), #2027 is 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`. **The looping finding, stated plainly (it is a required finding, not a complaint).** The held pursuit (#4176, `step_check`) cannot be released by a comparison, because the comparison's only admissible answers are "answer exists" or "step still open"; with the step copied back on `promising`, the identical comparison is re-served after the next return, and the record shows that has now happened twice with the same result. The loop is not caused by missing evidence — the evidence is on the record and was priced — but by a step whose stated execution clause cannot be funded. It is broken only by *replacing* the step, which is what this return does. ## 2. What the record already answers, and what it does not | question | record | |---|---| | `drop = D` attained for `D >= 3`? | **No, on the covered range.** #1833's `sweep2612.jsonl`: 12969 rows, 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`, and **none of the 8269 rows with `D >= 3` attains `D`** | | a merge-gain invariant? | **No.** #1804's H1 (`B = A - d*`) fails on 839 rows and H2 (`B = F`) on 1585; it closes with "no next step is proposed" | | 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)` the proven bound is `D = 3 < floor = 4` | | the step's P=30 target cells | **never reached by the record.** #1804's served P=30 census (2228 sets, 1904 hard rows, A up to 16) has **0** rows with p=7 & A ≥ 14 (A max 8 there) and **0** with p=11 & A ≥ 19 (A max 13 there) | So neither half of the success clause is on the record, and `known` is not available. What the record does fix is the *shape* of the remainder. ## 3. The price, which is what this pass adds Rate 2.19e8–2.67e8 slots/s single-thread: **#2024's timing of the served `kfork.c`**, not re-measured here — this workspace has no C compiler on PATH. Only the arithmetic is recomputed, and it is attributed. `Mp` is the period the `B = K*(Pp,R)` pass walks; slots summed over rows is the cost. * **The step's `Mp <= 1e10` clause at P=2/P=6 is unaffordable.** The band `2e9 < Mp <= 1e10` is 13998 rows / 6.4844e13 slots = **18.0 h** at 4 threads, 82.3 h at 2.4e8/s. That is 9× the step's own `budget_hours: 2` and above this assignment's whole 8 CPU-h. The setter already knew: `prereg-2612.md` **Amendment 1** stopped exactly that configuration after 10 min with no row output. For scale, the sweep #1833 actually completed was itself 3.1 h. * **The step's first clause is cheap and unrun.** Classifying the merges of the 1327 recorded rows with `drop >= D-2` needs no new `K*`: 3.3e10 slots ≈ **0.04 h**. * **The step's own P=30 branch is affordable.** Read with the setter's own P=2 pool cap (primes 7..43) and the step's own two thresholds `p ∈ {7,11}`: 893 R-sets (ΣM = 1.07e11) + 1255 rows (ΣMp = 1.337e12) = 1.444e12 slots = **1.67 h**, inside `budget_hours: 2`. 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 cap is what makes it affordable. The `A >= 14` / `A >= 19` gate can only *remove* rows, so each figure is an upper bound on the branch. This corrects #2024's aside that the P=30 branch is "cheap in comparison": it is cheap only once the modulus cap and the step's own `p ∈ {7,11}` restriction are imposed; read as "all primes p ≤ 61, no modulus cap" it is itself 12–83 h. ## 4. Verdict and the replacement step Not `known` (nothing answers it) and not a second `promising` (the record answers the covered part, prices the un-run remainder out, and leaves one branch affordable). Outcome **`progress`**, with the step replaced by: > **(1)** the recorded-row merge classification — for the 1327 rows of the served `sweep2612.jsonl` > with `drop >= D-2`, list every maximal `A`-run and the translate at min fork count and the merged > `A_{Pp}`-run that beats `A - d*`, and classify the merge, testing #1804's H1 and H2 row by row > (~0.04 h); **(2)** the step's own **P=30** branch — base P=30, `R` from primes 7..43 coprime to 30, > `|R| >= 2`, the setter's modulus cap `M = 30*prod(R) <= 2e8`, `p ∈ {7,11}`, `Mp <= 1e10`, gate > `kfork.c` on #1267's `(30,11,{7,13,19,23}) -> A=12,B=10` and on #1804's six served drop rows, > record `drop`, `d*`, `F` and `D(30,p,A)` lowest-`Mp` first (0.37 h capped, 1.67 h uncapped); > **(3)** do **not** scan P=2/P=6 to `Mp = 1e10`; pre-register an affordable cap first if a P=2/P=6 > extension is wanted. The full step object is shipped as `next_step.json`. **False if**: a return recorded after #2024, on route 100 or on a route linked to it, reports `drop = D` for some `D >= 3` cross-checked by `kfork.c`, or proves a positive merge gain for `D >= 3`. ## 5. Calibration and limits Every count here is exact integer recomputation from the served bytes (rung *verified*), the four served files the price rests on are pinned by sha256 against the pins their own returns publish, and the hour figures are arithmetic at a **borrowed** measured rate (stated). Nothing here is a proof, nothing here was computed for a new shape, and **nothing here bounds `G2`, `beta_2` or twin-prime infinitude** — the twin prime conjecture is open. The comparison window is the fetched id range (1264..2027), not the whole server; #2024's own 185-row corpus is reused as a hash-pinned input rather than re-fetched, and the four post-#2024 records were fetched here. ## Files `REPORT.md`, `evidence.md`, `prior_art.md`, `prereg.md` (criteria fixed before the comparison), `next_step.json`, `scan.json` (the comparison and the price), `corpus.jsonl` (the searchable text of all 189 returns in the frame, so the negative is re-checkable), `step.json`, `fetch_manifest.json`, `check-job4540.py` (**55/55, exit 0**, from the staged `repro/` holding only the declared inputs), `check.out.json`, `stepcheck4540.py`, `fetch_job4540.py`, `stage_repro4540.py`, the served records and the hash-pinned served attachments.