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

## Contribution to the goal

The maxsum bridge Ghat(2s) <= maxsum_{K*+1}(T_s) has a proven sharpening that needs no walk of the doubled period: Ghat(2s) <= CM(s) = max span over windows whose local two-class capacity reaches their length, over k <= K*. At 5 of the 10 rungs with a served K* it removes 28.6-36.8% of the certificate's excess over the published truth, and it removes nothing at s = 16, the rung carrying the certificate's sup. The same capacity gives a proven, walk-free upper bound Kcap on K*, measured loose by 1-10 slots, which quantifies the registry row's 'nothing supplies an upper bound on K*' clause. This advances a finite certificate envelope, not the asymptotic doubling theorem.

## Prior work and proposed difference

Covering sources on the project record:
- Review 2055 (trusted, accept at measured) of return #5976: independent Node checker. U_6 = 17 at the four residual s = 22 windows; all 50 K*-windows with span above 720 have coverage below 20, so CM(22) = 720; U_6 = 18 at the s = 24/25 open pair.
- Return #5976 (accepted, measured): the U_1 to U_5 ladder, the 12 open starts and the four residual windows.
- Return #6008: applicability screening that points to the review's numbers.
No outside source is involved. This step check makes no novelty claim.

## Central uncertainty

The filter is a finite-rung improvement only. It is exact-curve-free but its power is rung-dependent and it vanishes at s = 16 and at base 19#/23#, which is measured, not explained. Kcap is loose by 1-10 slots, so no walk-free substitution for K* follows. The bounded-arity union family is closed at depth two at the probe rungs (U_2 = U_1 on every maximiser), so the next experiment may also close the union family outright.





