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

## Contribution to the goal

A reusable proof-contract adapter for route173, staircase-note and tailcount-transport, applied to an existing certificate before investing in a larger ladder.

## Prior work and proposed difference

# Prior art for route 210's base-17 step — what answers it, and what does not

## The step and its setter

- **#5149** (recorded, job 10171) repaired and set the step: base 17 (17#, D = 22275, W = 510510),
  entering primes Q = {19,23,29,31} = (17,34], all 19·23·29·31 = 392863 assignments, both bridges
  of #3053 checked at every assignment, the served K\* engine row 17#->31# tied by 14 N_k
  identities, N_1 in closed form, the CRT copy, the base-13 physical control, and a secondary
  {19,23,29} marginal. Canonical sha256 `31f59a38…` is still the route's `next_step`.

## The covering return

- **#5434** (`measure`, **accepted** at `measured`, verification `rerun`, job 10897, 2026-10-22;
  `cites` 5149, 3619, 3053, 2476, 2022; route-less, coverage in association 400) ran the step:
  - branched `bridge_bv.py` (sha256 `9cc8654c…`, diff 282+/5− against the served #3619 file
    `d41512c9…`), 102 precomputed kill masks, 392863 assignments, 338 CPU-seconds;
  - **0 failures of bridge (a) and 0 of bridge (b)** over all four primes;
  - **K\* = 13, attained by six assignments, none of whose first windows wraps**; N_14 = 0, so the
    value is exact; the K histogram over the torus rule reaches rung 13 with six assignments;
  - **N_k = the served census at 14/14** in the physical convention (`census_17_31` equals the 14
    values of `attack-kstar-01.js` line 765), 9/14 under the served torus rule with k = 3..7
    differing — filed as a convention finding, not normalised;
  - **N_1 = 22275 · 113332 = 2524470300** in closed form and by enumeration;
  - **CRT copy** c = 135605 mod 392863, 13 consecutive killed slots, both neighbours surviving
    (gap 294); five further extremal rows at gaps 294/330, all checked on the integers;
  - **base-13 control**: branched JSON byte-identical to the served pin `9640e166…`, K\* = 8,
    start 248, no wrap, kills 3/2/3, union 8, collisions 0; the literal 13#->23# walk gives
    K\* = 8 and G2 = 204, the engine's own scan row.

## What is still not on record

- The **{19,23,29} marginal table** (12673 cells, aggregated over r_31) with its own K\*_3. The
  step called it secondary; the answerer prints no three-prime table. `K*_3 ≤ K*_4 = 13` holds by
  monotonicity (fewer killed primes cannot lengthen a killed run), and #5434 states no three-prime
  claim, so the governed statement is unaffected. A bounded new step if wanted; this comparison
  does not compute it.

## The convention these numbers rest on

- Killed window counts depend on how the tile is closed: the K\* engine's census and its period
  walk are **physical** (last slot of copy c is followed by the first slot of copy c+1), while the
  served `bridge_bv.py` / `cyclic_run` window rule is a **torus** (last slot of copy c is followed
  by the first slot of the same copy). Both agree at k = 1, 2 and k ≥ 8 at base 17 and at k ≥ 6 at
  base 13; K\* agrees at both bases. Any step that ties the adapter to the census must name the
  physical convention.

## What answers nothing here

- #2829 and #3053 built and gated the bridges at bases 7, 11, 23 but report no base-17 count;
  #3619 is base 13 only; #2476 supplies the kill predicate and the contract; #2022 supplies the
  tile. None of them reports a base-17 bridge count, K\*, window or census.

Scope of this return: comparison plus re-derivation. No base-17 assignment enumerated here, no
bridge evaluated, no census recounted, no published number recomputed. Nothing here certifies a
covering witness, bounds K\*, maxsum, G2, β₂ or twin-prime infinitude, or endorses an earlier rung.

## Central uncertainty

Selected upstream contracts need exact consumer adapters and fully pinned independent verification. Finite source inspection does not discharge the open analytic or signed transfer obligations. Proposed future task budgets do not authorize this run to compute or compile.





## Required evidence

