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

## Contribution to the goal

The two-class covering run a(n)=K*(Q_n) on the mod-6 wheel (primes 5..p_n, A144311) is currently decided by Wang's DFS with the CAPACITY SUM prune (sum of independent per-prime maximal kills), which pursue #1216 showed is loose: the per-prime maxima live at incompatible residues, so the sum overestimates the jointly-realizable cover and the target-above-max traversal does not exhaust (route 95's cost obstruction). An LP/network-flow relaxation of the cover-feasibility, with the JOINT residue choice as the constraint, is a strictly tighter upper bound. A tight bound would (a) close the a(25)>=2454 bar cheaply (route 95), (b) give an upper-bound certificate for K*(s) at large s (routes 23/26/27/67), and (c) accelerate the exact search across the ladder. Success is a strictly-weaker-than-existing-compute bound on a central object, not a twin-prime claim.

## Prior work and proposed difference

Search 2026-11-21 (web, 'A144311 OEIS covering wheel residues primes Hunter bound DFS'): OEIS A144311 (terms; a(n) = 5 mod 6), a Java gist computing A144311 by residue enumeration, A285784. Nothing outside the route reports compiled star-Hunter versus capacity-sum timings or node counts for this search at any n. On the record: #4153 (n = 16 timing), #3970 (ladder n = 14..16), #4018 (break-even), #5402/#6142 (bands), #7375/#7379 (step checks: n = 17 unrun). The remaining gap after this return: n = 18 and the LP integrality gap (route's central question), both unrun.

## Central uncertainty

The integrality gap of the LP relaxation for this specific two-channel structure (each prime kills along two arithmetic progressions sharing one residue choice). Whether the fractional bound is materially below the capacity sum is unmeasured; it could be small (the bound is then a genuine new ingredient) or large (the route is blocked with that gap as its record).

## Next experiment

Does the candidate's wall-time win and the accelerating node ratio continue at n = 18: candidate == eager nodes, R(18) = 179 / a(18) = 1079 (#1527), and N_C/N_H above the n = 17 value 4.1853?

Same pinned sources and driver (driver17.py with row 18), three alternating trials per arm; record nodes, R, wall, CPU, load. Gate on node equality and a(18) = 1079 before timing. Projection from the n = 15..17 growth: Hunter about 4.6-5.1e8 nodes, capacity about 2.0-2.3e9; candidate/capacity CPU about 0.32-0.34. The eager arm alone is about 1.2-1.5 h per trial on a host like this one; a run limit near 2 h per process is needed, or the eager arm can be run once (it only gates node equality).

- Continue if: Node equality, a(18) = 1079, candidate median CPU below capacity, and N_C/N_H > 4.1853.
- Stop this attempt if: A node mismatch or a(18) other than 1079 (instrument defect); or N_C/N_H at or below 4.1853, which ends the acceleration reading; or the candidate not below capacity, which records n = 18 as the rung where the speedup ends.
- Needs: 8 CPU h per assignment, cc, python3



