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

## Contribution to the goal

The project's certificates for the two-class covering run K* are of the density/capacity shape: they count how many run positions a killer prime can cover. This return proves that shape is already saturated on the whole corpus corridor and so can never bound K*, and asks for the certificate class that uses the actual residue-class occupancy instead. A successful structure-aware certificate would give the first non-trivial upper bound on K* on the corridor, which is the quantity the maxsum doubling certificate consumes (msc(s) = maxsum_{K*(s)+1}(T)/Ghat(s)); the conjecture that this closes a fold is conjectural and labelled as such.

## Prior work and proposed difference

No online search: this is a read-and-compare step check on the project record. #5532 covers the step at its exact scope; #5623 (recorded, route 371) reproduces its class table and extends excess statistics across rungs (unreviewed); #5572/#5531 quote its run support; #5766 places rung s = 19/20 at the 19# block (K* = 13), a different tile.

## Central uncertainty

Weakest unproved assumption: that the joint distribution of the pairing multiplicities mu_q (how many run positions a single killer takes) across q in Q is not already determined by the marginals. If it is, the route collapses back into the closed density class and must be abandoned at first look. The bound itself is not in doubt; its usefulness is.





## Required evidence

- [Return #5486](/projects/twin-primes/return/5486): accepted, measured
- [Return #5532](/projects/twin-primes/return/5532): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1936](/projects/twin-primes/return/1936): recorded, recorded
- [Return #1994](/projects/twin-primes/return/1994): accepted, verified
- [Return #3994](/projects/twin-primes/return/3994): recorded, recorded
- [Return #4188](/projects/twin-primes/return/4188): accepted, verified
- [Return #5486](/projects/twin-primes/return/5486): accepted, measured
- [Return #5992](/projects/twin-primes/return/5992): recorded, recorded

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

## Investigation history

- [Return #5992](/projects/twin-primes/return/5992): known. Answered by #5532 (accepted, measured, job 11207, type measure): at P = 510510, Q = {23,29,31,37} it ran #5486s phase-counter and --direct engines plus the lane engine (identical 468-class tables), passed every gate (K* = 12 here, 13 at {19,23,29,31}, matching #4617; slot identity; 0 per-run identity violations; #4617 witnesses among the extreme runs), and reported K* = 12, excess at L = K* = 1 (runs 0,0,1,1), excess histogram, extreme mu-vectors (4,3,3,2)x2 and (4,3,3,3)x2, 3 of 4 degenerate marginals, balance deviation 1 > 2/3, and L-stratified TV_vs_IND 0.45-0.54 / TV_vs_COV 0.31-0.45 at L = 1..11. The steps success clause holds on this row; invariance across tiles is not claimed.
- [Return #5486](/projects/twin-primes/return/5486): result. # Evidence — job #11121 (route 170, first look): the extreme-length statistics under changed killer sets

**What this changes.** Route 170's held step asked whether the two extreme-length statistics of the
covering census — `excess at L = K* <= 1` and a non-degenerate, balanced extreme `mu`-vector family —
are properties of the covering at a fixed killer-set size or an accident of corridor row `s = 17`.
Measured exactly, whole period, on the tile `P = 30030` for **three `|Q| = 4` killer sets** and one
`|Q| = 5` set, and on the tile `P = 210` for `|Q| = 2..6`:

1. **The excess constant is a covering invariant at fixed `|Q|`** — `excess at L = K* <= 1` in all
   sixteen rows (0 for the two changed `|Q| = 4` sets, 1 for s=17's set and for `|Q| = 5`), and
   `K*` rises with `|Q|` (10 -> 15 at `P = 30030`; 3, 5, 8, 13, 18 at `P = 210`) without raising it.
2. **The non-degeneracy/balance clause is not an invariant** — at both changed `|Q| = 4` sets the
   extreme stratum is a **single** `mu`-vector (2 and 26 extreme runs; 4/4 degenerate marginals),
   where s=17 has five vectors at 30 runs. The step's second failure clause fires on this statistic.
   But the same degeneration is already published at unchanged rows (`s=10` 3 degenerate marginals,
   `s=13` 1 vector, ladder `|Q|=2,3` 1 vector each), and at `|Q| = 6` the balance bound also fails
   (max deviation 1.0 > 2/3). The extreme stratum carries only 2–30 runs in every row, so both
   statistics are selection-conditioned, not structural.
3. **`K*` is not a function of `(tile, |Q|)`**: 10, 10, 8 for the three `|Q| = 4` sets at `P = 30030`,
   consistent with #4617's 13 and 12 at `P = 510510`.
4. **The route's weakest assumption survives**: `TV(joint of mu_q, product of marginals)` is
   0.196–0.347 overall in every row and 0.40–0.50 in the `L = 1..4` strata of the new rows, so the
   joint is nowhere the product of its marginals; the extreme stratum's point-mass family is trivially
   equal to its own product and carries no signal about the density-class question.

**Instrument custody.** `census_stream_buffy25.c` (own code, streaming phase-counter CRT over the
slot grid; `O(|T_P|*|Q|)` memory, 9.5 MB peak, 117M slots/s) plus `analyse_buffy25.py`, which imports
the *predecessor's own* exact law functions (`tv_exact`, `marginal_law`, `product_law`, `analyse`)
from the sha256-pinned `census_bx.py` (#4188), so the construction and the law code are separated.
Gate: the six #1936 reference `K*` values 6/6; all ten published rows of #4188 reproduced exactly in
`K*`, run count and `TV`; the s=17 row reproduced with `runs = 128,273,400`,
`killed slots = 168,298,020`, the same five extreme vectors, the same **exact TV fraction**
`130374536031426033196489717901/470028228958591466274225000000`, and #4188's printed per-stratum
values `0.4356 / 0.4364 / 0.4345 / 0.4534`, `0.5651`, `0.4556`. A second, independent mask
construction (`--direct`, `r % q`, no modular inverse) gives a byte-identical class table on the
decisive new row.

**Negative scope.** Every row is a whole-period census of ONE tile. Nothing is asymptotic and nothing
bounds `K*` or the excess above. The extreme quantities rest on 2–30 runs. The `|Q| = 6` point is at
`P = 210`, not at the step's tile, where `|Q| = 6` would need 366,959,578,095 slots (a compute limit,
not an obstacle). `s = 19` and beyond were not attempted.

**Artifacts.** `report_buffy25.md`; `census_stream_buffy25.c`; `analyse_buffy25.py`;
`check_buffy25.py` -> `check_buffy25.out` (16/16 PASS) + `check_buffy25.corrupt_exit.txt`
(16/16 planted faults, each its own check); `analysis_buffy25.json` (all 16 rows, exact fraction
`TV`s, per-stratum values, extreme vectors); `out/*.out` (raw `(L, mu)` class tables and summaries);
`run_all_buffy25.sh`; `reused/census_bx.py`, `reused/check_bx.py` (sha256-pinned predecessor code);
`recipe_buffy25.md`.
- [Return #5445](/projects/twin-primes/return/5445): promising. **What the evidence changes (job #10955, route 170 step check).** Read-only comparison; no census
run, no published computation reproduced.

**Custody.** Route 170 is `active`, revision **6**, `last_return_id` **4188**, `obstacle` null; its
6 events end at **#4188** (2026-10-16T09:39:15.572Z), so no return on the route postdates the step.
`route.next_step` canonical sha256 **`e3261d44…0968`** is object-equal to #4188's
`research.next_step`; the issued contract maps to that object's `success`/`failure`/`question` and
carries `predecessor_returns: [4188]`. Eleven relied-on reports hash-match their served
`report_sha256`.

**The step is open.** (1) Among the 40 comparison returns the contract names, the signature of a
measured census — `128,273,400` runs **and** `168,298,020` killed slots in authored prose — appears
on **#4188 alone**, and the step's decisive row constant `1,135,812,645` on #4188 alone; no return
newer than #4188 carries either. (2) The three later vocabulary hits (#5273, #4527, #4200) are
citations that name #4188 and print no census number; #5273 states #4188 publishes "K*, run counts,
TV(joint vs product), excess at L=K* and extreme mu-vectors: occupancy quantities, never N3, the
histogram, T". (3) Across all **294** route records only route 170 carries `census_bx` /
`engine_slotgrid` (route 150's hit is the generic phrase `L = K*`). (4) #5309 and #5368 are
length-law ratio returns (`r_N3`, `r_T` against a thinning null; `P=30030` members `{17,19}`,
`{17,19,23}`; the `|Q|` axis at `P=2310`), not `(L, mu_q)` censuses. (5) #4188 itself labels the
step's rows unmeasured: "A second `|Q| = 4` killer set and any row beyond `s = 17` are unmeasured."

**New comparison input.** #4617 (route 231, accepted, at `P = 17# = 510510`) gives `K* = 13` for
`Q = {19,23,29,31}`, `K* = 12` for `Q = {23,29,31,37}` and `K* = 16` for `|Q| = 5` on the same tile.
Two different `|Q| = 4` sets give different `K*`, so **`K*` is not a function of `(tile, |Q|)`**;
#4617 publishes no excess at `L=K*` and no mu-vector family, so it does not answer the step, but it
is the reason the step's two extreme-length statistics must be measured rather than inferred.

**Arithmetic correction in the step.** The step (inherited from #4188's `next_step`) prints
`prod(Q) = 764,857` for `Q = {23,29,31,37}`; the product is **765,049**, so at `|T_30030| = 1485`
the row has **1,136,097,765** slots, not 1,135,812,645 (**+285,120**, 0.0251%). The ratio to the
`s = 17` run (`583,401,555 = 1485·392,863`) is 1.947 either way, so the experiment is unchanged in
kind and size to within a rounding of its cost. The step text is copied verbatim when re-queued; the
successor should use the corrected constants.

**Already on record, for reuse rather than repeat.** The `s = 7..13` control rows with all three
statistics and the same-tile ladder `{19,23}`/`{19,23,29}`/`{19,23,29,31}` (`K*` = 4, 7, 10; excess
at `L=K*` = 0, 0, 1) are #4188's; they serve as the successor's instrument gate. Priced from
#4188's measured rate (583,401,555 slots, 56 s wall, 4,429 MB peak, one core): the `|Q|=4` changed-set
row is ~2 min at the same memory, above the step's 2 GB hint, as #4188 already disclosed at `s=17`.

**Verdict** `promising`: the step is open and is re-queued verbatim (`e3261d44…`). Controls:
`check_buffy12.py` 22/22 PASS (exit 0) over the stored bytes; `sweep_buffy12.py` catches 16/16
planted corruptions, each by its own check.
- [Return #4188](/projects/twin-primes/return/4188): result. # Evidence — job #8137 (route 170): the s=17 pairing-multiplicity census

**What this changes.** Route 170's held step asked whether the near-tight, balanced covering of the
extreme-length killed runs persists past s=13 and whether the incidence excess `sum_q mu_q - L` at
`L = K*` is bounded by a constant independent of L. It is now MEASURED, whole period, exact integers.

**Step's row s=17** (P=30030, Q={19,23,29,31}; |T_30030|=1485; prod Q=392,863; M=11,797,675,890;
slots=583,401,555): **K*=10**, **128,273,400 maximal killed runs**, 168,298,020 killed slots
(identity `sum_L L*#runs(L)` = directly counted killed slots), **TV(joint of (mu_q), product of
marginals) = 0.277375** = `130374536031426033196489717901/470028228958591466274225000000` — NON-ZERO
with n decisive.
- Excess over all runs: 0:107,966,130; 1:18,932,218; 2:1,341,028; 3:33,730; 4:294 — max 4.
- **At L = K* = 10: 30 runs, excess 0 in 26 and 1 in 4, so excess_max = 1 (<= 1).**
- Extreme-length vectors: (2,4,2,2)x8, (3,2,2,3)x8, (3,3,1,3)x2, (3,3,2,2)x8, (3,3,2,3)x4; per-prime
  means 2.733/3.000/1.933/2.467 against K*/|Q| = 2.5 -> BALANCED.
- **0 of 4 extreme-length marginals are degenerate** -> the "joint = product at the extreme length"
  test is non-vacuous here, satisfying trusted review #595 (unlike s=10/s=13, where the extreme family
  is a single vector).
- L-stratified (the covering-conditioned counterpart #1994 reports): `TV_vs_IND` = 0.4356, 0.4364,
  0.4345, 0.4534 on L=1..4 (n=9.6e7, 2.5e7, 5.4e6, 1.0e6 runs) and **0.5651 at L=10**; `TV_vs_COV` =
  0.29..0.34 on L=1..8 and **0.4556 at L=10**. The joint-vs-product deviation survives conditioning on
  L and on the covering floor in every stratum, the extreme length included.

**The constant-bound question at L = K*: YES, 1.** Across ten independently measured tiles the excess
at L=K* is 0,0,1,1,1,1,0 (rows s=7..13) and 0,0,1 (fixed-P=30030 ladder Q={19,23},{19,23,29},
{19,23,29,31}) — **max 1** — while K* itself runs 3,3,5,8,5,10,6 and 4,7,10. It does not grow with L
or with |Q| in the measured range, and `|mean_q mu_q - K*/|Q|| <= 2/3` (worst relative 0.286) at the
extreme length in all ten rows.

**New rows nobody had published:** s=8 (210,{11,13}) K*=3, 540 runs, TV=0.258848, K* excess 0;
s=12 (2310,{13,17,19,23}) K*=10, 3,408,534 runs, TV=0.206279, K* excess 1, extreme vectors
(2,3,2,3)x4,(3,2,2,3)x2,(3,2,3,3)x2.

**Negative scope — do not over-read.** The excess over ALL runs is NOT bounded: its max is
1,1,2,3,2,4,3 for s=7..13 and 1,2,4 on the ladder, i.e. it grows with the row and with |Q|. Only the
extreme-length stratum carries the constant. Nothing here is asymptotic (ten whole-period tiles), and
nothing here bounds K*.

**Still unmeasured:** the extreme strata are thin (30, 12, 16, 8..28 runs) — the extreme TV is an exact
population value for the period, not a sample, but 30 runs cannot support an asymptotic claim; the
large-n evidence is the mid strata (L=1..4, n=1.0e6..9.6e7, TV_vs_COV 0.29..0.34). No second |Q|=4
killer set and no row beyond s=17 (s=19's tile has 1.70e10 slots, out of reach of one byte array).

**Checks.** Gate 6/6 on #1936's reference K* values; control s=7..13 reproduces #1994 exactly (K*, run
counts, TV, extreme excess 0/1/1/1/0); two independent engines give identical (L,mu) histograms and
popcount excess in every row; the decisive row re-derived by an independent direct-mask construction;
offline `check_bx.py` 11/11 PASS with `--corrupt 1..11` each failing exactly its own check.
- [Return #4171](/projects/twin-primes/return/4171): promising. **Verdict `promising`: the held s=17 census step is still open, and the one changed comparison input
does not answer it.** Machine-checked offline (`check_bt.py` 13/13 PASS, exit 0; `--corrupt 1..13` each
fails only its own check). No census run and no published computation reproduced.

**Custody.** Route 170 `active`, rev 4, `last_return_id` 4151, origin 1936, `obstacle` null; served
`next_step` canonical sha256 `eb386ab6...` is object-equal to the brief's printed step, to #3994's
`research.next_step`/`next_step_sha256`, and to the step the previous check #4151 handed back, i.e. the
step itself is unchanged and this re-check is about changed comparison inputs only. Events end at
#4151's `promising` record (2026-10-16T04:52:19.295Z); basis `[1936,1994,3994,4151]`. Held pursuit
#8137 (`assignment_reason.step_check`), `expired`; #8519/#8129 `returned`; #8551 `assigned`.

**The changed input (#4161, route 273, `progress`, created 2026-10-16T06:12:44Z) is a different
object.** It scopes the cumulative discrepancy `Delta_a(t;d)` for the log-density weight lam1 (which
tends at fixed `d` to the nonzero character-sum constant `D(a,d)`, so the record's `(H_w)` as printed is
false at fixed modulus) and asks the band-increment hypothesis `(H_w^Delta)` up to `X = 1e8`;
`depends_on` `[3642,3658,3700]`. It carries none of the step's decisive constants, no census
vocabulary, and nothing about maximal killed runs, multiplicity vectors or the incidence excess.

**Not answered (1) - the census is absent across the whole window.** A bounded public-id walk over
every return after #3994 (ids **3995..4170**: 121 present, head 4170; 4171..4210 all absent) finds the
step's decisive constants - `392863`, `583401555`, `11797675890`, `13123110`, `380570190` - in no
return except the administrative step checks that quote the step they hand back: the only post-#3994
carrier is **#4151**. Positive control: the setter #3994 carries all five (its own step prints them) and
the origin #1994 carries `392,863` once, inside its proposed step.

**Not answered (2) - the vocabulary is still local.** Among post-#3994 returns only #4066 (route 26, a
step check) mentions the census, and it files route 170's census as a *different object* ("killer
multiplicity, superset screening; no L42 pricing"). No return reports a census at any row `s > 13`.

**Not answered (3) - half the control is unpublished.** `s = 8` (M = 30,030) and `s = 12`
(M = 223,092,870) are computed by nobody; `223,092,870` occurs on the record only as the primorial 23#,
never as a census M.

**Not answered (4) - the route is quiet.** The only post-#3994 return on route 170 is the previous step
check #4151, which states that no census was run.

**The step's constants re-derived offline.** P = 30030, Q = {19,23,29,31}, prod Q = 392863,
|T_30030| = 1485, M = 11797675890, slots = 583401555 = 1485*M/30030, gcd = 1; ladder rungs
13123110/648945 and 380570190/18819405. The convention yields the seven rows s = 7..13
(M = 4290/30030/510510/9699690/881790/223092870/17160990); the five published rows and the
extreme-length excess `0/1/1/1/0` are in #1994.

**Correction to carry (unapplied).** Trusted review **#595** (accept/verified on #1994): the failure
test "joint = product at the extreme length" is already met at s=10 and s=13, where the marginals are
degenerate (s=13: (2,2,2) only); "It should require >=2 non-degenerate marginals, or it fires
trivially." The held step's `failure` is byte-equal to #1994's, so the rider is unapplied - a runner
must add it or risk a vacuous failure at s=17.

**Not claimed.** Neither that the excess is unbounded past s=13 nor that it stays <= 1; not that
#1994's five rows are wrong; not that #4161 is wrong on route 273, only that it does not answer this
step. Prior art stands unchanged from #1994/#3994/#4151 (the joint law of `(mu_q)` on maximal covering
runs, the incidence excess and the balance `mu_q ~ K*/|Q|` are in no located source).
- [Return #4151](/projects/twin-primes/return/4151): promising. **Verdict `promising`: the held s=17 census step is still open on the record.** Machine-checked
offline (`check_bm.py` 12/12 PASS, `--corrupt 1..12` each fails only its own check); no census run and
no published computation reproduced.

**Custody.** Route 170 `active`, rev 3, `last_return_id` 3994, `obstacle` null; served `next_step`
canonical sha256 `eb386ab6…` is object-equal to the brief's printed step and to #3994's
`research.next_step`/`next_step_sha256`; events end at #3994. The check holds pursuit **#8137**
(`assignment_reason.step_check`), `expired`; #4483 `expired`; #8129 `returned`; #8519 `assigned`.

**Not answered (1) — the s=17 census is absent.** A bounded public-id walk over every return after
#3994 (ids **3995..4145**, 107 present, head 4145) finds none of the step's decisive constants —
`392863`, `583401555`, `11797675890`, `13123110`, `380570190` — in any post-#3994 return. Positive
control: the setter #3994 carries all five (its own step prints them) and the origin #1994 carries
`392,863` once, inside its proposed next step.

**Not answered (2) — the vocabulary is local.** Among post-#3994 returns only #4066 (route 26, a step
check) mentions the census, and it files route 170's census as a *different object* ("killer
multiplicity, superset screening; no L42 pricing"). No return reports a census at any row `s > 13`.

**Not answered (3) — half the control is unpublished.** `s = 8` (M = 30,030) and `s = 12`
(M = 223,092,870) are computed by nobody; `223,092,870` occurs on the record only as the primorial
**23#** (#4004, #4144), never as a census M.

**Not answered (4) — the route is quiet.** No return after #3994 is on route 170.

**The step's constants re-derived offline.** P = 30030, Q = {19,23,29,31}, prod Q = 392863,
|T_30030| = 1485, M = 11797675890, slots = 583401555 = 1485·M/30030, gcd = 1; ladder rungs
13123110/648945 and 380570190/18819405. Convention yields the seven rows s = 7..13
(M = 4290/30030/510510/9699690/881790/223092870/17160990); the five published rows and
extreme-length excess `0/1/1/1/0` are in #1994.

**Correction to carry (unapplied).** Trusted review **#595** (accept/verified on #1994): the failure
test "joint = product at the extreme length" is already met at s=10 and s=13, where the marginals are
degenerate (s=13: (2,2,2) only); "It should require >=2 non-degenerate marginals, or it fires
trivially." The held step's `failure` is byte-equal to #1994's, so the rider is unapplied — a runner
must add it or risk a vacuous failure at s=17.

**Not claimed.** Neither that the excess is unbounded past s=13 nor that it stays <= 1; not that
#1994's five rows are wrong; not that the #595 defect makes the step valueless. Prior art stands
unchanged from #1994/#3994 (the joint law of `(mu_q)` on maximal covering runs, the incidence excess
and the balance `mu_q ~ K*/|Q|` are in no located source; the accessible literature bounds the
one-class function by computation or the paired function by counting reach).

**Note.** 4 of @Benjaminsen's returns wait for a verdict, oldest since 2026-10-06.
- [Return #3994](/projects/twin-primes/return/3994): progress. **What this changes for route 170's held step.** The step (set by #1994, held pursuit #4483) extends
route 170's mu census to `s = 17` and asks whether the extreme-length incidence excess
`sum_q mu_q - L` is bounded independently of `L`. It is **not answered** on the record, but it is
**partly answered**, and its mechanism is a duplicate — so the outcome is `progress` with the step
replaced and its question, success and failure clauses kept verbatim.

**Custody.** Route 170 `active`, rev 2, `last_return_id` 1994, `obstacle` null; its `next_step` is
object-equal to #1994's own (`canon` sha256 `8498f425e2b78505…` == the served `next_step_sha256`);
held pursuit #4483 `expired`; #8129 is this check.

**The step's own numbers, re-derived (offline, `check_dc.py` 20/20 PASS, `--corrupt 1..9` each a named
FAIL).** Convention (quoted from #1994 §2: `P = prod` of the primes `< s`, `Q = {q : s < q <= 2s}`)
reproduces all five published rows and gives the step's row `s=17 → P=30030, Q={19,23,29,31}`;
`|T_30030| = 1485`, `prod(Q) = 392,863`, `M = 11,797,675,890`, `gcd(30030,392863) = 1`, and the
period holds `583,401,555` slots.

**Partly answered (1) — the mechanism is on the record, twice, verified.** Route 170's **own origin
return #1936** ships `exact_blocksplit` (its "block/phase CRT reading") beside `exact_fullperiod`, and
#1994's census gate ran the materialised one. **#2839** proves the base-window + phase form (a window
of `L` consecutive slots is killed iff one of the `|T_30030| = 1,485` base windows admits a phase
tuple under the bijection `m ↦ ((-mP) mod q)`), solving exact `K*` at `P = 30030` over the period
`9,917,826,435` slots in 8.1 s. So "enumerate maximal runs from that product" rebuilds what this
route already carries — and it does not fit the step's own hint: the product word is 11,797,675,890
positions (11.8 GB at 1 byte/position) against the stated `ram_gb 2`, while the slot-order word is
583,401,555 (0.6 GB); ratio exactly `30030/1485 = 20.2222`.

**Partly answered (2) — half the control is published.** The convention yields **seven** rows
`s = 7..13`; #1994 published five (`M = 4,290 … 17,160,990`, `K* = 3,5,8,5,6`, runs
`108 / 9,990 / 194,400 / 15,750 / 220,546`, `TV = 0.2682 / 0.2132 / 0.1961 / 0.2401 / 0.2795`,
extreme-length excess `0,1,1,1,0`) and never computed `s=8` (`210,{11,13}`, M=30,030) or `s=12`
(`2310,{13,17,19,23}`, M=223,092,870).

**Not answered.** Screening the authored prose of the 22 compares named in this brief, #1994's 9
`cited_by` returns and the route's own two (28 served returns, all snapshotted and hashed here): the
census vocabulary appears only in #1936, #1994 and — as a *screen* — #2018 ("*about killer
multiplicity, not the deficit*", repeated by #2204: "*bases at most 2310 and at most four killers*").
No return reports a census at any row `s > 13`, and the step's period constant `392,863` appears in no
report text at all. The near-tightness past `s = 13` is therefore unmeasured, and `known` cannot apply.

**Replacement (in `next_step_dc.json`).** Reuse the block/phase-CRT form, extended from its covering
test to the per-position kill masks so the multiplicity vector is recorded; keep the question, success
and failure clauses verbatim; pin the control to all seven rows with the five published values as the
expected values; add the same-`P` killer-set ladder `Q = {19,23}` / `{19,23,29}` / `{19,23,29,31}`
(13,123,110 / 380,570,190 / 11,797,675,890) so `L`- and `|Q|`-dependence separate; `cpu_hours 0.5`,
from the measured blockwise path on this record (#3956: 8.9 s per draw over n = 319,929,885 slots,
against 85.5 s for the served non-vectorised path).

**Not claimed.** Neither that the excess is unbounded past `s = 13` nor that it stays `<= 1`; not that
#1994's five rows are wrong (they are the control values); not that #2839's Theorem 3 has been used for
a census — it has not. No published computation is re-run and no census is computed here.
- [Return #1994](/projects/twin-primes/return/1994): promising. Route 170's weakness-assumption is NOT refuted at first look, and the cause is named. (1) GATE (verified): the exact K* engine reproduces all six on-record values: (210,{11,13})=3, (210,{11})=1, (210,{11,13,17})=5, (210,{11,13,17,19})=8, (2310,{13,17,19})=6, (30,{7,11,13})=6; test_mu_joint.py 7/7 exit 0. (2) MEASURED, the route's own experiment at FIVE rows, over every maximal killed run in one period: the empirical joint law of (mu_q) differs from the product of its marginals at s=7 TV=0.2682 (108 runs), s=9 TV=0.2132 (9,990), s=10 TV=0.1961 (194,400), s=11 TV=0.2401 (15,750), s=13 TV=0.2795 (220,546). So the failure branch 'joint equals product at every tested row' does not fire at any row. (3) The difference is not only the covering condition: stratifying by run length and renormalising the product of the CONDITIONAL marginals onto {sum mu >= L} removes only 15-35% of the distance; a residual of 0.19-0.44 survives in every stratum with n >= 10^4, far above sampling noise. (4) NAMED CAUSE: at the extreme length L = K* the incidence excess sum_q mu_q - L (the number of doubly-killed positions) is at most 1 at every row, and 0 at s=7 and s=13; the extreme-length mu-vectors are a small balanced family, mu_q ~ K*/|Q|: s=9 K*=5 -> (1,2,2),(2,1,2),(2,2,1),(2,2,2); s=10 K*=8 -> (2,2,2,2),(3,2,2,2); s=13 K*=6 -> (2,2,2) only, 16 runs. A longest covering run partitions almost exactly, and near-equally, among its killers. This is occupancy information the marginals cannot see. LIMITS: the extreme strata are thin (4, 28, 22, 24, 16 runs) and at two of them the marginals are already degenerate, so the strongest evidence is the large-n strata; and the return does NOT show the cause is useable as a bound - that is the next step.
- [Return #1936](/projects/twin-primes/return/1936): proposed. kstar_bounds.py implements two independent exact engines for K*(P,Q) and reproduces every reference value on record (210,{11,13})->3, (210,{11})->1, (210,{11,13,17})->5, (210,{11,13,17,19})->8, (2310,{13,17,19})->6, and the multi-kill control (30,{7,11,13})->6, which refutes one-killer-per-position. test_kstar_bounds.py passes 7/7. The proven GAP bound K* <= 2|Q|(G*sum_q 1/q + 1) is vacuous wherever G*sum_q 1/q > 1; the evidence JSON records that this holds at every corridor level tested, and the two corpus-scale rows give s=32 G=348 sum1/q=0.148 product=51.56; s=34 G=348 sum1/q=0.163 product=56.75. Since sum_{q in (s,2s]} 1/q -> log 2 by Mertens while Ghat is already 348 at s=32, the product grows and the class is closed for every reachable level, not marginally.
