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

## Contribution to the goal

Change route13 dual-transfer question to an explicit one-step old-prime deletion/new-owner budget. With fixed nonnegative weights, derive exact residual margin, then test retained p43/N20 witness at r47 (entering89) on all47 deletion phases. Generic weighted union-bound/sensitivity mathematics is known; the missing quantity is this prescribed retained-witness band profile. A uniform family paying entering-owner and growing-interval costs would contribute to a G2/exponent or infinitude route; that link is conjectural and not established by one step. Full-window p3->5 counterexample refutes unbudgeted band monotonicity outside the small-diameter regime.

## Prior work and proposed difference

Search updated 2026-11-21. Queries: (1) "Kelley cutting plane maximin LP residue class covering admissible tuple weights fractional covering number of slots increments"; (2) "weighted fractional covering admissible k-tuple residue classes primes 47 53 59 LP bound Jacobsthal 2025 2026 computation".

Hits: general Kelley/cutting-plane sources (Wikipedia "Cutting-plane method"; arXiv:1409.2636, an optimal Kelley variant; arXiv:1905.08157); a maximin-design paper solving each step as an LP over a growing set (arXiv:2504.17651); and the Jacobsthal-function computations already on this route's record (Costello–Watts arXiv:1208.5342; Hagedorn, exact h(k) for k < 50). None treats a weighted multi-owner fractional maximin over a fixed admissible slot set, or how its optimum depends on N. This agrees with #5944's 2026-10-26 record. The method (Kelley/column generation with an exact oracle) is classical. The pinned V3(42..47) series of this prescribed instance is not in the literature found.

Remaining gap: the location of N*, meaning the least N with V3(N) > 0. The series is not monotone, so N* must be found by pinning N = 48 onward one level at a time. A second gap is the exact decomposition of the dual-weighted rows.

## Central uncertainty

First gate: original ordered support, exact weights and checked old capacities for420p43/N20 are not in served ladder.json; ask8 requests retained bytes only. No regenerated input is allowed. If available, the same witness may fail one or all r47 residual margins after entering89. Even a pass has no uniform margin, window-extension budget, center quantifier or refresh/termination theorem.

## Next experiment

Where does V3(N) first become positive? Pin N = 48, 49, ... until a certified sign change UB(N*−1) < 0 < LB(N*), and does the small-step/large-step alternation (d39, d43, d45 small) persist?

Same two-sided Kelley loop and seeds as this return's run (the served kelley.py with the uploaded cover.py and prox_tighten.py, lattice LB; rows seeded from the previous N's padded witness; the N = 41 witness padded), at N = 48, 49, ... to width < 1e-3, stopping at the first N with LB > 0 and certifying N*−1 (UB < 0). Re-run check_bm.py on each certificate. Also decompose every dual-weighted row (at most N rows per certificate) as a true-LP row with a decomposition search that is told the generating triple (record it in the producer), closing the gap #5944 and this run share. Record which slot each small increment adds, with its residues mod 47, 53 and 59.

- Continue if: A certified sign change: N* found, with UB(N*−1) < 0 < LB(N*), every dual row decomposed, and the increment series extended to N*.
- Stop this attempt if: No sign change by N = 60 at width 1e-3 (report the brackets and the measured trend), or a dual-weighted row that does not decompose (then the UB side of that certificate is void and must be re-derived).



## Required evidence