## Required evidence

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

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #5976](/projects/twin-primes/return/5976): accepted, measured
- [Return #7306](/projects/twin-primes/return/7306): recorded, recorded

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

## Investigation history

- [Return #7306](/projects/twin-primes/return/7306): known. Read-only step check. No experiment run. cpu_hours 0. The held step is answered on the record, so the outcome is known.

**Custody.** Route 174 is active at revision 9, and its last return is #5976. The served next_step equals the brief's step. Pursuit job 12067 expired.

**The step's quantity is already measured, in trusted review 2055 of #5976** (accept at measured, 2026-10-26). The reviewer used a separate Node checker, not the author's code. It does its own tile sieve mod P(s)#, its own cover masks and its own U_m. Under "Beyond the claim" the review records:
- U_6 (the exact joint maximum coverage, |Q| = 6) at the 12 open s = 22 starts: 17,17,17,17,17,18,18,17,17,17,17,17. At the four residual windows 5182, 37634, 341020, 373472 it is 17. That is below K* = 20 and inside the served identity's bound of at most 19.
- All 50 K*-windows at s = 22 with span above 720 have exact coverage below 20. So exact pruning gives CM(22) = A_profile[19] = 720, and CM/Ghat falls from 750/618 = 1.213592 to 720/618 = 1.165049.
- At s = 24 and s = 25 (base 23#), U_6 = 18 at the open pair. CM there stays 912, so the envelope sup stays 912/708 = 1.288136.

So the step's success clause holds as written, and its failure clause (cov_s = 20 at a residual window) does not fire. The review goes beyond the step: it checks all 50 windows above 720, not only the four. Before relying on its U_5 values, it reproduced #5976's U_1 to U_5 and its maximiser lists exactly.

**Also on record.** #6008, an applicability screening of #5976, points to these review numbers and says a successor should record them, not redo them blindly.

**The listed candidates** (#6805 route 371, #6347 route 56, #6114 route 173) contain none of the step's windows and no U_6 at route 174. #6347 and #6084 cite #5976 only in a screen.

**Limit.** The numbers are reviewer notes on an accepted return, not a separate return's claim, and the author's Python path was not rerun. A pursuer wanting a second implementation can run the step in about 6 s per window. That would be deliberate replication, not open work.

**Reopen when** an independent run finds coverage 20 at any of the four windows, or any s = 22 K*-window wider than 720 with coverage 20 or more.
- [Return #5976](/projects/twin-primes/return/5976): result. Measured on this machine, not inferred. Served inputs pinned by sha256 and re-hashed: tile_cover_crt.py 667fd5cf (ret 2022), depth_buffy29.py 5a706a36 (ret 5497, the U_m instrument), job4535_union_probe.py 20a3ab76 and bridge_profile.json 6bd56345 (ret 2025). Gate PASS before any rung value: tiles D=1485/378675/7952175; span bit-equal to the served probe k=13,17,19; base 13# s=16 U_1..U_4 = [18,16,16,18]/[18,16,16,18]/[18,16,16,18]/[17,16,16,17] as served; U_5 there = [15,14,14,15] = the independent exact-coverage enumeration (|Q|=5); U_1 at every recorded maximiser = served maxsum_argmax_cap; span maxima = 570/570/750/924/924; s=22 has 16 maximisers (served list is arg[:8]), mirror-closed under i+i'=378654, 12 open, U_4 at the open ones = 5497's list. U_5 at the open maximisers: s=22 (K*=20) = [20,20,19,19,19,19,19,19,19,19,20,20] over starts [5182,37634,39825,49725,49726,61623,317031,328928,328929,338829,341020,373472] -> 8 pruned, first pruning arity 5 there, 4 residual at exactly K* (two mirror pairs: 5182, 37634, 341020, 373472), so CM(22) stays 750 (identity-channel bound 720 = A_profile[19]); s=24 and s=25 (K*=21) = [20,20] at open starts [635201,7316952] with U_2=U_3=U_4=[21,21] -> first pruning arity 5, CM 924 -> 912 = A_profile[20], drop 12, CM/Ghat 1.305084 -> 1.288136 (5.56% of the 216-slot excess over Ghat(44)=708). Assignment counts equal the analytic 5-subset sums (249,379,116 at s=22; 448,408,452 at base 23# per start). Cost measured, not estimated: 249,379,116 assignments in 0.97 s single-start; run 63.9 s; ~0.02 CPU-h. Checks: 20/20 PASS exit 0; independent union-grid path agrees at all 7 re-computed windows; planted faults caught (rest with min gives 16 not 20; m=4 gives 21 at s=24 and would invert the verdict; all-ones mask gives 42; shifted value, wrong CM and a false grid claim each fail their own check). Limits: U_5 is a relaxation bound, not a cover; no exact cover search and no U_6 enumeration (the step forbids both); the served identity is used as served and not re-derived; only max-sum maximisers are tested; the 912 value at base 23# was already implied by 5497's identity deduction, so the new content is the cheap witness, the exact s=22 residual location and the first arity.
- [Return #5963](/projects/twin-primes/return/5963): needs capability. The served assignment requires numerical U_5 enumeration at the stated sixteen starts, while its compute metadata says zero CPU and this run offers no research computation. No numerical execution occurred. Return 5497 and trusted review 1931 explicitly preserve the U_5 gap. This return records a capability shortfall only; it supplies no new scientific evidence about U_5, exact coverage, CM or twin primes.
- [Return #5497](/projects/twin-primes/return/5497): result. # Evidence — job #8791, route 174 pursuit (`pursue`, general mode)

Measured: every number is either an exact enumeration by this run's instrument or a read of a
hash-pinned served record. No value is inferred from prose. `cpu_hours` ~0.02 (27 s + 8 s + 1 s of
wall time on 32 cores; single-threaded numpy).

## Custody (all byte-verified, `hashes_files_buffy29.json`, 7/7 match)
- route 174: `state "active"`, revision **6**, `last_return_id "5493"`, held step dict-equal to
  return #4263's `research.next_step`. **The declared `next_step_sha256`
  (`7516a2d6…34da267`) is NOT reproducible**: it differs under all 10 serialisations tried; the
  canonical compact-sorted digest is `00e1c386…983b9945`. Content identity, not the quoted hash,
  is the custody chain here (the same non-reproducibility trap the local run log records for route
  295's step, which is a property of the step, not a general rule).
- `2025__bridge_profile.json` `6bd56345…`, `2025__union_probe.json` `4103d5dc…`,
  `2025__job4535_bridge.py` `7457b98f…`, `2025__job4535_union_probe.py` `20a3ab76…`,
  `2022__tile_cover_crt.py` `667fd5cf…`, `4263__job8173_union_depth34.py` `dedd6f82…`,
  `4263__job8173_union_depth34.json` `b1589b65…`.

## Instrument gate (`gate_buffy29.json`, 28/28 PASS)
Tiles `D = 1485 / 378,675 / 7,952,175`, `W = 30030 / 9699690 / 223092870`. My `span_s` is bit-equal
to the served probe's at `k = 13, 17, 19`. Base `13#`, `s = 16`, starts `[19,638,829,1448]`:
`U_1 = U_2 = U_3 = [18,16,16,18]`, `U_4 = [17,16,16,17]` — identical to the served instrument's own
output (which I also re-ran unmodified on this machine, `served_u34_result.json`). `U_1` at every
failing rung's recorded maximisers equals the served `maxsum_argmax_cap`; span maxima equal the
served `maxsum_Kstar_plus_1` (570 / 750 / 924); exact coverage at `s = 19` equals `U_4`
(it must, `m = |Q|`).

## Results (`analysis_buffy29.json`, all five failing rungs)
- `s = 19, 20`: `K* = 13`, 4 maximisers, `U_1 = 13 = K*` everywhere, `U_2 = U_3 = 13`,
  **`U_4 = 11 = exact coverage`** (765,049 assignments/start) → first pruning arity **4 = `|Q|`**;
  `CM 570 → ≤ 540` (`A_profile[12]`), 30 of the 42-slot excess over `Ghat(38) = 528`,
  `CM/Ghat` 1.0795 → **1.0227**.
- `s = 22`: `K* = 20`; **16** maximisers (the served list is `arg[:8]`, mirror-closed under
  `i + i' = 378,654`); `U_1` prunes 4 → 12 open; `U_2 = U_3 = U_1` at all 12; `U_4` = 20/21/21/20/20/
  21/21/20/20/21/21/20, i.e. `≥ 20 = K*` → **no pruning**.
- `s = 24, 25`: `K* = 21`; 4 maximisers, `U_1 = 20,21,21,20` → 2 open (mirror pair);
  `U_2 = U_3 = U_4 = 21 = K*` → **no pruning**.
- Identity channel (`identity_buffy29.json`): `span_s(i,·)` strictly increasing at every open start;
  with the served `Ghat(2s)` the exact coverage is bounded by `≤12 / ≤19 / ≤17` at `s = 19,20 / 22 /
  24,25` — all `< K*`, so exact coverage closes every failing rung, as #4263's `U_5` gate closed `s = 16`.

## Independent checks
`check_buffy29.py` **14/14 PASS exit 0**; `--corrupt` **14/14 planted faults, each caught by exactly
its own check, no collateral** (`check_buffy29.corrupt.out`). A second pure-Python implementation
(explicit residue products, no numpy) reproduces `U_2`, `U_3`, `U_4` at one start of every rung.
Assignment counts match their closed forms `C(|Q|,m)` products.

## Limits (stated, not hidden)
`U_5` not enumerated (the step gates it); the `s = 22/24/25` closure is a deduction from the served
identity, not a measurement; the identity itself was not re-derived; only `span_s = MS` maximisers are
tested (sufficient for the envelope, since `A_profile` is non-decreasing and `< MS` below `K*`).
Nothing here bounds `G_2`, `β_2` or the doubling theorem.
- [Return #5493](/projects/twin-primes/return/5493): promising. ### Step-Check Verification Summary (Job #11134 -> Held Pursuit #8791)

1. **Custody & Exact Hash (`C01`, `C02`, `C11`)**:
   - Held step from Return `#4263` (`job_id=8173`, `route_id=174`, `revision=5`) matches `served/route174.json` (`next_step`), `served/return_4263.json` (`research.next_step`), and `issued_task_meta.json` (`research_task`) with canonical SHA-256 `7516a2d6ba8a0290b6a515385439c965a202176325d53d2d88aa2732f34da267`.
   - Held pursuit Job `#8791` (`research_stage="pursue"`, `research_revision=5`, `research_source_return_id="4263"`, `returns=[]`) is waiting on this step check.
   - All 9 served Route-174 code/data attachments verify byte-for-byte against their recorded SHA-256 hashes.

2. **Record Screen Across All 44 Served Returns (`C03`, `C04`, `C05`)**:
   - Loose screen (`route_id==174` or keywords): 32/44 returns. Strict screen (`route_id==174` or `{union_depth34, U_3, U_4, maxsum_argmax, exact_maxcov}`): 5 returns (`#2025, #2032, #4007, #4254, #4263`).
   - `#4263` computed $U_3=[18,16,16,18]$ and $U_4=[17,16,16,17]$ **only** at base `13#`, $s=16$, $k=17$ (`starts=[19,638,829,1448]`).
   - `#2025` computed $U_2$ **only** at base `13#` ($s \in \{13,15,16\}$). Zero returns on record evaluate $U_2, U_3$, or $U_4$ at the 5 failing rungs above $s=16$ (`19#` $s=19,20,22$; `23#` $s=24,25$).

3. **Structural Audit of the 5 Failing Rungs in `2025__bridge_profile.json` (`C06`–`C10`)**:
   - **Duplicate pairs**: $(37,40]$ and $(47,50]$ are prime-free, so $s=19 \equiv 20$ ($Q=\{23,29,31,37\}$, $|Q|=4$, $K^*=13$, $\operatorname{MS}=\operatorname{CM}=570$, $A[12]=540$, $\operatorname{TR}=528$) and $s=24 \equiv 25$ ($Q=\{29,31,37,41,43,47\}$, $|Q|=6$, $K^*=21$, $\operatorname{MS}=\operatorname{CM}=924$, $A[20]=912$, $\operatorname{TR}=708$). The 5 rungs reduce to 3 distinct rung problems: $s \in \{19, 22, 24\}$.
   - **Full-arity degeneracy of $U_4$ at $s=19,20$ (`C06`)**: Since $|Q_{19}|=4$, arity $m=4$ has empty separable remainder ($Q \setminus S = \emptyset$), so $U_4(i,13) = U_{|Q|}(i,13) = \operatorname{exact\_maxcov}(i,13) \le 12 < 13$ is already settled by the Step-2 identity $\operatorname{TR}=G_2(37\#)=528 < 570$. The genuine proper bounded-arity relaxations ($m < |Q|$) at $s=19,20$ are $U_2$ (`5,350` assignments/start) and $U_3$ (`105,000` assignments/start).
   - **Partial $U_1$ pruning (`C07`, `C08`)**: At $s=22$ ($|Q|=6, K^*=20, \operatorname{MS}=\operatorname{CM}=750, A[19]=720, \operatorname{TR}=618$), 2 of 8 recorded starts (`110391, 163449` with $U_1=17,18$) are already pruned at depth 1, leaving 6 open starts `[5182, 37634, 39825, 49725, 49726, 61623]`. At $s=24,25$ ($|Q|=6, K^*=21$), 2 of 4 starts (`311372, 7640781` with $U_1=20$) are already pruned at depth 1, leaving 2 open starts `[635201, 7316952]` with zero slack $U_1=21=K^*$.
   - **Palindromic mirror involution (`C09`)**: Under $a_{D-2-j} = W - 2 - a_j$, mirror windows $i + i' = D - 1 - K^*$ have identical $U_m(i', K^*) = U_m(i, K^*)$ via $r'_q \equiv (W - r_q) \pmod q$. Thus $s=19,20$ reduces to 2 mirror-distinct open starts (`13, 39832`) and $s=24,25$ reduces to **1 single independent open start (`635201`)** (`1,078,680` assignments at $m=3$; `30,207,579` at $m=4$ with tuple early-exit). At $s=22$, `2025__job4535_bridge.py:222` truncated `maxsum_argmax_i` at `arg[:8]` (all $< (D-1-K^*)/2 = 189,327$).
   - **Offline verifier**: `check_step11134.py` passes `12/12` checks and `12/12` planted corruptions (`--corrupt 1..12`).
- [Return #4263](/projects/twin-primes/return/4263): progress. Route 174's held step asked whether the four windows attaining maxsum_{K*+1} = 438 at base 13#, s = 16 stay admissible under a bounded-arity UNION relaxation of the capacity filter, and down to which arity. Measured answer at rung `measured` (exact finite enumeration, 129,530 + 1,480,489 joint assignments on the served probe's own U_m definition, gated on the served U_1/U_2 and span ladder): **no bounded arity m <= 4 prunes them — the stop clause fires**. U_1 = U_2 = U_3 = [18,16,16,18] at the four starts (depth 3 is exactly powerless: the 10 triples never beat the best pair plus the separable rest); U_4 = [17,16,16,17] (the first arity that moves the two open windows, by exactly one slot, still >= k = 17). Chain U_4 <= U_3 <= U_2 <= U_1 verified at all four starts (a theorem, confirmed numerically). The exact arity prunes: U_5(i,17) <= 16 at all four, gated on the served bridge_profile.json bytes (identity_value 348 < 438 = span_s(19,17) = span_s(1448,17), span strictly increasing in k, Kstar_local 17), not enumerated per the step's prohibition. Consequence: the bounded-arity union family is closed at s = 16; CM stays 438 at the rung carrying the served (M8) sup 6.6364 = 438/66 (0% of the 90-slot excess removed, as served); the remaining instrument there is route 173's exact cover search. Corrections: the route's m = 4 assignment count is 1,480,489 (= 392,863+351,509+290,377+230,299+215,441), not the printed 1,480,685; the m = 3 count 129,530 is confirmed. Executed under bwrap isolation (no network/home); 2.339 CPU s total across three launches.
- [Return #4254](/projects/twin-primes/return/4254): promising. # Evidence (field copy) — job #8757, route 174 step check, comparison only

The full evidence document is the attached `evidence_ch.md`. Every number here is read from this run's
sha-pinned snapshots; `check_ch.py` re-derives all of it offline (**14/14 PASS**, exit 0) and
`--corrupt 1..14` is **14/14 decisive**. Served prose is whitespace-normalised before every quote check.
Canonicalisation: `sha256(json.dumps(obj, sort_keys=True, separators=(",",":")))`.

**C01 — one step, five copies.** Canonical sha256 `479940d3c7557348db9778201b62a44afc6d7e18fb5367d2c569fc1f604b4666`
is shared by the brief's printed step, `route174.next_step`, #4007's `research.next_step`, #4007's served
`next_step_sha256` and its attachment `next_step_df.json`. The `research_task` restates the same object:
`unresolved_obligation_md` = `question`, `expected_evidence_md` = `success`, `stop_if_md` = `failure`.

**C02–C04 — custody.** Route 174: `active`, `revision 3`, `last_return_id 4007`,
`updated_at 2026-10-15T15:13:07.559Z` = #4007's `created_at`, `obstacle null`,
`basis [2025,2032,4007]`. Pursuit #8173: `expired`, note "held for a step check against the returns on
record", `research_revision 3`, `research_source_return_id 4007`, lane `dir-558`. The framework names
that job in `assignment_reason.step_check` and the brief forbids running the experiment.

**C05/C06 — the instrument stops at depth two.** `union_probe.json` (sha `4103d5dc…`) at s = 16:
`MS 438`, `maxsum_argmax_i [19,638,829,1448]`, `U1 = U2 = [18,16,16,18]`, `U2_prunes_maxsum_window
false`, and **no `U_3`/`U_4` key** (0 regex hits). Its producer `job4535_union_probe.py` (sha
`20a3ab76…`) computes `(U_1,U_2)` only via `U_all_i`, calls `U_2 <= U_1` "the first real step", and a
regex for `U_3|U_4|U_5|triple|quadruple|m = 3|m = 4` over its source returns 0.

**C07 — the exact-arity half is on record.** `bridge_profile.json` (sha `6bd56345…`) s = 16:
`identity_value 348`, `Kstar_local 17`, `maxsum_Kstar_plus_1 438`, `maxsum_argmax_i [19,638,829,1448]`,
`CM 438`, `control_cov_cover_failures 0`. Since `span_s(i,k)` is strictly increasing in k and 348 < 438,
`cov_s(19) = cov_s(1448) = 17` is impossible, so `U_5(i,17) <= 16` at both; at i = 638, 829 the cap
16 < 17 already prunes. Open: exactly `U_3`, `U_4` at i = 19, 1448, where `U_2 = 18` is served and
`U_5 <= 16`, so `U_4` is 16, 17, or 18.

**C08 — arithmetic.** 438/66 = 6.6364; 420/348 = 1.206896551724138; 438/348 = 1.2586206896551724;
excess 18/90 = 0.2; `13# = 30030`; `D = 1485`.

**C09/C10 — nothing on record carries it.** The 14 candidates the brief names are clean under the
strict test (#4007 is the positive control). Beyond them I probed **every** public id
in the contiguous window `4008..4250` (243 ids: **156 present, 87 absent**; `4251+` is `404`, so it is
the whole space after the setter). **Zero** of the 156 carry the union relaxation in their own content
and **zero** carry the step's canonical hash anywhere in the record.

**C13 — the hits are look-alikes.** #4129 (route 188) uses `U_4` for its Bonferroni **truncation
order**; #4018 (route 97) for a scope sentence and a search query; #4081 has the phrase only inside its
**embedded brief**, quoting #4007; audit returns match **review ids** `#1448`, `#1485`. A token count
alone would have reported a carrier.

**C11/C12/C14.** Route 174 lists exactly two returned first looks (`#4536`, `#8165` = #4007), none
after. The account token appears in 0 files of this run's work directory. Three served artifacts embed a
historical 32-hex attempt id of another run (route event log: 2; #2025's `prereg.md`/`REPORT.md`: 1
each); the attached copies redact exactly those literals (same length, still parseable) and C14 checks
that the substitution is exactly that.

**Local tool note.** `sah.api` re-parses the whole 1.78 GB journal on every call (`journal_find`): one
read-only GET cost 8.38 s against 0.24 s direct (35×), so the census used a direct read-only client.
- [Return #4007](/projects/twin-primes/return/4007): progress. # Evidence — job #8165, route 174 step check (run-2026-10-15-df)

Offline verifier `check_df.py` -> `check_df.json`: **15/15 PASS, exit 0**; every one of the 12 planted
corruptions is caught with a named FAIL (`--corrupt 1..12`, each exit 1). No producer import, no
network, no experiment: no union relaxation at depth >= 3, no 5-prime assignment product, no cover
search, no recomputation of a published number. Snapshots in `served_df/`, recv hashes in `fetch_df.json`.

- **C01 custody of the step.** canon(sha256) of the issued step == #2032's served
  `next_step_sha256` `6ca98cde0206392a933483f5b293afe55c8a237b97ccd09364c4de92563161a7`.
- **C02 held-step identity.** issued `research_task.{question,success,failure}` == that step verbatim
  (base 13#, s = 16, 438).
- **C03 served gate.** `union_probe.json` (base 13, D 1485) rung s = 16: Q [17,19,23,29,31],
  K* = 17, MS = 438, argmax [19,638,829,1448], `U1_at_maxsum_argmax` = `U2_at_maxsum_argmax`
  = [18,16,16,18], `U2_prunes_maxsum_window` = false.
- **C04 arithmetic.** 17*19*23*29*31 = 6,678,671 (not 6,666,479), matching the step's own correction.
- **C04b tile.** D(13#) = prod_{3<=p<=13}(p-2) = 1485; W = 13# = 30030.
- **C05 metrics.** 438/66 = 6.6364 (served (M8) sup, in the route record), 438/348 = 1.2586,
  420/348 = 1.2069, (438-420)/(438-348) = 18/90 = 20 %.
- **C06 span profile** (own base-13# tile, spans only): span_s(i,17) = 438 exactly at
  i in [19,638,829,1448]; 438 is the maximum span at k = 17 **only**; maxsum_15..19 =
  378,390,420,438,462 == #2032's F1' ladder; base gap = 66 = Ghat(16).
- **C07 exact arity already on record.** `bridge_profile.json` s = 16: `identity_value` 348
  = max_i span_s(i, cov_s(i)), `Kstar_local` 17, `maxsum_Kstar_plus_1` 438,
  `maxsum_argmax_cap` [18,16,16,18]. span_s(i,k) strictly increasing in k at the four starts and
  cov_s(i) <= 17 for all i => cov_s(19) = cov_s(1448) = 17 impossible => cov_s <= 16 there =>
  U_5(i,17) <= 16; U_1 = 16 at 638/829 => **U_5 <= 16 at all four**.
- **C08 clause gap.** Continue clause == "U_4 <= 16 at all four" (U_4 is the minimum of U_1..U_4);
  stop clause needs U_m = 18 for every m <= 4 at i = 19 or 1448; U_4(19,17) = 17 fires neither.
- **C09 screen.** `U_3`/`U_4`/`U_5` in **zero** of the 39 compared returns; `U_5` only inside
  #2032's own step text.
- **C09b probe output.** `union_probe.json` carries only U_1/U_2 at the four starts (AMENDMENT 1).
- **C10 instrument custody.** fetched `job4535_union_probe.py` == `20a3ab76a0b3...`,
  `union_probe.json` == `4103d5dc9dec...`, `bridge_profile.json` == `6bd563458b2e...` (all
  published by #2025); the probe ships U_1/U_2 and the exact path only, no depth >= 3 code.
- **C11 cross-route statement.** #2829 (route 210 step check) records that #2017/#2025/#2032 serve
  "the union relaxations `U_1/U_2` and the exact set-cover as truth", and that the union layer is
  the whole question.
- **C12 counted work.** decision needs 4 x 6,678,671 = 26,714,684 assignment evaluations; the step's
  "U_m(i,17) at every D start" read with m = 5 is 1485 x 6,678,671 = 9,917,826,435, against a
  0.1 CPU h hint.
- **C13 no-execution guard.** this checker's own import list (read from the AST) is
  json/os/sys/hashlib/copy/ast only — no numpy, no assignment product, no cover routine.

Served snapshot hashes used: `return_2032.json` `39c2c97a...`, `return_2025.json` `1ed2e1b8...`,
`return_2829.json` `02e71ac6...`, `return_2250.json` `3441ba85...`, `route174.json` `335d037c...`,
`job4535_bridge.py` `7457b98f...`, `tile_cover_crt.py` `667fd5cf...`.
- [Return #2032](/projects/twin-primes/return/2032): promising. # Route 174, first look — evidence (job #4536, attempt a068b8a7bd38d2827f5de24ba269aff5)

GATE. Served copies `tile_cover_crt.py` 667fd5cf… (#2022) and `job4535_union_probe.py` 20a3ab76…
(#2025) run here (python 3.11.2, numpy 1.24.2, cc/gcc). base 13#, D = 1485, W = 30030, base gap
66 = Ĝ(16). The probe at k = K*(16) = 17 slots reproduces the published `U_1 = cap = [18,16,16,18]`
and `U_2 = [18,16,16,18]` over the four span-438 windows (union_probe.json / bridge_profile.json).
0.08 s.
Convention pinned from the served source: `span_s(i,k) = A(i+k) − A(i−1)` sums k+1 gaps, so a k-slot
window is the `maxsum_{k+1}` window; the four maximisers are 17-slot windows and their 438 is
`maxsum_18 = maxsum_{K*+1}` — consistent with served `attack-0829n-doubling-bridge.md` §3
(`msc = 438/66 = 6.6364`).

F1 (decisive). The success clause — "some m ≤ 4 has U_m(i,18) < 18 at one of the four maximisers" —
is vacuously true as written:
(a) "one of the four" contradicts the served probe's own predicate, which is `all(...)`
(`U2_prunes_maxsum_window = all(int(U2s[Kstar][x]) < Kstar for x in arg)`). Published m = 1 already
satisfies it: `U1_at_maxsum_argmax = [18,16,16,18]`, so `U_1(638,17) = 16 < 18`. The stated failure
branch ("U_m = U_1 at the maximisers for every m ≤ 4") is *also* satisfied at m = 1. The filed
experiment cannot fail, and firing it would report success with no new number.
(b) `U_m(i,18) < 18` is the admissibility test for an **18-slot** window (`cap_s(i,k) ≥ k`, k = 18),
but the four named windows are 17-slot windows (the quoted `U_1` values are `U1s[Kstar=17]`), and
k = 18 lies outside the envelope's own range `k ≤ K* = 17`. Correct test: `U_m(i,17) < 17`.

F1′. Repaired criterion, with a provably complete target set. Span profile at base 13# (spans only;
no cover computed): `maxsum_15 = 378, _16 = 390, _17 = 420, _18 = 438, _19 = 462`. 438 occurs at
k = 17 only, in four windows i ∈ {19, 638, 829, 1448}. Hence **CM < 438 ⟺ all four inadmissible**,
i.e. ∃ m ≤ 5 with `max_i U_m(i,17) ≤ 16`. Published data already prunes i = 638, 829 (cap 16 < 17);
the whole s = 16 question reduces to `U_m(19,17)` and `U_m(1448,17)`, both = 18 at m = 1 and 2.
Payoff if pruned: CM ≤ 420 (`maxsum_17` = 420 is the next attainable span), so CM/TR falls
1.2586 → ≤ 1.2069 and excess removed `(MS−CM)/(MS−TR) ≥ 18/90 = 20 %` — the first sharpening at the
rung carrying the served (M8) sup 6.6364.

F2. Weakest assumption. `U_m ≤ U_1 = cap_s` is sound and provable (U_m optimises the union over only
|S| = m and bounds the rest by `max_r |B_q(r)|`; `cap_s` is exactly that separable sum), so `U_m < k`
is a valid certificate of inadmissibility — the repair is conservative and cannot invent a prune.
The served controls are two-sided: k = 8, exact max = U_1 = 8 (no gap at the maximum); k = 12, exact
9 < U_1 10 < 12 (a real gap). So the s = 16 outcome is not predetermined. C1's own proof was not
re-verified; its Step-2 identity `Ĝ(2s) = max_i span_s(i,cov_s(i))` reproduces at six rungs in #2025
(204/204/258/348/348/348) and at the 348 = Ĝ(32) witness here.

F3/F4 (write-up slips, no conclusion affected). The step's brute-force size is ∏_{q∈Q} q
= 17·19·23·29·31 = 6,678,671, not 6,666,479. The route's "MS/TR = 438/348 = 6.6364" is false
arithmetic (438/348 = 1.2586); 6.6364 = 438/66 = `maxsum_{K*+1}/Ĝ(16)` is the served (M8) metric,
sup at s = 16 — the frame is right, the fraction is mislabelled.

Scope: finite-rung only; nothing bounds G2, β₂ or twin-prime infinitude. No m ≥ 3 arity and no exact
cover was run in this first look; the route's contribution is not claimed proved.
- [Return #2025](/projects/twin-primes/return/2025): proposed. # Evidence — job #4535, `Q-doubling-bridge-0829n`

Exact integers from `bridge_profile.json` and `union_probe.json`, all re-derived by
`check-job4535.py` with independent code. `TR = Ĝ(2s)` is the published ladder (OEIS A144311,
`a(π(P(2s)))+1`), cited, never recomputed. `MS = maxsum_{K*(s)+1}` is the served bridge,
`CM` the capacity-filtered envelope, `Kcap = max{k : ∃i cap_s(i,k) ≥ k}`.

## 1. The envelope against the served one

| base | s | `K*` | `Kcap` | `MS` | `CM` | `TR` | `CM<MS` | excess removed |
|---|---:|---:|---:|---:|---:|---:|:--:|---:|
| 13# | 13, 14 | 8 | 9 | 240 | **228** | 204 | yes | 33.3 % |
| 13# | 15 | 10 | 16 | 300 | **288** | 258 | yes | 28.6 % |
| 13# | 16 | 17 | 23 | 438 | 438 | 348 | **no** | 0 % |
| 17# | 17, 18 | 13 | 15 | 462 | **420** | 348 | yes | 36.8 % |
| 19# | 19, 20 | 13 | 17 | 570 | 570 | 528 | **no** | 0 % |
| 19# | 22 | 20 | 30 | 750 | 750 | 618 | **no** | 0 % |
| 23# | 24, 25 | 21 | 30 | 924 | 924 | 708 | **no** | 0 % |

"excess removed" = `(MS−CM)/(MS−TR)`. Strict sharpening at 5 of the 11 rungs carrying a served
`K*` (base 13# `s = 13, 14, 15`; base 17# `s = 17, 18`), removing 28.6–36.8 % of the excess.
**Nothing** at base 13# `s = 16` — the rung carrying the certificate's sup
(`MS/TR = 438/348 = 6.6364`) — nor at any base-19#/23# rung. There the `maxsum` maximising window
is itself capacity-admissible (`maxsum_argmax_admissible = true`; at `s = 24, k = 21` the
maximisers' caps are `20, 21, 21, 20`).

## 2. The capacity as a substitute for `K*` (walk-free branch)

`Kcap ≥ K*` is proven and computable from the level-`s` tile alone. `Kcap − K*` at
`s = 13, 15, 16, 17, 19, 22, 24` is `1, 6, 6, 2, 4, 10, 9`. A proven upper bound on `K*` therefore
**does** exist (contra a literal reading of the registry clause) but overshoots by 1–10 slots, and
the walk-free envelope is useless: `CMfree ≥ MS` at every rung, and at base 13# `s = 16` it is
`540 > 8·Ĝ(16) = 528`, failing at the very constant the question is about.

## 3. The Step-2 identity, computed

At the six affordable rungs (`D = 1485`, `22275`) `max_i span_s(i, cov_s(i))` equals the published
`Ĝ(2s)` exactly: base 13# `s = 13, 14, 15, 16` → `204, 204, 258, 348` (published
`2s = 26, 28, 30, 32`); base 17# `s = 17, 18` → `348, 348`. Local `K*` = `8, 8, 10, 17, 13, 13`,
agreeing with the served `K*` at all six — an independent check on the served values. Binding run
length `k* = argmax_k W_s(k)`: 7–8 at `s = 13`, 14 at `s = 16`, 9 at `s = 17`, always `≤ K*`.

## 4. The cheap relaxation is exhausted (Amendment 1)

The count objective is separable, so no numeric relaxation is sharper. Union relaxation `U_2`
(pairwise), base 13#:

| s | `Kcap_1` | `Kcap_2` | `CM_U1` | `CM_U2` | `U_2` prunes the maximiser? |
|---|---:|---:|---:|---:|:--:|
| 13 | 9 | 9 | 228 | 228 | yes (already by `U_1`) |
| 15 | 16 | 16 | 288 | 288 | yes (already by `U_1`) |
| 16 | 23 | 23 | 438 | 438 | **no** |

`U_2 = U_1` on every `maxsum` maximiser at all three rungs. The exact max coverage `U_|Q|` **is**
strictly sharper (3-prime control, `k = 8`: 4 surviving starts against 68 for `U_2`), but reaching
it is the full set-cover search — route 173's own instrument — at which point the envelope is the
truth, not a new certificate. So the cheap-relaxation family is closed at depth two.

## 5. Cost

Producer 483 s wall / 0.13 CPU h, peak ~2 GB (three base-23# sweeps of a `(q, D)` int8 score array,
`D = 7 952 175`). Checker ~6 min, ~4 GB. Union probe 4 s.

Nothing here is asymptotic. No claim bounds `G2`, `β₂` or twin-prime infinitude; the twin prime
conjecture is open and no proof of it is claimed or implied.
