# Job #4540 pre-registration — route 100 step check (comparison only) Attempt `0cc3128f59c81c0cdfa05b4ab6017339`. Written **before** any return is read for the comparison and before any number is computed. Amended only under a dated `## Amendment` section. ## What this job is A **step check**: compare route 100's next experiment (set by return **#1833**) against the returns already on record, and decide whether they answer it. The brief forbids running the experiment. **No `K*`, no `A`, no `B`, and no sweep row is produced for any new shape here.** The only new computation is a *price* (a population enumeration and a slot count), which is what a step check may add — the same class of work return #2024 added and was recorded for. ## The step under check (fixed; copied from the brief) > 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`? > > method: Reuse `sweep2612.jsonl` (rows with `D >= 3` at P=2 and P=6, all with `drop < D`) and > `kfork.c`: for each row with `drop >= D-2`, list every maximal `A`-run and translate at min fork > count and the merged `A_{Pp}`-run that beats `A - d*`, and classify the merge (end-extension > through a removed unkilled slot vs a different window). Then scan P=2 and P=6 with `Mp` up to > `1e10` for `drop = D` at `D >= 3`, lowest `Mp` first, and P=30 rows with `p=7, A >= 14` or > `p=11, A >= 19` (the smallest `A` where `D(30,p,A) >= 3`). > success: A row with `drop = D >= 3` (cross-checked by `kfork.c`), or a proven lower bound on the > merge gain for `D >= 3` that matches the observed maximal drops. > failure: No `drop = D` row for `D >= 3` through `Mp 1e10` and no merge-gain invariant: record the > observed max drop per `(P,p,D)` and stop. > budget_hours: 2, compute: {ram_gb 2, disk_gb 1, cpu_hours 0} The step string is hashed (below) so that "unchanged" is a byte fact, not a reading. ## Questions, fixed before the comparison is read **Q1 — is there anything newer?** Does any return recorded *strictly after* #2024 carry either half of the step's success clause (`drop = D` for some `D >= 3`, or a merge-gain invariant), or compute the step's own object `A - B` = `K*(P,R) - K*(Pp,R)`? *Positive branch:* name it, quote it, and report what it settles. *Negative branch:* the step is unchanged since #2024. **Q2 — is the queue looping on this step?** Has this exact step already been the subject of a step check on this route? If Q1 is negative and the step string is byte-identical to the one those checks compared, the looping finding is recorded as a required finding (one paragraph), not as a complaint. **Q3 — is the un-run remainder the whole question, or a priced-out tail?** Two numbers, both recomputed from the served artefacts rather than trusted: 1. *Covered range.* `sweep2612.jsonl` and `dbound2612.json` (both served with #1833): rows, the `drop > D` guard, the number of rows with `drop >= 3`, the rows attaining `drop = D`, the maximum attained `D`, and the smallest `A` with `D(30,p,A) >= 3`. 2. *Price of the step's own branches.* (a) The P=2/P=6 band `2e9 < Mp <= 1e10` that #1833 did not run; (b) the step's **P=30 branch**, priced here for the first time as an exact population: every `R`-set matching the setter's own driver convention (`|R| >= 2`, `R` from primes coprime to 30, no `A` gate — the `A` gate can only *remove* rows, so the enumeration is an upper bound) crossed with every prime `p <= 61`, `p !| 30`, `p not in R`, `Mp = 30 * prod(R) * p <= 1e10`, counted in rows and in `sum(Mp)` slots. The step's `p=7, A >= 14` / `p=11, A >= 19` clause restricts `p` to `{7,11}`; the all-`p` figure is reported alongside as the wider upper bound. ## Outcome rule (fixed now, before any of Q1–Q3 is read) * If **Q1 positive** → outcome per what the answering return reports. * Else if the record answers the step's question over the whole range the step claims → `known`. * Else if the record answers the **covered** part negatively **and** kills the un-run remainder on price grounds **and** at least one branch of the step is affordable → `progress`, with the old step **replaced** by that affordable branch (a step that cannot be executed within its own `budget_hours: 2` must not be copied forward a third time; copying it again is what keeps the loop alive). * Else if **no** branch of the step is affordable → `progress` is **not** justified by price alone: fall back to `promising` with the step copied exactly and state the obstacle in `evidence_md`. **Affordability criterion, fixed now:** a branch is affordable iff its `sum(Mp)` slots cost `<= 2 h` at the rate #2024 measured for the served `kfork.c` (2.19e8–2.67e8 slots/s single-thread) and `<= 8 CPU-h` at the conservative single-thread end. This workspace has **no C compiler on PATH**, so the instrument rate is *not* re-measured here; it is taken from #2024's artefact and attributed as such, and the arithmetic is recomputed independently. **Falsifier of the `progress` verdict:** a P=30 branch price above 8 CPU-h at the conservative single-thread rate. Then the honest outcome is the `promising` fallback above. ## Calibration boundary (fixed now) Everything here is *verified finite computation* or *transport/hashing*. Nothing here bounds `G2`, `beta_2` or twin-prime infinitude, and nothing here is a proof about the twin prime conjecture. The step's question is about this department's own `D(P,p,A)`; no external source can settle it, so no literature survey is run (the brief assigns a comparison, not a pursuit). ## Amendment 1 (2026-09-28, after the comparison was read) — disclosures, no criterion changed The outcome rule above was applied exactly as written; nothing in it was relaxed or moved. 1. **The P=30 price was extended after the first figure.** The prereg fixed the *criterion* (affordable iff the branch's `sum(Mp)` fits 2 h at the attributed rate), not the branch's exact definition. Two readings of the step's own P=30 clause were therefore priced and both are in `scan.json`: the step's `Mp <= 1e10` clause alone with the setter's P=2 pool cap (primes 7..43) gives 1.67 h, and adding the setter's own modulus-cap convention (`M = 30*prod(R) <= 2e8`) gives 0.37 h. Both are inside the budget, so the verdict does not depend on which reading is taken. 2. **A served artefact read after the prereg changed the *replacement step*, not the rule.** #1804's served `sweep2785.json` is a P=30 census (2228 R-sets, 1904 hard rows, exhaustive full periods) whose `A` never reaches 14 at `p = 7` (max 8) or 19 at `p = 11` (max 13). That is the record evidence that the step's two P=30 target cells are **unrun**, and it is why the replacement step is aimed at base P=30 rather than at a capped P=2/P=6 extension. It was found among the step's own `required_sources`, which the brief already directs a step check to compare against. 3. **A data-derived observation is recorded rather than predicted.** At the step's own `p = 7` threshold `(30,7,14)` the proven bound is `D = 3 < floor = 4`; at the four other thresholds `D = floor`. This is a finding about #1833's table, not a pre-registered criterion. 4. **Reused work is disclosed.** #2024's 185-row `corpus.jsonl` is reused as a hash-pinned input rather than re-fetched; this job fetched only ids 2024..2027 and probed 2028..2060 for absence. The prereg did not state that reuse, so it is recorded here.