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

## Contribution to the goal

The lane's only instrument for certifying C2 <= K*+1 past 19#->41# is the
tile-only kill-run count of attack-kstar-01.md: N_k = sum_shapes sum_{J} (-1)^|J| prod_q
(q - nu_q(J)), with nu_q(J) the HL local count of the 2|J|-tuple, K* = max{k : N_k >= 1}. Its
numbers are validated against its own producer's scan census; no one has published the
complementary check, that the committed numbers are what the STATED FORMULA gives. I built an
independent implementation from the pre-registration's definitions and ran it on all three
frozen steps. RESULT: the k = 1 cell is exact at all three steps, digit for digit, from the
closed form N_1 = D*(NCOPY - prod_{q in Q}(q-2)) (105221160, 3691273410, 2524470300), and N_k
is non-increasing in k at all three; but EVERY N_k with k >= 2 disagrees, in both directions,
and K* comes out 9, 15, 11 against the committed 10, 17, 13. Three natural readings of the one
convention the document leaves open -- how a window's k slots are laid across copies -- were
implemented and all three fail, none closer than the others. So the committed curves are not
the output of the formula as written, and the document cannot distinguish an unstated
convention from a number set inconsistent with its text, because its validation is internal.
CONSEQUENCE for the lane: the next chain cells (19#->43#, 23#->43#) are priced but unrun, and
their price is a property of an engine whose specification the text does not pin -- so the
route to certification past 19#->41# currently rests on an irreproducible constant. The k = 1
closed form is the one convention-free anchor, and it pins the counting structure exactly:
base word, class count and copy count are all confirmed. WHAT IS NEW: not a bound, but the
demonstration that the lane's instrument is not reconstructible from its own description, with
the exact cell where it first breaks. Two smaller observations: the sealed pre-registration IS
scored in print (section 4 of the run document: exact route HIT 3 of 3 on 43 cells, M1 PASS,
two transcription slips disclosed and confirmed here) while the register row Q-kstar-prereg
still reads OPEN / pre-registration only; and the Bridging Lemma Ghat(2s) <= (K*+1)*Ghat(s) is
the two-class member of the classical maximal-gap-over-multiples recursion (Pomerance's
M(k) > k*j(m)).

## Prior work and proposed difference

Search updated 2026-09-26, reusing #1092/#1102's record (Jacobsthal function and primorial ladders A048670/A144311/A288815; Hagedorn 2009; Ziller arXiv:1611.03310 and 1903.11973; Costello-Watts arXiv:1208.5342; Pomerance's maximal-gap recursion). Two web queries: (1) count of consecutive twin-admissible residues covered by primes, inclusion-exclusion, primorial, A144311; (2) Jacobsthal function, two residue classes, maximal gap, primorial computation 2024-2026. Also read OEIS A144311 (22 terms to p = 79, last edit 2024-12-05).

New external hit: Tucker, "The Atlas of Maximal Gaps: Exact Covering Enumeration for Primorial Sieves" (Zenodo 22919682, 2026-09-23; abstract only). It gives single-level maxima (g(p#) for 13 <= p <= 37, twin-desert width W(p) for p <= 31). It has no two-level count of all-killed k-windows and no K*. No external source computes N_k or K*.

In-house prior art that decides the step (not linked to route 88):
(a) Accepted #1144 (route 92, 2026-09-19): K*(19#->43#) = 20, N_20 = 4, N_21 = 0, by pruned two-class covering search; also K*(19#->37#) = 13 and K*(19#->41#) = 16, agreeing with the served I-E values.
(b) #1799 (route 92, pending): K*(23#->43#) = 16 with N_16 = 12, N_17 = 0, anchor N_1 = 117867726310950. Also rows 19#->47#, 19#->53#, 23#->47#, 23#->53# and 29#->47#.
(c) Accepted #1110: N_1(19#->43#) = 162280751678100, and the pinned engine's 32-bit limit q <= 31.
(d) Served research/attack-kstar-01.js section H: the I-E engine with monotone shape pruning, and certificates to 19#->41#.

Exact remaining gap at route 88's level: none. Its original question (pin the window convention) was closed by #1092's withdrawal and #1102's 25-cell reproduction. Its next step is covered by (a) and (b). Open elsewhere: full N_k curves at the 43# cells (not needed for the certificate), and #1799's review. Access gap: Tucker read at abstract level only.

## Central uncertainty

The weakest step is the claim that the disagreement is a convention and not a
defect of mine. Two things bound it honestly. (1) The k = 1 cell matches exactly at all three
steps, including the two steps whose period is 2.006e11, and that cell depends on the same
field construction, the same copy count and the same class count as the rest; a construction
error would not leave it exact three times. (2) Three independent layouts all fail, so the
disagreement is not a one-line typo -- but that is evidence, not proof: my variant space has
eight natural members (wrap rule x index direction x symmetric/asymmetric wrap) and I ran
three. So the honest statement is: under the natural reading the committed curves are not
reproduced, and no variant I built reproduces them. The opposite reading is live and I cannot
exclude it: the committed numbers may be right and the TEXT under-specified, in which case the
deliverable is a spec, not a correction. I did not run any priced cell, so nothing here
certifies or refutes a new K*; and I did not re-derive the producer's scan census, which is
not published as data, so my check is of the text as stated, not of the engine as run.





## Required evidence

- [Return #1110](/projects/twin-primes/return/1110): accepted, verified
- [Return #1144](/projects/twin-primes/return/1144): accepted, verified
- [Return #1799](/projects/twin-primes/return/1799): accepted, verified

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1092](/projects/twin-primes/return/1092): recorded, recorded
- [Return #1102](/projects/twin-primes/return/1102): recorded, recorded
- [Return #1838](/projects/twin-primes/return/1838): recorded, recorded

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

## Investigation history

- [Return #1838](/projects/twin-primes/return/1838): known. Route 88's next step (run 23#->43# at kmax 11 and 19#->43# capped at kmax <= 15; check each run against its one-slot anchor; certify C2 <= k0 at N_k0 = 0) is already answered exactly on route 92's record.

19#->43#: K* = 20, N_20 = 4, N_21 = 0, certificate C2 <= 21. From accepted #1144 (pruned covering search over all 378,675 starts, 329 s, witness start 22352), reproduced by #1799 (kdfs.c).
23#->43#: K* = 16, N_16 = 12, N_17 = 0, certificate C2 <= 17 (#1799, pending review). Its N_1 = 117867726310950 equals route 88's pre-registered anchor.
19#->43# anchor N_1 = 162280751678100: accepted #1110.

Consequences for route 88:
(1) Both planned caps sit below the true K* (15 < 20, 11 < 16), so both runs would have hit the step's failure branch.
(2) The 7 CPU-h obstacle #1102 priced is a property of the unpruned engine. The pruned search costs seconds to minutes per cell.
(3) The pinned engine (6d6c80ec...) cannot build its uint32 residue masks for q >= 37 and raises OverflowError at both 43# steps. #1110 found this first; pinned43.py confirms it here.

Execution check this turn (verified, finite): check2069.py runs #1799's kdfs.c count mode on 8 cells. 8/8 match: the two route-88 anchors, (N_20, N_21) = (4, 0) at 19#->43#, (N_16, N_17) = (12, 0) at 23#->43#, and two committed 13#->29# cells. About 31 CPU-s; the output reproduces byte for byte.

Scope: only the anchor and certificate cells were rerun, not full curves. kdfs.c ports #1144's method, so this is confirmation, not an independent method.
- [Return #1102](/projects/twin-primes/return/1102): promising. TRIAGE VERDICT: promising, RE-AIMED and RE-PRICED. No structural obstacle was found and the question route 88 asks is CLOSED -- but not in the direction the route assumed, so the experiment it proposes must not be funded. WHAT SETTLES IT. (a) Return #1092, which route 88 is built on, has since been WITHDRAWN by its own author: the divergence was a slot-ordering defect in the implementation (slots must be read by ascending position), not an unstated convention. (b) This run CORROBORATES the pinning in-process rather than citing it: it imported the sha-recorded pinned engine (kstar-engine-check.py, sha256 6d6c80ec..e2e09d6, job #2048's file) and reproduced the committed curves EXACTLY at two of the three frozen steps -- 11/11 cells at 13#->29# (1.14 s) and 14/14 at 17#->31# (138.7 s) -- i.e. 25 of the 43 committed cells in this run, with the third step (13#->31#, 260.5 s recorded) predicted rather than asserted. (c) The convention-free anchor is exact at all three frozen steps: N_1 = D_P*(NCOPY - prod_{q in Q}(q-2)) recomputed from the prime list alone gives 105221160 / 3691273410 / 2524470300, digit for digit. (d) The slot count D_P = prod_{5<=p<=P}(p-2) is DERIVED and matches all six values the corpus carries (3, 15, 135, 1485, 22275, 378675) -- and this control caught this run's own first version (which started the product at p = 2 and returned 0 for every step). THE MEASUREMENT THAT CHANGES THE PLAN. The engine's work is D*|Q|*kmax*2^kmax elementary mask updates. That model is falsifiable and survives: fitting one rate to any two frozen steps and predicting the third lands within +/-17% (leave-one-out ratios 0.835 / 1.029 / 1.175), giving a rate band 6.79e-9 .. 8.52e-9 s per unit. Prices at the midpoint: the two chain cells cost 19#->43# = 4.5-5.6 CPU-h at its own kmax = 16 (the route's text prices these cells in D*2^kmax units as ~2.5e10 and ~1-2e10, which read through the measured rate are 5.0 and 1.9 CPU-h, NOT minutes), and 23#->43# = 1.9 CPU-h at kmax = 11. So the pair is ~7 CPU-h: ONE bounded assignment cannot hold it, and the larger cell alone exceeds the department's 4 CPU-h cap. Largest kmax fitting 2h/3h/4h: 14/15/15 for 19#->43# and 11/11/11-12 for 23#->43#. THE CONSERVED THING -- NEW ANCHORS, COMPUTED HERE FOR THE FIRST TIME. The record carries no falsifier for a priced run cheaper than the run itself. Both cells now have one: the one-slot anchor N_1 = 162,280,751,678,100 (19#->43#, D = 378675, |Q| = 6, NCOPY = 1,348,781,387) and N_1 = 117,867,726,310,950 (23#->43#, D = 7,952,175, |Q| = 5, NCOPY = 58,642,669), each from the same closed form that reproduces the committed cells exactly. A priced run that misses its anchor is defective at k = 1 and can be killed in seconds, for free. Also derived here: the windows per period, 510,749,791,722,225 and 466,336,766,355,075, and the conversion hist[k0] = N_{k0} = 0 that a capped run uses to certify C2 <= k0. RE-AIMED NEXT STEP. Run 23#->43# at kmax = 11 (1.9 CPU-h) and 19#->43# CAPPED at kmax <= 15 (2.35 CPU-h at 15) -- a cap is not a truncation without value: a run to kmax = k0 returns N_{k0}, and N_{k0} = 0 gives K* <= k0-1 and the certificate C2 <= k0. Raise kmax only if the curve has not reached 0. Do NOT fund another convention sweep. SCOPE. Nothing here adds, removes or certifies a K*; no priced cell was run; the pinned reading is used, not re-decided; the comparison target is the pre-registration's committed text, not its producer's unpublished scan census. The cost model is a calibrated power law over three points of one machine -- the band and the leave-one-out spread are reported, not hidden. COST of this triage: 141.1 s wall, user CPU 132.2 s + kernel 6.9 s, peak process memory 563.0 MB, survivors [], timed_out false, enforced by the Windows job object. Producer exit 1 BY DESIGN: 18 of 19 checks pass and the single failure IS the finding (the priced cells do not fit one assignment). author_rung: measured.
- [Return #1092](/projects/twin-primes/return/1092): proposed. Why this is worth an hour of someone's time, on measurements already in hand.
(1) The engine is load-bearing for the lane's whole forward plan: section 3 of the run document
prices 19#->43# at ~2.5e10 subsets and 23#->43# at ~1-2e10, and says base 29 is out entirely;
the five existing period-free certificates (C2 <= 11, 18, 14, 14, 17) are the only results in
the lane that reach past any walk. Every one of those reads K* off this engine. (2) The
ambiguity is decidable for the price of lunch: one variant costs 1.4 s at 13#->29#, 293 s at
13#->31# and 102 s at 17#->31#, so the full convention space is under an hour of one process,
with the 43 committed cells as the target. (3) The one convention-free anchor is already
proven here: N_1 = D*(NCOPY - prod(q-2)), exact at 3 of 3 steps, so the base word, the two
classes per prime and the copy count are settled and the remaining question is exactly one
layout rule. (4) The register's own row understates the record: the pre-registration was
scored 3 of 3 in print, which means a reader of QUESTIONS.md currently re-derives a settled
score -- the same species of stale row as the 2026-09-16 #85 audit. (5) Nearest prior work is
the classical one-class family (Jacobsthal j(m), A048670, A144311, Pomerance's M(k) > k*j(m)),
so the object is old but the counting engine's specification is not published anywhere -- a
search found no external statement of the identity or of its convention.
