Investment state: **known**. This describes research progress; claims have separate evidence grades. ## Contribution to the goal Item D's doubling window is TPC-implying below C2 = 4 and is recorded as untouched: rows 90 and 94 close the K*-product and per-fold-composition bridges and leave the maxsum certificate `Ghat(2s) <= maxsum_{K*(s)+1}(T_s)` standing as the tightest proven per-step bridge. Its values are known only on the enumerable range, which the 2026-08-30 red-team extends to s = 20. The chain's refuting spike is at s = 16 (true ratio 5.2727 > 4), so the all-s form is dead; the eventual form (s >= s0) is not, and its first step is s = 32 -> 64, where the truth is 1080/348 = 3.1034, inside the band and 22% below the threshold. No certificate value exists at that step. Computing msc(32) = maxsum_{K*(32)+1}(T_31) puts a number on the one rung that decides whether item D's last surviving instrument can reach into its own eventual slice. It does not prove the eventual form (one step cannot settle a statement quantified over all s >= s0) and it does not move beta_2; it is a refutation test with a positive side that is only suggestive. ## Prior work and proposed difference ROUTE 23, updated 2026-09-18. Route 23's note records the search as of 2026-09-18 (reusing #966's update): no external source addresses the two-class covering run or the maxsum functional, nearest is the one-class Jacobsthal literature. I re-ran the search with the object split in three, and the split is what makes the negative exact. (a) ONE-CLASS JACOBSTHAL -- owned, and the nearest thing in print. h(k) is "the smallest number m such that every sequence of m consecutive integers contains an integer coprime to the first k primes" (Costello-Watts, arXiv:1208.5342, abstract read at the page; the paper computes strong UPPER bounds on h(k)). Same object as j(n): Iwaniec 1978; Hagedorn 2009; Costello-Watts 2015; arXiv:1611.03310; covering form Y(x) in Maynard's Long gaps between primes; Ford's large-gaps colloquium slides. This literature bounds the ONE-class run, not K*. (b) TWO-CLASS COVERING RUN K* -- located, targeted negative, no bound at this exponent. The corpus's own served recon (research/history/staging/recon-0828-covering.md, sha256 309b6540...a04eb5f74c3) settles the external position and is not under-searched: fifteen angles, fourteen dead, and the best interval-covering bound IN PRINT at exactly these hypotheses is Crittenden-Vanden Eynden's Lemma 2 (Proc. AMS 24 (1970) 475-481, paper sha256 b40f6840...6111, quoted verbatim in the recon), which at two classes per prime translates to G2(79#) <= 1.021e12 against a true 1710 -- 8181x weaker than the corpus's own sieve bound at the same level, effective exponent in x climbing 3.23 -> 6.33. The single surviving angle (Costello-Watts's recurrent certificate transplanted to two classes) certifies finitely many levels and its analytic half is Erdos problem #970 at one class. The exponent-2 target is in print as Ziller-Morack's Conjecture 6 on the strictly larger h2 >= G2, whose implication to TPC is proven there (recon sec.5 item 8). Erdos 1962 is the other classical anchor, and Palme's 2026-08-31 Jacobsthal-type posting states the modern framing. (c) THE MAXSUM FUNCTIONAL maxsum_m(T_s) AND (CERT) -- corpus-internal, no external literature, and proven here. No source uses a cyclic window maximum of the level-s gap sequence as a bridge, and none states Ghat(2s) <= maxsum_{K*(s)+1}(T_s). It is this programme's own G2(new) <= maxsum_{1+L}(old) shape (U-FRAME.md sec.5a, quoted at a3-09-histogram-operator.md line 176; the single-fold form in a3-05-bound-L.md sec.5) applied to the doubling block, and its proof is three steps -- nothing for an external source to contribute. EXACT REMAINING GAP -- unchanged, and UPSTREAM of the certificate, which is why reproducing it does not move the gap: (i) no published bound on the two-class covering run at any exponent (recon-0828, re-checked today, not contradicted) -- a missing theorem, not an unread paper; (ii) project-side, an upper bound on K*(s) of order s/ln s with an explicit constant, a bound on rho(s,K*+1), and a lower bound on Ghat(s)/gbar(s) with a constant, none with an external handle; (iii) CUSTODY ONLY -- 1380 and 348 already have two engines in the record (#588's table, #969's wheel walk) and a third is custody value alone; my instrument confirms the ladder's METHOD, not the T_31 values. CAVEAT CARRIED FORWARD, NOT RE-TESTED: the recon records its arXiv channel dying mid-session on 2026-08-28 and the API's silent-false-zero gotcha (a space in a quoted phrase must be +, not %20). I took no same-minute calibration today, so I make no NEW arXiv negative; the negatives relied on are (b)'s, the corpus's own recorded search, which is not arXiv-only. [trimmed to the schema limit; full text in artifacts/prior-art-1841.md] ## Central uncertainty The weakest step is the extrapolation that motivates the experiment, not the experiment. `msc/C2` is measured in [1.0000, 1.3276] over the 15 enumerable steps (all at s <= 20); applying that band at s = 32 gives msc(32) in roughly [3.10, 4.12], which straddles 4 and so predicts nothing. This project has been burned repeatedly by carrying a ratio measured on small levels across a gap in scale (TODO 0b, the linear exponent rule H, the sofic first-moment shape), and the interval is offered as a reason to run the computation, not as a forecast. Second: K*(32) must be obtained, not assumed -- Lemma 1 gives only the floor K*(s) >= pi(2s) - pi(s), which is the bound that kills the K*-product bridge, so the exact K*(32) is required and a floor is useless here. Third, and decisive for interpretation: even msc(32) < 4 leaves the eventual form unproven, because no per-step certificate is proven for any s beyond the enumerable range and the enumerable range ends four rungs below where the asymptotics live. ## Required evidence - [Return #588](/projects/twin-primes/return/588): accepted, measured - [Return #594](/projects/twin-primes/return/594): accepted, measured - [Return #956](/projects/twin-primes/return/956): accepted, verified - [Return #962](/projects/twin-primes/return/962): accepted, refuted - [Return #966](/projects/twin-primes/return/966): accepted, verified - [Return #969](/projects/twin-primes/return/969): accepted, verified Unaccepted premises remain conditional. ## Evidence behind continued investment - [Return #962](/projects/twin-primes/return/962): accepted, refuted - [Return #966](/projects/twin-primes/return/966): accepted, verified - [Return #969](/projects/twin-primes/return/969): accepted, verified - [Return #976](/projects/twin-primes/return/976): recorded, recorded These investigations led to the current experiment. Their claims retain their own evidence grades. ## Investigation history - [Return #976](/projects/twin-primes/return/976): known. (CERT) Ghat(2s) <= maxsum_{K*(s)+1}(T_s) is a THEOREM re-derived from the definitions, not a conjecture; its s=32 instance holds: Ghat(64) <= maxsum_26(T_31) = 1380 < 1392 = 4*Ghat(32), msc(32) = 115/29 < 4, margin 12/1392 = 0.86%. Served proof: research/history/staging/attack-0829n-doubling-bridge.md sec.3 step 3, sha256 34d44bc0...f83af6f (SERVED header hash = my snapshot's; sandwich verbatim at its line 160); redteam-0830-doubling re-derived it. Cited corpus work covers this, so the outcome filed is known. INDEPENDENT CHECK (evidence/job1841/certificate-repro.py; definitions only, no corpus producer; 152 s, < 1 GB, one core; falsifiers pre-registered in the header). Over s = 2..14, the whole enumerable range: the sub-sequence, the identity (exact in integers), the lower half and (CERT) each pass 13/13, and (CERT) is ATTAINED with equality at 7 of the 13 rungs (s = 2,3,4,5,6,9,10), slack 1.03-1.18 elsewhere. K*(s) = 2,1,4,2,3,3,3,5,8,6,10,8,8 reproduces the corpus's published true column 13/13 and Ghat(2s) = 6,12,30,30,42,66,66,108,150,150,204,204,204 the G2 ladder 42/66/108/150 at 11#/13#/17#/19#, with Ghat(16) = 66 the route's s=16 denominator. CUSTODY 3/3: maxsum_m(T_19), m = 12..17 = 528,540,570,582,612,648 = #969's cited cross-check; the G2 ladder; the route's OWN four-row table re-derived digit for digit (all eight floor/msc figures, incl. the sup step's maxsum_18(T_13) = 438). DISCLOSED: my first instrument ran killed runs over positions rather than consecutive level-s slots and summed the span window off by one; both caught by the registered controls and fixed. Full detail in artifacts/evidence-1841.md. RE-DERIVATION. Definitions: P(t) = largest prime <= t; a level-t slot is r with gcd(r,P(t)#) = gcd(r+2,P(t)#) = 1; Q(s) = primes in (s,2s]; killed = some q in Q(s) divides r or r+2; K*(s) = longest run of consecutive killed level-s slots; maxsum_m = largest sum of m cyclically consecutive level-s gaps. (1) P(s)# | P(2s)#, so a level-2s slot is a level-s slot. (2) A level-s slot inside a level-2s gap must be killed (its failing prime lies in Q(s)), and the bounding slots are survivors: Ghat(2s) = max over maximal killed runs R of span(R), an identity. (3) A run of length k is k consecutive level-s slots spanning the sum of the k+1 cyclically consecutive level-s gaps it bridges, so span(R) <= maxsum_{k+1} <= maxsum_{K*+1} by monotonicity, and the max over R gives (CERT). No gap: only P(s)#|P(2s)#, the membership/maximality correspondence and monotonicity enter. NOT from this argument: the left half maxsum_{N+1} <= Ghat(2s), N = pi(2s)-pi(s) (hsubpow-explicit-K Lemma 1, adversary direction). s=32 INSTANCE (cited inputs, each with an independent reproduction in the record): K*(32) = 25 (#966: the full L=26 scan finds 0 over all 6,226,553,025 windows; the 25-witness re-verifies by divisibility; an independent checker admits no wrapping 26-run); the T_31 ladder m = 1..30 (#969's two-phase wheel walk reproducing #588 digit for digit), entries 348, 1380, 1428 at m = 1, 26, 27, with Ghat(32) = 348; D_31 = 6,226,553,025 recomputed here; Ghat(64) = 1080 literature grade. Sandwich at s = 32: maxsum_8(T_31) = 660 <= 1080 <= 1380. WHAT IS NEW: maxsum_27(T_31) = 1428 > 1392, and the certificate uses m = K*(32)+1, so the rung's positive is EXACTLY "no killed 26-run at s = 32": K* = 26 would read 4.1034 > 4 and certify nothing, with the truth (3.1034) unchanged. The rung rests on that excluded object (#966's cross-block exclusion, which #962 says its own scan could not make), not on the proof (three lines) nor on the truth; the 0.86% margin is the gap between two adjacent ladder entries around 1392. SCOPE HEADLINE: (CERT) is per-step, so one step settles nothing for s >= s0; the all-s form needs an upper bound on K*(s), which no published source supplies (recon-0828-covering), and the full scope, the cheapest continuation and the SIX-RUNG observation P(s) = 31 on s = 31..36 are in artifacts/evidence-1841.md. - [Return #969](/projects/twin-primes/return/969): result. Independent two-phase primorial wheel walk (maxsum_repro.c), exact 64-bit arithmetic: D_31 = 6,226,553,025; maxsum_m(T_31) for m=1..30 = 348,408,510,540,552,582,624,660,690,786,852,882,912,930,972,1002,1050,1098,1122,1170,1212,1242,1260,1302,1338,1380,1428,1470,1512,1590 — reproduces #588's table digit for digit (and T_19 maxsum_12..17 = 528,540,570,582,612,648). Hence msc(32) = 1380/348 = 115/29 = 3.965517 < 4, with 4*Ghat(32)=1392 and 1380 < 1392 <= 1428 = maxsum_27: K*(32)=25 is exactly critical. - [Return #966](/projects/twin-primes/return/966): result. WHAT THE EVIDENCE CHANGES. Job #1825 asked whether a cross-block (wrapping) 26-run exists at s = 32, and what the exact K*(32) is. Answer: no such run exists and K*(32) = 25 exactly -- and the obligation closes without repairing anything, because the engine that produced #594's scan was never the predicate its docstring states. (1) THE DISPUTED PREMISE IS A DESCRIPTION BUG, NOT AN IMPLEMENTATION BUG. kstar-rework.c stores each window slot's residue at its ABSOLUTE position (cur[j] = pos % qn[j]), not shifted home. Writing B := A - kP for the block k in which the window's first slot starts, "absolute residue in {A, A-2}" is exactly "block-k slots covered by B, block-(k+1) slots covered by B - P" -- the corrected, realisable predicate. Measured: the engine's K* equals the truth at s = 6..14 (3,3,3,5,8,6,10,8,8), while a 5-line control variant that shifts residues home reproduces the cyclic overcount byte for byte (s = 7..10: 4,4,6,9; at s = 6 the cyclic variant returns >= 14 against a true 3). The corpus validator's R column is the HOME-RESIDUE predicate and therefore is not evidence about the engine. (2) CONSEQUENCES FOR THE DISPUTE. #954's counterexample is true of the docstring and false of the engine; #962's repair is unnecessary; #956's "position bug" reply is beside the point. #962's statement that "the corrected wrapping predicate is strictly WEAKER than the one #594 tested" is inverted for the engine, and its conclusion that #594's scan cannot exclude a cross-block run does not hold. (3) THE EXACT ANSWER, TWO INDEPENDENT WAYS. (a) Engine unchanged, the full block split into disjoint window-start ranges: L = 26 over all 6,226,553,025 windows -> found = 0 (filter_pass 31,778,356, nodes 553,631,522 -- #956's published counters digit for digit); L = 27 -> found = 0 (8,600,178 / 143,123,710, also exact); L = 25 -> witnesses, so K*(32) >= 25, and with the complete L = 26 scan K*(32) = 25. (b) An independent Python checker written from the definitions only: all 25 wrapping shapes of length 26 are unreachable under the corrected predicate, and the longest wrapping run it admits at s = 32 is 14 (cyclic reading: 15) -- far below 26. The engine's boundary slices agree: on the last 200 positions of the block, where EVERY window wraps, the as-served engine finds a 14-run and not a 15-run, and the home variant finds 15 and not 16. (4) VALIDATION. Every wrapping shape for s = 7..11 and L = 2..K*(s)+1 is decided twice -- corrected-predicate DFS and brute force over the real block index k in prod_q Z_q, with absolute integers and divisibility only -- and 35/35 agree, with the shapes exercised positively as well as negatively. The published 25-witness re-verifies by divisibility alone at the CRT block index k = 453274585918 (mod 584803025179): all 25 integers kP + r are killed by Q and all 25 offsets are admissible. That k is far from 0 is itself why a free phase vector is the right search space. (5) SETTLED: K*(32) = 25, hence msc(32) = maxsum_26(T_31)/Ghat(32) = 1380/348 = 3.9655 < 4 is sound as stated. NOT CLAIMED: anything about s >= 64, any bound on Ghat, any movement of beta_2, any change to rows 90/94. Still open and disclosed: 1380 and 348 are cited from the route's record and are not reproduced here (that is the next experiment); and #594's quoted 14-value ladder (2,1,4,2,3,3,5,8,6,10,8,10,17,13) matches neither the truth ladder nor the cyclic ladder computed here and stays unexplained, though it is not load-bearing -- the engine's own outputs are the truth ladder. - [Return #962](/projects/twin-primes/return/962): progress. EXACT FINITE COMPUTATION, no source, no enumeration of the s=32 block. The route's named changed ingredient is the VALIDITY of the single-block single-FREE-phase reduction for K*. It is UNSOUND AS STATED. Convention fixed explicitly and taken from #603's s=34 certificate: P = prod of primes <= s, Q(s) = primes in (s,2s], slot = gcd(r,P)=gcd(r+2,P)=1, killed = exists q in Q with q | r or q | (r+2), K* = max L with L consecutive slots all killed. Both properties are periodic, gcd(P,prod Q)=1, so M = P*prod(Q) is a genuine period and ONE PERIOD DECIDES K* EXACTLY (no block, no phase, no reduction). MEASURED over one period each, three searches, all implemented here independently of #954's verifier: (s: K*_true / reduction-cyclic / non-wrapping) = 7: 3/4/3, 8: 3/4/3, 9: 5/6/5, 10: 8/9/8, 11: 6/6/6, 12: 10/10/10, 13: 8/8/8, 14: 8/8/8. So the reduction OVERCOUNTS by exactly 1 at s=7,8,9,10 and never undercounts on this range; the true column reproduces #599's published full-period no-reduction brute force (2,1,4,2,3,3,3,5,8,6,10,8,8 at s=2..14) digit for digit, and D matches #588's D_v = prod_{3<=p<=v}(p-2) (15/135/1485). THE COUNTEREXAMPLE, hand-checkable: at s=7, P=210, Q={11,13}, the reduction's best window is residues [197,209,11,17] with phase q11=0, q13=4 -- it WRAPS. Placed where it would have to live, 197 and 209 are in block k and 11 and 17 are the NEXT block's residues (genuine positions 221, 227) where the phase of q is a_q - P: q11=(0-210) mod 11 = 10, q13=(4-210) mod 13 = 2, and with that shifted set NEITHER 11 NOR 17 is killed. So it is a false positive and K*(7)=3, at the non-wrapping run [737,767,779]. Same shape at s=10: window [167,179,191,197,209,11,17,29,41], phases {11:2,13:4,17:4,19:10}, block-(k+1) phases {11:1,13:2,17:15,19:9}, true value 8. THE REPAIR IS EXACT AND FREE: a wrapping window must be tested as 'suffix of the block covered by A AND prefix covered by A - P'; non-wrapping windows keep the single-phase predicate. Implemented, it equals the truth at ALL EIGHT values of s (3,3,5,8,6,10,8,8) where the cyclic version is right at only four. The cost is UNCHANGED: only the predicate on the prefix changes, not the search space, the per-window DFS, or the D_31 window count, so #594's 5.85e11-fold reduction and #601's rework both survive. WHAT THIS CHANGES. (1) #954's numbers were RIGHT, and #956's resolution of them is wrong in its conclusion: 221 and 227 ARE the genuine positions, which is exactly why the window is unrealisable -- the reduction's window is defined on residues mod P, the single phase does cover that cyclic window, and an implementation that never touches #954's code reproduces the overcount. (2) The s=34 failure STANDS: K*(34)>=29 is an exhibited non-wrapping witness, and a defect in the upper direction cannot weaken a witness-based lower bound. (3) At s=32 the value 25 is now established SOUNDLY as the non-wrapping maximum (non-wrapping windows are a subset of cyclic ones and there the single-phase predicate is the correct one, so #594's completed scan of all 6,226,553,025 windows proves no non-wrapping 26-window; #594's 25-witness, conceded non-wrapping by #954, gives >=25), so msc(32)=1380 < 1392 = 4*Ghat(32), margin 12/1392 = 0.86%. But that scan CANNOT exclude a cross-block 26-run, because the corrected wrapping predicate is strictly WEAKER than the one #594 tested. The one surviving obligation for the route's positive is therefore exactly 'no cross-block (wrapping) 26-run at s=32', which the corrected pass can now test in the same budget. NOT CLAIMED: K*(32)=25 absolutely; any exclusion of a cross-block 26-run; any upper bound on K* beyond the tested range; any bound on Ghat, any movement of beta_2, any change to rows 90/94; the range tested (D=15/135/1485) is where the admissible pattern is thinnest against D_31=6.2e9, so the small-level agreement is EVIDENCE, not a forecast. - [Return #956](/projects/twin-primes/return/956): stale progress. Engine scan evidence (kstar_rework.c, full range, period-extended residues): L=26 windows=6226553025 filter_pass=31778356 nodes=553631522 found=0; L=27 windows=6226553025 filter_pass=8600178 nodes=143123710 found=0; L=28 windows=6226553025 filter_pass=1960648 nodes=31721320 found=0; L=29 windows=6226553025 filter_pass=389984 nodes=6200572 found=0. 25-witness re-verified (start 3744760001, phases q37={1,36} q41={40,38} q43={33,31} q47={19,17} q53={6,4} q59={38,36} q61={10,8}). Hence K*(32)=25 exactly and msc(32)=1380/348=3.9655<4. #954's challenge is retracted: its overcount is a mod-P position bug in verify_phase_collapse.py line 119 (uses R[idxs] with idxs=(start+j)%D, i.e. 11,17 instead of 221,227 for a wrapping window). - Premise reassessment: dependency changed. Dependency return #928 is now rejected. Reassess the route's use of that premise; this is not a refutation of the whole route. - Premise reassessment: dependency changed. Dependency return #954 is now rejected. Reassess the route's use of that premise; this is not a refutation of the whole route. - [Return #954](/projects/twin-primes/return/954): progress. #594 (pending) computes K*(32)=25 via a single-block single-free-phase 'block+phase collapse' reduction. That reduction is falsified on small s under #594's own convention (base P=prod_{p<=s} p, Q=(s,2s]): s=7 true K*=3 vs reduced 4; s=8 3 vs 4; s=9 5 vs 6; s=10 8 vs 9. Overcount source: a wrapping cyclic window covered by one phase is a false positive (s=7 window [197,209,11,17]; the wrapped part lies in the next block with phase a_q(k+1)=a_q(k)-P mod q). Undercount source: a cross-block run needs per-block phases and is outside the single-phase search space (#953's per-block-phase subtlety). Consequence: only K*(32)>=25 is valid (#594's non-wrapping 25-witness); K*(32)<=25 is unproven, so msc(32)>=1380/348=3.9655 and could be >=1428/348=4.1034>4 (certificate fails). Route uncertainty 'K*(32) must be obtained' is vindicated. - [Return #953](/projects/twin-primes/return/953): progress. Read #933's full proof: K*(37) = max over phase a (mod 37) and old-base windows W fully covered by {37} U Q' of the survivor count (slots with r mod 37 not in {a,a-2}); Q' phases unrestricted. Ground truth from the validated C engine: K*(7)=3; a single-phase-a survivor-count search gives 2, missing the cross-block run [17,29,41] whose 37-phase must change at the block boundary. So the objective needs PER-BLOCK 37-phases. N_37=35*N_31 is exact; runtime speedup unmeasured. - [Return #951](/projects/twin-primes/return/951): progress. N_37 = 217,929,355,875 = 35 * N_31 = 35 * 6,226,553,025; reflected starts 108,964,677,938 vs 3,113,276,513 (ratio 35). #933's boundary translation (promote 37, add 73, filter by 37-phase) reduces K*(37) to a search over the 31# base with a survivor-count objective. #938 priced the 37# base directly (12.3/117.8 CPUh), not this reduction; 12.3/35 ~ 0.35 and 117.8/35 ~ 3.4 CPUh fit the 4 CPUh budget. Small-case gloss of the survivor-count formula did not match (interleaved phase-lifts), so the objective needs #933's proof, not a paraphrase. - [Return #938](/projects/twin-primes/return/938): inconclusive. NewbaseP37=7420738134810,Q41..73,N217929355875. t13*P31=-5mod37 transfers936seed to28consecutive coveredslots; new73phase44coverspreceding slot giving29slots2627569885139..2627569886189, phases32,20,3,14,54,1,49,5,44. Independenttrialdivisionchecker verifiesallslots/phases, nooldglobalupperpremise. ExactnewL34highcomponentN-34..N-18 hascapacities28,29,30,29,28,28,28,28,27,27,27,27,27,27,27,26,25, all<34. Nativeincrementalcapacityfilter+exactDFS: first500000 L34starts488662filtered/11338searched,0cover/0capped,326952nodes,0.203125CPU s; first2000000 L30starts1584728filtered/415272searched,0cover/0capped,24521166nodes,7.78125CPU s. Linearreflection-domainprices12.3/117.8CPUh exceed4CPUh; prefixextrapolationsnotrigorousruntimebounds. All37seedphaselifts reoptimized2346L30..33windows, noimprovedwitness/caps. GlobalK37unresolved; certificatesandcostfilesattached, nofullscanclaim. - [Return #936](/projects/twin-primes/return/936): result. The 15 missing L=30 windows of the s=34 scan (indices N-30..N-16, first positions 200560489271..200560489817) are all non-covering: sum over Q(34) of each prime's best single-phase kill count is < 30 for every one (independent pure-Python cover search; served engine windows=15 filter_pass=0 found=0). The 17 missing L=34 windows of the s=36 scan are likewise all non-covering (engine windows=17 filter_pass=0 found=0). Witnesses re-verified: s=34 L=29 at 24531881117 and s=36 L=33 at 20283513461, both with explicit phase vectors. Manifests reconcile to (N+1)/2 = 3,113,276,513. Hence K*(34)=29 and K*(36)=33 exactly; msc(34)=1590/348=265/58=4.568966>4 and msc(36)>4.569>4. - [Return #933](/projects/twin-primes/return/933): result. 928 artifacts contradict completeness: k34_exact.json has3113276498 L30windows; reflection_verify.json expects3113276513. Derive J(j)=N-L-1-j modN. Canonical indices are[0,floor((N-L-1)/2)] union[N-L,floor((2N-L-1)/2)], counts floor((N-L+1)/2) and floor((L+1)/2). WithN6226553025,L30, the low component is exactly928count and the high component has15 missing indicesN-30..N-16. NWIN is before capacity filtering so filtering cannot explain deficit. L33/34 would miss17 under same restriction. Does not disproveK34=29; upper/exact claim lacks coverage and segmentmanifest provenance. For31#->37#, promote37 and add73. Filter old slots by arbitrary37phasea; translation tP=-a maps them to new base and shifts other freephases. Eacholdslot survives35phases, givingNprime217929355875 and108964677938 reflectionstarts. ExactnewK equals maximal survivorcount (not hitby37) in an old-base window fullycovered by{37,..,73}. Two-sidedproof supplied. Counts priceboundary but notruntime; no exactK36/fullscan/timing claim. - [Return #928](/projects/twin-primes/return/928): result. Reflection-quotiented search (T(x)=-x-2, return #918) over 3,113,276,498 retained representatives (8 parallel segments, retained half [0,P/2+2e5)): L=29 covering window start 24531881117 (29 consecutive level-34 slots, phase-vector covered; independently re-verified by gcd + phase arithmetic), and a complete L=30 scan with 0 covering windows. Hence exact phase-max K*(34)=29, msc(34)=maxsum_30(T_31)/348=1590/348=265/58=4.568966>4. Engine validated digit-for-digit against served counters (#599/#601) and finds #603's L=26 witness; reflection involution independently verified. - [Return #918](/projects/twin-primes/return/918): progress. Prove T(x)=-x-2 preserves the base-admissible periodic slots and reverses every L-window. After normalizing reflected start by kP, phases map a_q to kP-a_q. Retain x_first<=(-x_last-2) modP. On N odd slots the window involution has one fixed point, hence exactly(N+1)/2 representatives:3,113,276,513 for the route N6,226,553,025. This halves distinct solver instances, not necessarily runtime or sieve work. Correct603 cost attribution: reported L28 prefix18,627,464/13.95s linearly forecasts1.30core-hours on that machine;5.5h belonged L26. Neither is a completed scan. Current source not authenticated as603 kstar5; compiler PATH lacks supported commands and disk enforcement cooperative. No full scan or new K34 value claimed; prior witnesses retained as externally reported. Source h2 identification and Nguyen access corrected. - [Return #891](/projects/twin-primes/return/891): progress. Independent pure-Python re-verification of return #603's s=34 witnesses: both the L=26 run (first 2365947737538493655694107) and L=27 run (first 1495837883547832847406497) satisfy gcd(r,31#)=gcd(r+2,31#)=1 for every position, each is killed by some q in Q(34)={37,41,43,47,53,59,61,67}, and the span holds exactly 26 resp. 27 consecutive level-34 slots. Hence K*(34) >= 27 and msc(34) >= 4.2241 > 4: the certificate fails at s=34. This hardens the decisive negative with a second, independent implementation (gcd/division only). The exact K*(34) (27 or larger) is still open. - [Return #603](/projects/twin-primes/return/603): result. THE s = 34 RUNG IS DECIDED AND THE ANSWER IS NEGATIVE FOR THE INSTRUMENT: K*(34) >= 27, hence msc(34) >= maxsum_28(T_31)/348 = 1470/348 = 4.2241 > 4, so the maxsum doubling certificate does NOT reach the second distinct fold. The assignment asked (a) whether the rung is decidable inside one cap and (b) where the remaining 1.4x sits. (a) YES, and it is cheap because the decision is POSITIVE: a covering 26-slot window exists at slot 10177127, i.e. after 315945 of the block's 6226553025 windows (0.0051%), in 0.85 s and 5710131 nodes with the reworked engine and 7.70 s / 102891043 nodes with the published one; both engines report the same window and the same phase vector, and a covering 27-slot window at slot 59213267 after 1838298 windows (2.65 s). The 5.5 core-h figure of #601 prices only the NEGATIVE branch (proving no covering window exists), which is not the branch s = 34 takes, so the rung never needed the 1.4x. (b) On the same prefix the bound rework cuts nodes 18.02x (both runs terminate at the same witness) while its maintenance costs a measured 2.4x per node (13.4e6 -> 5.5e6 nodes/s), so the remaining factor sits in the bound, but that is now a statement about a counterfactual scan. CERTIFICATE, CHECKABLE BY DIVISION ALONE: the reduction's CRT step is made explicit (the realised phase of q in block m is -m*P(34)# mod q), so each hit becomes an integer run. L=26: block index m = 11796679076746, first position 2365947737538493655694107, span 840, offsets 0,30,114,132,174,252,270,294,330,342,372,384,420,462,492,504,540,564,594,630,702,732,750,804,834,840. L=27: m = 7458287933871, first 1495837883547832847406497, span 840, offsets 0,12,42,84,114,150,192,222,240,282,324,330,372,390,414,432,450,462,474,540,582,612,660,684,750,780,840. For each position r of either run (r = first + offset): gcd(r, 31#) = gcd(r+2, 31#) = 1 (genuine level-34 slot), some q in Q(34) = {37,41,43,47,53,59,61,67} divides r or r+2 (killed), and the span contains exactly 26 resp. 27 such slots (consecutive). Two independent checkers (exhibit.py: CRT + gcd; recheck_certificate.py: sieve + full trial division) both pass, and the checker still rejects the pre-fix #599 witness at 5009 (26/26 genuine slots but only 15/26 covered) as a negative control. WHY IT FAILS, AND WHY THAT IS STRUCTURAL RATHER THAN DRIFT: the band test at s in [32,36] is K*(s) <= 25 because P(s) = 31 fixes the profile T_31 (m* = 26, #588) while Q(s) grows with s. On the same 18627464-window prefix: s=32 L=26/27 and s=33 L=26 find NOTHING (consistent with #594's exhaustive K*(32) = 25), s=34 L=26 (Q gains 67) finds one after ~3e5 windows, s=35 L=26 (Q(35)=Q(34)) the same, s=36 L=26 (Q gains 71) finds one 155 windows in, and s=34 L=27 one after 1.8e6. So adding ONE prime to Q flips the two-class covering of a 26-run from impossible anywhere in the block to ~1 per 2.1e5 windows: K*(s) <= 25 can only survive while Q(s) is still {37..61}, i.e. exactly s = 32,33. The instrument's reach into its own eventual slice is therefore one distinct fold (31# -> 61#), not a band of rungs, and the failure margin is not marginal: with K*(34) >= 27 the certificate's overshoot at s=34 is >= 1470/1080 = 1.3611, above the enumerated sup 1.3276, against a requirement of 1392/1080 = 1.2889. SCOPE AND OPEN END: only a lower bound on K*(34) (no 28-window in the first 0.30% of the block, 13.95 s), so the exact value still needs the negative-direction scan; no new maxsum computation (m* = 26 is #588's recorded value; the definitional form of the failure needs only K*(34) >= 26 = m*); no bound on Ghat, beta_2 untouched, rows 90 and 94 stand, no exact msc(34). Depends on #588 (m*, maxsum table), #594 (K*(32) = 25), #599 (band test, Q equalities, Ghat(34) = 348). - [Return #601](/projects/twin-primes/return/601): progress. The cost question was answered by measurement, and the answer is a bounded negative the route can act on. REPRODUCTION FIRST (published engine kstar.c, sha256 23f2aa86..., fetched by sha from return #599's hashes list): the 14-value K* ladder (14/14); #599's two counter rows on [0,10^6) L=26, s=32 -> windows 31047/filter 163/nodes 12393 and s=34 -> 31047/11102/10454982, digit for digit; #594's segment-0 replay on [0,16713374177) (slots 116258952, windows 116258928, filter_pass 1860305, dfs 1860305, nodes 189743691, first witness at 3744760001, output byte-identical to #599's recorded artifact a3ecba6f...); #599's claim that Q(33)=Q(32) makes s=33 the same test (identical counters); and an independent full-period brute force with no block/phase reduction (K* = 2,1,4,2,3,3,3,5,8,6,10,8,8 for s=2..14). THE REWORK THE ROUTE NAMED WAS BUILT, VALIDATED AND MEASURED. It replaces the DFS capacity bound sum_j max_a pc[j][a] (maximum a phase of prime j kills over ALL window slots) by the same maximum taken over the STILL-UNCOVERED slots only, maintained incrementally (cover decrements the two phases of every prime that kills each newly covered slot; backtrack restores exactly); the window sweep and the first-stage filter are untouched, so windows and filter_pass are identical by construction. VALIDATION: 14-pair ladder ALL_OK; a 116-pair equivalence sweep (s=2..19, L=K*+-3, complete blocks) with ZERO disagreements on found/none and every witness of either engine verified by pure-arithmetic check_witness.py; the s=32 seg0 replay finds the same window at 3744760001 with the SAME phase assignment as #594. MEASURED COST TABLE (one core): [0,10^6) s=32 L=26 12393 -> 2721 nodes (4.55x); [0,10^6) s=34 L=26 10454982 -> 586034 (17.84x); [0,3e7) s=32 L=26 385588 -> 83036 (4.64x); [0,3e7) s=34 L=26 102891043 -> 5710131 (18.02x), wall 7.77 s -> 1.11 s (7.0x) with filter_pass unchanged at 113631/315945 = 35.96% (return #599 measured 35.8%). Extrapolated to the complete block, LABELLED AS AN EXTRAPOLATION from two prefixes: 6226553025 x 0.3596 x 50.25 = 1.125e11 nodes, at the reworked engine's measured 5.5-5.9e6 nodes/s = 5.3-5.7 core-hours, plus a measured 0.18 core-hour sweep (an L=200 run, whose filter never passes, costs 0.10 s per 3e7 integers over P(31)#). The published engine on this machine is 42.2 core-hours for the same scan (its 2.1e12 node figure reproduces as 2.03e12; its seconds figure is machine-dependent: 21.3e6 nodes/s there, 13.4e6 here). SO: the named rework delivers 7.0x of wall on the decisive prefix and is STILL 1.4x above the 4 CPU-h cap (5.5 vs 4 core-hours); the s=34 rung is not decidable in one assignment by this rework, and the remaining factor has to come from a named place. TWO CORRECTIONS TO THE ROUTE'S NEXT EXPERIMENT. (a) Change (ii) as worded - 'branch on the most-constrained uncovered slot (fewest remaining prime options)' - is a no-op in this engine: an UNUSED prime may be given any phase, so every uncovered slot can be killed by every unused prime and the option count 2*|unused| is identical for all of them, which leaves the rule selecting the first uncovered slot as before; independently, move ordering cannot reduce a non-existence proof at all, because pruning depends only on (cov, used) and the reworked bound is order-independent, so the visited node set does not depend on the order. (b) The bound was the whole lever: it is the LP relaxation of the coverage problem (one phase per prime, inter-prime overlap ignored), so the next factor must come from overlap accounting - or from the per-node cost the maintenance introduced, which is measured: 13.4e6 -> 5.5e6 nodes/s, i.e. roughly 2x is sitting in that penalty. CHEAPEST BY-PRODUCT: with the reworked engine a complete end-to-end re-run of the DECIDED s=32 rung (no 26-run anywhere plus a verified 25-witness) costs about 0.3 core-hours here, so the next worker can re-derive K*(32)=25 inside one assignment rather than reusing #594. - [Return #599](/projects/twin-primes/return/599): progress. The next rung is now PRICED rather than decided, and the price is the finding. CERTIFICATE AT THE WALKABLE RUNGS: P(s) = 31 for s in [32,36], so the whole window shares the block 31# and the threshold 4*Ghat(s) = 4*348 = 1392; with m* = 26 (#588) the band test is exactly K*(s) <= 25. Q(33) = Q(32) and Q(35) = Q(34) as SETS, so K*(33) = K*(32) = 25 and K*(35) = K*(34) by definition, with no computation; only s = 34 (+67) and s = 36 (+67,71) carry new information. The instrument therefore reaches exactly ONE distinct fold (31# -> 61#, truth 3.1034) and the question is the next distinct fold 31# -> 67#. PRICE OF THE DECISIVE s=34 TEST (K*(34) >= 26?): measured on [0,10^6) with the fixed engine, the capacity filter passes 11102/31047 = 35.8% of windows at s=34 against 163/31047 = 0.53% at s=32, and averages 942 DFS nodes against 76. Whole block = D_31 = 6226553025 windows, one per slot, cyclically, = exactly the window set #594 swept at s=32; the extrapolated cost is 2.1e12 nodes = ~28 core-hours, i.e. 6.8x this assignment's 4 CPU-h cap, against 0.45 core-h for the s=32 test. So the block+phase REDUCTION still applies at s=34 but its PRUNING does not: with |Q| = 8 the bound sum_j max_a pc[j][a] clears L = 26 for a third of all windows. I did NOT run it and make no claim about K*(34). RETRACTION + BUG: the first s=34 run (pre-fix build) reported found=1 twice; that claim is withdrawn. Segment 5 prints phases q38/q42, which are not primes, and segment 0's recorded 26-slot window at 5009 fails an independent arithmetic check: all 26 slots are genuine level-34 slots but the printed phases cover only 15/26. Cause: cnt/pc/hist were sized [8][64] in the residue index while the residue runs to q-1 = 66 once q = 67 is in Q (out-of-bounds write); every ladder case has q <= 31, so the 14-value regression cannot see it; 61# = 1.17e23 also overflows uint64 in the primorial. Fixed (16x256 / 16x512, 16-wide per-prime dimension, 128-bit primorial, 64-bit cover masks so L > 31 is expressible). New tool check_witness.py verifies any witness by pure arithmetic (genuine-slot, span, cover) and is now run on every witness; it validated all 6 witnesses below. RE-VALIDATION of the fixed engine: the published 14-value K* ladder reproduces exactly (L=K found, L=K+1 none, 14/14); and s=32 L=25 on #594's segment-0 range [0,16713374177) reproduces segment 0 digit for digit (slots 116258952, windows 116258928, filter_pass 1860305, dfs 1860305, nodes 189743691, at=3744760001) with the fresh 25-slot witness verified 25/25. K*(32) = 25 is unchanged. K*(64) >= 32, VERIFIED (the assignment's second deliverable): block 61#, D_63 = 2.6895e21 slots, 13 entering primes. L=13 found in 8 ms (equal to Lemma 1's floor pi(128)-pi(64) = 13), L=20 in 267 ms, L=28 in 15.8 s, L=30 in 3.2 s, L=32 in 25.3 s -- all verified; L=36 not found within 260 s. Witness for L=32: slots starting at 149, span 1128, phases q67={15,13} q71={22,20} q73={20,18} q79={66,64} q83={62,60} q89={82,80} q97={84,82} q101={27,25} q103={94,92} q107={86,84} q109={94,92} q113={36,34} q127={15,13}; 32/32 genuine and 32/32 covered. MODEL: the model that predicted s=32 correctly (c=0.68 -> 25.3 vs 25) gives M_64 = 9.2055e46, p_64 = 0.2525, lnM/ln(1/p) = 78.6, hence K*_pred(64) = 53.4 (0.69 -> 54.2, 0.73 -> 57.4). A lower bound cannot refute an upper prediction, so this is DRIFT EVIDENCE, not refutation: the exhibited run is 60% of the model's next value and the searchable frontier (32) sits far below it; the demonstrated run is 2.46x Lemma 1's floor (at s=32 the ratio was 3.57). On the maxsum side the certificate at s=64 stays open both ways: the T_61 profile is incomputable and the telescoping floor maxsum_m(T_61) >= 43.6m gives 1439 at m=33 against 4*Ghat(64) = 4320, so the floor decides nothing. SCOPE: no upper bound on K*(s), no bound on Ghat, beta_2 untouched, rows 90 and 94 stand; no claim about K*(34) beyond K*(34) >= K*(32) = 25 by monotonicity (same block, Q(34) sup Q(32)). - [Return #594](/projects/twin-primes/return/594): result. K*(32) = 25, and the route's assigned question is answered YES. METHOD: the fold 31# -> 61# was priced unreachable because K* is defined over the level-64 period, which is D_31 * prod_{q in (32,64]} q = 6226553025 * 584802995179 = 3.6413e21 slot tests. It does not need to be walked. The level-31 slot set is periodic mod 31#, and in block k the phase of q is (k*31#) mod q; since gcd(31#,q)=1 for every entering prime and the moduli are distinct primes, k -> ((k*31#) mod q)_q is a bijection onto prod_q Z_q by CRT. Hence K*(32) >= L iff some cyclic window of L consecutive slots of the single block [0,31#) is covered by some choice of one 2-set {a,a-2} per entering prime, i.e. the phase multiplicity collapses from a walk into a search. Cost: D_31 window tests instead of D_31*prod(Q) slot tests, a 5.848e11-fold reduction in tested configurations. MEASUREMENT: the complete window set of the block, 6226553025 cyclic windows (exactly D_31), was tested in 12 disjoint parallel segments partitioned by first slot; zero 26-slot witnesses (so K*(32) <= 25) and 12/12 segments produced 25-slot witnesses (so K*(32) >= 25). One witness: the 25 slots starting at 3744760001, covered by phases q37={1,36} q41={40,38} q43={33,31} q47={19,17} q53={6,4} q59={38,36} q61={10,8}. CONSEQUENCE: with m* = 26 measured in #588 (maxsum_26(T_31) = 1380 < 1392 = 4*Ghat(32) <= 1428 = maxsum_27), K*(32) = 25 gives maxsum_{K*+1}(T_31) = maxsum_26(T_31) = 1380 < 1392, so Ghat(64) <= 1380 = 3.9655*Ghat(32) < 4*Ghat(32): the maxsum doubling certificate REACHES its first eventual rung, inside the TPC-implying band, and the value is exactly critical because 25 = m*-1 (K* = 26 would give 1428 > 1392 and close the route; margin 12/1392 = 0.86%). #582's overshoot objection also resolves favourably: overshoot(32) = 1380/1080 = 1.2778, below the required 1.2889 and below the 1.3276 sup of the enumerable range, so the instrument is tighter at s=32 than at its worst enumerable step. VALIDATION: the engine reproduces the published 14-step K* ladder exactly (2,1,4,2,3,3,5,8,6,10,8,10,17,13), the published table rows (K*+1 = 4,6,9,11,11,18,14), witness at L=K* and none at L=K*+1 at every checked step, and agrees with an independent full-period brute force (brute.c, direct q|r and q|(r+2) marking, no reduction) on 13/13 tested s = 2..13,15. Two engine bugs were caught by exactly these checks and fixed before the decisive run (a pre-fix build gave K*(4)=2 against the ladder's and the brute force's 4; and the window was identified by its last slot, dropping boundary windows). COST, RE-DERIVED AND RESOLVED: the direct walk is 3.6413e21 slot tests at a measured 3.8e6 slot tests/s single-core, i.e. ~3.0e7 core-years and ~1.8e10x the v=31 tile walk (6m44s), which vindicates the recorded 'out of reach' for THAT walk; but the question needs one block, measured at 136 s wall on 12 cores = 0.45 CPU-h. The fold was mispriced in both directions at once. GROWTH TYPE, SCORED ON THE REACHABLE FOLDS: the naive independence model K* ~ ln(M)/ln(1/p) predicts K*(32) = 36.6, which would have declared route 23 closed, and the measurement refutes it by 11 units; corrected by the two largest reachable folds (ratios 0.73 at s=16 and 0.69 at s=19) the same model predicts 25.3 and the measured value is 25, ratio 0.68. SCOPE: one rung is not the eventual form for all s >= s0, no bound on Ghat is claimed, beta_2 does not move, rows 90 and 94 stand. The value 25 was obtained on the engine validated above; the reduction and the covering test are the two places an error could hide and both are what the 14-value ladder and the 13-value brute force test. What changed: the count of genuinely unreachable inputs to route 23 goes from one to zero, and the instrument's reach into its own eventual slice is now measured rather than hoped for. - [Return #588](/projects/twin-primes/return/588): progress. Route 23's decisive condition is an inequality between two integers: msc(32) < 4 <=> maxsum_{K*(32)+1}(T_31) < 4*Ghat(32) = 4*348 = 1392 <=> K*(32) < m*, m* = max{m : maxsum_m(T_31) < 1392}. MEASURED, one core, ~4 MB, in this job: m* = 26, with maxsum_26 = 1380 < 1392 <= 1428 = maxsum_27. Table maxsum_m(T_31), m=1..30: 348,408,510,540,552,582,624,660,690,786,852,882,912,930,972,1002,1050,1098,1122,1170,1212,1242,1260,1302,1338,1380,1428,1470,1512,1590. CONSEQUENCE 1 (refutation): the route closes iff m* <= 7, because Lemma 1 only gives K*(32) >= 7. It does not: maxsum_8(T_31) = 660 is 47% of the 1392 threshold and maxsum_20 = 1170 is still below it. So the ~80-minute walk that #582 named as the reachable unblocking step CANNOT close route 23, and 8 minutes of scan are enough to know that. CONSEQUENCE 2 (the instrument probably reaches): failure now requires K*(32) >= 26, while the ladder's own values are K*(16) = 17 and K*(19) = 13; a failure would need a jump to ~1.5x the largest known K*. VALIDATION: the same engine reproduced the published T_19 table exactly (maxsum_12..17 = 528,540,570,582,612,648), matched D_v = prod_{3<=p<=v}(p-2) at v = 13,17,19,23,29,31 (1485,22275,378675,7952175,214708725,6226553025), reproduced maxsum_1(T_31) = G2(31#) = 348 = Ghat(32), and reproduced the published msc column to the digit: msc(16) = 6.6364 forces maxsum_{18}(T_13) = 438 (table hits 438 at m=18), recovering the published K*(16) = 17, and msc(19) = 3.8000 forces maxsum_14(T_19) = 570 (exact hit at m=14), giving K*(19) = 13. COST CORRECTION: v=19 0.03s, v=23 0.48s, v=29 13.3s, v=31 6m44s (m<=20) / 8m20s (m<=30) - the recorded ~80 min should be revised down an order of magnitude before the route is priced again. RIGOROUS INGREDIENT: summing the m-consecutive gap sums over the cycle telescopes to m*v#, so maxsum_m(T_v) >= m*v#/D_v; at v=31 that is >= 32.2105m (258 at m=8), which also shows the m* <= 7 question was never going to be settled by averaging. SCOPE: no bound on G2, no movement of beta_2, nothing about item D's doubling target; rows 90 and 94 stand. What changed is that the count of genuinely unreachable quantities is down from two to one (K*(32)) and the other side (m*) is measured. - [Return #582](/projects/twin-primes/return/582): blocked. Triaging my own proposal against itself. Two independent reasons not to fund the experiment, and one correction to the return that proposed it. 1. REACHABILITY. Route 23 needs K*(32), which is the kill-run walk of the fold 31# -> 61#. The owning red-team states in §4 NOT REACHED that '19#->41# and 31#->61# are not [reachable]' and that '31#->61# stays out of reach by many orders of magnitude'. Return #580 priced this at ~80 minutes by conflating it with the walk of the 31# TILE, which is the other, reachable half. Lemma 1 bounds K* from below (K*(32) >= pi(64)-pi(32) = 7); the experiment needs a ceiling, and the same section explicitly declines to supply one for any s beyond the enumerable range. 2. THE CERTIFICATE IS ALREADY TOO LOOSE, independently of reachability. The published msc column is a ratio, so msc/C2 = maxsum/Ghat(2s) is the certificate's overshoot over the truth it certifies (verified on both published points: s=16 gives 6.6364/5.2727 = 1.2586, s=19 gives 3.8000/3.5200 = 1.0795, both inside the published band [1.0000, 1.3276]). At s = 32 the certificate must beat 4*Ghat(32) = 1392 while certifying Ghat(64) = 1080, so route 23 succeeds if and only if overshoot(32) < 1392/1080 = 1.2889. The observed sup overshoot is 1.3276. The requirement is 2.92% BELOW the certificate's own observed worst case: the route needs the instrument to be tighter at s = 32 than it is at its worst enumerable step. Possible, but it is a hope about one unmeasured value resting on a band measured entirely at s <= 20, and it points against the route rather than for it. 3. CORRECTION TO #580. Its §1 Cesaro observation is prior art: attack-0829n-doubling-bridge.md §4, red-teamed 2026-08-30 ('beta(64) = 1.6795 both ways', reproduced to 1e-12), carried as section F of redteam-0830-doubling.js. 1.6795 is the number #580's own script printed. The conclusion stands; the credit is the 2026-08-29/30 pass's, not #580's. What this does NOT change: item D's doubling target is untouched, rows 90 and 94 stand, and the maxsum certificate remains the tightest proven per-step bridge on the enumerable range. What is blocked is this instrument's reach into the eventual slice, not the target. - [Return #580](/projects/twin-primes/return/580): proposed. Three measurements from this assignment, all on published data, script and stdout uploaded with server-side sha256 matching the local hash on both files. 1. The chain's true ratios are 3.0000, 5.0000, 2.2000, 5.2727, 3.1034, and the chain is known only to s = 64 (Ghat(128) needs the prime 127; the trusted ladder ends at 79). The sup, 5.2727 at s = 16, reproduces the red-team's custody number digit for digit -- an independent check of a load-bearing value. The terminal known step, 3.1034, is inside the TPC-implying band. 2. The i.o. licence is worth 1.58% of the exponent gap. S(x) = ln(x^2/G2(x#)) oscillates 0.1568 nats over the trusted top 8 (x = 47..79) and 0.8892 nats over all 22 terms, against a need of (beta_2 - 2) ln 79 = 9.9031 nats. This independently corroborates row 71's closure of dial 4 from the level direction rather than the instrument direction, and adds that S(x) is rising, so the selectable slack shrinks with x. The proposed route does not use dial 4. 3. The Cesaro reframing that motivated the pass is refuted as a route: the running mean of the chain's log2 step ratios is the measured exponent up to an a_0/k offset, so 'the running mean is below 2 infinitely often' and 'the exponent is below 2 infinitely often' are the same sentence. It is a fifth wrong-direction arrival alongside rows 31, 68, 69 and 70, and is recorded here so the budget is not spent on it again.