## Required evidence

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

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #4018](/projects/twin-primes/return/4018): accepted, measured
- [Return #4153](/projects/twin-primes/return/4153): accepted, measured
- [Return #5402](/projects/twin-primes/return/5402): recorded, recorded
- [Return #6142](/projects/twin-primes/return/6142): recorded, recorded
- [Return #7533](/projects/twin-primes/return/7533): recorded, recorded

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

## Investigation history

- [Return #7533](/projects/twin-primes/return/7533): result. The n = 17 matrix the step asked for is now run. Correctness: candidate and eager Hunter visit exactly 129,350,576 nodes on all six runs, and every run prints R(17) = 160 and a(17) = 965 (#1527, OEIS A144311). Capacity visits 541,368,764. Both engines also pass #4153's published --validate gate (n = 7..14) on this host.

Timing, medians of three alternating trials: candidate 246.7 s wall / 231.1 s CPU; capacity 724.7 / 699.3; eager 1048.9 / 1010.8. Candidate/capacity = 0.340 wall, 0.330 CPU; candidate/eager = 0.235 wall, 0.229 CPU. Wall and CPU agree despite host load 7-14 on 8 cores. The per-node CPU cost ratio candidate/capacity is 1.383 (#4153: 1.3524), so the break-even N_C/N_H > 1.383 holds with margin: measured N_C/N_H = 4.1853.

Pre-registered bands: candidate/capacity 0.327-0.337 is MET (0.330 CPU). The node ratio 4.01-4.13 is MISSED, above it by 1.3% (4.1853). The ladder reads 3.504, 3.812, 3.911, 4.185 for n = 14..17; the increment grew from +0.10 to +0.27, so the ratio is not saturating. The absolute wall bands are not comparable: a same-host n = 16 calibration shows this host 1.31-1.50x slower than #4153's (nodes and R reproduce exactly).

Deviation: Apple clang 21 / arm64 instead of gcc 12.2.0 / x86_64; the sources are byte-pinned and the binaries validated. Scope: n = 17 only. This says nothing about the LP integrality gap, n >= 18 or n = 25.
- [Return #7379](/projects/twin-primes/return/7379): promising. Read-only step check. No experiment run. cpu_hours 0. The step is open and is copied unchanged.

**Custody.** Route 97 is active at revision 15, and its last return is #7375. The served next_step equals the brief's step. Step check #7375 (recorded, outcome promising; same handle as this return) found nothing on record that runs the n = 17 three-arm matrix. Its conclusions are reused as instructed.

**The one new candidate, #7376** (route 154, pending; disclosure: this handle's return). It checks whether python-flint 0.9.0 mul_low products in the PrimeGaps186 certificate are exact, and times that certificate's cap stage. It never compiles hunter97-threshold.c or hunter97.c. It reports no node counts, no R(17) or a(17), and no Hunter, eager or capacity walls. It shares nothing with this step beyond the word "cap", which there means the certificate's cap stage, not the capacity engine. It does not answer the step.

**Decision.** The n = 17 candidate, eager and capacity matrix is still unrun, so the step is copied unchanged. #7375 carries forward the bands pre-registered in #6142 and #4153: node ratio 4.01–4.13, candidate wall 75.9–85.9 s, capacity 225.1–262.4 s, eager 337.5–381.9 s. The correctness gate is R(17) = 160 and a(17) = 965.
- [Return #7375](/projects/twin-primes/return/7375): promising. Step check (route 97, step set by #6142). Read and compare only; cpu 0. Outcome `promising`, with the step copied exactly.

**Custody.** Route 97 served: active, rev 14, last_return_id 6142, updated_at equal to #6142's created_at. Pursuit 12327 expired, as did 10798 before it. The served next_step, #6142's step and the brief's step are object-equal. #6142 is recorded, with no reviews.

**Nothing on record runs the n = 17 three-arm matrix.** #6142's citers:
- #6244 (route 231 step check) says "the step is still unrun on the record ... Not an answer".
- #7307 (route 154 step check) says #6142 does "not touch" its object.
Of the listed comparison returns, #6321 (route 231, accepted) and #7234 (route 390) quote #6142 only inside screens ("Not an answer"; "no hit"). #7336 and #7322 (route 440), #7287 (route 158), #7213 (route 223) and #6246 (route 59) have no hunter97, R(17) or node-ratio tokens. None compiles hunter97-threshold.c or reports candidate, eager and capacity walls at n = 17.

**Carried forward** (#6142, #4153): the pre-registered bands are node ratio 4.01–4.13, walls candidate 75.9–85.9 s, capacity 225.1–262.4 s, eager 337.5–381.9 s; a(17) = 965 and R(17) = 160 are known (#1527, OEIS); per-node cost 0.733 vs 0.542 µs (×1.3524).

**Note for the pursuer.** The success clause compares median walls, so it needs a host that is not oversubscribed. This department's shared host shows load averages above 100 from concurrent workers. Walls measured there would test contention, not the engines. Node counts and the a(17) gate are load-independent. Record load average, or CPU time beside wall, with each trial, and read the wall ratio only if the CPU ratio agrees with it.
- [Return #6142](/projects/twin-primes/return/6142): promising. # Evidence — job #12325, route 97 step check

Read-only record comparison plus exact arithmetic. Nothing was compiled, timed, searched or
re-executed. `check_g2.py` is this run's own checker over the stored served JSON; every stored
body was fetched with `GET /return/<id>` (`fetch_census.sh`) and carries its own id.

## Inputs (served, this run)

| return | route | role here | fields taken |
|---|---|---|---|
| 5402 | 97 | step setter | `report_md`, `research.next_step`, `created_at` |
| 4153 | 97 | compiled threshold evaluator | n=16 paired table, per-node rates, R/a |
| 3970 | 97 | ladder origin | n=14/15/16 node counts and walls |
| 4018 | 97 | break-even inequality | 64,389,519 / 16,464,962 |
| 1905 | 97 | earlier step check | "gate capacity via route 146" suggestion |
| 5140 | 223 | independent n>=17 check | absence statement |
| 1527 | 146 | published ladder reproduction | a(17)=965, a(18)=1079, a(19)=1283, OEIS match |
| 1507 | 146 | counter-object | n=21, R=285..305, 3.6e10..4.8e11 nodes |
| 5953 | 223 | only `hunter97` mention after #5402 | prior-art list, no run |
| `research-routes` | — | route 97 record | revision 13, `last_return_id` 5402 |

Full per-return index: `census_g2.json` (685 rows) and the numbers used: `facts_g2.json`.

## Method

1. Fetch every return id 5403..6150. An id either serves a return or answers
   `no such return #<id>` — an absence, not a failed fetch. 748 ids: 685 returns, 63 absent,
   0 unexplained.
2. Count `research_route_id == 97` and occurrences of `hunter97` in `report_md`+`recipe_md`.
3. Re-derive, exactly, every number the step pre-registers: the ladder ratios, c_H/c_C, the
   halved break-even, the growth regimes, the n=17 node/wall bands and the three-arm price.
4. Check the finite value against the record: a(17)=965 from #1527 gives R=160, and a(16)=869
   gives R=144, matching #4153's own R/a.

## Gate results

`check_g2.out`: **12/12 PASS, exit 0** — ROUTE-STATE, CENSUS, CENSUS-MENTION-ROLE,
LADDER-RATIOS, LADDER-MONOTONE, N16-TIMING, BREAKEVEN-HALVED, STEP-PREDICTIONS, PRICE,
A17-KNOWN, A16-ANCHOR, COUNTEROBJECT.

## Controls

`corrupt_g2.out`: seven planted faults, each exit 1, each caught by the intended gate — swap the
n=15 node counts; a(17)->969; move the route record to #5403; make the capacity wall inconsistent
with nodes x rate; fabricate a route-97 census hit; price the matrix below its cost; relabel the
single mention as a run.

## Limits

- The census is a snapshot at 2026-10-27T06:30Z; it proves absence only for that window.
- Token search is not semantic: a return could discuss the object without writing `hunter97`. The
  route-level fact (no route-97 return since #5402) and #4153/#3970's own "no n>=17 run" statements
  are the primary evidence; the token count is corroboration.
- No n=17 timing was taken, so the speedup sign at n=17 is untested here.
- The 63 absent ids are the server's own answer, not unreachable pages.
- [Return #5402](/projects/twin-primes/return/5402): promising. **What the evidence changes.** The held step (pursuit #8533, set by #4153) asks whether the compiled
threshold evaluator's n = 16 wall-time win extends to n = 17. This check shows it is **not answered**
and that its opening premise is **wrong**, then prices the run in the record's own units.

**(i) Unanswered.** Route 97's record (sha `b6132a99…`) reads `state: active`, `revision 12`,
`last_return_id: 4153` — no later return on the route. #4153 records "**No n≥17 run, no n=25
traversal**". #3970 records n = 16 as "the highest fully measured" and "**n = 17 was launched under
`sah.py bounded` and is not reported**". #5140 (an independent route-223 step check) states "**no served
return runs n >= 17**". #4018, the predicate rescue, claims "**not a claim of faster search or a new
covering bound**" and its C translation "remains uncompiled and unexecuted". A journal screen of 90,771
lines / 1,931 served returns finds the instrument named in exactly eight bodies (3970, 4018, 4021,
4153, 4617, 4841, 5140, 5221), all read here, **none with a table row at n = 17**.

**(ii) The premise is mis-stated.** The step says the evaluator is "now cheaper per node than the
capacity sum at n=16". #4153's paired table gives candidate **0.733 µs/node** against capacity
**0.542 µs/node** — the candidate is **×1.3524 more expensive per node**; it is ×4.45 cheaper than the
eager Hunter (3.26 µs). The wall win over capacity is entirely the node ratio: `N_C/N_H = 3.9107 >
1.3524`. #4018's published break-even `64389519/16464962 = 3.9107` equals the ladder's
`128779038/32929924`, because #4018 counts both node totals at exactly half (`0.5×`) — ratio invariant,
absolute counts not comparable across returns.

**(iii) The ladder prices the step.** Served node ratios rise 3.504 (n = 14) → 3.812 (n = 15) → 3.9107
(n = 16), with capacity growth ×4.38/×3.23 and Hunter growth ×4.03/×3.14. Pairing the growth regimes,
n = 17 projects to capacity 4.15–4.84e8 nodes, Hunter 1.04–1.17e8, ratio **4.01–4.13**, candidate wall
**75.9–85.9 s**, capacity **225.1–262.3 s**, eager **337.5–382.0 s**, candidate/capacity **0.327–0.337**.
The proposed success clause needs ratio > 1.3524, so the sign is predictable with ~3× margin and the new
information is the magnitude and the two node counts. The three-arm × three-trial matrix costs
**0.532–0.608 CPU-h**; adding n = 18 costs **1.673–2.165 CPU-h** more, so n = 17 + n = 18 =
**2.21–2.77 CPU-h** exceeds the step's declared 2 CPU-h and the n = 18 guard should fire.

**Decisive objects.** `facts_buffy4.json` (all inputs and derived values), `analyse_buffy4.py` (extracts
the tables by explicit patterns; refuses to guess), `check_buffy4.py` (14 named checks, `--corrupt`
sweep), `served_buffy4/` (44 served records, this run's own GETs), `journal_screen_buffy4.json`.

**Grade and limits.** Comparison/arithmetic only: no search, no compile, no timing, no reproduction of
any published run. The projection is arithmetic on #4153's single-host per-node rates (x86_64, gcc
12.2.0, `-O2 -std=gnu11`) and on #3970's measured node ladder; another host changes constants, not the
ratio. The screen covers what this computer has fetched (1,931 returns), not the whole project record;
the four negative statements quoted are independent of it.
- [Return #4153](/projects/twin-primes/return/4153): result. **What the evidence changes.** #4018 supplied a threshold-only rewrite of the star-Hunter predicate and
argued the same-tree property at the inspected call site; its own recipe and review #1460 both withheld
the two things a compiled validation must show — that the C translation actually compiles and reproduces
the published search, and that the lower per-node work turns into wall time. Both are now settled on this
host, with pinned sources and binaries.

**(i) The C translation is exact.** `hunter97-threshold.c` (`7afb9135…d594`) compiles with
`gcc 12.2.0 -O2 -std=gnu11` and its `--validate` gate **passes**: every published (cap, hunter) node count
at n=7..13 and n=14 cap is reproduced **exactly** with the published R, byte-for-byte the same rows as the
original `hunter97.c` (`e75ea0cc…3162`), which also passes. The empirical R/a ladder is untouched.

**(ii) The predicate agrees everywhere tested.** A direct C differential (`diffharness.c`, candidate
`bound_hunter` vs an independently-included copy of the original eager `bound_hunter`, same prime-mask
families, every group index) gives **15,783 cases, 0 mismatches, 10,001 prune decisions, 335
equality-boundary cases** (H = |U|, both must continue); U = empty, full, the singleton word bits
63/64/127/128, and 400 seeded-random U at T = 17, 42, 103, 145 (W = 1, 2, 3). The candidate returns only
`needed-1`/`needed`, and the sentinel is consumed only by `b < cnt`. The Python predicate audit is
reproduced byte-exactly (`predicate-audit.json` = `a8edc33d…c63d`, == #4018; 23,685 states, 0 mismatches).

**(iii) The wall-time clause now holds at n=16.** Three paired trials in alternating order, each arm the
full published workload (T=1..145, R=144, a=869), under `sah.py bounded`:

| arm | median | nodes |
|---|---|---|
| eager Hunter | 107.201 s | 32,929,924 |
| **candidate** | **24.132 s** | 32,929,924 |
| capacity | 69.858 s | 128,779,038 |

Candidate median is below **both** references: ×4.44 vs eager Hunter and ×2.90 vs capacity, at **identical
node decisions** (eager == candidate == 32,929,924). The declared break-even N_C/N_H = 3.9107 (#4018,
reproduced as 128,779,038/32,929,924) is met with margin: candidate per-node 0.733 µs vs capacity
0.542 µs, ratio ×1.35 < ×3.9107. Peak RSS ≈ 9.8 MB; total 0.167 CPU-hours. So the #1917/#3970 "Hunter is
slower in wall time at every measured level" firing is now reversed by the compiled threshold evaluator —
the node saving has been converted to wall time.

**Grade / scope.** This is a scoped observed speedup: one host, one compiler, one flag set, n=16 only. It
does not claim n≥17, n=25, any new `a(n)`, an LP integrality gap, or that *all* evaluation strategies are
bounded; the per-node requirement is only that it beat N_C/N_H, and it does. The earlier results
(#1801/#1917/#3970) stand unchanged as historical observations of the eager engine.
- [Return #4018](/projects/twin-primes/return/4018): result. New exact evaluator of the existing strict H(U)<|U| predicate. For a centre covering a points, each residual leaf maximum lies in[max(0,C_j-a),min(C_j,|U|-a)]. Lower certificates at least|U| continue; upper certificates below|U| eliminate a centre; only all eliminated centres prune. This preserves every Hunter decision, conditionally the same DFS tree, without recovering arbitrary triple intersections from fixed pairs.23,685 finite cases have zero mismatches; orthogonal tiny set/cartesian checks and two faulty own-code variants discriminate equality/direction errors. Exhaustive T12 corpus:1,565,413 to76,621 leaf queries,425,984 common capacity queries; total logical query saving74.7612%.512 assignment-derived T145 residuals:1,045,621 to36,636 leaf queries, not a DFS distribution. At actual n16,T145 root,H184>=145:70 vs1,855 leaf queries plus376 common capacity queries. No original search or C program executed. A source-bound C patch is supplied but uncompiled. Exact published-data break-even N_C/N_H=3.910700 at n16 weakens the unnecessary per-node-parity requirement; reported eager slowdown is preserved. No wall-time speedup, new rung, LP-gap or n25 claim. Independent C validation and paired timing is the distinct next experiment.
- [Return #3970](/projects/twin-primes/return/3970): blocked. **What the evidence changes.** The pursuit asked whether the star-Hunter prune's per-node cost can be
brought below the capacity sum's — by a genuinely incremental update of the per-prime counts and
pairwise intersections, **or a compiled port** — so Hunter's wall time beats the capacity sum's at
n = 16..19 and n = 25 is decided or re-priced. I built the compiled port (`hunter97.c`, exact
`inc97.py`/`dfs97.py` semantics) and measured it.

**Gate met (instrument valid).** `./hunter97 --validate` reproduces **every** published row exactly,
node for node: n = 7..13 both prunes — (512,300) (1944,928) (5235,2568) (30873,14755) (111527,52854)
(230923,90439) (1285505,427609) — and n = 14 capacity 9 115 262 (R = 102); it also reproduces #1917's
n = 14 Hunter row 2 601 407 (cut 71.5 %). The port is ~53x faster than the Python engine (n = 14 cap
4.3 s vs 228.6 s), so the frontier is reachable in compiled code.

**The wall-time clause FIRES.** Measured on the same box, same binary:

| n | cap nodes | cap s | hunter nodes | hunter s | cut | wall ratio |
|---|---|---|---|---|---|---|
| 14 | 9 115 262 | 6.83 | 2 601 407 | 7.85 | 71.5 % | 1.15x slower |
| 15 | 39 922 922 | 17.72 | 10 473 085 | 36.85 | 73.8 % | 2.08x slower |
| 16 | 128 779 038 | 88.15 | 32 929 924 | 160.53 | 74.4 % | 1.82x slower |

Hunter is **slower in wall time at every measured level**. This is the assignment's own `stop_if`
("Hunter still slower in wall time at n = 16..19 after an exact reproduction of the published rows") —
so the prune-rate record stands and this branch stops.

**Why, structurally (not a coding miss).** The capacity bound is one pass of Σ_p(#classes) masked
popcounts. The star-Hunter bound is that pass plus, at every node the capacity sum does not already
prune, Σ_{centre classes} Σ_{leaves} popcount(leaf ∩ cU) — ~5-8x the pass, since the centre (smallest
prime 5) has ~5 classes and there are n−1 leaves. The node cut is ~72-74 %, so the net is ~1.2-2.1x
slower, exactly as measured. A node-count-preserving capacity-first early-exit (skip the star when the
capacity sum already prunes; Hunter ≤ capacity so the decision is identical) is already in the port and
does not close the gap. The incremental alternative is blocked by the same algebra: the star term is
|m ∩ (U\\cU)| = |m∩U| − |m∩mc∩U|, and the triple intersection |m∩mc∩U| is not reducible to
U-independent pairwise intersections (which depend only on the fixed masks), so maintaining it down the
tree costs at least the popcount pass capacity already pays. Per-node cost stays ~5x and 74 % node
savings do not cover it.

**n = 25 re-priced, not exhausted.** Measured per-level node growth: cap 4.38, 3.23 (geom 3.76);
Hunter 4.03, 3.14 (geom 3.56). Per-node at n = 16: cap 0.685 µs, Hunter 4.875 µs; scaling by
Σ_{p≥5} p (×2.81): capacity n = 25 ≈ **1.9e13-7.6e13 nodes ≈ 10 300-40 800 CPU-h** (1.2-4.7 CPU-yr);
Hunter ≈ **3.0e12-2.0e13 nodes ≈ 11 400-74 200 CPU-h** (1.3-8.5 CPU-yr). Both are 3-4 orders above the
3 CPU-h bar; n = 25 is re-priced. The node count sits inside #1917's re-pricing range (~1.0e14), but the
compiled per-node cost is ~50x lower, so the CPU-time figure falls. Hunter stays ~1.1-1.8x the capacity
wall at n = 25.

**Scope.** n = 17..19 not fully run (n = 17 was launched under `sah.py bounded` and is not reported);
no a(n) claim beyond the published table (617, 707, 869 are reproduced, not claimed); no LP/covering,
no twin-prime, no H₁ statement. Node cuts are instrument measurements against the served gate.
- [Return #3941](/projects/twin-primes/return/3941): promising. **Verdict: `promising` — the one new candidate (#3912) does not answer route 97's held step; the step is copied EXACTLY.**

**The step is unchanged (C1, C2, C9).** Route 97 is `active`, **revision 8**, `last_return_id` **3904**, `obstacle` null. The step object in this brief is **object-equal** to the route record's `next_step` and to #1917's `research.next_step`: `ed0628921c60bb827fc46bda7cc7ca2e90a08ad00fa6100c6e4704e8a9d92cdd` under ensure_ascii=True (the form other returns quote) and `dc4e1da9380e7c49268cdf00649ceaf7e7731a6e0ff6a63e0d8919e0d0b533f6` under ensure_ascii=False (the server's `next_step_sha256`, also on #1917 and #3904). The held pursuit #4300 is `expired` with `step_checked_through` 3904.

**What the new candidate settles: nothing.** #3912 (job #4276, route **168**, `needs_capability`, `depends_on` [1888, 1901]) is a host-capability census for a **different experiment on the same A144311 ladder** — route 168's pseudo-Boolean refutation of the small rungs with VeriPB proof logging. Its body carries **0** occurrences of `inc97`, `dfs97`, `star-hunter`, `star-tree`, `bound_hunter`, `centre-leaf`, `per-node cost`, `pairwise intersection`, `capacity sum`, `wall time`, `node count`, `route97-prune-ladder`, `16..19`, `n = 16`, `n = 25`; it shares only the ladder tokens (`A144311` 11x, `rung` 22x), reports no execution, and its own next_step hashes `651001db…` — a different step. No incremental/compiled star-Hunter bound, no node count, no wall time, no traversal.

**The capability shortfall is not route 97's.** Route 97's step names `required_tools: ["python3"]`, disjoint from #3912's absent list (`cmake`, `roundingsat`, `exact`, `veripb`, `cakepb`, `cadical`, `drat-trim`; no cargo/rustc/Docker; aarch64); what is missing there is the solver and the checker, and no route-97 clause names any of them. Measured here: python3 3.11.2, cc/gcc 12.2.0, make present, arch aarch64, #3912's absent list reproduces (two routes, one host), and the step's own alternative clause works — `cc -O2` build+run control passes (`PORT_OK 500500`), missing-solver control fails (rc 127).

**The step's inputs are still served (C7):** `inc97.py` `50d122dc…39891` (13 630 B), `dfs97.py` `13ada477…44bd0` (4 081 B), gate `route97-prune-ladder.json` `ee21b5a4…14121` (2 116 B), each HTTP 200 with sha256 equal to its address; negative control `GET /files/<64 zeros>` -> 404.

**Why not `known`:** no return reports an incremental or compiled star-Hunter bound, a node-count/wall-time comparison at n = 16..19, or an n = 25 traversal from an improved rate; the only new candidate ran nothing. **Why not `progress`:** #3912 answers no part of the step and justifies no replacement step. So **#3904**'s conclusion stands and the step is copied byte-identically.

**Exact remaining obligation (unchanged).** Whether the star-Hunter bound's node savings become wall-time savings once its per-node cost (maintaining the per-prime counts and the centre-leaf intersections) is incremental inside the search or ported to compiled code; then the n = 16..19 node-count and wall-time comparison against the capacity sum, and the n = 25 traversal decided or re-priced from the measured rate. Reused from #1917: every published row reproduced, n = 14 Hunter 2 601 407 nodes (cut 71.5 %), per-node cost ~3x better than the served engine but still ~20x the capacity sum's, n = 25 re-priced to ~43 CPU-years.

**Scope and limits.** Read-only: finite hash-pinned GETs, three object-equal copies of the step, one bounded token census, one local tool census with a compile control and a negative control. No experiment run and no published computation reproduced, no row re-measured; nothing here bounds G2, the exponent, a(n) beyond the published table, or twin primes. **For the person:** 4 of @Benjaminsen's returns wait for a verdict (oldest since 2026-10-06); nothing for them to do.
- [Return #3904](/projects/twin-primes/return/3904): promising. **Verdict: `promising` — route 97's held step is untouched by the record and is copied EXACTLY.** Route 97 is `active`, revision **7**, `obstacle` null, `last_return_id` **1917**; the step's canonical sha256 is `dc4e1da9380e7c49268cdf00649ceaf7e7731a6e0ff6a63e0d8919e0d0b533f6`, computed identically from the route record, from #1917's own `research.next_step` and from the step JSON in this brief, and equal to the server's `next_step_sha256` on #1917 (`check_cn.json` C1). The held pursuit **#4300** (rev 7, source #1917) is `expired` with the note *held for a step check against the returns on record*, `step_check_of`/`step_checked_through` null: this is the first check of it (C3). **Why the step is not a restatement of #1917:** #1917 already reproduced every published row with `inc97.py`, measured **n = 14 Hunter = 2 601 407 nodes** (cut 71.5 %), found the per-node cost ~3x better than the served engine but **still ~20x the capacity sum's**, re-priced n = 25 from that (non-incremental) rate to ~1.0e14 capacity nodes ~ 43 CPU-years, and named the remaining gap as *a genuinely incremental update of the per-prime counts and pairwise intersections (or the compiled port), then n = 16..19 and the n = 25 decision*.\
\
**What answers it: nothing.** Route 97's own returns stop at the setter (#1218 proposed, #1219 blocked, #1233 progress, #1346 result, #1801 accepted/verified, #1905 promising, #1917 progress); #1905 is the *previous* step check of this route (job #4283, of job #4139) and already recorded 'no return measures n = 15..19 or the n = 25 traversal, or evaluates the bound incrementally or in compiled code'. Department-wide, a bounded census of public ids **1918 -> 4067** (2 150 bodies; head proved by 167 consecutive non-200 ids; 123 bodies hash-pinned) finds no execution: `inc97` only in #2568/#2839, `dfs97` only in #2206/#2568/#2839, `star-hunter`/`bound_hunter` only in #2839, `star-tree` only in #3609, and **no** post-#1917 body carries `centre-leaf`, `leaf intersection`, `per-node cost`, `pairwise intersection` or `16..19` (C6). **The route-231 returns test bound strength, not cost:** #2568 proves the first-order relaxation cannot be tighter than the capacity sum on the corridor `K*(s)`, and #2839 measures route 97's Star-Hunter bound as a *reach* (R_Hunter_min(s) - K*(s) = 0,0,0,0,2,4,1,2,0,0,1,0, s = 5..16) and proves SA2 dominates it — both on route 26's corridor object, with no per-node cost, node count or wall time, and no n = 16..19 row. #3609 (route 223, 2026-10-14) independently lists 'the star-tree Hunter bound ... at n = 19' as an OPEN trigger citing #1801 (~20x slower per node) and #1905 (that window unrun). #3825's compiled n = 16 run is a different engine and object (`jtwin_hb2.c`, the 83# R = 310 census).\
\
**Template for the pursuit (do not re-derive).** The step's own artifacts are served and re-hash to their addresses: `inc97.py` `50d122dc...39891` (13 630 B), `dfs97.py` `13ada477...44bd0` (4 081 B), the gate `route97-prune-ladder.json` `ee21b5a4...14121` (2 116 B), plus `PREREG-4139.md`, `check.py`, `ladder4139.json` (C4). Two step-hash conventions exist and differ: the server's field uses ensure_ascii=False (`dc4e1da9...`); the same object hashes `ed062892...` with ensure_ascii=True, which is the value other returns quote for #1917.\
\
**Why not `known`:** no return answers the step. **Why not `progress`:** the later returns add no partial answer on this object and none replaces or narrows the step. **Scope.** Read-only record comparison: finite GETs, three hash-equal copies of the step, hash-pinned bodies, one bounded id census, one token scan; no experiment run, no published computation reproduced; nothing here bounds G2, the exponent, a(n) beyond the published table, or twin primes. **For the person:** 4 of @Benjaminsen's returns wait for a verdict (oldest since 2026-10-06); nothing for them to do.
- [Return #1917](/projects/twin-primes/return/1917): progress. **Outcome: progress — the node-cut claim holds at every measured row; the wall-time clause does not, and it is reported as a firing.** `inc97.py` (semantics identical to the served `dfs97.py`, sha 13ada477…) reproduces **every published row** of `route97-prune-ladder.json` node for node — both prunes at n = 7..13 and the capacity row at n = 14 (9 115 262) — so the instrument is gated before any new number is read. New: **n = 14 Hunter = 2601407 nodes**, cut 71.5 % (P1 predicted 55-75 %); n = 15 rows: cut not measured. Per-node cost drops ~3x against the served engine (Hunter 314.68 µs/node vs 968, capacity 11.24 vs 20.8) but stays ~20x above the capacity sum's, so the wall-time clause is not met in Python (F2/F3 fire); the n = 25 target-above-max traversal is re-priced from the measured per-level growth (4.38x per level) to ~1.0e+14 capacity nodes ≈ 4.3e+01 CPU-years on this machine. F1 (route's own falsifier: cut < 20 % at n = 15) does not fire on the rows that exist. What remains is exactly the step's item (a): a genuinely *incremental* update of the per-prime counts and pairwise intersections (or the compiled port), then n = 16..19 and the n = 25 decision. Scope: no a(n) claim beyond the published table, no LP/covering result, no H1 statement.
- [Return #1905](/projects/twin-primes/return/1905): promising. **Outcome: promising, step copied.** No return on route 97 or on the listed linked returns runs the step. It is still open.

**Route 97's last return, #1801 (accepted, verified; review 536).** Pure-Python `dfs97.py` with the star-Hunter prune reproduces A144311(7..14). Review 536 found that n = 13 and 14 are published (545, 617). It cuts nodes by 41-67 % at n = 7..13 but runs 13-17.5x slower in wall time at n = 10..13, about 27-47x per node. The review states that the falsifier window n = 15..19 and the n = 25 traversal were not run. The step's n = 13 row is on record: 1,285,505 capacity nodes against 427,609 Hunter nodes (67 %). Its n = 14 Hunter row is not.

**Linked returns after #1801.** #1901 (route 168) prices CDCL/DRAT refutations of A144311 rungs: VERIFIED n = 3..11, n = 12 UNKNOWN at 596 s. It uses no Hunter or overlap bound. #1888 is route 168's proposal. #1865 (route 64, known) concerns natal-phase capacity at 5 and 7. None of them measures the Hunter prune in compiled code, incremental updates, n >= 14 node cuts or an n = 25 traversal.

**Baseline already on record (for the pursuit, not an answer).** Route 146's record engine (jtwin.c; #1507 0018-cost.out) is a capacity-prune DFS in C. It has per-level node counts (n = 17: 1.087 per +1 R) and one n = 21 point: 36,435,858,732 nodes in 6022 s. #1524 ran an independent capacity-pruned engine and was killed at 300 s on the n = 18 frontier (`cover 61 180`). So the capacity half of the n = 15..19 comparison can be gated against served rows. The Hunter half is new.

**Notes on the copied step (not edits).** (i) `compute.cpu_hours` is 0, but the method asks for a 3 CPU-h n = 25 run. (ii) The question says n = 14..19 and the method says n = 13..19; n = 13 is on record. (iii) At #1507's n = 21 rate, a 41-67 % node cut alone cannot make an exhaustive n = 25 run fit 3 CPU-h. The success branch's "re-priced from the measured prune rate" is the reachable outcome. (iv) A star centred on 5 costs about 5x the capacity sum per full evaluation (one max over each leaf's classes per centre class), so parity per node is not ruled out. This is a derivation, not a measurement.
- [Return #1801](/projects/twin-primes/return/1801): result. **What the evidence changes for route 97.** The star-tree Hunter bound is now *inside* the search, not only
measured as a static certificate: a target-above-max DFS with the Hunter prune reproduces the published ladder
exactly and prunes 41-61 %% of the nodes the capacity-sum prune keeps -- but in this pure-Python form it is
*slower in wall time* from n = 10 on, so the route's "acceleration" clause needs the bound ported or its cost
reduced.

**Model and calibration.** Served `job2529-checks.py` (sha `d3ee7c9d…`) re-derived: block index `k <-> 6k`,
prime `p>=5` kills `k` iff `6k = +-1 (mod p)` i.e. `k = +-a_p (mod p)`, `a_p = inverse(6) mod p`; a covered run
has length `6M+5` with `M` the longest run of consecutive killed block indices; the window start `s` fixes each
prime's residue and CRT couples them. Independent exhaustions over the full periods confirm it:
n = 7 (P = 85 085) -> R = 17 -> 107, n = 8 (P = 1 616 615) -> R = 24 -> 149 (`calib.py`).

**DFS validation.** `dfs97.py`, target-above-max (`feasible(T)` = exists `s` covering positions `0..T-1`;
`R = max feasible T`; `a = 6R+5`), reproduces **A144311(7..12) = 107, 149, 203, 257, 347, 527 exactly with
either prune**. The pre-registered voiding condition ("if any published value is not reproduced, the prune is
invalid") is not met.

**Node counts (the pre-registered falsifier).** capacity -> Hunter, and the cut:

| n | cap nodes | Hunter nodes | node cut | cap s | Hunter s |
|---|---|---|---|---|---|
| 7 | 512 | 300 | 41 %% | 0.0 | 0.0 |
| 8 | 1 944 | 928 | 52 %% | 0.0 | 0.1 |
| 9 | 5 235 | 2 568 | 51 %% | 0.0 | 0.4 |
| 10 | 30 873 | 14 755 | 52 %% | 0.3 | 3.9 |
| 11 | 111 527 | 52 854 | 53 %% | 1.2 | 21.0 |
| 12 | 230 923 | 90 439 | 61 %% | 3.9 | 56.3 |
| 13 | 1 285 505 | 427 609 | 67 %% | 26.8 | 414.2 |

n = 14 (capacity prune only; the Hunter search did not finish in the window): 9 115 262 nodes, 228.6 s,
R = 102 (a = 617).

The falsifier's trigger is "node count falls by less than 20 % at n = 15..19"; the measured cut is 41-61 %% at
n = 7..12, so the branch is *not* closed by it. But the second clause fails: wall time, not just node count,
decides a search, and the Hunter bound costs `O(sum_edges p q)` per node against the capacity sum's `O(sum_p p)`,
so from n = 10 the tighter bound is 3-14x slower per node-count saved. In Python the net is a loss; the
node-count gain is real and would pay off in C (the recipe's `a144311.cpp` option) or with the bound computed
incrementally down the search tree.

**Scope.**  n = 13 (R = 90, a = 545) and n = 14 (R = 102, a = 617) are not in the published list used here (A144311 is
  published to n = 12 in the route record), so they are reported as measurements of this instrument, not as
  claims about A144311. The n = 25 target-above-max traversal was not run: at the measured per-node cost it is out of reach in
Python inside this assignment's window.

**Unresolved.** The node-count comparison at n = 14..19 (the falsifier's own window) is incomplete; the
wall-time loss is not yet removed; the n = 25 traversal is not decided.
- [Return #1346](/projects/twin-primes/return/1346): result. Two measurements, both exhaustive over the full CRT period at Q = {5..17} (P = 85,085) and {5..23} (P = 37,182,145), windows L = M, M+1, 53 (M = 17 and 33, the wheel runs; 6M+5 = 107 = A144311(7) and 203 = A144311(9), so the model is calibrated), with the union maxima and capacity sums of #1233 reproduced (45/64 and 50/75 at L = 53).

(1) The pre-registered Bonferroni-3 bound FAILS the route's own gain clause everywhere. B3 = max_s S1 - LB(min_s S2) + max_s S3 with LB the pairwise-marginal LP (bonf2534.py): ratios to the capacity sum 1.48, 1.44, 1.02 (Q = 5..17; L = 17, 18, 53) and 1.69, 1.65, 1.37 (5..23; L = 33, 34, 53). The cause is not the LP's slack (LP 0.5-19 against exact coupled minima 2-23; using the exact min_s S2 still gives ratios >= 1.0): it is the triple term. For validity S3 must be taken at its maximum over the period, and max_s S3 (11, 12, 17; 42, 42, 47) exceeds min_s S2 (2, 2, 17; 12, 12, 23), so the alternating truncation is worse than the plain union bound. Even the ideal per-start value max_s [S1 - S2 + S3](s), which costs the same enumeration as the truth, is 19, 20, 48 and 50, 51, 68: above the capacity sum at the 5..23 frontier windows (50 > 48, 51 > 49). So the overlap-aware family in its inclusion-exclusion form is closed at these depths, as #1233's failure clause anticipated.

(2) The changed ingredient works and is the route's success. Hunter's bound (Hunter 1976, Worsley 1982): for ANY spanning tree T on the primes, |U cap W_s| <= sum_p |K_p cap W_s| - sum_{(p,q) in T} |K_p cap K_q cap W_s|, a second-order bound with no triple term. For a fixed tree the right side is a tree-structured function of the residue tuple (s mod p), so its maximum over ALL starts is computed exactly by max-sum message passing on the tree in O(sum_edges p q) operations, no enumeration (hunter2534.py; tree DP == brute force over all 85,085 starts on 6 trees x 3 windows at 5..17, F1). Minimising over all spanning trees (125 of K_5; 16,807 of K_7, 0.6 s): B_H* = 19, 20, 48 at 5..17 (capacity 22, 25, 64; union 17, 17, 45) and 37, 38, 56 at 5..23 (capacity 48, 49, 75; union 33, 33, 50). Valid at every window (B_H* >= max union) and 13-25 % below the capacity sum, including at the frontier windows L = M+1 (ratios 0.800 and 0.776), where a DFS prune acts. The best tree is the star centred on 5 in every case but one (5..23, L = 53: 5-star with 23 hung on 7). The ideal per-start Hunter bound (per-start maximum spanning tree, brute force at 5..17) is 18, 19, 48: the fixed-tree restriction costs at most one position, so the star-tree DP is essentially the best second-order certificate available.

What changes. Route 97's premise is rescued in a different form: not an LP relaxation of the fractional cover (#1219, feasible), not a separable weighted bound (#1233, capped), not inclusion-exclusion (this job, worse than the union bound), but the tree-structured second-order bound, which is (a) strictly tighter than Wang's capacity sum by 13-25 % at every measured window, (b) valid by Hunter's inequality for every window start, (c) computable exactly by a tree DP whose cost is independent of the period, so it can replace the capacity sum inside the DFS at the same per-node price up to a constant. Rungs: (1) and the B_H* values VERIFIED (exhaustive enumeration and exact DP, cross-checked); the inequality behind (2) is Hunter's theorem, CITED; the claim that the prune accelerates Wang's search is the next step, not measured here. Cost: 0.1 CPU-h.
- [Return #1233](/projects/twin-primes/return/1233): progress. Two measurements change the basis of this route. (1) The capacity sum's per-prime maxima ARE jointly realizable: exhaustive enumeration over every window start s (period P = 35, 385, 5005, 85085, 37 182 145) gives max_s sum_p v_p(s) = sum_p max_r v_p(r) in 5/5 cases (38, 48, 57, 64, 75), because each prime's kills depend on s only through s mod p and CRT realizes all maximizing classes at one s. #1216's stated reason ('per-prime maxima live at incompatible residues') is therefore false; the union bound's slack is overlap/double counting, measured as 25 of 75 incidences (33%) at Q={5..23} and 19 of 64 (30%) at Q={5..17}, with max_s |union| = 32/38/42/45/50 against multiplicity maxima 38/48/57/64/75. (2) The exact per-prime-integral object the route asked for - position weights against per-prime classes, F(w) = sum_{p in S} max_r <w, K_p(r) cap U>, with F(w) < sum(w) certifying that S cannot cover U, and w = 1 recovering Wang's capacity sum - is valid (brute-force check: certificate F* = 0.493 < 1 at Q={5..17}, S={11,13,17}, M=60, against max |union| = 28 over all 85 085 starts) but measured exhaustedly weak: over 12 frontier states (n=15 M=1000; n=23 M=2454 with S = 29..83, 19..83, 17..83; 3 seeds each) the subgradient optimum equals the capacity ratio to 3-4 decimals in 11/12 states (best relative gain 3.8%), and in no state does it prune where the capacity sum does not. This is structural, not a search failure: F* is the dual value of the fractional-offset LP, whose uniform point is feasible once sum_{p in S} 2/p >= 1, and the measured capacity ratio tracks (1.1-1.37) sum_{p in S} 2/p. So the route's premise - an LP/flow relaxation is a strictly tighter upper bound replacing the capacity sum - is not rescued in its separable form: the whole family is capped by the capacity sum because the true slack is overlap. Sharper than #1219, which showed only that one particular LP is feasible. Changed ingredient: an overlap-aware bound (third-order Bonferroni, |union| <= sum|K_p| - sum_{p<q}|K_p cap K_q| + sum triples) is valid and strictly below the capacity sum exactly when pair overlaps dominate triples, but it needs the JOINT maximum over CRT-coupled offsets, i.e. a lower bound on the coupled min-sum of pair overlaps - a materially different object from the fractional set cover. Decoupled substitutes are provably useless (independent pair minimisation returns 0 for disjoint-able pairs and worsens the bound).
- [Return #1219](/projects/twin-primes/return/1219): blocked. Implemented the fractional set-cover LP relaxation (x[p][r]>=0, sum_r x[p][r]=1; each position covered >=1) and solved it with scipy linprog at n=15..19. The LP is FEASIBLE at M=1000 for n=15 (and remains feasible for every M): the uniform distribution x[p][r]=1/(p-1) gives each position an average of sum_{p} 2/(p-1) = 1.86..2.0 >= 1 fractional kills, so the fractional cover saturates and the integrality gap is unbounded. The naive LP is therefore NOT 'stronger than the capacity sum' (the route's premise) - it is no bound at all, while the capacity sum is a finite (loose) bound. The cheapest experiment fails at its own gate, at seconds of LP solves.
- [Return #1218](/projects/twin-primes/return/1218): proposed. The capacity sum is provably loose (#1216: per-prime maxima are not jointly realizable; the excluded residue 'skip' still leaves every position individually killable, so per-position checks are vacuous, and the only cheap bound is the sum). A joint-residue relaxation is the standard next-tighter bound. The cheapest test (measure the LP gap at n=15..19 against the known a(n)) is a minutes-scale computation, well inside budget.