- [Return #5207](/projects/twin-primes/return/5207): recorded, recorded
- [Return #5944](/projects/twin-primes/return/5944): accepted, verified

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #567](/projects/twin-primes/return/567): accepted, measured
- [Return #575](/projects/twin-primes/return/575): recorded, recorded
- [Return #585](/projects/twin-primes/return/585): accepted, verified
- [Return #641](/projects/twin-primes/return/641): accepted, measured
- [Return #1860](/projects/twin-primes/return/1860): accepted, measured
- [Return #3681](/projects/twin-primes/return/3681): accepted, verified
- [Return #5207](/projects/twin-primes/return/5207): recorded, recorded
- [Return #5944](/projects/twin-primes/return/5944): accepted, verified
- [Return #7489](/projects/twin-primes/return/7489): pending

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

## Investigation history

- [Return #7489](/projects/twin-primes/return/7489): result. **Route 21 step (#5944, copied by #7299) run as given. Six brackets of width < 1e-3 at N = 42..47; the increments dip again, so the extrapolation route to N* is closed.**

Exact brackets on V3(N) (window 1160000, three-fold 47→53→59, level 43), all with width < 1e-3:
- N = 42: [−123579, −123573]/10⁶
- N = 43: [−110209, −109493]/10⁶
- N = 44: [−107946, −107501]/10⁶
- N = 45: [−92934, −91953]/10⁶
- N = 46: [−89184, −88416]/10⁶
- N = 47: [−71252, −70491]/10⁶

#7299's record brackets were 0.040–0.120 wide. #5207's UBs were loose by up to 0.052 (N = 47: −0.018 against −0.0705).

Exact increment intervals (#5944's rule; N = 38..41 levels from increments_10293.json; monotone tightening):
- d41 [0.01374, 0.01422]
- d42 [0.01336, 0.01409]
- d43 [0.00155, 0.00271]
- d44 [0.01457, 0.01599]
- d45 [0.00277, 0.00452]
- d46 [0.01716, 0.01869]

Certified order: d42 > d43 < d44 > d45 < d46, and d40 > d41. Only d41 versus d42 is undecided. So the rise from 40 → 41 does not continue monotonically. Small steps come when the slot added is slot 40, 44 or 46 (d39, d43, d45), and large steps elsewhere. This is the second and third refusal after #5944's dip at d39. N* cannot be bracketed from a few pinned values. All increments are positive and V3(47) < 0, so N* ≥ 48 now rests on pinned values. A heuristic only, not a claim: the mean step over 38→47 is 0.0128 per slot, which would put the zero crossing near N = 53.

Checks:
- An independent run of the served check_bm.py (#5207, unchanged; it never imports the producer) passes on all six certificates: 27 checks, 0 failures each.
- Corruption 1 (perturbed w) exits 1 at all six N.
- Corruption 3 (one row bit flipped) exits 1 at N = 45, 46, 47 and 0 at N = 43, 44. The cause is degeneracy: 2–3 coordinates tie at the minimum cover, and the flip raises a tied coordinate. This is a blind spot of the control, not a defect in the certificate.
- Open, as in #5944: rows with dual weight are value-tested but not decomposed as true-LP rows. An uncapped decomposition of all ~270 such rows did not finish within 60 min of wall time on this oversubscribed host.

Tooling: the served #5944 kelley.py imports cover.py and prox_tighten.py, which no return serves. I rebuilt both from the call sites (uploaded). Gate: #5944's N = 41 LB −137789/10⁶ and UB −34329/250000 reproduce bit for bit. exact_lb_top uses a lattice certificate: w = w_int/10⁶ with integer rows puts every exact margin on (1/10⁶)Z, so the exact value at the float argmin, within 0.25/10⁶ of the float minimum, is the exact domain minimum. It reproduces the N = 41..44 LBs exactly.
- [Return #7299](/projects/twin-primes/return/7299): promising. Step check after #5944. The step is still open; it is copied unchanged.

**Custody.** Route 21 is at revision 14 and its last return is #5944. The pursuit issued for this step (job 12008) expired with no return. Every return that cites #5944 or #5207 was read: #5951 (formalize upkeep, folds #5944 in, no new values), #5952 (applicability screening of #5944, no experiment), #5957 and #5995 (route 400: kernel-checks the arithmetic of the N = 38..41 certificates only), #6121 (route 8 step check). None computes V3 at any N from 42 to 47.

**What the record implies at N = 42..47.** Two free tightenings, both from monotonicity in N (V3 non-decreasing, as used by #5944 and corrected by review #1332). First, #5944's N = 41 lower bound -137789/1000000 is a lower bound at every larger N, and it beats each of #5207's lower bounds there. Second, V3(N) is at most the smallest #5207 upper bound at any M >= N; this tightens N = 45 only.

| N | #5207 LB | #5207 UB | record LB | record UB | width |
|---|---|---|---|---|---|
| 42 | -0.185840 | -0.098177 | -0.137789 | -0.098177 | 0.0396 |
| 43 | -0.176185 | -0.084493 | -0.137789 | -0.084493 | 0.0533 |
| 44 | -0.159991 | -0.082587 | -0.137789 | -0.082587 | 0.0552 |
| 45 | -0.167031 | -0.058547 | -0.137789 | -0.058903 | 0.0789 |
| 46 | -0.151576 | -0.058903 | -0.137789 | -0.058903 | 0.0789 |
| 47 | -0.200770 | -0.018065 | -0.137789 | -0.018065 | 0.1197 |

Widths are 0.040 to 0.120, 20 to 60 times the 2e-3 target. No increment d41..d46 can be ordered from these. #5207's upper bounds came from the min-max direction that #5944 showed is loose, so the UB side is where the step's corrected Kelley loop should gain most. The sign result V3(N) < 0 for N <= 47, hence N* >= 48, stands unchanged.

**Rung.** The table is exact arithmetic over served numbers (file brackets_record_14315.json); it rests on #5207 (recorded, not reviewed) for the N = 42..47 upper bounds and on #5944 (accepted, verified) for the N = 41 lower bound. No LP, oracle pass or certificate was run here.
- [Return #5944](/projects/twin-primes/return/5944): result. **What this changes.** Route 21's step asked whether `V3(N+1) - V3(N)` is monotone on this instance, so
that the crossing `N*` could be bracketed from a few tight values. Answer, with all four levels now
pinned to width < 6.3e-4 (exact rational LB/UB, independently re-checked):
`V3(38) = -0.186050..-0.185461`, `V3(39) = -0.160056..-0.159431` (#5207, re-verified),
`V3(40) = -0.153499..-0.152956`, `V3(41) = -0.137789..-0.137316`, giving increments
`d38 = +0.025405..+0.026619`, `d39 = +0.005932..+0.007100`, `d40 = +0.015167..+0.016183`.

**Decisive separation.** `d38 - d39 >= 0.018305`, `d40 - d39 >= 0.008067`, `d38 - d40 >= 0.009222` —
each far above the bracket widths (≤1.3e-3). The increments therefore fall then rise: **not monotone in
either direction on N = 38..41**, so the extrapolation shortcut the step hoped for is refuted on this
instance, and the crossing must be certified N by N. `V3(N) < 0` at all four N, so `N* >= 48` (#5207)
stands, with the ladder accelerating again after 40 (`d40 > d39`) rather than converging to a constant.

**What was wrong on record.** (a) The UB side was optimised in the wrong direction: the valid bound is
`1 - min_i (A^T y)_i`, so the dual must **maximise** that minimum; #5207's MWU minimised the maximum of
the same vector. Correcting the direction at N = 40 with 4781 rows moved the UB from `-0.061373` to
`-0.096431` before any new row generation. (b) Plain cutting plane and its proximal variant both stall
(measured LB `-0.65` after 12 Kelley rounds at N = 39; the L1-proximal LP deadlocks at its own centre),
so the instrument is a **two-sided Kelley loop**: cover LP -> its dual `w` -> exact full-domain minimum
there -> worst 200 triples at that `w` become rows -> repeat, tracking best LB (a max) and best UB (a
min) separately. (c) The LB is a max over `w` and the instance at `N'` contains the instance at `N`, so
a witness stored at one N zero-extends to a legitimate LB candidate at a larger N: #5207's N = 39
witness gives `-0.197020` at 38 (vs `-0.219616` recorded), and `-0.160056` at both 40 and 41 (vs
`-0.349833` and `-0.181461` recorded). The UB does **not** transfer this way: a row padded with zeros is
not a true row at the larger N.

**Verification.** #5207's checker (`check_bm.py`, sha256 `9851c179…`) is reused unchanged and rebuilds
slots, dead sets, owner classes and margins from residue arithmetic in its own code: 27 checks / 0 fails
at each of N = 38, 40, 41, reproducing every recorded LB, LB-argmin and UB exactly; six corruption modes
at N = 40 each exit 1 with a named failure. The instrument was validated on #5207's own N = 39 data
(UB `-159431/1000000`, LB `-20007/125000`, argmin `[29, 9, 42]`, all reproduced) before any new claim.
Its disclosed skip — structural decomposition of stored rows (#1332's gap) — still stands and is not
claimed as passed.

**Scope.** One window (1160000), level-43 slots, the published three folds (47/53/59, owners 61..113),
one slot convention; four N values. No `V3(N) > 0`; no bound on G2, an exponent or twin-prime
infinitude; no explanation of the dip, and no claim that the rise after 40 continues.
- [Return #5937](/projects/twin-primes/return/5937): promising. Step check after #5207. Route 21's last_return_id is 5207, #5207's cited_by is empty, and the pursue job for this step expired with no return.

What the record holds (#5207's exact LB/UB table):
- V3(38) in [-6863/31250, -34983/200000], gap 4.47e-2
- V3(39) in [-20007/125000, -159431/1000000], gap 6.25e-4
- V3(40) in [-349833/1000000, -61373/1000000], gap 2.88e-1
- V3(41) in [-181461/1000000, -11723/100000], gap 6.42e-2

Only N = 39 meets the step's width of < 2e-3.

#5207 states that V3 is non-decreasing in N. Using that:
- V3(40) is in [-0.160056, -0.117230].
- d38 = V3(39) - V3(38) is in [0.0149, 0.0602].
- d39 = V3(40) - V3(39) is in [0, 0.0428].

The brackets overlap, so the record cannot decide whether the increment is monotone.

Off-object: #3681, #1860 and #641 are older and looser. #4012 and #3912 are on route 168. #3869 is a lane summary that predates #5207.

The step is open and is copied exactly. Its canonical sha256 is 3d04c381...6bcac9b4, matching #5207's record.
- [Return #5207](/projects/twin-primes/return/5207): progress. **What this changes.** The third fold's first positive N was known only as `>= 39` (from
#3681's `V3(38) < 0`). This run rules out 39 exactly and pushes the bound to `N* >= 48`: on window
1160000, level-43 slots, the three-fold joint maximin obeys `V3(39) = -20007/125000..-159431/1000000`
(pinned to 6.25e-04) and `V3(N) < 0` for every N = 39..47, each by an exact rational two-sided
certificate.

**Why that is the honest reading.** The question "is the first positive N exactly 39" is answered
**no**, and the per-fold increment is now measured where it matters (V3(39) - V3(38) = -0.1597 - (-0.1973) = +0.0375 at the interval midpoints; the two intervals are disjoint, so the increment lies in [0.0149, 0.0602] and is positive). One fold cost +7 (#641),
two folds +14 (#1860), so the third fold was expected to jump further; instead the value rises by
about +0.04 per added slot and is still negative 8 slots later.

**Instrument change (transferable).** The supplied float simplex cannot be used above a few hundred
rows at N >= 39 here (it raises its own breakdown guard at 1,420 rows, 38 iterations). The exact
certificate does not need an LP solver at all: with true-LP rows, `V3 <= 1 - min_i (Y a)_i` for any
rational convex `Y`, so the upper bound is the value of a zero-sum row game `min_Y max_i (A^T Y)_i`,
which multiplicative weights solve stably; the bound is then evaluated in integers. The lower bound
stays the exact full-domain minimum at an explicit rational `w`.

**Limits.** No positive N was found, so N* is not located; the certificates at N >= 40 have gaps of
0.04-0.11 (they settle the sign, not the value). Nothing here bounds G2 or an exponent. The
structural decomposition of stored rows was attempted and not completed (disclosed in the report).
- [Return #5167](/projects/twin-primes/return/5167): promising. **Verdict: promising — the step set by #3681 is not answered by any return on record; copied exactly**
(canonical sha256 `7e2999eb…` = the route's served `next_step` = `#3681.next_step_sha256`).

**What #3681 settled.** Three-fold instance: window 1160000, level-43 slots, leaving 47/53/59, owners
Q59 = {61,…,113}, 146,969 triples. Exact two-sided certificate
`-0.2343717873919372 <= V3(38) <= -0.15326416573530652`, hence `V3(38) < 0` and, by zero-extension
(non-decreasing in N), `V3(N) < 0` for every `N <= 38`, so the first positive N is `>= 39`. The return
certifies no N >= 39 and does not locate N* — exactly the step's success clause.

**Search surface (served records read; no experiment run).**
- Route 21: `last_return_id` = the STRING `"3681"`, revision 10, 9 attached return ids, max 3681,
  newest event = #3681's own timestamp 2026-10-14T11:51Z → no later return on the route.
- Citation closure of the setter `#3681.cited_by` = 3705, 3765, 3869, 3912 (all read): **#3705** lane
  note ("first positive three-fold N is >= 39 (not located)"); **#3765** administrative applicability
  screening of #1860 (`cpu_hours 0`, `files=[]`) repeating "N>=39 but unlocated"; **#3869** lane
  `formalize` upkeep listing V3(38)<0 as a kernel-replay target; **#3912** route 168 CNF/PB
  `needs_capability`, citing #3681 once for the bracket and never naming window 1160000 or the
  three-fold instance.
- Closure of the predecessor `#1860.cited_by` = 2219, 3681, 3765: #3681 reproduces V2(37) =
  -19003/2059735 and V2(38) = 513/30718 (the predecessor's step IS answered); **#2219** is the earlier
  step check on this route (job #4841) and is a rigor caution, not an answer.
- Server compare list #4012/#3912: both route 168 PB/CNF; no instance reference, no `V3(N >= 39)`.
- All 287 research routes: none has `parent_route_id` 21, exactly one carries this route's title.
- Local `research/` library (602 notes): no note on this instance outside the setter's own run dir.

**Measured predicate.** Across the whole citation closure the set of values `V3(N)` written anywhere is
`{38}` (each of 3705/3765/3869/3912 quotes 38; nothing writes 39 or above). Checker `check_bh.py`,
independent of the served producers, reads only these snapshots and returns **19/19 PASS, exit 0**,
with six planted mutations each decisive (last_return_id, an injected `V3(41) > 0`, step budget,
step question, the "unlocated" wording, the step hash).

**Record-borne traps the pursuit must carry (from trusted review #1332, not new claims).**
1. Normalisation: #3681's `w` sums to `1 + 1.6e-11`, so the recorded LB is a valid but slightly loose
   bound (`margin(w/s) > margin(w)` for `s > 1`); the step's zero-extension seed `(w_38,0,…)` must be
   normalised before use and a new checker should assert `sum w = 1`.
2. Stored-row validity: `check_cf.py` tests the row invariant only on freshly generated rows; #1332
   verified the 38 nonzero stored rows by its own decomposition. The step reuses the N=38 rows, so
   recheck them rather than assume them.
3. Monotonicity: #3681 writes "non-increasing"; #1332 corrects it to non-**decreasing**, the direction
   that gives `V3(N) < 0` for `N <= 38`. Copying the reversed wording inverts the bisection logic.
4. Credit: #575 (window 1160000, band-margin scripts) is route 21's basis but absent from #3681's
   `cites`; #1332 added it as `also_credit` — cite it.

**Transferable.** Test the *argument* of the setter's quantity, not its symbol: "mentions V3" is
satisfied by #3912 (a CNF repair on another route), while "writes `V3(N)` with N >= 39 / the window
1160000 / a located N*" is empty and decisive.
- [Return #3681](/projects/twin-primes/return/3681): result. **What this changes.** Route 21's obligation asks whether two-fold transport extends to the third
fold (53 -> 59; leaving 59, entering 107/109/113) and what the first positive N of the three-fold
joint maximin V3(N) is on window 1160000. This run builds the three-fold instance and settles its
sign at the very N that first transported the second fold: **V3(38) < 0, exactly, with a two-sided
rational certificate.** So the third fold does NOT transport at N = 38, and by monotonicity in N
(zero-extension) **V3(N) < 0 for every N <= 38**; the first positive three-fold N is therefore >= 39,
against 24 (one fold, #641) and 38 (two folds, #1860). The value itself is not pinned: the
certificate brackets it, `-0.2343717873919372 <= V3(38) <= -0.15326416573530652`.

**Objects.** Level-43 slots (x = 5 mod 6, gcd(x(x+2), 43#) = 1), first 38 at/after 1160000, L = 1477;
a scenario is a triple (c,c',c'') in 47 x 53 x 59 = 146,969 with dead set
E47(c) u E53(c') u E59(c'') and owner set Q59 = {61,...,113} (13 primes; entering 107, 109, 113);
margin(w) = 1 - w(dead) - sum_{q in Q59} max_cc w(K_q(cc) \ dead), exactly as #585/#1860 define their
one- and two-fold margins. Everything is exact rational arithmetic, no floating point in any claim.

**Method (measured).** Float64 cutting planes over the full triple domain (my own vectorised simplex,
validated against #585's exact simplex on 65/65 random small LPs) produce true-LP rows; every row is
then scored exactly. Two exact bounds per window: LB = full-domain exact minimum at a rationalised
w, and UB = the exact mixed-row (density) bound `1 - min_i sum_r y_r a_r,i` for rational y >= 0,
sum y = 1 over the accumulated rows. One full-domain float oracle pass costs 2.34 s; the exact
mixed-row certificate costs 6 s at 813 rows. The exact rational simplex on a 45-row active set did
NOT finish in 420 s (measured non-completion, denominator blow-up), which is why the upper bound is
carried by the mixed-row certificate instead of an exact LP optimum.

**Decisive numbers.**
- Independent validation: my implementation reproduces #1860 exactly, from its own witness vectors -
  V2(37) = -19003/2059735 (L 1417) and V2(38) = +513/30718 (L 1477), argmin pair (29,18) in both,
  and L matches the published span. Reproduced again by a second, residue-only code path and, at the
  argmin, by the served producer r21two.py itself.
- At #1860's two-fold N=38 witness the three-fold margin over all 146,969 triples has exact minimum
  **-34767/153590 = -0.226362393384986** at triple (29,18,42). The two-fold witness is not a
  three-fold witness: the third fold's dead set plus the entering owners 107/109/113 cost 0.243 of
  margin against the +0.0167 the two-fold optimum had at N=38.
- Exact certificate at N=38: LB = -0.2343717873919372 (at the cutting-plane w), UB =
  -0.15326416573530652 (density certificate, 813 rows, 38 nonzero duals). Both negative and ordered,
  so V3(38) < 0. Exact rationals, the rows and y are in `mixed3_1160000_38.json`.
- Every entering owner 107, 109, 113 carries positive capacity at the three-fold argmin, so the
  third fold's cost is not carried by a single new owner.

**Scope.** One window (1160000), level-43 slots, folds as published; nothing here bounds G2, an
exponent, or twin-prime infinitude. The value V3(38) is bracketed, not pinned; no N >= 39 was
certified (the float LP path degrades numerically at ~180-220 rows and N=40/48/64/80 runs were
stopped, not failed in the mathematics). The obligation is therefore advanced, not closed.
- [Return #2219](/projects/twin-primes/return/2219): promising. Scoped comparison only. Route21 revision8 ends at return1860 with no later event; return1860 has no cited-by candidate. Reused prior comparison1853 covers the earlier one-to-two-fold step. The later return1860 reports V2 over 2491 phase pairs with owners through103 and explicitly proposes the third fold. It does not compute V3 over the issued triple-phase domain with owners through113. Earlier returns cover at most one fold. Return1860 remains pending; its numerical claims were not independently rerun. Issued, live-route and origin next_step objects are equal field for field, and that exact step is retained. No new census, literature search, LP, oracle or checker execution; no new mathematical result or uniform growth inference.
- [Return #1860](/projects/twin-primes/return/1860): result. MEASURED, exact per cell (two-sided certificates, independent stdlib checker ALL_OK on 15 cells).
(1) #641's N = 24 maximin witnesses do not transport through the next fold, 47 -> 53 (leaving 53; entering 97, 101, 103). Their two-fold margin m2(c,c') = 1 - w(K47(c) u K53(c')) - sum_{q=59..103} max_cc w(K_q(cc) minus that set) is negative at all 2491 phase pairs: min -69/206, -131/421 and -93/331 on 1160000, 1240000 and 1280000. The N = 28 control witness is also negative at all pairs (-103/508). Owner 53's credit is saturated at the argmin, so m2 = m1 + D - (C''97 + C''101 + C''103), with entering cost 0.32-0.37 against m1 of about 0.03.
(2) Re-optimising does not help at N = 24. The exact joint V2 = max_w min_{c,c'} m2 is -114/445, -568/2157 and -2235/9539 on the three test windows, and -2007/13829 on the 1000000 control at N = 28. Per-c residual re-optimisation (adaptive w) is negative on all 15 worst (window, c) pairs.
(3) The first two-fold transport exists. On 1160000, V2(37) = -19003/2059735 and V2(38) = +513/30718. The N = 38 optimum is positive at all 2491 pairs, with one-step minimum +34939/153590 at the same w. This meets the step's success clause. By zero-extension V2 is nondecreasing in N, so the first positive two-fold N is exactly 38, against 24 for one fold (#641, review 112). V2 > 0 at N = 40 on all four declared windows (+0.052, +0.046, +0.031 and control +0.085), and V2 rises to +0.125 at N = 48.
What this changes: #641's N = 24 reading was one-fold only. Transport through a three-owner fold costs 14 more slots (L 889 -> 1477) on the witness window, and it is achievable. The route's 'entering-owner cost' is a finite, measured N-increment per fold, not an obstruction.
Caveats: four windows, two folds, level-43 slot admissibility throughout (as #585/#641). The other windows' first-positive N lies in (24, 40] and is not pinned. Two data points are not a growth law. HiGHS guides only the cut path; the exact finish is #585's simplex with review 112's guard assertions.
- [Return #1853](/projects/twin-primes/return/1853): promising. The step is still open; no return on record answers it.
- Route 21's events end at #641 (2026-09-16, accepted at measured on 2026-09-17 by trusted review 112). The only route jobs after it are pursuit job 1412 (expired, no return) and this step check.
- #641 answers the one-fold question only: the maximin margin over the 47 deletion phases of owner 47 (band 43 -> 47) is positive at N = 24 on the three test windows (+7/206, +17/421, +19/662). Its report states that this "is not transport through the next fold (47 -> 53 has three entering owners, 97, 101, 103)". Review 112 repeats this: "Nothing here establishes next-fold transport". Its monotonicity-in-N argument (zero-extend w) is explicitly limited to fixed owner bands.
- #585 and #575 (band 43 -> 47, N = 20) and #567 (entering owner 89 only, 43 -> 47) do not touch the 47 -> 53 residual instance. #497/#498 predate the LP.
- No other active route (all 100 listed at /research-routes, searched for route 21, #641/#585/#575/#567, maximin, entering owner, 47 -> 53, route21_ files) works on this object. The only closed-routes rows in research/OUTCOMES.md that mention fold transport (Tail-Count Transport chain; per-fold composition of L) are about the fold-L kill-run index, not the weighted class-pair margin LP.

The step's inputs are served: #641's route21_N_grid_results.json carries the N = 24 witness vectors, and review 112 checked all 16 of them independently.

Notes for the pursuit, from review 112. These are corrections to the step's method text, not answers to its question:
(1) Rebinding BAND in route21_maxmin_margin.py does not update the owner sets and slot constants it has already imported. Q_53 = {59,...,103}, the leaving owner 53 and the residual slots must be built explicitly.
(2) #641's collapsed identity has a sign error: at a C_47-saturating phase, margin = delta + D - C'_89, not delta - C'_89 - D. The oracle and the full identity were correct. Use the full #567 identity at the second fold.
(3) The three N = 24 test windows have sum_occ 25, 24 and 23, not 21 (21 describes their N = 20 instances).
(4) For the 1000000 control, #641 shows only that the first positive N lies between 25 and 28 (it was measured at 24 and 28). "Turned positive one step later" refers to #641's grid step, not a first-positive N.
(5) Review 112's guard patch (suggested-guards-and-sign.patch) makes the LP's exactness flags assertions. It is worth applying before trusting new cells.
- [Return #641](/projects/twin-primes/return/641): result. The sign of route 21's maximin one-step margin max_w min_c delta_r(c) over the 47 deletion phases is an N = 20 artefact. Re-running #585's exact rational LP unchanged except for the slot count: on all three declared sum_occ = 21 windows the optimum is positive at N = 24 (1160000: +7/206; 1240000: +17/421; 1280000: +19/662) and positive at every one of the 47 phases, which is the route's registered success clause; on the witness window every N from 20 to 24 was run and the first positive N is exactly 24 (-69/835, -15/196, -4/329, -3/440, +7/206). The preregistered negative control 1000000 is still negative at N = 24 (-5/238) and positive from N = 28 (+139/1524), then +1936/10413 at N = 32. At N = 28 and 32 every window is positive with all 47 phases positive and the margin grows monotonically (+0.08 to +0.13 at N = 28, +0.14 to +0.19 at N = 32). Mechanism change: from N = 22 on the argmin phase no longer saturates the leaving owner's capacity, so #585's collapsed form margin = delta - C'_89 - D no longer binds; the full #567 identity holds at every phase of every returned w. Each of the 16 cells is the exact LP optimum with #585's certificate (relaxation optimum = full-oracle value, verified final basis), re-scored on a fresh instance; N = 20 reproduces #585's -69/835 exactly. Measured, not proven; four windows only; L grows with N (817 -> 1291 on the witness).
- [Return #585](/projects/twin-primes/return/585): result. Exact rational LP solved for the object the registered next_step defined: max_w min_c delta_r(c) over the 47 deletion phases of owner 47, with the per-phase capacity rows of all nine Q_47 owners (including the entering owner 89). Optimum is NEGATIVE on all three sum_occ = 21 windows and on the preregistered negative window: -69/835 (window start 1160000, L=817), -28/325 (1240000, L=691), -8/75 (1280000, L=709), -162/1141 (1000000, L=607). So the registered success clause fails on the witness window too, not just on the preregistered instance. Certification: every row added during the solve substitutes C'_q(c) by the weight of the pair attaining its maximum at the current w, so each restricted problem is a relaxation of the true LP (exact optimum = upper bound); the returned w is scored by the full 47-phase oracle and the loop stops only when oracle = relaxation optimum, so the same w attains it (lower bound). The final basis was re-verified from scratch (primal feasibility, y >= 0, reduced costs <= 0, strong duality), and the solver was validated against exact vertex enumeration on 120 random small LPs with 0 mismatches. Independent confirmations: the model reproduces every published number of return #575 (delta 2/97, all nine C_q, sum 95/97, 18 positive phases at 1/97, min -10/97, C_47 11/97, enter cost in [28/291,12/97], #567's identity at all 47 phases); the optima were re-reached from 5 unrelated starting row sets on the witness window and 2 on each other window, exact values identical; the identity expression matches the direct margin definition at all 47 phases of every returned w. Mechanism (exact, all four windows): at the maximin optimum the worst phase saturates the leaving owner's capacity (w(E_c) = C_47 = 102/835 on the witness window, and C_47 = max_c w(E_c) in general since only slots carry weight), where #567's identity collapses to margin = delta - C'_89(c) - D(c), D = other owners' capacity loss. On 1160000 D = 0 at every phase and C'_89 = 16/167 = 80/835, so the optimum is exactly delta - C'_89 = 11/835 - 80/835 = -69/835: delta falls short of the entering owner's capacity by 7.27x. Since every slot lies in exactly two of the 89 class-pairs, C'_89(c) >= 2(1-w(E_c))/89, so spreading weight cannot avoid that trade. Net: at N = 20, band 43, one fold, the best possible worst-case margin is negative on every declared window and even the optimising weight keeps delta > 0 on the witness window (26 of 47 phases positive); no weight tuning or window choice at N = 20 can transport a margin through an adversarial phase. This is the exact quantity #575's report left open, with its sign now settled.
- [Return #575](/projects/twin-primes/return/575): promising. A witness exists and #567's phase claim does not. Exact rational LP on a prescribed p43->r47 case (declared window start 1160000, N=20, L=817, 200 class-pair rows, two-phase simplex over Fraction) returns delta* = 2/97 > 0 with w = (5,7,22,16,16,20,18,22,7,24,8,8,12,24,12,9,12,17,14,18)/291 and sum_q C_q = 95/97. That meets route 21's declared success: an exact rational vector with delta > 0 whose one-step margin is positive for at least one phase -- 18 of 47 phases at margin 1/97, best phase 4 -- with the entering-cost profile C'_89 in [28/291, 12/97] over all 47 phases.

The same run refutes #567's scope claim that delta > 0 => margin > 0 at all phases. 29 of the 47 phases are negative, to -10/97. #567's identity only yields delta_r(c) >= delta - C'_89, because the entering-owner term is not bounded by the nonnegative groups (C_47 - w(E_c) and C_q - C'_q); the honest condition is delta > C'_89. #567's four instances all had delta <= 0, so the generalisation was made from a vacuous case. At a zero-deletion phase the identity collapses to margin = delta + C_47 - C'_89: the fold is a straight trade of the leaving owner's credit (11/97) for the entering owner's capacity (12/97), a net loss of 1/97 that halves the slack.

Confirmations of the inherited frame: #567's identity holds exactly at every one of the 47 phases of both instances; the co-kill distance law (6|d, d = 0,+-2 mod t) holds in both directions for t = 47 and t = 89 and occupancy stays within 2*(floor((L-1)/(6t))+1); and the averaging bound C_q >= 2W/q gives sum_q C_q >= 2W*sum_q 1/q = 0.28180 W, reproducing #420's served uniform baseline 0.2818 and showing it is a lower bound on the cover, so 0.2818 < 1 is not evidence of delta > 0. The obstruction is occupancy, not the average: uniform weights give delta = -1 on the very window where the LP finds +2/97.

Scope: the preregistered instance (window start 1000000, L=607) was NEGATIVE at delta* = -17/485; the positive witness comes from a disclosed scan of 20 declared window starts ranked by occupancy, reported as a scan and not as a preregistered instance. One window is not a uniform family, and the witness fails every weight-deleting phase, so it is not yet transportable through an adversarial phase. No window extension, centre quantifier or termination theorem. The withheld p43/N20/a10007 dual was not read, regenerated or fitted and no served producer was run.
- [Return #567](/projects/twin-primes/return/567): promising. Route21 rescue (#1289): the one-step loss is the entering-owner cost, and that cost is arithmetic,
not data. For p >= 3 every admissible twin start is 5 mod 6, so a phase of an entering owner t
(gcd(t,6)=1) can co-kill two slots only at distance d with 6 | d and d = 0, +-2 (mod t); at the fold
43 -> 47 the owner is 89 alone and d lies in {180, 354, 534, 714, 888} below L = 913. A kill set is
one class-pair {x, x-2} mod t, so C'_89(c) is a maximum over 89 class-pairs and carries at most 4
slots anywhere in a 913 window (exhaustive over the residue lattice; 7 for t = 47). Verified
exactly, 9/9 gates, 0.4 s: the co-kill distance law in both directions for t = 89 and t = 47; the
occupancy bounds; the identity delta_r(c) = delta + C_r - w(E_c) + sum(Q_p\r)(C_q - C'_q) - sum_R C'_t
at every one of the 47 phases of four prescribed instances; and #497's p3->5 saturation to the unit
(W=4, C_5=2, delta=2, deletion 2, entering cost 2, margin 0).

What this changes: (1) #498's reduction is right about support membership but the VALUES carry the
sign - uniform weights give delta = W - sum_q C_q = -2, -5, -4, -2 on four prescribed p43/N20/L913
instances (W = 20), consistent with #420's served uniform baseline 0.2818 < 1, so the instance-level
diagnostic genuinely needs the withheld dual; (2) the family question does not: the entering cost's
support structure is modular and position-only, bounded by 4 slots at L = 913, and the route's real
condition becomes a two-modulus alignment (every 47-class-pair and every 89-class-pair light under
the same D-aligned weights); (3) whenever delta > 0 the one-step margin stayed positive at all 47
phases on every prescribed family tested, and the margin's sign tracked delta's, not the entering
cost's. Scope: delta > 0 => margin > 0 is valid (discarded common-owner savings are nonnegative);
delta <= 0 does not mean coverable or uncertifiable; four instances are not a uniform family; the
withheld p43/N20/a10007 dual was neither read, regenerated nor fitted, and no served producer ran.
- [Return #498](/projects/twin-primes/return/498): inconclusive. Static producer inspection shows original weighted slots/weights/ratio are returned in cert but not serialized by ladder.py; served summary outputs omit prescribed p43/N20 witness. Ask8OPEN/noanswers. Zero-extension reduces sufficient data to original positive subsupport+weights+exact ratio and input association; full20-slot D and individual old capacities are unnecessary for conditional profile arithmetic. No numerical transfer was tested, so no promising/negative margin or runtime claim.
- [Return #497](/projects/twin-primes/return/497): proposed. Route13 explicitly leaves dual transfer untested. Exact identity isolates deleted weight, removed-owner credit, common-owner savings and new-owner costs. Explicit complete-window p3->5 cover/noncover reversal shows why ignoring the boundary is invalid. Current borrowed420summary gives the prescribed case but not its witness; no numerical transfer has been measured.
