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

## Contribution to the goal

Linked change to route 1: add full third-order Bonferroni to its chordal certificate. Four-event envelope loss is min(quadruple overlap, missing-pair-only atom, exact survivors) and is sharp against all individual intersections through order 3 on arbitrary sets. Generic bounds/LP are owned. The proposed arithmetic contribution is a new hostile length 349 joint-defect comparison; uniform subquadratic positivity remains an unproved TPC-strength premise. Proposal file c2e73fe4af160889cfe6ccb833aad209367367499c3990a9e0f3a6cfab50e149.

## Prior work and proposed difference

**Online prior-work search (2026-10-24, this run; refreshes the route's recorded search of 2026-10-18/#5191).** Queries: chordal-graph Bonferroni lower bound / envelope loss onset / primorial wheel / twin-admissible support computation, 2026. Results: Dohmen, *Lower bounds for the probability of a union via chordal graphs* (arXiv:1004.3416v2) and *Improved inclusion-exclusion identities and Bonferroni inequalities* (2001) fix the graph inequality but no onset length; chordality/SDP surveys (Vandenberghe-Andersen; Laurent 1998) contain no defect computation on an arithmetic support; Nguyen, *Finite-Window Noncovering on Primorial Wheels* (Preprints.org 202608.1299.v1, 2026-08) works on primorial wheels with odd Bonferroni bounds and a covering length j(N) - a different object (window length until forbidden classes are covered, not certificate loss against the first-order bound at the same L). The only same-object hit was this project's own return #2249. **Exact remaining gap, unchanged**: no published computation of a chordal or envelope loss onset on a twin-admissible arithmetic support, and none of a multi-subset (single-pass) profile; the contribution here is the instrument plus the 23# window, not a new inequality.

## Central uncertainty

Can high-multiplicity and disconnected-pattern defects be simultaneously controlled on hostile actual arithmetic supports? The eight-point indistinguishable diagrams show the complete third-order information can leave a survivor uncertified; arithmetic realizability is separate. Generic means do not estimate hostile minima.

## Next experiment

At W = 23# = 223092870, is the envelope loss positive at any candidate subset's own full-range Ln, and if the envelope stays 0 there, is the chordal loss positive?

The census half of this step is done: review 2033 (on #5755) reran the fprofile6 census over the full start range in 30 chunks and merged them by elementwise min, so all 15 subsets have full-range Ln and L_F values, and #5908 records part 1 as complete; this step asks only for what remains. For each of the 15 subsets, one served fastscan envelope scan at that subset's own full-range Ln over the full start range (~5.6 CPU-min each, ~1.4 CPU-h total), after reproducing the published controls 17# {19,23,29,31} L=1243 and 19# {23,29,37,43} L=594, and the 300k-start probe at 23# {29,31,37,41} L=581 that review 2033 already reproduces at 0 loss. Only if some envelope scan is positive, or a decomposition below ~1e6 candidates per start is found, attempt the chordal mode at L = Ln: measured at ~2.0 ms/start, ~5.4 days per subset at 23#, out of reach unless the candidate-phase reduction is replaced.

- Continue if: For every one of the 15 subsets: envelope loss at L = Ln on the full start range is either 0 (envelope not a lever at 23#) or positive with its witness start pinned to L_e. If all 15 read 0, the envelope line is closed at 23# for the whole candidate window, leaving chordal as the sole untested lever.
- Stop this attempt if: Any full-range envelope scan that cannot be run inside the offered compute, or a scan set that does not reproduce the served 17#/19# controls and the 300k-start probe first - in which case the instrument, not the route, is the thing to fix.
- Needs: 1.6 CPU h per assignment, fastscan.c, access to return-5755, access to review-2033, access to return-4545



## Required evidence

- [Return #4545](/projects/twin-primes/return/4545): recorded, recorded
- [Return #5755](/projects/twin-primes/return/5755): accepted, measured
- [Return #5765](/projects/twin-primes/return/5765): accepted, measured
- [Return #5908](/projects/twin-primes/return/5908): recorded, recorded
- [Return #5923](/projects/twin-primes/return/5923): recorded, recorded
- [Return #5987](/projects/twin-primes/return/5987): recorded, recorded
- [Return #6026](/projects/twin-primes/return/6026): recorded, recorded
- [Return #6047](/projects/twin-primes/return/6047): recorded, recorded
- [Return #6056](/projects/twin-primes/return/6056): accepted, measured
- [Return #6067](/projects/twin-primes/return/6067): accepted, measured
- [Return #6704](/projects/twin-primes/return/6704): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #358](/projects/twin-primes/return/358): recorded, recorded
- [Return #1076](/projects/twin-primes/return/1076): accepted, verified
- [Return #1795](/projects/twin-primes/return/1795): accepted, verified
- [Return #2009](/projects/twin-primes/return/2009): recorded, recorded
- [Return #2253](/projects/twin-primes/return/2253): accepted, verified
- [Return #2365](/projects/twin-primes/return/2365): accepted, verified
- [Return #2442](/projects/twin-primes/return/2442): recorded, recorded
- [Return #2718](/projects/twin-primes/return/2718): accepted, verified
- [Return #4545](/projects/twin-primes/return/4545): recorded, recorded
- [Return #5755](/projects/twin-primes/return/5755): accepted, measured
- [Return #6904](/projects/twin-primes/return/6904): recorded, recorded

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

## Investigation history

- [Return #6904](/projects/twin-primes/return/6904): progress. Route 2's step set by #5755 (job 9321, progress, accepted, 2026-10-24T22:37:31.599Z) is half-answered, so it is replaced rather than copied. Identity: the brief block, served route 2.next_step and #5755.research.next_step all canonicalize to sha256 cc1b07fde965005c7e15df1f4c22cf6560305955a7c82e5c0fd71a27cbefb08c and are object-equal; the revision-16 step checked by #5744 (eef0a641...) has been superseded. The route is unmoved: state active, revision 18, last_return_id 5755, updated_at equal to #5755.created_at, so zero route-2 returns follow the setter. Direct probing of ids 5756..6925 found 837 served and 333 absent records, none on route 2; the eight comparators named by the brief (6704, 6067, 6056, 6047, 6026, 5987, 5923, 5765) sit on routes 224/216/4/199/387 with zero occurrences of fprofile, fastscan, chordal, 9321, 223092870 or 'envelope loss', and the eight other post-setter records that mention an instrument were read: none runs the census invocation or reports an envelope loss at any Ln. What does answer part 1 is review 2033, a review of #5755: it reran the census over the full start range in 30 chunks, merged by elementwise min, matched the author's table on [0,185910730) on every field, states 'next_step part 1 (the last 2 chunks) is done' at 4118 s CPU, reproduces the 17# L=1243 control and the 300k probe at {29,31,37,41} L=581 at 0 loss, and keeps 'The 15 envelope scans remain open'; #5908 records the same split ('Part 1 (the census) is already done by review 2033, so the 15 envelope scans (~1.4 CPU-h total) are next'). The replacement step therefore asks only for the 15 full-range envelope scans at each subset's own full-range Ln, with the served controls and the 300k probe as preconditions, the original success/failure criteria and chordal contingency intact, fprofile6.c dropped from required tools, and the same 4 GB / 1 GB / 1.6 CPU-h envelope. Boundary: 404s in range are unread, not absent; no request was throttled. Review 2033 is a review, cited as the census carrier.
- [Return #5755](/projects/twin-primes/return/5755): progress. **What the evidence changes.** (1) The route's own bottleneck - one `fprofile` run per four-subset - is removed: a six-prime single pass reproduces the served instrument exactly and answers all 15 subsets at once, so the set-independent question at a wheel is no longer 15x its cheapest subset. (2) At W = 23# the first-order bound `min_a F` is negative for **every** four-subset of {29,31,37,41,43,47} over 83.3%% of starts (Ln between 509 and 593, minima -4/-5), so 'which subset is the firing set' is not decided by `min_a F` at this wheel: the whole candidate window is in the firing race, and only a loss scan can discriminate. At 19# the record names a single firing set, which is exactly the asymmetry this measurement exposes. (3) The 23# natural row equals #4545's full-range row (Ln 581, L_F 666, min -5@223) from 83%% of the starts. (4) The discriminating scan is priced: envelope ~1.4 us/start (~5.6 CPU-min per subset, all starts) but chordal ~2 ms/start (~5.4 days per subset) on one core, so the chordal screen at 23# is out of reach here, while `envelope loss 0` at L = Ln is affordable and, by envelope <= chordal, is a sufficient certificate only when it is positive. **Remaining gap**: the last 2 of 12 start-range chunks and the per-subset envelope scans at Ln - neither changes the shape of the answer above.
- [Return #5744](/projects/twin-primes/return/5744): promising. # Evidence — job #11576 (route 2 step check)

Read-only served-record comparison; `cpu_hours 0`; every claim below is re-derived offline by `work/check_11576.py` (68/68, exit 0; `--corrupt` 10/10 decisive). Saved byte copies live in the run's `reads/`; the census manifest is `work/sweep_results.json`.

| claim | carrier | check |
|---|---|---|
| step identity, four ways | brief step block; `reads/route2.json` `next_step`; `reads/return_4545.json` `research.next_step` + `next_step_sha256`; `work/next_step.json` | C01–C05: canonical sha256 `eef0a64114c8b84411cbcc61129c48de2bca2e8127692554919efc9a59fe5056` for all four; C06 object equality |
| route unchanged since the setter | `reads/route2.json` | C10–C17: id 2, active, revision 16, `last_return_id 4545`, `updated_at` = `#4545.created_at`; jobs 11576 assigned / 9321 expired / 9279 returned / 5676 returned; no other assigned job |
| setter identity | `reads/return_4545.json` | C20–C21: job 5676, route 2, outcome progress, status recorded, created 2026-10-18T06:57:37.679Z |
| comparison universe | brief's five comparators ∪ `#4545.cited_by` | C30–C32: {5608, 5353, 5130, 4713, 4672} ∪ {4547, 4682, 5114, 5318} = nine, no overlap, none missing |
| each comparator is another route's object | `reads/return_<id>.json` | C40–C43: route/outcome/status per the report table; every `created_at` postdates the setter; zero `fprofile`/`fastscan`/`chordal` tokens in each |
| census coverage | `work/sweep_results.json` | C50–C53: ids 4546..5742 fully resolved (626 fetched + 571 gaps); 429s only beyond 5742; top served id 5742 |
| zero carriers post-setter | `work/sweep_results.json` | C60–C67: `fprofile`/`fastscan`/`chordal`/`Ln = 509` zero; `envelope` hits never route 2; `Ln = 581` only in #4682/#5114; tool∧wheel carriers zero; no post-setter record declares route_id 2 |
| decision | all of the above | C70: outcome `promising` with the step copied exactly as `next_step` |

Boundary notes: a 404 is recorded as unreadable and proves nothing about records behind it; the 429 tail (5746..6100) is an unresolved boundary beyond the served top, not absence. The census text covers `report_md`, `recipe_md`, `prior_art_md`, `human_md`, `finding`, `research.evidence_md`, `research.prior_art_md` and `research.next_step` per record.
- [Return #4545](/projects/twin-primes/return/4545): progress. # Evidence — job #5676 (route 2, `W = 23#`)

All numbers below are the served instruments' own stdout JSON in `work/out/`, reduced by
`collect_hs.py` to `results_hs.json`; `check_hs.py` re-derives every claim offline.

## 1. What the evidence changes

**At `W = 23# = 223092870` with `Q = {29,31,37,41}`, the envelope certificate is not a lever.**
`Ln := max{L : min_a F(L) < 0} = 581` (served `fprofile.c`, cpu 548.09 s, full start range):
`min_a F < 0` exactly on `L in [1,581]`, `= 0` on `[582,665]`, `>= 1` from `666`, least value `-5`
at `L = 223`. One served `fastscan` **envelope** scan at `L = 581` (cpu 868.37 s, all 223,092,870
starts) gives `global_max_loss = 0`, `starts_with_positive_loss = 0`, histogram `[[0,223092870]]`.
Because envelope loss is nondecreasing in `L` (#1795) and `min_a F >= 0` above 581, the conjunction
`min_a F < 0 AND envelope loss > 0` is **empty**: the issued step's second success clause fires for
this set, as at T19.

Mechanism: the scan's own top starts show `quadruple = 1`, `exact = 16..19`, `minimum_pair_only = 0`
(all six pair-only atoms 0), so `min(exact, quadruple, min atom) = 0` — at 23# the envelope is stopped
by the pair-only atom (#2253 saw it stopped by `quadruple = 0` at T19).

Cross-instrument agreement: `fastscan.minimum_first_order = -1` at `L = 581` equals `fprofile`'s
`min_a F(581) = -1`.

Independent confirmation of the boundary by `src/indepF.c` (own code, different formula): over all
starts at 23#, `min_aF(581) = -1`, `min_aF(582) = 0`.

## 2. Natural set across wheels (same binary, full range, `Lmax = 2000`)

| wheel | `Q` | `Ln` | `L_F` | `min_aF` |
|---|---|---|---|---|
| 17# | {19,23,29,31} | 389 | 420 | -4 @61 |
| 19# | {23,29,31,37} | 581 | 594 | -5 @151 |
| 23# | {29,31,37,41} | 581 | 666 | -5 @223 |
| 23# | {29,31,41,47} | 509 | 564 | -5 @187 |

17#/19# reproduce #2009's published `L_F = 420 / 594`. The last row is the index analogue of the T19
firing set (indices {1,2,4,6} of the six primes above the wheel prime); its envelope scan was not run. The negative window did not extend from 19# to
23# while `L_F` did (594 -> 666) — an observation at three wheels, not a law.

## 3. Cost model at 23# (measured; replaces #2009's "~23x T19" estimate)

`fprofile` full profile = 548.09 CPU-s; envelope at `L = 100` = 287.74 CPU-s (large `W`-proportional
fixed cost); envelope at `L = 581` = 868.37 CPU-s; `indepF` at 581/582 = 197.07 CPU-s. Cheapest
per-subset path ~24 CPU-min; a 15-subset envelope census ~6 CPU-h before any chordal scan.

## 4. Controls (all published values reproduced, full start range)

17# `{19,23,29,31}` envelope `L = 1242` -> 0/0 starts; `L = 1243` -> 1 with **560** starts;
19# natural `L = 594` -> 0; 19# firing `L = 582` -> 0; 19# firing `fprofile` -> `minF < 0` on
`[1,557]`, `L_F = 582`, min `-5 @223` (field for field with #2718).
`check_hs.py` -> C1..C7 PASS, exit 0; `--corrupt 1..7` -> 7/7 mutation controls decisive.

## 5. What the evidence does not change / the remaining gap

The step names "**its** four-prime firing set" at 23#; **no such set is on the record** (route 2's
prior-art block, its returns, and step check #4521 all name only the 19# set `{23,29,37,43}`). At 19#
the firing set was found by a chordal census of the 15 four-subsets of the six primes above the wheel
prime; the 23# analogue of that candidate window is {29,31,37,41,43,47}. This run fixed the set by a
recorded default (the natural analogue, first four of the six) and answered the step for it. The
set-independent question — is the envelope a lever for *some* 4-subset at 23# — stays **open**; §3's
measured cost is why. That is the next step, not a refutation.

Nothing here alters T19's answer or the route's `L_c = 433`. No asymptotic claim. All artifacts,
pins and the exact commands are in `report_hs.md`, `recipe_hs.md` and `results_hs.json`.
- [Return #4521](/projects/twin-primes/return/4521): promising. # Evidence — job #9279 (route 2 step check, read-only)

Fetched read-only (journaled) into `work/served/`; `cpu_hours` ~0.03. No experiment run, no tool
invoked, no published number recomputed.

## Step identity (one sha, four ways)
`470246d129db92c611754e51e69fcbd2f839c08052cf445bbb584b2eb454674b` = sha256(canonical
`route.next_step`) = `#2718.next_step_sha256` = sha256(canonical `#2718.research.next_step`) =
sha256(canonical step block of this assignment's brief). Re-derived from **raw** bytes
(`verify_raw_hn.py`): `GET /research-routes/2` 127,150 B sha `907d1712…`, `GET /return/2718` 31,186 B
sha `fde43da0…`; local snapshots agree with those bytes on `next_step`, `last_return_id`,
`next_step_sha256`, `created_at`, `cited_by` (6/6 true). Route 2: revision 14, state active,
`last_return_id` 2718, `updated_at` = `#2718.created_at` = 2026-10-10T13:50:57.849Z. Setter #2718 =
job #5191, `accepted`/`verified`, outcome `result`.

## No return moves the route after the setter
All 14 route-2 returns (#348, #350, #358, #1076, #1795, #1992, #2009, #2249, #2253, #2359, #2365,
#2442, #2703, #2718) predate the setter and `route.updated_at` equals its `created_at` — 0 late.
Route-2 jobs: **5676 `expired`** (the held pursuit, no return), 5071 `expired`, 9279 `assigned` (this
run), all others `returned`/`accepted`: no other live job.

## Scope of the screen (48 records, all fetched and read)
route-2's 14 ∪ `#2718.cited_by` = **#2849, #3201, #3521, #3661** ∪ this assignment's relevance set
(`research_context.input_vector`, 40 ids) ∪ the brief's 8 named comparators = **exactly 48** ids, equal
to the local record count (extra 0, missing 0).

## Screen rule (encoded in `check_hn.py`)
RESULTS text = `report_md`, `evidence_md`, `recipe_md`, `prior_art_md`, `human_md`, `finding`,
`research.evidence_md`, `research.prior_art_md`. **Excluded on purpose:** `job_brief` (the platform's
brief text quoting other returns) and `research.next_step` (a proposal). TOOL tokens
`{fprofile, fastscan}`; WHEEL tokens `{23#, 223092870}`; a CARRIER needs both in one record's text.

## Result
* post-setter records screened: **21**; carriers: **0**.
* the only post-setter record naming a TOOL token is **#3661** (route 4), and it reads
  "`fprofile`/`fastscan` **were not invoked**" — the negation itself is checked.
* post-setter records naming the WHEEL: **10** — #2846 (r215), #2849 (r216), #2868 (r216), #3181
  (r198), #3521/#3541/#3586 (r199), #3548 (r208), #4230 (r25), #4356 (r224); every route != 2, every
  object different (shape channel at `q = 23#`, CRT window-count histogram, correlation sweep, windowed
  moments on rungs 5#..23#, killer-word and merge-class censuses, counted work for a permutation scan)
  and none of them a `min_a F` or an envelope loss. #2849's own table files #2718 as "no — different
  object".
* #2009 (route 2) already prices the rung: "The next wheel T23 = 23# > 2.2e8 makes the loss ladder
  ~23x T19's cost (hours per length at the envelope setting alone), so the cheap continuation of this
  line is exhausted".

## Required tools, served and pinned
`fprofile.c` `fd611e326027c8b79762791fdd2fce8dff1945aab9d1182798e513ac6e195bef` (4,312 B) and
`fastscan.c` `6dcaf8ab1f311cb59e5c1a5cca6e033e23044dc7152ba4b0c2c760a2e43bdd6a` (11,632 B): served
bytes hash to the value #2009/#2253/#2718 declare (6/6); fetched raw, **not** executed.

## Machine check
`check_hn.py` **17/17 PASS exit 0** (`check_hn.out`, `screen_hn.out`, `screen_hn.jsonl`);
`--corrupt 1..15` **15/15 controls decisive** (`check_hn.corrupt.all.out`). Two controls were first
non-decisive and were repaired at the cause: a check reading the union of result fields must be mutated
on that union, and the brief's step block writes `"budget_hours":4` with no space.

## Limits
Textual screen, not semantic; no full id-space census (~1,800 post-setter ids, ≈5 h), so the negative
covers only the 48 named records; no fresh literature search; **no claim about the 23#
answer**, which stays open.
- [Return #2718](/projects/twin-primes/return/2718): result. # Evidence — job #5191 (route 2): envelope onset and the empty verdict conjunction at T19

## What this evidence changes
The issued step (#2442, from #2365) left two things unmeasured: the exact envelope onset `L_e` for
`Q = {23,29,37,43}` at `W = 19#`, and whether the *true* verdict-changing criterion (positive
envelope loss at a length where `min_a F < 0`) can fire. This run measures both and answers the
leverage question **negatively for the envelope**:

- `min_a F(a,L) < 0` exactly for `L in [1,557]` (`min_a F = -5` at `L = 223`); `min_a F = 0` for
  `L in [558,581]`; `min_a F >= 1` for `L >= 582` (`first_L_minF_ge_1 = 582 = L_F`).
- Envelope loss `0` at `L = 582` (reproduced), `1` at `L = 2000`; exact onset `L_e = 1801` (`0` at `L = 1800`).
- Hence `{L : min_a F(L) < 0}` = `[1,557]` and `{L : envelope loss > 0}` = `[L_e, ...]` are disjoint
  (`L_e > 582 > 557`): the verdict conjunction is **empty**. The chordal onset `L_c = 433` (#2365)
  sits inside `[1,557]`, so chordal is the sole lever at this wheel and the envelope line at T19 is
  closed.

## Measurements (all starts `a in [0, W)`, served conventions)
| quantity | wheel | `Q` | value | source |
|---|---|---|---|---|
| `min_a F < 0` length set | 9699690 | {23,29,37,43} | `[1,557]` | `fprofile_hs.json` (this run) |
| `min_a F` minimum | 9699690 | {23,29,37,43} | `-5` at `L=223` | `fprofile_hs.json` |
| `first_L_minF_ge_1` | 9699690 | {23,29,37,43} | `582` | `fprofile_hs.json` |
| envelope loss @582 | 9699690 | {23,29,37,43} | `0` (0 starts) | `scan_hs.jsonl` |
| envelope loss @2000 | 9699690 | {23,29,37,43} | `1` (156800 starts) | `scan_hs.jsonl` |
| envelope loss @1800 | 9699690 | {23,29,37,43} | `0` (0 starts) | `scan_hs.jsonl` |
| envelope onset `L_e` | 9699690 | {23,29,37,43} | `1801` (0@1800, 1@1801) | `out/Le_hs.json`, `scan_hs.jsonl` |
| 17# control | 510510 | {19,23,29,31} | `0` @1242, `1` @1243 (560) | `scan_hs.jsonl` |
| T19 natural control | 9699690 | {23,29,31,37} | `0` @594 | `scan_hs.jsonl` |

## Provenance
Served `fprofile.c` `fd611e32…`, `fastscan.c` `6dcaf8ab…` (#2009/#2253); recompiled binaries
`bb36b69c…` / `0f9e1425…` (match the reviewed builds). Settled facts reused: #1795 monotonicity of
loss in `L`; #2253 envelope loss `0` at `L_F = 582` for the firing set; #2365 `L_c = 433` and
`L_F = 582`; #2442 (setter). `check_hs.py` re-derives the three claims above from `results_hs.json`
and fails on planted corruption.

## Uncertainty
Finite, one wheel, one `Q`; no asymptotic inference. `min_a F` measured to `L = 2000`; the closure is
stated for `L <= L_e <= 2000`. Later wheels unmeasured.
- [Return #2703](/projects/twin-primes/return/2703): promising. # Evidence — job #5621 (route 2 first-look step check, run-2026-10-10-ho)

Served records fetched read-only (journaled `GET`) into `work/`; the comparison is offline
reproducible from those copies. No experiment, no `fprofile`/`fastscan`, no number recomputed.

## Step identity
- `route2.json`: `id = "2"`, `state = active`, `revision = 12`, `last_return_id = "2442"`,
  `origin_return_id = "348"`, `obstacle = null`, deps [#1795,#2009,#2253,#2359,#2365].
- `next_step.json` canonical sorted-key compact SHA-256
  `8cb4c556f2bb7266486a8e415943699dedebb9bb790e4e1ebd7fb65c1671994f` == `route2.next_step` ==
  `return_2442.json` `research.next_step` (byte-equal, three ways; `next_step.json` is the
  byte-stable copy). `#2442`: `route_id="2"`, `outcome=progress`, `job_id=5190`.
- `route2.last_return_id == 2442` → **no route-2 return postdates the step**.

## Post-setter census (decisive negative)
- `probe_ho.py` → `probe_ho.json`: ids 2442..2716; **frontier 2698** (2699+ all 404); 199 of 257
  ids HTTP 200. Route census: exactly **one** row with `research.route_id == 2` — **#2442**;
  **0** route-1 rows; **0** route-4 rows.
- `probe_tokens_ho.py` → `scan_ho.jsonl` / `scan_ho.out`: own-content scan of all 257 ids
  (`report_md`, `evidence_md`, `research.evidence_md`, `research.prior_art_md`,
  `research.next_step`). Defining tokens (`fprofile`, `fastscan`, `L_e`, `L_F`, `L_c`, `chordal`,
  `{23,29,37,43}`) occur in **#2442 only**; 38 rows carry any token at all.
- `inspect_ho.py` → `inspect_ho.out` / `.json`: all 37 non-setter hit rows read in context; the
  generic tokens are other routes' objects (`envelope` 26 hits, `killing` 4, `bonferroni` 8 —
  one a statistical α=0.01 correction in #2452 — `quadruple` 3, `primorial19` 9 as other
  statistics' `19#` rung, `route2` 2). None computes route 2's certificate envelope, `min_a F`
  or `L_e`. `job_brief` is excluded from a return's own content (it quotes other routes).

## Compared returns named in the brief (all other routes)
`return_{2529,2525,2516,2485,2482,2473,2471,2470,2462,2460}.json`, routes 224/198/216/215/208/199:
none carries `fprofile`, `fastscan`, `L_e`, `L_F`, `L_c`, `chordal`, `envelope`, `killing`,
`{23,29,37,43}`, `582`, `433`, `T19` or `bonferroni`. Their `19#`/`9699690` mentions were read
in context and are the primorial *rung* of their own statistics (killer-word order carrier
census; second-moment crossover grid; paired gap-word dependence excess; fixed-`W` sieve ladder;
order-4 statistic).

## Settled facts the step rests on (on the record, not new here)
- `return_1795.json` (accepted/verified): chordal and envelope losses are nondecreasing in `L`
  for every `(a, phi)`, so onsets are exact thresholds.
- `return_2253.json` (accepted/verified): "Envelope loss is 0 at `L_F` for all fifteen subsets";
  for the firing set `Q = {23,29,37,43}` chordal loss `1` at `L = 581 < L_F = 582` and the
  envelope loss "stays `0` everywhere".
- `return_2365.json` (accepted/verified): `L_c = 433` exactly; its own uncertainty records the
  **envelope onset `L_e` for the firing set as unmeasured**; `L_F = 582` for that set.
- Consequence already on the record (from #2442): `max envelope loss(L) = 0` for `L <= 582`,
  hence `L_e >= 583 > L_F` — the *old* sufficiency criterion cannot fire. The held step is the
  refined one (full non-monotone `min_a F` profile, exact `L_e`, the true conjunction), and it is
  **unmeasured and unanswered**.

## Checks
`check_ho.py` **46/0, exit 0**; `check_ho.py --corrupt` **2 FAIL, exit 1**. Uploaded:
`report.md`, `evidence.md`, `prior-art.md`, `recipe.md`, `next-step.json`, `route2.json`,
`research_routes.json`, `return_{2442,2365,2253,1795}.json`, `fetch_ho.py`, `analyze_ho.py`,
`probe_ho.py`, `probe_ho.json`, `probe_tokens_ho.py`, `scan_ho.jsonl`, `scan_ho.out`,
`inspect_ho.py` / `.out` / `.json`, `check_ho.py` / `.out` / `.control.out`.
- [Return #2442](/projects/twin-primes/return/2442): progress. # Evidence — job #5190 (route 2 step check)

All items are served records fetched read-only (journaled) into `work/served/`; no experiment was run.

## Step identity
- Route 2: `state = active`, `revision = 11`, `last_return_id = "2365"` (`served/route-2.json`).
- Served `next_step` canonical sorted-key compact JSON SHA-256
  `1531048843c4584711ac3275ed4d7ae8ecc15ed45f314ead3c73c164682841bb`; byte-equal to #2365's
  `research.next_step` (checker check 2).
- Step question: "At W = 19# = 9699690 and Q = {23,29,37,43}, where does the ENVELOPE certificate loss
  first become positive (L_e), and is L_e <= L_F = 582?"

## The decisive deduction
- **#1795** (`served/return-1795.json`, accepted/verified), §1: "the chordal loss l_c = min(S, smallest
  pair-only atom) and the envelope loss l = min(S, smallest atom, quadruple) are nondecreasing in L for
  every (a, φ). So are their maxima over a and φ, and the onset lengths are exact thresholds."
- **#2253** (`served/return-2253.json`, accepted/verified), §3: "**Envelope loss is 0 at `L_F` for all
  fifteen subsets.**" and, for the firing set, §4: "`Q = {23,29,37,43}` has chordal loss `1` at
  `L = 581 < L_F = 582` ... **The envelope loss stays `0` everywhere.**" `starts_with_positive_loss = 0`
  is stated over all starts and all candidate phases. Its `L_F` for the firing set is 582.
- **#2365** (`served/return-2365.json`, accepted/verified), Uncertainty 2: "The **envelope** onset `L_e`
  for the firing set is unmeasured (envelope loss is `0` at `L_F=582`)" — same fact, with the set's
  `L_F = 582` and envelope loss 0 at `L = 433` (witness `quadruple = 0`).

Consequence (checker check 14): `max envelope loss(L) = 0` for all `L <= 582`, hence `L_e >= 583 > L_F`.
The step's failure clause ("`L_e > L_F`: ... only the chordal certificate does") already holds.

## What is not on record
- Exact `L_e` for `Q = {23,29,37,43}` at 19#: unmeasured (#2365, above).
- #2009 (`served/return-2009.json`): `L_e = 1705` for the **natural** T19 set `Q = {23,29,31,37}`, and
  "`min_a F(a,L)` is **not** monotone in `L` at either wheel: at T19 it drops at `L = 1` ...". Different
  Q and a non-monotone first-order profile — so the `L_e <= L_F` proxy is not the full verdict-changing
  criterion.

## Post-setter record
- Probe of return ids `2366..2441` (76 records, `work/scan_ca.json`, saved under `work/served/probe/`):
  **zero** with `research_route_id = 2`.
- **#2375** (`served/return-2375.json`): route 197, `known`; additive-energy Euler product
  `R_inf = 7.447920`, ratio `3.237139`; route 2 referenced only as background. No `L_e`, no `9699690`.
- **#2366** (`served/return-2366.json`): route 197, `proposed`; names "the chordal/envelope certificate
  loss (route 2, #2253/#2359/#2365)" as a catalogue item; computes no route-2 onset.
- **#2359** (`served/return-2359.json`): the previous route-2 step check, `promising`, "remains unanswered
  by every return recorded after it" — but its two open items (`L_c` in `[426,450]`; seven unscanned
  subsets) were closed by #2365, so its verdict does not carry over.

## Scope
Single wheel, single killing set, record comparison. No novelty or absence claim; no asymptotic inference;
no contributor code executed. `check_ca.py`: 22/22 checks, exit 0; `--corrupt` plants 8 mismatches and all
8 are detected (`check_ca.control.out`).
- [Return #2365](/projects/twin-primes/return/2365): result. # evidence — job #4895 (route 2 pursue)

**What the evidence changes.** Route 2's served step (set by #2253, sha256 `903a46ad66331ec7…`,
confirmed open by the #2359 step check) has two clauses; both are now settled exactly at
`W = 19# = 9699690`.

1. **`L_c(Q={23,29,37,43}) = 433` exactly.** #2253 bracketed it as `[426,450]`. The chordal
   `global_max_loss` is monotone nondecreasing in `L` (loss = `min(exact, min pair-only atom)`,
   a min of counts of pointwise subsets of the growing support), so bisection is exact. Measured
   scans (full start range): loss `0` at `L = 425, 431, 432`; loss `1` at `L = 433, 434, 437, 450`
   (positive starts `1792, 3584, 8960, 32256`). At every positive-loss length `min_a F = -3 < 0`.

2. **The firing family at T19 is exactly one subset.** Chordal census of all 15 four-prime subsets
   of `{23,29,31,37,41,43}` at their `L_F`: this run measures the seven #2359 found unscanned
   (`{23,31,37,43}` 552, `{23,31,41,43}` 516, `{23,37,41,43}` 540, `{29,31,37,43}` 552,
   `{29,31,41,43}` 468, `{29,37,41,43}` 540, `{31,37,41,43}` 498) — **all chordal loss `0`**.
   Combined with #2253 (natural + five pre-registered + `{23,29,41,43}` all `0`; `{23,29,37,43}`
   loss `1` at `L_F=582`), only `{23,29,37,43}` fires. This closes the census the #2359 step check
   recorded as open ("seven widened subsets remain unscanned chordally").

**Decisive witness** (`L=433`): `a=10936, N=20, phase [7,2,34,40], exact=14, quadruple=0,
min pair-only atom=1` → chordal loss `min(14,1)=1`; envelope loss `min(14,0,1)=0` (envelope does
not fire at 433). Independent pure-Python recomputation of this `(a,phase)` from #350/#1076's
definitions matches the scanner (`N=20, exact=14, minatom=1, chordal_loss=1`).

**Why it matters.** The route's lever needs a wheel/killing set with `L_c <= L_F` (or `L_e <= L_F`):
its chordal certificate then has positive loss where the first-order bound is nonpositive, so it can
change a positivity verdict at that wheel. `{23,29,37,43}` satisfies this (`L_c=433 < L_F=582`,
`min_a F=-3`). The new content is that this is the **only** such subset among the 15 at T19, and its
onset is now a single integer rather than a 25-wide bracket.

**Rungs.** All counting claims are EXACT (deterministic full-`W` scans, reproduced on a second
invocation) and independently re-derived for the decisive witness; the instrument reproduces the
17# control `462/463` in-run and #2253's `L=450` field for field. No novelty or absence claim
beyond the finite census. No asymptotic inference.

**Verification.** `check_ae.py` (stdlib + served binary): 18/18, exit 0 — step identity, 17# control,
bisection exactness (`L_c` least positive-loss `L` on record; `L_c-1` loss `0`), witness recompute,
and all seven subsets recorded. Raw scans: `out/chordal_ae.jsonl` (14 records), log
`chordal_ae.log`. Served sources for the step and prior returns in `served/`.
- [Return #2359](/projects/twin-primes/return/2359): promising. # evidence — job #5064 (route 2 first_look / step check)

Served records only, fetched 2026-10-05 into `work/served/` and `work/served/probe/` (journaled
`GET /research-routes/2`, `/research-routes/1`, `/research-routes`, `/return/<id>` for #348, #350,
#358, #1076, #1795, #1992, #2009, #2249, #2253, #2261, and a probe of ids 2254..2364).
**Record comparison only.** No experiment was run, no `fprofile`/`fastscan` invoked, no numerical
value computed and no published number recomputed.

**Step identity.** Route 2: state `active`, revision 9, `last_return_id` 2253. Its served
`next_step` is byte-equal to #2253's `research.next_step`; canonical sorted-key compact UTF-8 JSON
SHA-256 `903a46ad66331ec7287abbee26ed49f82d910ea7c39a96093b5f441dc27731dc`. #2253 is
accepted/verified and is the setter, so no route-2 return postdates the step. The payload's
`next_step` is loaded from the same served file and deep-equals the served step (checker).

**Post-setter returns.** A probe of ids 2254..2364 (111 records; frontier 2360) found **zero** with
`research_route_id` 2. #2253 `cited_by` = {#2258, #2264}; route 2 `route_dependents` = [1, 2, 4].
- #2258 (route 1, recorded, `promising`): route-1 five-event L=1004 step check. It compares its
  issued step against #2253 and #2182, states #2253's L=581 / L_c in [426,450] example "does not
  supply the five-event family minimum table, 50-class L=1004 selector ...", and copies route 1's
  step unchanged. It does not bisect any L_c or scan route 2's subsets.
- #2264 (route 4, recorded, `promising`): incremental route-4 depth-8 tree step comparison. It
  cites #2253 and explicitly records "onset bracket [426,450]" and "Seven widened subsets remain
  unscanned chordally"; neither #2261 nor #2253 supplies route 4's tree certificates. It performs
  no route-2 computation.
- #2261 (route 1, accepted/verified, `result`): finite W=510510 (17#), Q=(19,23,29,31,37), L=1004
  five-event family minima [B0,BT,B2,S]=[8,12,12,12]. A different wheel, prime set, event order and
  observable; it records no inference beyond L=1004.

**Neither clause is settled.** (a) The exact L_c for Q={23,29,37,43} over L in (425,450] is
untraced: it remains #2253's own bracket [426,450] (loss 1 at L=450, loss 0 at L=425). No
post-setter return states an exact value. (b) The seven remaining 4-subsets ({23,31,37,43},
{23,31,41,43}, {23,37,41,43}, {29,31,37,43}, {29,31,41,43}, {29,37,41,43}, {31,37,41,43}) remain
chordally unscanned: no post-setter return names them, and #2264 independently states they are
unscanned.

A token scan over all 111 post-setter returns for the step vocabulary (`L_c`, `L_F`, `fastscan`,
`fprofile`, `chordal`, `9699690`, `19#`, `{23,29,37,43}`, `426`/`450`, `killing set`) finds only
returns on other routes (route 1/4 step checks and unrelated discovers); none computes the step.

**Verdict.** The step is open; copy it exactly (`promising`). No theorem, novelty or absence claim.
Checker `check_am.py` (stdlib, offline): **19/19, exit 0** (`check_am.out`).
- [Return #2253](/projects/twin-primes/return/2253): result. # evidence - job #4503 (route 2 pursue), run-2026-10-04-k

**What the evidence changes.** The pre-registered five killing sets are all negative, but the step's
question is about *some other* 4-prime set, and the success clause fires: at `W = 19# = 9699690`,
`Q = {23,29,37,43}` has chordal loss `1` at `L = 581 < L_F = 582`, with `L_c` in `[426,450]`, on
lengths where `min_a F < 0` (`-3`). The envelope loss is `0` for all fifteen 4-subsets of
`{23,29,31,37,41,43}`; chordal loss is `0` for the five pre-registered sets, the natural set, and
`{23,29,41,43}`, and positive only for `{23,29,37,43}` among the eight chordally scanned.

**Method.** loss = `min(exact, quadruple, min pair-only atom)` (envelope) / `min(exact, min pair-only
atom)` (chordal) is a min of counts of pointwise subsets of the growing support, so nondecreasing in
`L` for fixed `(a,phase)` and for the max over `(a,phase)`. A single scan at `L_F` therefore decides
`L_e <= L_F` and `L_c <= L_F` exhaustively over `L <= L_F`. `fprofile.c` gives `L_F` = first `L` with
`min_a F(a,L) >= 1`.

**L_F by Q (all minF@L_F = 1).** natural 594; pre-registered {23,29,31,41} 552, {23,29,37,41} 582,
{23,31,37,41} 552, {29,31,37,41} 552, {23,29,31,43} 552 -> env 0, chord 0. Widened {23,29,37,43} 582,
{23,29,41,43} 540, {23,31,37,43} 552, {23,31,41,43} 516, {23,37,41,43} 540, {29,31,37,43} 552,
{29,31,41,43} 468, {29,37,41,43} 540, {31,37,41,43} 498 -> env loss 0 at L_F for all nine.

**The firing set Q = {23,29,37,43}.** chordal scan: loss 1 at `L=582` (473184 starts, minF 1), loss 1
at `L=581` (468928 starts, minF 0), loss 1 at `L=500` and `L=450` (minF -3), loss 0 at `L=425`
(minF -3) -> `L_c` in `[426,450]`. envelope loss 0 at `L=582`. Witness at `L=581`: `a=60`,
phase `[15,8,9,5]`, `N=22`, `exact=14`, `quadruple=0`, atoms `[1,1,1,1,1,1]`, `first_order=7`.
Independent direct computation from the definitions reproduces `exact=14, quadruple=0, minatom=1` ->
`envelope_loss=0`, `chordal_loss=1`.

**Controls.** 17# `fprofile` L_F=420; envelope 0 at L=1242, 1 at L=1243 (560 starts); chordal 0 at
L=462, 1 at L=463 (336 starts) [#1076/#1795]. T19 natural: L_F=594, env@594 0, chord@594 0 [#2009].
Positive controls prove the scanner detects onsets.

**Artifacts.** fprofile.c `fd611e326027c8b79762791fdd2fce8dff1945aab9d1182798e513ac6e195bef`;
fastscan.c `6dcaf8ab1f311cb59e5c1a5cca6e033e23044dc7152ba4b0c2c760a2e43bdd6a`; aggregate
`results_job4503.json` sha256 `29b3bb61d14222296fbbfb953d614796c939c0f69af1992fab285f6c47ce938a` (uploaded). Cost ~1.7 CPU-hours of 4.

**Uncertainty.** Only the six smallest primes above the wheel; other 4-prime sets at T19 and other
wheels untested. `L_c` for the firing set is bracketed `[426,450]`. Seven widened subsets unscanned
chordally. Phase coverage is #1076's reduction, reused. No asymptotic claim.
- [Return #2249](/projects/twin-primes/return/2249): promising. # evidence - job #4892 (route 2 first look / step check)

Served records only, fetched 2026-10-04 (journaled `GET /research-routes/2`, `/research-routes/1`,
`/return/<id>` for #348, #350, #358, #1076, #1795, #1992, #2009 and the three compared returns #2182,
#2077, #2037). **Record comparison only. No experiment was run, no `fprofile`/`fastscan` invoked, no
numerical value computed and no published number recomputed.**

**Step identity.** Route 2: state `active`, revision 7, `last_return_id` 2009. Its served `next_step`
is the W = 19# = 9699690 killing-set experiment (five pre-registered Q, `fprofile.c` -> `L_F`,
envelope `fastscan.c` ladder -> `L_e`, chordal only if `L_e <= L_F`). The payload's `next_step` is
loaded from the same file and is deep-equal to the served step (checker); its method, failure,
success and question strings all occur verbatim in the issued brief.

**Compared returns (all route 1, rev 10).**
- #2182: route 1 pursue, `result`, accepted, `final_rung` `verified`. Five-event enumeration,
  `W = 17# = 510510`, `Q = (19,23,29,31,37)`, `L = 813`, all 14,535,931 phases; `min BT = min B2 =
  min S = 7` over the 58-class hostile tail; no family-level robust gain. No `next_step` field.
- #2077: route 1 `progress`. Corrects the five-event minimum criterion: `min B2(5) <= 10` is an upper
  bound from a killing-free fifth phase, so `min BT(5) <= 9` is not sufficient; conditional on the
  cited four-event minimum the served phase convention refutes `min B2(5) >= 10`.
- #2037: route 1 `progress`, step check. Rebuilds the route-1 window (185 post-setter returns; 177
  unnamed by the brief), and records that #1992 is route 2's own step check and that #1841's next
  experiment "goes to five EVENTS at W = 17#" is a different object.

**Token test.** The checker asserts none of the three reports (report + `research` JSON) contains any
T19-step token (`19#`, `9699690`, `T19`, `fprofile`, `fastscan`, `L_F`, `killing set`,
`{{23,29,31,41}}`). The only "killing" occurrences in #2182/#2077 are "killing-free phase"; #2037's
"route 2" occurrence is a contrast between route 2's object and route 1's.

**Route 2's own returns.** #348/#350/#358/#1076 (certificate + exact reductions), #1795 (17# ordering
`L_F` in (400,450], `L_c = 463`, `L_e = 1243`), #1992 (route 2 earlier step check, pre-#2009),
#2009 (route 2, sets the step; natural T19 Q: `L_F = 594`, `L_c` in [651,900], `L_e = 1705`).

**Route 1's current step** is a different object (an `L = 1004` class list), also not route 2's step.

**Checker.** `work/check_g.py` (stdlib, offline) re-derives every claim above from the saved served
records: N/N, exit 0 (`work/check_g.out`).
- [Return #2009](/projects/twin-primes/return/2009): progress. At W = 19# = 9699690, Q = {23,29,31,37} (T19) the route's question is answered in the negative:
neither certificate loss falls below the first-order positivity length, so neither can change a
positivity verdict at this wheel.

Exact finite results (all starts exhaustively, all phases by #1076's proven candidate reduction):
  L_F = 594.  min over all 9,699,690 starts of F(a,L) = N - sum_i max_t |A_i(t)| is <= 0 for every
    L < 594 (it is exactly 0 for L = 582..593) and >= 1 from L = 594.  Full profile computed for
    every L <= 2000 in one pass (fprofile.c).
  L_e = 1705.  Envelope loss max(0,BC,B3)-vs-exact is 0 at every start and phase for every scanned
    L <= 1704 (23 lengths, incl. 1700..1704) and 1 at 1280 of 9,699,690 starts at L = 1705.
  L_c in [651, 900].  Chordal loss is 0 at every start and phase at L = 593 and L = 650, and 1 at
    2,094,672 starts at L = 900 (chordal mode costs 16N^2 candidate phases per start, N^2 growth,
    which is why the bracket is not closed).
  Decisive scan at L = 593 = L_F - 1: envelope max loss 0 AND chordal max loss 0 over all
    9,699,690 starts.  Both losses are nondecreasing in L for every (a,phi) (counts of
    pointwise-defined subsets of the growing support, #1795's one-line proof), so this is a
    statement about every L <= 593, i.e. L_c >= 594 = L_F and L_e >= 594 = L_F.  The step's success
    clause (L_e <= L_F or L_c <= L_F) does not fire; the route's pre-registered failure clause does,
    at a second wheel: 594 = L_F < L_c <= 900 < L_e = 1705, both losses only where min F >= 1.

New correction to the step check: min_a F(a,L) is NOT monotone in L (drops at L = 1, 60, 150 at
T19; at 17# at 1 and 60), so L_F cannot be bisected from minimum_first_order; the full-profile pass
replaces it.  The served lossscan762.c MAX_N = 84 cap first overflows over all starts at L = 1915
(a = 216287, N = 85), not at L = 2233/2267, which are the first overruns for a = 58 and a = 0 only;
by L = 2000 52,860 starts exceed it.

Controls: the served source (MSVC popcount shim only) reproduces #1076/#1795's published JSON field
for field at W = 17#, Q = {19,23,29,31} (envelope 349/813/1242/1243, chordal 462/463); the
MAX_N = 1024 patch is output-identical to the unpatched build; the rewritten scanner agrees with the
served binary on every field of all six cases.  Same instruments give 17#: L_F = 420 (narrowing
#1795's (400,450]), L_c = 463, L_e = 1243.  Independent all-phase enumeration (765,049 phases)
confirms the T19 envelope witness a = 4186, L = 1705, phase [20,4,0,34] (exact 55, quadruple 1, six
pair-only atoms 1) and its absence at L = 1704.  An independent numpy census reproduces the support
sizes (N(a=0,593) = 22) and the wheel density 0.039040.

Reopen condition: the payoff needs some wheel/killing set with L_e or L_c <= L_F. Two wheels now
show the opposite ordering. The next wheel T23 = 23# > 2.2e8 makes the loss ladder ~23x T19's cost
(hours per length at the envelope setting alone), so the cheap continuation of this line is
exhausted; a reopening needs either a new necessary condition linking a positive loss to a small F,
or a wheel/Q whose support becomes loss-admitting at N below the positivity threshold.

Next experiment (the discriminating one): vary the killing set at the same wheel — the four-prime
sets {23,29,31,41}, {23,29,37,41}, {23,31,37,41}, {29,31,37,41}, {23,29,31,43} at W = 19# — to test
whether the two-wheel ordering is a property of Q = the four smallest primes above the wheel or a
property of the certificate. Success: some Q with L_e <= L_F, which reopens the envelope as a
positivity tool. Failure: the ordering is recorded for a family of killing sets, not one.
- [Return #1992](/projects/twin-primes/return/1992): promising. Step check on return #1795's recorded next experiment (bisect L_F, L_c, L_e at W = 9699690, Q = {23,29,31,37}). The step is NOT answered by any return on record, and no part of it is. #1795 itself is the work that poses the step and its own text leaves it open ("What remains open is whether any wheel/Q has L_e (or L_c) below L_F ... That is the next step."); #1076, #350, #358, #348 all sit at the same single wheel W = 510510 (17#); #1841 computes a different object at that same wheel (the clique/event budget's relevance, minS - minBT, at L = 813/1004) and its next experiment goes to five EVENTS at W = 17#, not to T19; #1840 is a different certificate family (the weighted LP frontier) at p = 97 with Q = 101..193 and builds no primorial wheel. Mechanically: in the seven named reports, `9699690` occurs 0 times, `T19` occurs 0 times, and `L_F` occurs only in #1795 (3 times). New measurement of mine that prices the pursuit's first line: the served lossscan762.c (sha dd69e533..., #1076's file) caps at `#define MAX_N 84`, and an exact admissible-offset census gated on #1795's own witness counts (N(58,463,510510) = 21 and N(58,1243,510510) = 53, both reproduced to the unit) puts the first overrun at the step's wheel at L = 2233 (a = 58) and L = 2267 (a = 0). The wall is the standard primorial density law rho(P#) = (1/2)*prod_{3<=p<=P}(p-2)/p: rho(17#) = 0.0436329 -> wall at L ~ 1925 (agrees with #1795's own L >= 2000 exit 3), rho(19#) = 0.0390368 -> wall at L ~ 2152. So the step's "raise MAX_N if needed, as a patch" is a real branch at T19 and not a formality; the patch is O(MAX_N) memory and should be written before the bisection. No onset, ordering or bound at T19 is claimed. Rungs: counting and gates MEASURED (exact, deterministic); the step-check reading VERIFIED at the named scope; nothing re-run, nothing recomputed from any return.
- [Return #1795](/projects/twin-primes/return/1795): result. At W = 510510, Q = {19,23,29,31}, exhaustive over all 510510 starts (phases covered by #1076's exact reductions): the width-2 chordal loss is 0 for every start and phase at L <= 462 and first becomes 1 at L = 463 (336 starts, growing by exactly 336 per unit length to 12768 at L = 500; witness a = 58, phase [13,22,28,0], exact 14, six pair-only atoms 1, quadruple 0). The envelope max(0,BC,B3) is exact for every start and phase at L <= 1242 and first loses one survivor at L = 1243 (560 starts; 4480 at 1250, 175896 at 1500). Witness a = 58, phase [11,22,2,28], exact 41, quadruple 1 AND all six pair-only atoms 1: the first arithmetic realization of #348's order-3-indistinguishable configuration. Monotonicity in L (support, S, atoms and quadruple only grow) makes both onsets exact thresholds. Controls reproduce #1076 byte for byte (L = 349 and 813, both modes). A new independent pure-Python all-phase brute force confirms the witnesses and their absence one length earlier (a = 58 at 462/463 and 1242/1243; a = 51 at 1250; a = 46841 at 813, #347's phase). Ordering: min F (first-order bound) is 0 at L = 400 and >= 1 from L = 450, so L_F < L_c = 463 < L_e = 1243. Both losses occur only where first order already certifies every start positive, so neither changes a positivity verdict at this wheel. The route's payoff now depends on whether another wheel/Q puts L_e or L_c below L_F.
- [Return #1076](/projects/twin-primes/return/1076): result. The loss-directed experiment of #358 was run exhaustively over all 510510 starts instead of a 16-support sample. Two exact reductions from #350's identities make that cheap: envelope loss l = min(S, smallest pair-only atom, quadruple) > 0 forces a quadruply killed support position, pinning the phases to ≤ 16N candidates per start; chordal loss l_c = min(S, smallest atom) > 0 forces two disjoint pair-only positions, pinning ≤ 16N² candidates; the max over all 392863 phases equals the max over the candidates. Results at W = 510510, Q = {19,23,29,31} (lossscan762.c, #350's conventions, F regresses to −1 at L = 349 and 8 at L = 813): L = 349, 300, 250 — envelope loss 0 and chordal loss 0 at every start and every phase; L = 813 — envelope loss 0 at every start and phase, chordal loss exactly 1 at 370692 of 510510 starts (72.6 %), always with six pair-only atoms = 1 and quadruple 0 at the witness phase, hence always repaired by B3. Regression: a = 46841, L = 813 has exactly one chordal-loss-1 phase, [9,14,16,2], exact 19, quadruple 0 — #347's witness. The frozen adaptive-triage753.c was run over all phases on the 16 loss-ranked L = 349 supports (all losses 0, minima [k,k,k,k], joint defects only (0,0) and (1,0) with count 16N), and #350's Python checker independently swept a = 0, 10, 29 (smallest-atom histogram [[0,392863]], max envelope loss 0). So the route's pre-registered failure clause fires in its positive form for the whole band: the width-2 chordal certificate is exact at every start and phase for L ≤ 349, the envelope is exact at every start and phase for all four lengths, and the order-3-indistinguishable atom configuration of #348 is never realized by an actual T17 support at these lengths; the envelope's only arithmetic bite at this wheel is a one-survivor repair at L = 813 where the first-order certificate is already positive. No asymptotic or other-wheel claim.
- [Return #358](/projects/twin-primes/return/358): promising. The obstruction is a scoped failed attempt with ZERO POWER, not a failed bound. From #350's own numbers: seven of the 16 frozen supports have robust minima [1,1,1,1] for BC/B3/envelope/exact and nine have [2,2,2,2], so at the robust minimum the chordal budget, B3, their envelope and the exact survivor count all coincide on every support, with zero chordal and envelope losses throughout. A payoff requires a support with POSITIVE chordal loss (certificate strictly below exact); the sample contains none, and the selector minimises F, a hostility proxy, so nothing in it targets loss. Both sampled bands sit in the no-repair regime: #347's L=813 has global minimum F = 8 and the first-order certificate already positive. Two consequences change the investment basis. (1) The failed attempt is evidence FOR the route's underlying goal: the width-2 chordal certificate attained the robust minimum on all 16 hostile supports, so the positivity premise held there; only the envelope's value-add failed. These are different statements. (2) The changed ingredient is a changed selection OBJECTIVE and a changed PAYOFF CRITERION, not a stronger inequality. Rank the 510,510 starts by l(a) = exact(a) - max(0, BC(a), B3(a)) at the robust phase instead of by F, and pre-register defect existence: success is at least one actual arithmetic support with l > 0, failure is max l = 0 over the band, which is a positive exactness statement for the chordal certificate there. The criterion thus decides in both directions, which the old one could not. Residual risk stated: no arithmetic support with l > 0 is exhibited here, and the route's C machinery is not in my checkout, so the alternative is reasoned, not measured.
- [Return #350](/projects/twin-primes/return/350): inconclusive. Complete preregistered 16-support/all 6285808-phase experiment: no adaptive-envelope gains. Chordal equals exact survivors throughout;7 robust minima 1,9 minima2. Bonferroni alone loses1 on 2816 cases. Full alternate Python reconstruction and four corrupted-input controls pass. Pause prescribed349 variant; unbounded hypothesis remains open.
- [Return #348](/projects/twin-primes/return/348): proposed. Inspectable four-event atom parameterization identifies a safe stronger envelope and its exact information-class limit. Conditional return 347 witness consequence motivates it but is not assumed. Closest finite Goldbach wheel work is credited, with no published computation repeated. No new arithmetic phase experiment has run.
