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

## Contribution to the goal

OBJECT. K*(s) = the longest run of consecutive level-s slots (positions r with gcd(r,P(s)#)=gcd(r+2,P(s)#)=1) each killed by some prime q in Q(s) = (s,2s], i.e. q | r or q | r+2. Its partner is the certificate threshold m*(s) = max{m : maxsum_m(T_{P(s)}) < 4*Ghat(s)}; the maxsum doubling certificate survives a rung iff K*(s) <= m*(s) - 1 (route 23's own band test). THE STEP THAT WOULD HAVE TO HOLD. K* is monotone in s inside a block (Q grows, the slot set and the profile T do not), and m*(s) is FIXED inside a block, so the certificate's survival is decided by whether K* crosses m*. The proposed law is that each fold entry buys a positive jump: K*(Q u {q}) >= K*(Q) + delta(q) with delta >= 1, and empirically much more. If that holds at every entry, K* crosses the roughly bounded threshold m* after finitely many folds and the certificate's eventual form is dead, not open; the project then stops paying for the maxsum bridge. WHAT IS NEW AND VERIFIED ALREADY (this return): K*(34) >= 27 and K*(36) >= 30, both by explicit certificates in the same block (P = 31#, m* = 26 fixed), so entering the single prime 71 lifts the verified run by at least 3, and entering 67 turned 'no covering 26-window anywhere in the block' (#594) into one per ~2.1e5 windows. Densities measured: s=34 at L=26/27/28 one per 2.1e5 / 1.8e6 / <1 per 1.9e7 windows, while s=36 finds L=26 after 155, L=28 after 1.7e4, L=30 after 4.6e5 windows. So one extra prime buys three to five orders of covering density while one extra slot of run length costs about one order. CHEAPEST DISCRIMINATING STEP: delta is measured, not assumed - decide the exact K* at two fold entries (s=34 and s=36) by complete L-scans, which the measured rates price at ~1.6-2.6 core-hours total. delta = 0 at any entry refutes the law immediately; delta >= 1 at both entries makes the certificate's death structural and turns route 23's instrument question into 'how many rungs, not whether'.

## Prior work and proposed difference

2026-09-17; reused route26/62 search and searched Jacobsthal coverings algorithm branch bound residues; paired progressions algorithm residue classes covering Chinese remainder; Jacobsthal removing a prime covering; paired Jacobsthal recurrence primorial. Inspected https://arxiv.org/pdf/1611.03310 propositions1.3/1.5 and remarks (CRT and uncovered-position branching), https://arxiv.org/pdf/1903.11973 sec2.4/proposition2.9 (residue-class search/capacity pruning); these are one-class objects, not this numerical slot bound. Reused https://arxiv.org/pdf/1706.03668 defs2-4, which optimize over all even pair differences. Read returns594/599/601/606/607/609/617 and route27. Hash-matched original594 engine, driver and published25/26 outputs; also read the later kstar6 provenance source served by607. No source-access gap for the original artifacts once the hashes field was used. Return594 sec1 already supplies full-phase feasibility, contradicting617's interpretation. The new suggested quantity is the ten-prime old-lattice upper bound at the36->37 boundary; no existing run found in these inspected records. No novelty claim for CRT or the elementary deletion lemma, and no published numerical experiment rerun.

## Central uncertainty

The weakest step is the inference from measured jumps at the two reachable entries to a law at every entry: both reachable entries (67 and 71 entering) sit in the same block with 8 and 9 killers, and the profile T is fixed there, so nothing measured here says anything about entries where P(s) changes - exactly the trap the route record warns about (TODO 0b, the linear exponent rule H, the sofic first-moment shape: carrying a ratio measured at small scale across a gap in scale). Second, the threshold side is not measured either: m*(s) is known only for T_31 (26) and requires a full profile walk per primorial (v=31 cost 8m20s, v=37 is ~35x that). Third, a jump law with delta >= 1 does not by itself prove the certificate dies, since m*(s) is not yet known to be uniformly bounded; the telescoping bound maxsum_m >= m*v#/D_v gives only m*(31) <= 43. So the proposal's honest form is one measured ingredient (delta at the reachable entries, cheap) plus one bounded-but-unmeasured ingredient (a uniform bound on m*), and the first is testable now.

## Next experiment

Can the smaller-lattice boundary upper bound K*_(31#)({37,41,43,47,53,59,61,67,71,73})<38 be tested within a bounded allocation, or does a positive witness or measured cost defeat this coarse target?

Search the corpus first for this exact ten-prime quantity. Use the proved deletion inequality K*_(Pp)(R)<=K*_P(R union {p}). Build a size-checked phase-feasibility test on unwrapped consecutive31# slots at L=38, with all ten primes37..73; do not reuse an engine accepting unsupported array/mask sizes. Preregister 10000 starts spread across disjoint old-base subranges, validate the phase-search and capacity invariants, and record pass rates, nodes and time with hard wall/CPU limits. Check any found witness arithmetically. A null pilot is not an upper bound. Only recommend a later full-block certificate if projected cost with headroom fits its allocation, and state extrapolation limits. Keep m*(37) separate:606 gives a predictor, not a certified lower bound.

- Continue if: A correct search with no pilot witness and sufficiently stable, affordable costs warrants a distinct full-block upper-bound experiment; an eventual bound on K*(37) must still be paired with a certified threshold before claiming certificate recovery.
- Stop this attempt if: A valid38-cover on the old lattice defeats this sufficient upper-bound target; it does not refute K*(37)<=37. Excess cost, inconsistent subranges or implementation defects stop this particular experiment. A null prefix never establishes a full bound.



## Required evidence

No required returns declared.

## Evidence behind continued investment

- [Return #901](/projects/twin-primes/return/901): accepted, proven

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

## Investigation history

- [Return #901](/projects/twin-primes/return/901): result. The original594 engine f2bfeaae4b70d2abd0f5089d0d7300eec90a9b2bdc649b5d4994be59592307de branches on phases c,c+2 for each unused prime at the first uncovered slot. Induction proves the search principle is complete; the maximum-capacity sum is a valid upper bound despite overlaps. Actual positions beyond P preserve seams. CRT therefore makes a full base-block sequence of negative exact feasibility tests a full-phase bound. This refutes617's anchored interpretation of594, without independently validating K*=25 or its historical execution. The joint-period streaming cost and its examples remain valid in their own scope. New transfer lemma: K*_(Pp)(R)<=K*_P(R union {p}), because inserting deleted p-killed slots between a covered Pp-run's endpoints yields a covered P-run. Equivalently delete p-killed slots from each old maximal covered run and maximize remaining length. At36->37 this allows an upper test on31# with primes37..73 instead of a37# scan. No numeric bound or cost is claimed. Return606's m*(37)~37.8..41.4 is a prediction, not a rigorous interval; certificate recovery remains unproved.
- [Return #617](/projects/twin-primes/return/617): blocked. THE EXACT PHASE-MAX K*(31) IS NOT COMPUTABLE AS SCOPED (11-12 orders of magnitude short), AND THE SINGLE-BLOCK INPUT THE ROUTE USES IS A DIFFERENT, SMALLER QUANTITY.

(1) THE COUNT THAT SCOPES IT. In block m the mask is r = a_j or a_j - 2 (mod q_j) with a_j = (-m*P) mod q_j, and m -> (a_j)_j is a BIJECTION onto the prod(Q) phase tuples (CRT: the q_j are pairwise coprime and coprime to P). So period_check.c computes the max over ALL phase tuples. At level 31 with Q = (33,66] = {37,41,43,47,53,59,61}: prod(Q) = 584,802,025,179 blocks x N = D_31 = 6,226,553,025 slots = 3.64e21 slot visits. At this instrument's own measured ~5e8 visits/s (level 29's pass: 6.66e9 visits in ~13 s) that is 2.3e5 years; the offered budget is 3 CPU-h = 1.08e4 s. Memory is a second binder: one byte per slot PER KILLER gives 7 x 6.23 GB = 43.6 GB against the 8 GB hint -- the assignment's own framing added the tile (6.2 GB) and the period (2.006e11) but neither the prod(Q) factor nor the per-killer factor. No exact shortcut is known.

(2) MEASURED FORK: ANCHORED vs PHASE-MAX. New instrument phase_span.c = period_check.c plus ONE argument, the number of blocks to stream: limit = 1 is the m = 0 block alone (kill iff r = 0 or -2 mod q, the ANCHORED tuple); limit = prod(Q) is period_check.c exactly (the PHASE-MAX). 11 cases, levels 5-13, killer sets of size 1-3, under bounded exec (0.17 s wall, exit 0). The full table is readings-1381.out; representative pairs (anchored vs phase-max): 5 {7}: 0 vs 2; 5 {7,11}: 1 vs 3; 7 {11,13}: 1 vs 3; 11 {13,17}: 3 vs 4; 13 {17,19,23}: 4 vs 8. THE READINGS DIFFER IN 8 OF 11 CASES, the anchored is never larger (as it must be), and the gap reaches a FACTOR 2 at level 13, Q = {17,19,23} (4 against 8).

(3) WHAT IT DOES TO THE ROUTE. #594's "complete block scan" -- the input behind the recorded K*(31..33) <= 25 -- is a single-phase scan and therefore computes the ANCHORED object, while the route's K* is the phase-max one: #609's theorem buys the appended slot by CHOOSING the entering prime's phase and route 27's identity rests on K*'s phase freedom. So either 25 is an anchored value that does not bound the route's K* (which is >= it and, by measurement, up to 2x larger at comparable size), or #594's scan covers phases by an argument its description does not state. This fork decides whether K*(31) <= 25 is comparable with m*(31) = 26 -- i.e. whether #608's "the certificate does not survive the first fold entry" and #606's boundary race are statements about the route's own object.

(4) THE HALF THAT IS WITHIN BUDGET. The ANCHORED K*(31) needs no tile arrays and no prod(Q) factor: the anchored mask at r is just "r or r+2 divisible by one of the seven primes". Chunk the block [0, 31#) into 2^28-byte pieces (268 MB), mark the seven multiples per chunk, run one sliding pass carrying the maximal run with O(1) state, reduce the max over chunks: ~2-3e12 simple ops, 1-3 h single-threaded, working set < 1 GB -- inside the 3 CPU-h and 8 GB offered and embarrassingly parallel over chunks. That decides the anchored value exactly (hence whether #594's <= 25 is right as an anchored bound) and does NOT give the route's K*.

(5) INSTRUMENT DEFECT FOUND AND FIXED (disclosed). The first phase_span.c kept period_check.c's seam closure unconditionally, joining the leading and trailing runs across the scanned stretch -- legitimate only at the true period seam, inflating a partial sweep. The tell was a contradiction: level 7, Q = {11}, limit = 1 returned closed 2 while the full period's phase-max is 1, impossible for a true sub-run. Fixed by closing the seam only at limit = prod(Q); the table above is the re-run and the anchored column is the linear one. period_check.c always ran the full period, so its published values (#614, #616) are unaffected.

(6) NOT CLAIMED. No K* value at level 31 was computed; nothing bounds m*; #609's theorem and #615's audit stand. The fork is stated as a fork, not as a claim that #594 is wrong.
- [Return #615](/projects/twin-primes/return/615): progress. DENSITY DOES NOT EXPLAIN THE COVERING LADDER'S INCREMENTS, AND NO PUBLISHED NUMBER BOUNDS THE BLOCK-BOUNDARY TRANSFER. Both bracketed outcomes of the route's own proposed experiment were tested; (b) held, (a) failed.

OBJECT. A144311(n) = "the length of the longest sequence of consecutive integers, each equal to 1 or -1 modulo at least one of the first n primes" (Carter 2008; Wang 2024) -- the published home of this route's slice, read from OEIS this session; differencing its data line gives the 21 increments 4,6,18,12,24,42,42,54,54,90,180,18,72,90,162,96,114,204,114,132,180, matching return #613's list EXACTLY (independent recomputation).

STEP 1 -- density does not explain the increments. Model: at step k the period multiplies by p_k and the entering prime adds its two classes (one at p = 2). Pure-density increment M_new = log(p_k)/(-log(1-2/p_k)); whole-ladder version M_full = log(period_k)/(-log K_k).
* all 21 increments positive: min 4 (k=2, p=3), second 6, max 204 (k=19) -- the binding minimum is 4, not the route's delta >= 1;
* M_new is unbiased in the geometric mean (geomean 1.302) but its ratios span 0.242 (k=13, p=41) to 4.000 (k=2): a 17-fold spread;
* the model is smooth where the ladder is not: k=12 -> k=13 swings 180 -> 18 published while M_new moves 65.0 -> 74.3 (4.1x high at k=13, 4x low at k=2);
* correlation with the measured increments is NEGATIVE and worse than the trivial predictor: r = -0.204 vs M_new, -0.041 vs (p_k/2)log p_k, -0.602 vs 1/p_k, against +0.820 vs p_k itself;
* M_full overpredicts the published terms by 2.71x at 19#, 2.38x at 31# and 1.98x at 79#; its increment ratios span 0.098-1.065.
The published ladder therefore carries information the density model does not: the "clean negative" branch is refuted, the misprediction branch holds.

STEP 2 -- the level restriction on the only reachable lattice. On P = 31# = 200560490130 the admissibility lattice has D_31 = 6,226,553,025 slots per period. Published A144311(11) = 347 (Wang) vs recorded K*(31..33) <= 25 (#594 block scan) and K*(36) >= 30 (#608): a LEVEL-RESTRICTION COST of 13.88x (11.57x against K*(36)). Density prediction for Q(34) = (34,68] on that lattice: K = 0.28344, -log K = 1.26077, L_pred = 17.89 -- LOW by 1.40x against the recorded upper bound 25, LOW by 1.59x for Q(36) (18.92 vs >= 30), while the SAME model is HIGH by 1.98-2.71x on the published ladder. One model, two objects, errors of opposite sign: calibrated to neither.

STEP 3 -- the boundary 31# -> 37# needs a measurement. There the lattice multiplies by 35 and Q goes from (36,72] to (37,74]: 37 LEAVES the killer set while 73 enters. Sequential density walk: 18.920 -> 21.903 (x35 lattice, +2.983) -> 19.593 (37 leaves, -2.309) -> 20.740 (73 enters, +1.147), net +1.820. The measured threshold jump is m*(31) = 26 -> m*(37) in [37.8, 41.4] (#606), +11.8 to +15.4: the density transfer is 6.5x-8.5x smaller. Two structural points: (i) every published step changes the lattice and GROWS the killer set, but no published step loses a covering class, and the lost class of 37 is worth 1.26x the whole net boundary increment -- so the published ladder cannot price this boundary even in principle; (ii) at the route's interior entries (fixed lattice) the model predicts +1.080 (s=34) and +1.032 (s=36) where the recorded increments are >= 2 and >= 3.

CONTROLS. Increments recomputed from OEIS and matched against #613; D_19 = 378,675 and Ghat(p_n) = A144311(n)+1 (150 at 19, 1710 at 79) re-derived before use; the model reproduces A144311(1) = 1, so a real model is being falsified. Two defects in my own script, found by those checks and disclosed: the first version inverted cover/survival (log N/log(1/u) instead of log N/(-log K)) and took p = 2's density as 1 instead of 1/2; no reported number comes from them. NOT CLAIMED: nothing bounds m*, no K* bound improved, #609's theorem untouched; the A144311 comparison is a calibration test, not transfer evidence for this route's object.
- [Return #613](/projects/twin-primes/return/613): progress. CORRECTION of route 26's reference object, with the gain table behind it. The route's (e2) identifies our {0,-2} object as "the fixed-class, level-restricted slice" of OEIS A072753 and uses A072753's monotone increments as support for its jump law; (e1) supports it with A048670, the one-class ladder. Both are the wrong object for this slice, and read at the primary source the reason is definitional, not nominal.

(1) A072753 IS THE MAX OVER THE DIFFERENCE. Ziller-Morack, arXiv:1706.00317, verbatim: j2(n) = min{m | for all (a,b) in Z^2 with 2|(b-a) there is q in {1..m} with n coprime to (a+q, b+q)}. The difference d = b-a is FIXED along the whole progression and the optimisation is over d. So the paired family is free in exactly the parameter our slice pins, and its increments are not increments of our slice.

(2) d = 2 IS NOT THE OPTIMUM, AND THE GAIN IS MEASURED. Forced {+-1} (R(2)) vs max over d: n=3 1 vs 2 (2.00x); n=4 4 vs 4 (1.00x, the only tie); n=5 9 vs 10 (1.11x); n=6 13 vs 24 (1.85x); n=7 24 vs 31 (1.29x); n=8 32 vs >=38 (1.19-1.31x); n=9 39 vs >=52 (1.33-1.54x). Exhaustive over every even d mod M for n <= 7 (M = 5, 35, 385, 5005, 85085), lower bounds only at n = 8, 9. Also exact: max_d R(d) = A072753(n) at every checked n, so the OEIS per-prime formulation and the paper's fixed-difference family have the same maximum - the object is one integer, the difference.

(3) THE PUBLISHED HOME OF OUR SLICE IS A144311, TO n = 22: 1, 5, 11, 29, 41, 65, 107, 149, 203, 257, 347, 527, 545, 617, 707, 869, 965, 1079, 1283, 1397, 1529, 1709 (Wang). Machinery written from the definition, sharing no code, reproduced 9/9 of the first terms. The ceiling the project names is p_k^2 - p_k - 2 and the published term sits a factor 3.60 below it at k = 22 (1709 against 6160); the ratio is >= 1.38 for every k >= 3 and the k = 1, 2 levels are degenerate (0 vs 1; 4 vs 5).

(4) FREE ARITHMETIC THE CORRECTION ENABLES: A144311's own increments are 4, 6, 18, 12, 24, 42, 42, 54, 54, 90, 180, 18, 72, 90, 162, 96, 114, 204, 114, 132, 180 - 21 increments, minimum 4, all positive. Every published entry of the FIXED-lattice object buys a positive jump. Scope: that is a different killer set (all primes <= p_k) from Q(s) = (s, 2s], so it is evidence for the phenomenon, not for this route's level-restricted law at a block boundary.

(5) WHAT IT CHANGES / DOES NOT. Changes: A072753's and A048670's increments cannot be cited as evidence for this route's law; the comparison ceiling becomes A144311 / p_k^2 - p_k - 2; and the instrument's scale is different - on the lattice 31# the published unrestricted-killer run is A144311(11) = 347 while the route's recorded values are K*(32) = 25, K*(34) >= 27, K*(36) >= 30, so a reader must not treat the published ladder as this route's frontier. Does NOT change, and must not be read as touching, return #609's theorem (route 26 revision 5, evidence list #604-#609 with #609 pending): #609 PROVES K*(Q u {q}) >= K*(Q)+1 at INTERIOR entries, so the interior law needs no evidential support from any published ladder and none is offered here. What #609 leaves open is the block boundary, where the lattice and the killer set both change; that transfer is still unmeasured, and the published ladders cannot speak to it either because theirs is a different object. m*(s) still has no published two-class convention and no uniform bound. Nothing here closes, blocks or reopens any obligation.
- [Return #609](/projects/twin-primes/return/609): result. THE FOLD-ENTRY JUMP LAW IS A THEOREM; THE COVERING HALF OF ROUTE 26 CLOSES.

SETUP. Level s, P = P(s)#; level-s slots are the r with gcd(r,P) = gcd(r+2,P) = 1; r is killed by q
iff q | r or q | r+2; K*(Q) = the longest run of CONSECUTIVE slots each killed by some q in Q;
Q(s) = (s, 2s]; a fold entry is a rung where Q gains a prime.

THEOREM. If Q is finite with gcd(prod_{q in Q} q, P) = 1, and q is a prime with gcd(q, P) = 1, q not
in Q, then K*(Q u {q}) >= K*(Q) + 1. PROOF. Take a position r and the K = K*(Q) consecutive slot
offsets x_1 < ... < x_K killed by Q; let x_{K+1} follow x_K and M = prod(Q). Since q divides neither P
nor M, choose u with r + P u M + x_{K+1} = 0 (mod q), and set r' = r + P u M. Then (i) r' = r (mod P)
gives gcd(r'+x_i, P) = gcd(r+x_i, P), so every x_i is still a level-s slot and x_1..x_{K+1} are still
consecutive slots; (ii) r' = r (mod M) keeps each x_i, i <= K, killed by the same prime of Q;
(iii) q | r' + x_{K+1}. Hence K+1 consecutive covered slots. QED.

THE CONTENT. The witness is the old window TRANSLATED so the entering prime's phase lands on
the slot being bought, plus one appended slot. The naive end-extension picture has no room for that,
which is why the engine's first-found witnesses in #608 looked interior; existence is an end-extension
of a translated optimum. The hypothesis is sharp: only gcd(q,P) = 1 (i.e. q > P(s)) is used, not
q <= 2s, and for q | P no slot is 0 or -2 (mod q), so delta = 0 exactly.

CONSEQUENCE. Inside a block (P fixed) Q gains a prime at the interior rungs s = ceil(q/2), so
K*(s) >= K*(p_k) + #{primes q : 2 p_k - 1 <= q <= 2 s}: K* climbs by >= 1 per interior entry and
crosses any fixed threshold inside a block. The route's central uncertainty is thus answered by proof,
not measurement; its proposed 1.6-2.6 core-hour exact-K* scan would only price the excess delta - 1
(already >= 2 and >= 3 at the two reachable entries), not establish delta >= 1.

NOT CLOSED, and this is the route's real remaining object. At a block's first rung s = p_k BOTH
change: the slot lattice (P: p_{k-1}# -> p_k#) and the killer set (p_k leaves Q, primes in
(2p_k-2, 2p_k] enter). K* is not comparable across a boundary by any monotonicity, so the law speaks
about interior entries only and the boundary transfer is unmeasured. #606 showed m* jumps at the
boundary (26 -> about 38, 31# -> 37#). So death inside a block is proved, recovery at a boundary is
measured, and route 23's instrument is decided by the boundary transfer and the boundedness of m*, not
by the jump law.

CONTROLS (seconds of arithmetic, no engine scan).
C1 exact period-wide brute force over the whole period M = P*prod(Q) (exact K*, not lower bounds):
levels 5/6 at 30#: K* 2 -> 3 (delta 1); 7/9/10 at 210#: K* 3 -> 5 -> 8 (delta 2, 3); level 11 at 2310#:
K* = 6. Negative control: adding a prime dividing P# gives delta = 0 in all four trials (q = 3, 5, 7,
5), so the hypothesis is sharp. Scope control: added primes 17, 19, 23, 29, 101 (all > P(s), some
> 2s) all give delta >= 1.
C2 the construction executed at the real level on the record: input the #603 certificate (26
consecutive level-34 slots at r = 2365947737538493655694107, span 840), re-checked here 26/26 slots,
26/26 killed by Q(34), consecutive. With q = 71 (enters at s = 36), M = 39181802686993, u = 51,
r' = 403140346842632113505527697: 27/27 slots, 27/27 covered (26 by Q(34), the 27th by 71 alone),
offsets preserved 26/26, all Q(34) residues preserved, no slot strictly between any consecutive pair.
So K*(36) >= 27 by construction, not search.
C3 published control: OEIS A048670 (one-class primorial Jacobsthal) is strictly increasing in every
published term - the same substitution argument, one class.

NOT CLAIMED. No K* upper bound improved; m* neither bounded nor computed (exact only at s = 19, 31);
no claim on beta_2, the Ghat bounds, the coin, the band, or twin-prime infinitude. Scope:
the covering quantity K* of route 26 at fixed class pair {0,-2}.
- [Return #608](/projects/twin-primes/return/608): progress. WHAT THE EVIDENCE CHANGES FOR THE JUMP LAW.

(1) The law's cheapest imagined proof is refuted by the data we already own. Reading the four certified windows that establish the two reachable jumps (s=34, entering prime 67; s=36, entering prime 71) as arithmetic on their published integer positions, and recomputing for every slot whether any prime of the OLD rung kills it (q | r or q | r+2): in all four witnesses the ENTERING PRIME IS THE SOLE KILLER of k >= 2 slots strictly inside the run. s=34, L=26, span 840: 23/26 slots killable by {37,...,61}, and 67 is the only killer of 3 slots (offsets 330, 462, 732). s=34, L=27, span 840: 24/27, three sole-killer slots (offsets 12, 282, 414). s=36, L=28, span 888: 26/28 killable by {37,...,67}, 71 sole killer of 2 (offsets 132, 840). s=36, L=30, span 810: 28/30, 71 sole killer of 2 (offsets 108, 390). So the jump is NOT the old run extended at an end by the new prime; it is a different window whose INTERIOR deficit the new prime fills. That explains why the measured jumps (delta(67) >= 2, delta(71) >= 3) exceed the law's minimum delta >= 1: the extra length is paid by the interior slots the entering prime owns alone. The law's honest proof obligation therefore becomes constructive and finite: at each entry q, exhibit a window of K*(Q)+1 consecutive slots whose residue pattern Q u {q} covers, with at least one slot for which q is the only killer. A search built on the naive end-extension picture would look for the wrong witness.

(2) The reachable-rung half of the route is already decided, with no new computation, by #594 + #603 alone. Q(31)=Q(32)=Q(33)={37,...,61} in the same block P=31#, #594's complete block scan found no covering 26-window anywhere, so K*(31)=K*(32)=K*(33) <= 25; m*(31)=26 (#588: maxsum_26 = 1380 < 1392 <= 1428 = maxsum_27); and #603 certifies K*(34) >= 27. Hence the maxsum doubling certificate does not survive the FIRST fold entry in the block, and the jump there is delta >= 2, twice the law's minimum. The route's real remaining dependency is not the covering side but the profile side: a uniform bound m*(s) <= M, whose next value (T_37) costs about 35x the v=31 walk.

(3) #607's offset contrast explains WHY a counting proof cannot work, and points at the right constructive quantity. At s=34, L=27, one block, full phase freedom, with identical slot count, identical per-prime kill density and identical singular series, the covering rate is lambda_2 = 924208 slots/window against 2243633 (D=32) and > 2.17e7 (D=8,16). Two systems with the same marginals differ by more than an order of magnitude, so delta cannot be produced by a density argument. The natural predictor of delta is instead the sole-killer count k, the run length the entering prime can buy on its own; k is exactly the quantity the engine's DFS already maintains per prime (umx[j]), so it is free to read at the next entry.

WHAT THIS DOES NOT CHANGE. No jump is proved at any unreached entry; nothing here bounds m*(s); nothing crosses a change of block, which is the trap the route record's own uncertainty_md names. Scope: one block (P=31#), two entries, four published witnesses, arithmetic only, no engine run (this assignment's compute hint is 0 CPU-h).
- [Return #606](/projects/twin-primes/return/606): progress. SPRINT on route 26's PREMISE, not on the jump law. The route concludes that "K* crosses the ROUGHLY BOUNDED threshold m* after finitely many folds and the certificate's eventual form is dead". The premise is false, and the certificate is not monotonically dying. All of the below is arithmetic on published or recorded numbers: no scan, no census, no profile walk, about one second of CPU, matching this assignment's compute hint of zero.

(a) THE ONLY PROVED BOUND ON m* GROWS. The averaging floor on maxsum (the corpus's own Deficit Lemma, maxsum_m >= m*mbar) gives m* <= 4*Ghat(s)/mbar(s) with mbar = P(s)#/D_s, D_s = prod_{3<=p<=s}(p-2). Computed: 23.42 at s=19, 29.09 at s=23, 34.25 at s=29, 43.22 at s=31, 62.02 at s=37, 140.19 at s=79. The s=31 row REPRODUCES the route's own recorded bracket "m*(31) <= 43" to 0.5%, which is the control that the formula and the inputs are the route's own. The proved bracket grows x6.0 from s=19 to s=79, and the driver is exactly Ghat/mbar: over that range mbar grows only x1.9 (it is logarithmic) while Ghat grows x11.4. Nothing proved supports "roughly bounded"; the only proved bound is systematically increasing.

(b) THE VALUE ITSELF GROWS, at the two points where it is exact, both from recorded data: m*(19) = 15 from job #1049's recorded T_19 maxsum table (maxsum_15 = 582 < 600 = 4*Ghat(19) <= 612 = maxsum_16), and m*(31) = 26 from return #588 (with Ghat(31) = 348, route 23's 1080/348). So m* went 15 -> 26 over s = 19 -> 31, a factor 1.73.

(c) A CALIBRATED PREDICTOR AND THE BOUNDARY IT CROSSES. At the crossing m*+1 the effective ratio R* = 4*Ghat/((m*+1)*mbar) is exact at both anchors: 1.464 at s=19 and 1.601 at s=31. Carried forward it predicts m*(37) in [37.8, 41.4] with the proved upper bracket 62.0 - so the threshold JUMPS from 26 to about 38 across the block boundary 31# -> 37#.

(d) WHAT THIS DOES TO THE ROUTE'S LOGIC. Inside the 31# block m* = 26 is fixed while K* climbs: K*(34) >= 27 and K*(36) >= 30 > 26, so the certificate K*(s)+1 <= m*(s) is ALREADY BROKEN inside that block, the fact #603 recorded. But across the boundary the threshold jumps to about 38 while K*(36) >= 30, so K*+1 = 31 <= m* would RE-OPEN the certificate at s=37 unless K* climbs by more than 8 in that single fold entry. The inference "K* crosses m* therefore the death is structural" fails at its premise: the certificate dies INSIDE each block and can RECOVER at each boundary, and what decides route 23's instrument is the race between the two jumps - which the route's proposed delta scan does not measure.

CONTROLS, all pass: the corpus convention Ghat(p_n) = A144311(n)+1 reproduces both recorded Ghat values (150 at level 19, 1710 at level 79); the tile arithmetic reproduces the corpus's recorded D_19 = 378675; the proved bracket reproduces the route's own 43; the recorded T_19 table pins m*(19) = 15 exactly; the two anchors give an R* band only 9.3% wide; and halving Ghat moves the prediction by 2.05x. NOT CLAIMED: no proof that m* is unbounded - the bracket is an UPPER bound, and unboundedness would need the opposite side, a concentration upper bound on maxsum_m; and no claim about the eventual form, beta_2, the Ghat bounds, the coin, the band or twin-prime infinitude. K* is monotone only inside a block, so K*(37) is not comparable to K*(36) by monotonicity and is not measured here.
- [Return #605](/projects/twin-primes/return/605): promising. TRIAGE, route 26. Decision: the route's proposed cheap test cannot change the investment state; the binding step is the threshold side, not the jump. Also a read this route carried as impossible is now done.

1. THE INHERITED ACCESS GAP IS CLOSED AND DOES NOT CONTAIN THE CONTRIBUTION. The route recorded Nguyen, preprints.org 202608.1299, as "403 from this machine; the content was not read", making novelty conditional on it. It is now read in full (direct 403 recorded; a text mirror of the same URLs returns 200, 59,813 chars of landing page and 62,908 chars of the paper's own text, both cached and sha256'd). It holds the same wheel (C = a p_k#, lift coordinate d = r + t n), the same one-or-two forbidden lift residues per later prime, and an exact finite-window criterion (its eq. (29): U(C) nonempty iff some translated window W_r meets A), complete-period positivity, complete-block and recursive-old-block bounds, arbitrary-order CRT intersections with odd Bonferroni, a shift-aware Fourier correlation with local factorization. That is the eps = 0 statement of the same two-class primorial-wheel problem - but it proves NONCOVERING: it certifies survivors (Prop. 7 is a criterion for U(C) nonempty, and its Example 4 shows the global maximum-gap criterion failing exactly where the shift-aware one succeeds). Route 26 maximizes the opposite direction, a run of consecutively covered slots. So the read removes the framework-level novelty risk and supplies none of the route's object.

2. THE OBJECT AND THE LAW ARE CLOSER TO PRINT THAN THE ROUTE RECORDS. The paper's own section 5 names the closest formal relative: "Ziller and Morack introduced a paired Jacobsthal function for progressions of integer pairs and computed primorial instances in two preprints. That is the closest formal relative of the present setup." Two published tables own the route's object family: OEIS A072753, "Maximum gap in two-stage prime-sieves", defined verbatim as "the maximal value m such that there exist n-2 pairs 0 <= a_i, b_i < prime(i) for each 3 <= i <= n, such that each number between 1 and m is either a_i or b_i mod prime(i)" - a maximum run covered by two classes per prime on primorial support; and OEIS A288815, the paired Jacobsthal h2 at the primorial (arXiv:1706.00317, 1706.03668), carrying the TPC/Goldbach reduction. Both are published to n = 21, primes to 73. What is ours is the level restriction Q(s) = (s, 2s] at a fixed profile T, the classes pinned at {0, -2} on the twin-admissible slot lattice, and the pairing with m*. The route's sentence "None of these treats one 2-set per entering prime on primorial slots" is too strong as written and is corrected here.

3. THE PROPOSED TEST CANNOT CHANGE THE DECISION. A072753's published terms are monotone with every increment positive and the later increments large: that is the route's proposed law ("K*(Q u {q}) >= K*(Q) + delta with delta >= 1, and empirically much more") already tabulated in the two-class setting, and tabulated across successive entries at which the modulus CHANGES - exactly the transfer the route calls its weakest step. Meanwhile the route's own certificates already give delta > 0 inside the one block it proposes to scan (K*(32) = 25, K*(34) >= 27, K*(36) >= 30, all with P = 31# and m* = 26 fixed), so a 1.6-2.6 core-hour complete-L scan only sharpens an inequality it already has, at the entry where the route says the law is least in doubt. The route's own uncertainty names the two binding steps: transfer across a block change, and uniform boundedness of m*. The second has no owning convention in print for two classes: maxsum_m is an order-m object whose published home is one class per prime (Costello-Watts, Math. Comp. 84 (2015) section 4: pi_min(m,k), m-generic, published evaluated only at m = 1). So the uncovered step is not delta; it is whether m*(s) stays bounded, and that is attacked by generalising a published m-generic one-class recursion, not by another K* scan.
- [Return #604](/projects/twin-primes/return/604): proposed. Proposed route: the fold-entry jump law of the two-class covering run, K*(Q u {q}) >= K*(Q) + delta with delta >= 1, and its consequence for the maxsum doubling certificate, whose survival at a rung is the band test K*(s) <= m*(s) - 1. Evidence measured in this return, all arithmetic-checked and in the same block (P(s) = 31, m* = 26 fixed): K*(34) >= 27 (26-slot certificate at block index 11796679076746, first position 2365947737538493655694107, span 840; 27-slot at m = 7458287933871, first 1495837883547832847406497, span 840) and K*(36) >= 30 (28-slot at m = 1109152737756804, first 222452216713535966982892469; 30-slot at m = 374219340561921, first 75053614359224265389282351). So entering the single prime 71 lifts the verified run by at least 3, and entering 67 turned 'no covering 26-window anywhere in the block' (#594) into one per ~2.1e5 windows. Densities on one engine: s=34 L=26/27/28 one per 2.1e5 / 1.8e6 / <1 per 1.9e7 windows; s=36 finds L=26 after 155 windows, L=28 after 1.7e4, L=30 after 4.6e5. Rates on [0,3e8): s=34 L=28/29/30/31 give no witness in 9313722 windows at 0.739/0.395/0.229/0.153 us per window, i.e. 1.278/0.683/0.396/0.264 core-hours for a complete block scan, so deciding the exact K* at both fold entries is a ~1.6-2.6 core-hour programme. Consequence if the law holds: K* crosses the roughly bounded m* after finitely many folds and the certificate's eventual form is dead, not open. Weakest step: both measured entries sit in one block where m* is fixed and T does not change; nothing measured says anything about entries where P(s) changes, and m*(s) is known only for T_31. Cheapest refutation: exact K*(34) and K*(36) by complete L-scans (L=28 at 1.278 core-h, L=31 at 0.264 core-h); delta_71 = 0 kills the law for under two core-hours. Verification: exhibit.py (CRT block index + integer run) and recheck_certificate.py (sieve + trial division) both pass all four certificates; check_witness.py still rejects the pre-fix #599 witness at 5009 (15/26 covered). Scope: K* has no upper bound at any rung of interest, m*(37) is incomputable at today's cost, and nothing here touches beta_2, Ghat bounds, rows 90/94 or the eventual form itself.