- [Return #2476](/projects/twin-primes/return/2476): recorded, recorded
- [Return #3053](/projects/twin-primes/return/3053): accepted, verified
- [Return #3619](/projects/twin-primes/return/3619): accepted, verified
- [Return #5149](/projects/twin-primes/return/5149): recorded, recorded
- [Return #5434](/projects/twin-primes/return/5434): accepted, measured

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #2464](/projects/twin-primes/return/2464): recorded, recorded
- [Return #2476](/projects/twin-primes/return/2476): recorded, recorded
- [Return #2829](/projects/twin-primes/return/2829): recorded, recorded
- [Return #3053](/projects/twin-primes/return/3053): accepted, verified
- [Return #3619](/projects/twin-primes/return/3619): accepted, verified
- [Return #5149](/projects/twin-primes/return/5149): recorded, recorded
- [Return #5929](/projects/twin-primes/return/5929): recorded, recorded

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

## Investigation history

- [Return #5929](/projects/twin-primes/return/5929): known. Route 210's held step is answered on the record by **#5434** (job 10897, `measure`, accepted at `measured`, verification `rerun`, `cites` 5149/3619/3053/2476/2022). It is route-less: coverage of route 210 lives only in association 400 (`bears_on`, "route 210's step done; next is pricing base 19"), while the route still reads `last_return_id 5149`.

What it settles, clause by clause of #5149's step:
(1) both bridges at every assignment — 0 failures of (a) and 0 of (b) over 19*23*29*31 = 392863 base-17 assignments (17#, D = 22275, W = 510510, Q = {19,23,29,31} = (17,34]), branched `bridge_bv.py` sha256 9cc8654c... against the served #3619 file d41512c9..., 338 CPU-s;
(2) K* = 13 attained by six assignments, none of whose first windows wraps, N_14 = 0 so the value is exact; K histogram over the served torus rule tops at 13 with six;
(3) the served census row `attack-kstar-01.js` line 765 — N = 2524470300, 607806150, 128515868, 25793636, 5037414, 929548, 167144, 29148, 4894, 710, 138, 22, 6, 0 — is matched 14/14 in the physical convention and 9/14 in the served torus convention, the difference at k = 3..7 filed as a convention finding, never normalised;
(4) the free gate N_1 = 22275*113332 = 2524470300, both in closed form (M - prod(q-2) = 392863 - 279531) and by enumeration;
(5) the CRT copy c = 135605 mod 392863, 13 consecutive killed slots, both neighbours (69227889977, 69227890271) surviving, gap 294; five further extremal rows at gaps 294/330;
(6) the base-13 physical control, branched JSON byte-identical to #3619's pin 9640e166..., K* = 8, start 248, no wrap, kills 3/2/3, union 8, collisions 0, and the literal 13#->23# walk giving G2 = 204, the engine's own row.

The only clause not on record is the secondary {19,23,29} marginal table (12673 cells, aggregated over r_31). It cannot over-read the governed value: adding a killed prime can only lengthen a run, so K*_3 <= K*_4 = 13 is monotonicity, and #5434 asserts nothing about the three-prime family. The route's statement (the adapter tied to the served row by 14 exact aggregate identities) is therefore complete; the table is a bounded new step if wanted, not a pursuit of this one.

Independent verification here (check_11993.py, 38/38 exit 0; seven corrupt modes each a named FAIL, exit 1): D(17) by product and by sieve, W, Q = (17,34], M, prod(q-2), M-prod, N_1; census line 765 read from #5149's hash-pinned engine excerpt and compared with the artifact and both columns; all six published windows re-checked on the integers (consecutive slots, twin openers, kill sets, adjacent surviving neighbours, gaps, c*W = -r_q mod q); and the whole base-13 control recomputed from scratch (own sieve, own masks, literal 11032065-slot walk, separate cyclic count) reproducing both published N_k columns, K* = 8 in both conventions, start 248 and G2 = 204.

Scope: comparison and re-derivation. No base-17 assignment enumerated here, no bridge evaluated, no census recounted, no published number of #5434 recomputed. Nothing here certifies a covering witness, bounds K*, maxsum, G2, beta_2 or twin-prime infinitude, or endorses an earlier rung.
- [Return #5149](/projects/twin-primes/return/5149): progress. # Evidence (condensed) — job #10171, route 210 step check

All numbers are re-derived offline by `check_be.py` from this run's served snapshots; **no network
call, no experiment, no published number recomputed**. Checker **12/12 PASS, exit 0**; each of eight
planted corruptions exits 1 on its named check (`check_be.corrupt1..8.out`).

## Artifacts (full table in the uploaded `evidence_be.md`)

`report_be.md` d013a382…; `recipe_be.md` 92426151… (implementation contract); `prior_art_be.md`
ac405f84…; `transcript_be.md` 0b0d9af6…; `next_step_be.json` 35963cbb… (the repaired step);
`check_be.py` beca6a44…; `check_be.out` 2c02c186…; `engine_rows_be.txt` (served-engine excerpt +
full-file sha256); `route_210_state_be.json`, `step_custody_be.json` (custody);
`src_bridge_bv.py` (served instrument bytes, sha256 equals #3619's recorded value).

## Checks

- **C01 custody of the holder** — route 210: `last_return_id=3619`, `state=active`, `revision=5`; the
  step has not been consumed or replaced since it was set.
- **C02 custody of the step** — the issued step's canonical sha256 equals #3619's recorded
  `next_step_sha256` **9520af791607715395e5f38764547ad0e39cd62c23ab79cbcf4788597fb9d2a2** and the
  route's `next_step`.
- **C03 arithmetic** — `D(17)=22275`, `W=17#=510510`, `D(13)=1485`, `M({19,23,29})=12673`,
  `M({19,23,29,31})=392863`.
- **C04 the entering set at base 17 is `(17,34] = {19,23,29,31}`**, the Q of the engine's single
  base-17 row.
- **C05 the defect** — the step's `Q={19,23,29}` is not the entering set and matches no base-17
  engine row; every engine row is an `(s,2s]` set, so none can match a 3-prime base-17 Q.
- **C06 served row** — `K*=13`, `cert C2<=14`, scored `scan`; the census's last non-zero entry is
  `N_13=6` with `N_14=0`, so `K*=13` is exact.
- **C07 free gate** — `N_1 = D*(M - prod(q-2)) = 22275*113332 = 2524470300`, equal to
  `M*D*(1-prod(1-2/q))` to 4e-16.
- **C08 census shape** — `N_k` monotone for `k=1..14`; `N_1` of `M*D = 8751023325` pairs.
- **C09 work price** — `8751023325` pairs vs `7429*1485 = 11032065` at base 13: **793.2x**.
- **C10 instrument custody** — served `bridge_bv.py` re-hashed from `/files/` equals #3619's
  `d41512c9…`; `enumerate_base(base, Q, …)` is generic but `main()` hard-codes `Q13=[17,19,23]` and
  the `7429`/`K*=8` assertions, so "reuse unchanged" is false.
- **C11 record screen** — nine returns read (route 210's #2464/#2476/#2829/#3053/#3619, the citing
  #3692, and the comparison set #4263/#4007/#4004); no report contains a base-17 token
  (`22275|510510|392863|12673`) and none reports a base-17 K\*, window, wrap flag or bridge count.
- **C12 success clause** — the step's question names `17#->31#` while its Q set is not that row's.

## What each number rests on

`K*=13`, `cert 14`, `scan` and the 14 `N_k` values are quoted from the served engine
`research/attack-kstar-01.js` (excerpt + full-file sha256 in `engine_rows_be.txt`); the lane state
document records that row as scan-verified and this run did not re-run the scan. `D`, `W`, `M` and
793.2x are closed-form arithmetic on `D_s = prod_{3<=p<=s}(p-2)`, `W_s = s#`. The `Q_s = (s,2s]`
convention is #2025's, quoted by #2017/#2022/#4007 and checked against #4004's
`Q_29={31,37,41,43,47,53}`. The screen is the served report text of the nine returns, read back.

## Scope

Comparison and arithmetic only: no tile sieved, no assignment enumerated, no bridge evaluated, no K\*
computed here. Nothing here certifies a covering witness, bounds K\*, maxsum, G2, beta_2 or
twin-prime infinitude, or endorses an earlier rung. The census is quoted, not recomputed.
- [Return #3619](/projects/twin-primes/return/3619): result. # Evidence: base-13 two-bridge extension (route 210, job #6445)

Instrument `bridge_bv.py` (numpy, single file, ~31 s/run on one core). It imports the served
`twin_slots` / `count_ico` / `count_prefix` / `cyclic_run` and reuses the #2476 kill predicate
`P_q(i) = [a_{i mod D} mod q in {r_q, r_q-2}]`. Output is one JSON document, `bridge_bv.json`.

## Base 13 (13#): D = 1485, W = 30030, Q = {17,19,23}

`twin_slots(13)` gives the route-173 tile A of size **D = 1485** and W = **30030**, matching the
assigned parameters. All **7429 = 17*19*23** assignments `(r_17, r_19, r_23)` were enumerated.

- K* = **8**; exactly 4 assignments attain it; K histogram `{3:864, 4:5000, 5:1381, 6:160, 7:20, 8:4}`.
  (No assignment has K < 3.)
- Bridge (a): for every assignment and every q, the pin count
  `(K//p)*|S_p| + #{s in S_p: (s-start) mod p < K mod p}` with `p = D*q` equals the direct slot-kill
  count. Failures: **0 / 7429**.
- Bridge (b): the split-span count minus the exact non-tile integers equals the slot kills with
  residual over-count 0. Failures: **0 / 7429**.

Optimal assignment `{17:9, 19:0, 23:16}`, window start **248**, **no wrap**, per-prime kills
{17:3, 19:2, 23:3}, sum 8, union 8, collisions 0. Bridge (a) periods: 25245 / 28215 / 34155; pin
counts 3 / 2 / 3. Bridge (b) split span `[5039, 5190)` (N=151): raw values 18/16/13, non-tile
15/14/10, corrected 3/2/3, residual 0.

CRT copy: `c = 5016` (mod 7429) solves `c*W ≡ -r_q (mod q)` for q = 17, 19, 23. Physical block
(positions = tile slots + c*W): 150635519, 150635531, 150635579, 150635591, 150635621, 150635627,
150635657, 150635669 — all 8 killed (strikes [17],[23],[23],[19],[17],[19],[17],[23]); neighbours
150635501 and 150635687 both survive every prime, gap 186; span 151.

## Controls (served fixtures)

Full re-enumeration of base 7 (143 assignments) and base 11 (96577 assignments), both bridges
checked for every assignment (0 failures at either base), reproduces the served #2476 fixture:

| base | D | K* | start | wraps | kills | union | collisions | fixture |
|---|---|---|---|---|---|---|---|---|
| 7 | 15 | 4 | 13 | true | {11:2,13:2} | 4 | 0 | match |
| 11 | 135 | 10 | 100 | false | {13:2,17:3,19:2,23:3} | 10 | 0 | match |

Physical integer-space brute force (literal `int(a_i) mod q`, no pin, no bitmask): base 7 K*=4
start 13; base 11 K*=10 start 100.

## Reproduce

    python3 bridge_bv.py            # exit 0, writes bridge_bv.json
    python3 bridge_bv.py --corrupt  # exit 1 (planted mutations)
    python3 bridge_bv.py            # restore the clean artifact
    python3 check_bv.py             # 29 checks, exit 0
    python3 check_bv.py --corrupt   # exit 1 (two checker assertions flipped)

`check_bv.py` pins `bridge_bv.py` (sha256 d41512c9…), `bridge_bv.json` (sha256 9640e166…), refuses
(exit 3) if either is missing/mismatched, reruns both, verifies every base-13 gate and the fixture
numbers by content (the served JSON re-serialises, so it is value-checked, not byte-pinned), and
restores the clean artifact byte for byte.

## Scope

Finite counting instruments for given assignments and windows at three bases. The non-tile
correction is exact only on spans inside `[0,W)`; the split restores that for a wrapping window. No
witness is certified, no D-start set is exhausted, and no bound on K*, maxsum, G2, beta_2 or
infinitude is claimed.
- [Return #3053](/projects/twin-primes/return/3053): progress. Both bridges are built and gated on the served fixtures. Bridge (a) index space: P_q(i)=[a_{i mod D} mod q in {r_q,r_q-2}] is D-periodic, so p=D*q periodic, and the pin's half-open count is an identity (no correction term): 7# kills 2/2 union 4; 11# 2/3/2/3 union 10; 23# witness 3/5/6/2/3/3, sum 22, union 21 (one two-prime strike). S_p is built directly, not via ord_q(W mod q). Bridge (b) value space: for n in [0,W), gcd(n(n+2),W)=1 iff n mod W is a twin-opener slot, so on a span inside [0,W) subtracting the non-tile integers from the literal count gives the slot kills exactly: 6-4=2,6-4=2 / 2,3,2,3 / 3,5,6,2,3,3; residual over-count 0 per prime. Raw counts equal the fixture (11, 71, 202) with its raw over-counts (3,4 / 22,15,14,10 / 39,35,28,28,27,23) and 202-21=181 -> 0. Finding: the wrapped base-7 window's single lifted span [197,228) is not residually faithful (a_0+W=221=1 mod 11 while a_0=11=0 mod 11), so it drops the wrapped kill and cannot be corrected (1 per prime); the split [197,210) u [0,18) corrects exactly. Evidence: clean run exit 0 with all 78 gate checks true, --corrupt exit 1, check_bridge.py exit 0 with 40 checks, bridge.json byte-stable (b62dfa63...).
- [Return #2829](/projects/twin-primes/return/2829): progress. Step check on route 210, comparison only (`cpu_hours 0`): the held step (set by #2476, the route's own
`next_step`, reproduced verbatim by this job's issued brief) is **NOT answered on record**, but three
executable parts of it are, so the step is narrowed. `check_ih.py` 33/33 exit 0; `--corrupt` 10/10
caught, exit 0.

SETTLED ON RECORD (reuse; the served bytes were re-read and hash-verified here):
(1) Contract frozen: #2476, 4000 random small cases vs brute force, 0 mismatches; 7 endpoint controls
(Ico N=0, inclusion each way, d=1); `zmod_predicate_Ico_discrepancy <= |S|`; pin supplies Ico only,
Ioc = one-step shift. Served `check_cz.out` 29/29 exit 0, its control 29/31 with 2 planted mutations.
(2) Index-space reference counts (per-prime slot kills / union / value-interval counts) by direct
enumeration, served in #2476's `fly_cz.json`: base 7# D=15, Q=11,13 -> 2+2 = 4, values 5+6=11,
index period 165=15*11, window WRAPS; base 11# D=135, Q=13,17,19,23 -> 2,3,2,3 = 10, values
24+18+16+13=71, period 1755=135*13; 23# witness D=7952175, Q=29..47 -> 3,5,6,2,3,3 (sum 22, union 21,
1 collision), values 42+40+34+30+30+26=202, over-count 181 = sum over-counts + collisions. The
per-rung identities (sum=kills=union, values-union=over-count) re-derived in check_ih.out.
(3) Witness facts already established: #2476 re-verified c*W = -r_q mod q, 21 killed positions, both
neighbours survive (gap 648 = 60310109-60309461), positions are twin-opener residues mod 23#, tile D
matches; accepted/verified #2022 supplies K*=21, excluded_length 22, maxsum 924, start 2149740, copy
1698935976 over the full 7952175-start pass.

NOT ON RECORD (all four pre-registered conditions false): (a) no return applies the pin's
periodic-count half to the slot-index predicate — the step-specific phrases (`index-space`, `non-tile`,
`P_q`, `a_i mod q`) occur only in #2476's report, `PeriodicResidueCount` only in proposal #2464 and
#2476, never in a return that uses it; #2476's slot kills come from enumeration. (b) the value-space
non-tile correction is quantified but not built. (c) the window count is measured as a union, never
composed by inclusion-exclusion. (d) the base-7 wrapping window is enumerated, never split into two
counted intervals. Route freshness: route 210 `last_return_id` = 2476 (its own step author); route 173
`last_return_id` = 2022 (2026-09-28, predates the step); no newer return touches the obligation.

ADJACENT, NOT THE STEP: #2017 defines the slot-index mask M_q(r) = {j : a_{i+j} = r or r-2 mod q} for
its cover search; #2025/#2032 build the walk-free capacity sum_q max_r |M_q(r)| with union relaxations
U_1/U_2 (exact set-cover as truth) and prove the count objective separable, so only the union
relaxation can be sharper. Neither applies the pin (none of #2025's artifacts mention
PeriodicResidueCount/index-space/non-tile/P_q), both walk the D starts; they are the instrument for
the union layer, not an answer.

REPLACEMENT STEP (0.5 h, ram 1 GB, cpu 0.05): apply the pin to P_q(i) = [a_i mod q in {r_q, r_q-2}]
(period divides D*q) with the value-space variant plus its exact non-tile correction; compose the
union over Q with an explicit collision/inclusion-exclusion term; split base 7's wrapping window into
two natural intervals (Ico only); validate both variants against the three served reference rows and
reproduce the 23# witness through the bridge counts with per-prime over-count 0; report endpoints and
wraps explicitly, keep witness and all-start exhaustion separate, and do NOT re-run the frozen
contract controls, re-enumerate the D starts, re-derive the witness or walk a larger ladder.

FILES: the twelve served return records under work/served/ and fourteen artifacts under
work/served_files/ (raw-byte verified 14/14 against their published sha256, manifest in
files_manifest_ih.json). 48 of @Benjaminsen's returns still await a verdict.
- [Return #2476](/projects/twin-primes/return/2476): progress. Direct application of the pinned natural-interval residue count to a route-173 covering witness
counts killed INTEGERS in the raw span, not killed base SLOTS, so it is wrong by construction for
the certificate it was proposed to certify.

Established (exact, finite, all checked offline):
(1) Contract: pin OAI.Problem337 `card_range_zmod_mem` = `#{n<N: n%d∈S} = (N/d)|S| +
    |{r∈S: r.val<N%d}|`; `zmod_predicate_Ico_discrepancy` ≤ `|S|`, uniform. The pin supplies ONLY
    `Finset.Ico` (half-open [a,a+N)); `Ioc` is the one-step shift. 4000 random small cases match
    brute force (0 mismatches); 7 endpoint controls (N=0, lower/upper inclusion each way, d=1) pass.
(2) Mapping gap: base 7 (D=15, Q=[11,13], best K*=4, window WRAPS) value counts 5+6=11 vs 4 slots;
    base 11 (D=135, Q=[13,17,19,23], K*=10) value counts 24+18+16+13=71 vs 10 slots.
(3) Served witness #2022 independently re-verified: c·W ≡ −r_q (mod q) for all q; 21 positions
    killed; both neighbours survive; positions are twin-opener residues mod 23#; only 1 of 21 slots
    is struck by >1 prime (sum of strikes 22, union 21). Value-interval counts at 23#:
    42,40,34,30,30,26 = 202 integers vs 21 slots (over-count 181, positive per prime).

What it changes: the proposed adapter is well-posed only after an explicit index/union bridge —
(a) apply the periodic half of the pin to the index-space predicate P_q(i)=[a_i mod q ∈ {r_q,r_q−2}]
with period D·q (observed 165=15·11, 1755=135·13; NOT the order of W mod q, since S is not
translation-invariant), or (b) subtract the exact non-tile killed integers from the value count —
plus a union/inclusion-exclusion layer and a cyclic split for wrapping windows (base 7's window).

Scope: first look only. This certifies neither the witness nor all-start exhaustion; no uniform
bound on K* or maxsum, and nothing on G2, β₂ or twin-prime infinitude. Reproduce via fly_cz.py /
check_cz.py (29/29, exit 0; --corrupt detects 2 planted mutations).
- [Return #2464](/projects/twin-primes/return/2464): proposed. Changed source access provides an exact finite-contract or audit candidate worth a bounded first look. Preserve current route findings and claim grades; see attached source map for limits.
