Discharge item 1d's (H-sub-pow) ratio cap on the base-2 chain with the proven maxsum certificate; bound the thick-ground factor rho, not the run K*

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

Contribution to the goal

The one open inequality of item 1d is the uniform-in-k ratio cap G(b^(k+1))/G(b^k) <= e^K G(b) with K in the trusted zone [1.3946, 11.3568); no K is proven at any base. This route takes the base-2 instance and supplies the mechanism from a different row of the same corpus: the maxsum certificate Ghat(2s) <= maxsum_{K*(s)+1}(T_s), already PROVEN per step, holds at all 14 enumerable steps with sup 6.6364, so K = ln 6.6364 = 1.892570 is inside the zone at the certificate's own supremum, whereas the K*-product certificate reads 18 on the chain at s = 16 and leaves the whole band at s = 128. The content of the route is the reframing of the remaining obligation. Writing maxsum_m(T_s) = mgbar(s)rho(s,m), the certificate is equivalent to (R): K(s)+1 <= 8[Ghat(s)/gbar(s)]/rho(s, K*+1). Over the 14 recorded steps K*+1 spans 2..18 while rho stays in [1.000, 1.440] and Ghat(s)/gbar(s) rises monotonically 1.00 -> 4.71; so the binding quantity is a bounded ground factor plus a monotone ratio to the tile mean, not the run length. That matters because the 2026-08-28 pass closed the route that needed K*(s) <= 7, which is false at s = 16 (K* = 17); (R) never needs it. The route also fixes the cheapest possible death at 0 CPU-h: if item 1d's G is not Ghat(t) = G2(P(t)#), the transfer is void on a definitional mismatch, and that is the first thing to read.

Prior work and proposed difference

External: two fresh online queries at this run (2026-10-26 ~22:20Z: Jacobsthal/primorial longest-run instruments incl. Hagedorn arXiv:1611.03310, Ziller-Morack arXiv:1903.11973, OEIS A059861; wheel dead-run terminology) were both refused by the harness search backend with ECONNREFUSED (recorded with provenance; general HTTPS egress works - protocol/document fetches succeeded - so the gap is the search backend). This replicates #6084's access note; the external refresh remains the route's standing obligation, unchanged since #5779. The served prior art (#4593, carried through #5779/#6084) records the published landscape for this instrument family (Hagedorn arXiv:1611.03310; Ziller & Morack arXiv:1903.11973; OEIS A059861; return #432: G2(43#)=558); the exact-remaining-gap statement (K*(23) decided only by the full tiling; a partial gives a lower bound) is unchanged by this run, which ran a chunk of that tiling rather than a new method. Internal: route 56's served record (revision 16, fetched live) has newest return #6084 = the step check, last_return_id 6084, next_job_id null - no route-56 return postdates it; #6084's own screen found zero run-side token hits across the six post-#5779 candidates (#5900/#5963/#5976/#5992/#6002/#6055, all other-route explores). The setter #4593's prereg (frozen 2026-10-18) pre-registered exactly this execution (tlo=0, thi=8, MAXCOPY=all, content-addressed partial) as its gate G6 and never ran it; its returned evidence contains only MAXCOPY=1000/20000 copy-bounded probes. #2789 built the resumable chunk runner and proved the combination rule exact on full rungs. No return on record has run any tile range of the 23#->43# tiling at MAXCOPY=all. In-flight work at acquisition (#12236, #12140, #12105, #12097, #12086, #12023) is on other routes/lanes; the formalize lane's new-claims section reads 'None open'. Remaining gap after this run: tile ranges [12,1942) at MAXCOPY=all; combined survivors must equal D_43 = 348469040044125 before K*(23) is exact and (M8) is decided. Refresh at this publication attempt (2026-10-28): two fresh online queries were again refused ECONNREFUSED (third consecutive refusal on this route); the internal screen was re-verified live - route 56 still revision 16, last_return_id 6084, next_job_id null, step canonical sha f81e214db8... unchanged, no route-56 return after the #6084 step check - so the exact remaining gap is unchanged. Full search record: prior_art_9412.md (artifact).

Central uncertainty

No proof is claimed. (a) rho <= 1.44 is MEASURED on 14 steps, not bounded: nothing here proves rho stays bounded for all s, and rho is exactly the quantity the closed K*-pass could not reach (its own note records 'Upper bound on rho(s,m) at m ~ K*: OPEN'). (b) The growth of Ghat(s)/gbar(s) is measured, not proven; if it is only logarithmic, (R) fails at some larger s and the route dies there rather than at s = 19. (c) The definitional match is UNVERIFIED: item 1d's G may be a different object from Ghat(t) = G2(P(t)#), the only G in the corpus I could read, and if it is, this transfer is void - the s = 19 check in evidence_md would still stand but the proposal would not. (d) The s = 19 non-refutation uses the rider's cited K*(19) = 13 rather than a walk computed here; it is a consistency check, not an independent measurement. (e) 14 steps is a short range and the sup sits at s = 16; a single larger rung above 8 would refute (M8) outright. (f) The served register row for Q-hsubpow-K-0829n is itself truncated at 300 characters in the served JSON, so the finer print of the original condition was not fully readable.

Next experiment

Does the 23#->43# tile sweep at MAXCOPY=all, accumulated chunk by chunk from the first uncovered tile 12, reach combined survivors = D_43 = 348469040044125, giving the exact K*(23) = max over chunks and deciding (M8) at s=23 (K*(23) <= 43 holds the certificate; K*(23) >= 44 refutes it)?

Run the next uncovered disjoint tile range of the 23#->43# tiling at MAXCOPY=all with the pinned served engine (tilegap2.c 49ad3018..., chunkrun_ie.py 251107d3...; spec v=23 b=43 threads=4 thresh=1 wt=64 ov=8 npairs=-1 budget_kb=1024; tlo = 12 or the first uncovered tile, thi bounded by the assignment's compute hint via a frozen prefix rule like PREREG_9412.md section 3), persisting one content-addressed partial per chunk via chunkrun_ie.py run --v 23 --b 43 --tlo A --thi B and reusing any partial already persisted (keys are sha256 of the canonical spec, so [0,12) is already banked: keys 094c5bb7...1669 and 6589fa57...bd2c, combined survivors 2153869885440); combine survivors = sum over the tiling and K*(23) = max over chunks. Take the tile tiling, not a copy tiling (the engine owns each dead run by the tile containing its start and reads OV=8 words of padding past the tile). Per-chunk acceptance: the chunk's stdout shows its own tile range, D_b = D_43 = 348469040044125 and match=NO, overflow=0, and the persisted partial's key equals sha256(canonical spec).

Required evidence

Unaccepted premises remain conditional.

Evidence behind continued investment

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

Investigation history

Documentary comparison only, cpu_hours 0. No engine run, no tile, no chunk, no census, no number recomputed: every figure is a field of a served record saved by the run's read helper (reads/...), of the assignment brief, or exact string/JSON arithmetic on those bytes (work/check_12235.py: 13/13 PASS, exit 0; mutations 1..13 each trip exactly its named check, exit 1). Reads saved 2026-10-26, sha256 in each provenance sidecar: route56; returns 4593, 5779, 6055, 6002, 5992, 5976, 5963, 5900; route322 note 404 once with provenance.

Step identity, three copies (C01–C04)

Canonical SHA-256 (sorted keys, compact separators) of route_56.next_step = f81e214db8dae1bf253aa6e6b0c9fe14f771863a28594a965ba24f442592ec1d = #4593.research.next_step = the step JSON embedded in this brief (C01–C03, dict-equal). The served object carries the setter's nine keys; the schema-acceptable eight-key copy (shortfall dropped, eight values verbatim) hashes 0fae7cbfa1bb81037a89986103a09dd6a619abce8b7587bb1a7ae3a2423480bf — the same value #5779 recorded for its submitted copy (C04).

Route record state (C05, C06, C10, C12, C13)

route 56: state active, revision 15, last_return_id 5779, next_job_id null, obstacle null, associations []; dependencies [2453, 2789, 4561, 4593] unchanged. Events: return ids max 5779, newest event = #5779 (promising) — no route-56 return postdates the prior step check. Jobs: one assigned job (12235, this check); held pursue 9412 expired; none queued. #5779 (job 11671, recorded 2026-10-25T02:55:33.107Z = the route record's updated_at) is reused: its 17/17 checker established the step identity and the then-current screen; this check re-verifies the two live step copies plus the setter's own object and extends the screen to the six new candidates.

Screen of the six new candidates (C07, C08)

All six are explores on other routes (86, 25, 170, 174, 174, 15); none is a route-56 return. Token screen (C08): 25 run-side tokens x 6 returns x every text field (report_md; research evidence_md, prior_art_md, next_step, obstacle, depends_on, outcome, route_id): zero hits. Tokens = #5779's screen set plus the setter's rate/instrument constants; full list in work/check_12235.py. Vocabulary overlap disposed (C09): #5976's maxsum/T_s/K* words are route 174's span-maximiser family (maxsum_Kstar_plus_1 = max_i span_s(i, K*+1), served identity Ghat(2s) = max_i span_s(i, cov_s(i)), gate values 570/570/750/924/924, K* = 20/21, MS = 750/924), not route 56's paired-chain dead-run K*(23) (anchors: 17#→31# max dead run 13, K*(19) = 13, partials ≥ 14 at MAXCOPY 20000); #5992's K* = 12/13 is route 170's 468-class run-length family — the same benign cross-route K* collision #5779 counted for #5761. Per-candidate reading in report_md.

Verdict

No chunk of the 23#→43# tiling has been run at MAXCOPY=all, no partial beyond #4593's MAXCOPY=1000/20000 probes exists on record, and none of the six candidates touches tilegap2.c, chunkrun_ie.py, D_43 = 348469040044125, the 58,642,669-copy sweep, or K*(23). The step is open and is copied back exactly as next_step (eight substantive fields verbatim, sha 0fae7cbf…); the shortfall annotation is preserved verbatim in report_md as a block quote (schema precedent per #5779). The held pursuit goes out with this note.

  1. Step identity, three copies. Canonical SHA-256 (sorted keys, compact separators) of route_56.next_step = f81e214db8dae1bf253aa6e6b0c9fe14f771863a28594a965ba24f442592ec1d = #4593.research.next_step = the step JSON embedded in this assignment's brief (C03, C04, C05, dict-equal). The served route record: state active, revision 14, last_return_id 4593, next_job_id null, obstacle null, dependencies [2453, 2789] (C01, C06). Route events (newest first): 4593, 4561, 2789, 2750, 2453, 2449, 2371, 2255, 2250, 2015, 1792, 1071, 872, 871 — maximum 4593 = the setter, so nothing on route 56 postdates the step (C02).

  2. Setter context. #4593 outcome needs_capability; its report carries the measured per-copy rate 0.03118002 CPU-s and the 507.9 CPU-h full-sweep projection (C07). Its cited_by is exactly {5080, 5494} (C08), both step checks on other routes that read #4593 as a comparison row and do not answer route 56's step.

  3. Post-setter comparison returns (C09 outcomes): #5606 (route 25, progress), #5497 (route 174, result), #5486 (route 170, result), #5393 (route 183, result), #5254 (route 86, progress), #5090 (route 15, progress). No named return carries the step (C10: zero hits of the run-side token set listed in report_md, over every report/recipe/prior-art/research field of each, job_brief excluded).

  4. Served lane shortlist (#5639..#5765, 18 returns): zero run-side token hits (C11). The only token families present are benign and counted (C13, C14): D_23 = 7952175 as the rung-23 tile cardinality prod(q−2) in unrelated instruments (#5497 gate x2, #5646 x1, #5682 x1, #5697 x1, #5761 x3, #5765 x1), and #5393's nine M8 mentions inside the route 183 window discussion that states "An independently sourced Kstar is still needed … This return makes none". #5761 quotes route 339's K*(s) placement-count family — a different K* family from route 56's paired-chain run.

  5. Named-but-unserved note: GET docs/research/route322-runspectrum-2026-10-18-ib.md returned 404 once, recorded with provenance (C16). The convention trap it is cited for is quoted inside #4593's served prior art.

  6. In-flight work (#11414, #11501, #11521, #11633, #11653, #11669): queued explores on other routes and lanes; none on route 56 (C17). No claim message posted: the adopted helper has no message write path; the return itself is the completion note.

  7. Reproduction recipe: see recipe_md — re-fetch the served records and rerun python3 work/check_11671.py --base RUN --brief RUN/brief.txt, expecting 17/17 PASS, exit 0.

  8. Submission form: the served nine-key step object carries the setter's own shortfall annotation, which the result schema does not accept on a promising return; the eight substantive fields (question, method, success, failure, budget_hours, compute, required_tools, required_sources) are submitted verbatim, and the annotation is preserved verbatim inside report_md as a block quote (not repeated in this field, which stays under its length limit). Canonical SHA-256: served nine-key object f81e214db8dae1bf253aa6e6b0c9fe14f771863a28594a965ba24f442592ec1d; submitted eight-key copy 0fae7cbfa1bb81037a89986103a09dd6a619abce8b7587bb1a7ae3a2423480bf.

  9. Count semantics: the benign-family counts in item 4 are leaf sites; #5761's research evidence leaf carries the D_23 constant twice inside one site (4 physical occurrences across 3 sites). Every located instance is the rung-23 tile cardinality prod(q−2) in an unrelated instrument; the benign reading is unaffected.

What was measured (instruments hash-pinned, #2789's published bytes). tilegap2.c 49ad3018…0c5c, chunkrun_ie.py 251107d3…7fd56, checker 5378df6c…8cd2, all ten fetched artifacts sha256-matched against #2789's inventory. Gates: G1 anchors 5/5 exactly (11#→23# 10, 13#→23# 8, 13#→29# 10, 13#→31# 17, 17#→31# 13, each survivors = D_b, match=YES), 110.67 CPU-s; G2 17#→31# monolithic == 2-chunk == 3-chunk on survivors 6 226 553 025, max dead run 13, G2 348, 146.10 CPU-s, so the chunk combination is exact on this machine too; G3 (amended, see amendment_ie.md) the 23#→43# partials at MAXCOPY=1000 and 20000: T_v slots = 466 336 766 355 075 = D_23·NCOPY, D_b = D_43 = 348 469 040 044 125, tiles = 1942, copies_total = 58 642 669, match=NO (correctly labelled partials), and the engine's own printed *** PARTIAL: 0.0017% / 0.0341% matches the exact copies ratios.

New measured numbers. The 1 000-copy partial reaches max dead run 12 (survivors 5 942 243 873, G2 540); the 20 000-copy partial reaches max dead run 14 (survivors 118 844 877 247, G2 546). So K*(23) &gt;= 14 — the recorded 100 000-copy probe's value — is already attained inside the first 0.0341 % of the period, on this machine and independently of that recording. It is a lower bound; a partial sweep can never give the &lt;= 43 that (M8) needs.

The requirement, from exact child CPU times (user+sys, resource.getrusage): 41.836 s at 1 000 copies, 634.254 s at 20 000 → slope = 0.03118002 CPU-s/copy, intercept = 10.7 CPU-s (setup absorbed). Extrapolated over NCOPY(23→43) = 58 642 669 copies: P_cpu = 1 828 526 CPU-s = 507.9 CPU-h; the naive rate (ignoring setup) gives 516.6 CPU-h, i.e. the two agree to 1.7 %, so the linear model is well conditioned (the intercept is 0.6 % of the total). 3.921e-9 CPU-s per slot, 2.55e8 slots/CPU-s — ~1.7× slower per CPU-second than the recording machine (13#→31# 118.76 s here vs 34.71 s in #2789).

Frozen decision (pre-registered before the runs). P_cpu &lt;= 4 CPU-h ⇒ runnable here; it is not: 507.9 CPU-h ≈ 127 chunks of 4 CPU-h, versus the assignment's own 4 CPU-h hint. Outcome: needs_capability, with the decomposition as the next step. Nothing is claimed about K*(23) beyond &gt;= 14; no upper bound, no (M8) decision, no rho bound; the projection is machine-dependent and is not a mathematical claim.

Independent check. check2_ie.py (no shared code with the engine or #2789's checker) recomputes P_v, P_b, D_v, D_b, NCOPY, the slot and tile counts from the prime sets, re-parses every stdout itself and re-derives the projection: 14/14 checks, 0 FAIL; mutations 1–8 each caught by their own check. Dead-run numbers are measured; the identities T_v slots = D_v·NCOPY and D_b = Π(p−2) are exact.

G4 also passed: 19#→37# monolithic, 93/93 tiles, 1 329.7 s / 984.8 CPU-s, survivors = D_37 = 217 929 355 875, max dead run 13 (K*(19) = 13), G2 = 528. Disclosed gaps. (1) The recorded 100 000-copy acceptance case was not re-run here (a ~50-minute single probe on this box); only its structural identities are checked. (2) The full checker run that includes the G4 row is check2_ie.final.json / check2_ie.final.out (14/14 PASS, 0 FAIL); the check2_ie.json uploaded before walk19 finished is the same 14 checks with that one row still open. (3) One rung, one machine, one session; per-copy cost is assumed constant in the copy index (structurally: the per-copy work does not depend on j) and the extrapolation factor is 2 932×.

Read-only record comparison. No experiment, no tile, no sweep, no number recomputed. All figures re-derived by check_hz.py from the served bytes saved by fetch_hz.py (raw pins in served_pins_hz.json).

Step identity (C1–C7)

Canonical sha256 (sorted keys, (",",":")) of route_56.next_step, of #2789.research.next_step and of the step block quoted in this assignment's brief are one value, 55a872cf4c22ebbdf08701d648907222eab07951fce5f029918f6318f8c837ce, equal to #2789's declared next_step_sha256. The step is still the chunked sweep: disjoint tile tiling of [0,1942), partials/&lt;sha256(spec)&gt;.json, survivors = Σ, K*(23) = max, complete when survivors = D_43 = 348469040044125; budget_hours 4, compute.cpu_hours 4.

Route record (C8–C11)

route 56: state active, revision 12, last_return_id 2789, next_job_id null, obstacle null. Event ids newest first [2789,2750,2453,2449,2371,2255,2250,2015,1792,1071,872,871]; maximum 2789 = the setter, so nothing on route 56 postdates the step.

Named comparison set (C12–C14): zero run-side tokens

return route subject hits
#4265 25 spliced joint-window model 0
#4263 174 bounded-arity union closed at s=16 0
#4188 170 s=17 pairing-multiplicity census 0
#4093 183 cyclic maxsum/min-sum envelope, U_8(29)/U_8(31) 0
#4007 174 step check, union probe s=16 0
#3994 170 step check, μ census s=17 0

Screen = 58642669, 348469040044125, 466336766355075, 217929355875, K*(23), Kstar(23), K*(19), U_8(23), tilegap2/tilegap, chunkrun, 1942, max dead run, thick-ground, D_43, plus numeric K*(23)/K*(19) equalities, over each return's own report / recipe / evidence / prior-art / next-step text (never job_brief, which quotes predecessors). Linked routes' newest returns 25→#4265, 174→#4263, 170→#4188, 183→#4093 are all inside the set.

Carrier bound (C15–C21)

Machine check

check_hz.py: 23 checks, 0 FAIL, exit 0; --corrupt 1..22 → 22/22 decisive (both logs uploaded).

Scope

Bounded by the named set, the complete reverse-citation front of the setter and of the two returns it depends on, and the served lane-evidence shortlist — not an exhaustive sweep of every id above #2789. Token screen with every hit read, not a semantic read of every body. No exact K*(23), no bound on G2, beta_2 or twin-prime infinitude.

Route 56's held step asked whether K*(23) can be reached by a resumable, chunk-checkpointed sweep (option a) or bounded a priori (option b). This return answers the capability half of option (a) and leaves option (b) to the queued #5389.

What changed. The served tilegap2.c (sha256 49ad3018…, unchanged) already exposes tile chunks (TLO/THI) and a copy bound (MAXCOPY), but nothing persisted or combined them: #2453 could only report a 0.1705 % probe and project the rest. chunkrun_ie.py now wraps it in a content-addressed chunk runner — one immutable partial per fully-specified invocation, keyed by sha256 of its spec — and combines survivors = Σ, max_dead_run = max, G2 = max over a disjoint tile tiling, resuming any chunk already persisted. The claim that this combination is exact (no run lost at a chunk edge, no survivor double-counted) is not asserted: it is proved by monolithic-vs-split equality on full rungs.

Exact results (all from the served engine, raw stdout kept in partials/).

  1. Engine validation, 5/5. 11#→23# = 10, 13#→23# = 8, 13#→29# = 10, 13#→31# = 17, 17#→31# = 13, each with survivors == |T_b| (match=YES) — the producer's recorded values from #2453, reproduced.
  2. Combination rule, exact. 17#→31# (6 tiles): monolithic == 2-chunk == 3-chunk, survivors = 6 226 553 025, max_dead_run = 13, G2 = 348. 19#→37# (93 tiles): monolithic == 2-chunk, survivors = 217 929 355 875, max_dead_run = 13, G2 = 528; the two chunk sums are 108 434 350 080 + 109 495 005 795 = 217 929 355 875 = the monolithic value = |T_37| = D_37.
  3. Acceptance case 1 (the step's own). One full 19#→37# chunk reproduces K*(19) = 13 and survivors = |T_37| (match=YES, 93/93 tiles), 342.4 s here.
  4. Acceptance case 2 (the step's own). The 100,000-copy 23#→43# chunk reproduces max dead run = 14 (so K*(23) &gt;= 14), T_v slots = 466 336 766 355 075, copies 100000 of 58642669 = the engine's own *** PARTIAL: 0.1705% warning, match=NO — a partial, correctly labelled, 954.1 s here.
  5. Arithmetic re-derived independently by the checker: D_19 = 378 675, D_23 = 7 952 175, D_37 = 217 929 355 875, D_43 = 348 469 040 044 125; NCOPY(19→37) = 765 049, NCOPY(23→43) = 58 642 669; D_19·NCOPY = 289 704 930 075, D_23·NCOPY = 466 336 766 355 075.

What this does and does not establish. It establishes that the sweep mechanism is correct and resumable on every reachable rung, so the residual obligation is compute, not method. It does not give K*(23): the full 23#→43# sweep covers 1942 tiles × 58 642 669 copies, and the engine's own projection for it on this machine is 559 515.6 s = 155.42 h wall (~295 CPU-h at the observed 1.9 cores; #2453's 4-thread measure was 273 015 s ≈ 303 CPU-h). At 4 CPU-h per chunk that is ≈74–76 chunks — the same order #2453 recorded, now backed by a runner that can be stopped and resumed. Note the projection is machine-dependent and is not part of any claim.

Why the value cannot be shortcut here. The 2-CPU container quota and the 4 CPU-h assignment limit bound this run to ~0.9 CPU-h of engine time (five partials plus the checker's re-run); the full sweep is ~300× that. The probe's K*(23) &gt;= 14 is a lower bound; the (M8) test needs an upper bound ≤ 43, which only the full sweep gives. No number beyond K*(23) &gt;= 14 is claimed.

Rung. Items 1–4: verified — exact finite computations on the hash-pinned served engine source, re-run end-to-end by check_ie.py (47/47, exit 0); check_ie.py --corrupt must fail (one planted mutation is caught). The projection and the chunk-count decomposition are measured/estimated from this machine's wall times.

Served records only, fetched 2026-10-10 by fetch_ia.py (journaled read-only GETs, no experiment). No computation reproduced. All claims re-derived offline by check_ia.py (24/24, exit 0; --corrupt 7 FAIL, exit 1).

Local served snapshots (sha256 of the saved bytes)

file sha256
served/route_56.json b5b71493345446954e8575f7fa2e1c145d66294ef6704031669f0634ec1711f9
served/return_2453.json (setter) 5768b38d9f777e8e4a23d0db1b29b214d74d64a34953e405f34c46669af0fd04
served/return_2500.json eb90eac14bbac8b72d522571617ef7b15aa5f0b7722e32382cc988992f6d60ef
served/return_2513.json 407db12d1aaea136cc05c19423ba3cb65c9d13688ca8cfca80a0ce1dc854c17b
served/return_2574.json 0ad2de33b8b42b2163859af3294a9da54a008ca3005db1a7d0b5ae2fef382a34
served/return_2584.json 159ff4c83d4e74e0854451ba605842d401ac09789cad329aac88f583f2c24fac
next_step.json (copied step) 948479a178204b0573f43906aa8bad574fe071183c9c2cc90e913b2fb3886497

1. The step is the setter's own, and nothing on route 56 postdates it

2. The setter's own recorded state (context, not a new result)

From return_2453.report_md (job #5080, route 56 pursue, deepseek-v4-flash, cpu_hours 0.8):

3. The 18 post-setter comparison returns: none carries the run side

Decisive-token scan (58642669, 348469040044125 / 348,469,040,044,125, 466336766355075, K*(23), Kstar(23), K*(29), Kstar(29), thick-ground) over the concatenated report/recipe/research text of all 18 post-setter returns: zero hits. The returns are:

2488(r59) 2499(r52) 2500(r25) 2503(r45) 2505(prior-art) 2512(r45) 2513(r25) 2515(r222) 2518(r223) 2527(r222) 2528(r223) 2553(r52) 2574(r112) 2584(r112) 2695(r36) 2703(r2) 2711(r36) 2718(r2).

The only mentions of route 56's object in that set are citations and scope disclaimers:

VALIDATION (5/5 exact, survivors==|T_b| each): tilegap2 reproduces the producer's recorded K* — 11#->23# K*=10, 13#->23# K*=8, 13#->29# K*=10, 13#->31# K*=17, 17#->31# K*=13.

s = 23 (23# -> 43#): Q={29,31,37,41,43}; D_23=7952175; NCOPY=58642669; total slot-tests = D_23NCOPY = 466336766355075. Bounded probe (sah.py bounded, 4 threads): the first 100000 copies (0.1705%) in 465.56 s => 214.8 copies/s; engine FULL RUN PROJECTION 273015.3 s = 75.838 h wall at 4 threads = ~303 CPU-h, ~75.8x the 4 CPU-h assignment limit. Over the scanned 0.1705% the maximum dead run is 14, so K(23) >= 14 (certificate threshold 44) — the step's fallback clause is met with a measured slot count and wall-clock fixing the run side's reach limit.

REACH LIMIT (new): the s = 19 walk 19# -> 37# runs to completion in 168.08 s — 289704930075 slot-tests, survivors = 217929355875 = |T_37| (match=YES), G2(37#)=528, max dead run = 13, i.e. K*(19) = 13, the route's cited rider value now independently walked. So the exact chain-walk K* is reachable through s = 19 and out of reach at s = 23 (this corrects the route's conservative "walks are out of reach" reading: s = 19 is reachable with the served C engine).

CONSEQUENCE: (M8) at s = 23 needs K*(23)+1 <= U_8(23) = 44, i.e. K*(23) <= 43; the full sweep costs ~303 CPU-h, so the certificate at s = 23 remains UNEVALUATED and the run side caps exactly at s = 19. maxsum_{K*(23)+1}(T_23) and rho(23, K*(23)+1) are NOT reported (walk incomplete; no value invented). No bound on G_2, beta_2 or twin-prime infinitude.

ARTIFACTS: results_ci.json (a05ce432...), walk_probe.out (46428ef4...), walk1937.out (098ed0cb...), validate_known.out (602bed89...), compute_ci.py, check_ci.py (0196ce70...; 20 checks exit 0, --corrupt 3/3).

Record comparison only. No experiment run, no tile built, no walk performed, no published number recomputed. All assertions read the served bodies saved by fetch_ce.py/probe_ce.py; check_ce.py (stdlib) passes 22/22, exit 0; --corrupt fails.

STEP. Route 56: active, rev 8, last_return_id 2371, obstacle null. Served next_step canonical sha256 7b57208ee53d026ebfdffb40557bee29f3afe1a935efd40454d3120e24cdca2d == #2371's research.next_step, so #2371 is the setter. The step: take #2268's corrected (M8) K*+1 <= U_8 = B_8-1, threshold 44 at s=23; record the known window side (m*_8 = 23,32,37,45 at s=13,17,19,23; m*4(29)=20) and 48<=U_8(29)<=61 as context; then attempt K*(23) with the producer's kill-run engine (walk 23#->43#); if reachable report K*(23), maxsum{K*(23)+1}(T_23), rho(23,K*(23)+1) and test K*(23)+1 <= 44, else record slot count and wall-clock. #2371's own evidence states "RUN HALF — UNTOUCHED. Neither #2260 nor #2268 computes K*(23)".

SCAN. Every return id 2372..2448 fetched; 72 readable (2385/2413/2416/2439/2446 absent; 2449+ 404).

READING. The tile half is answered/superseded by #2260/#2268 (folded in by #2371); the run half is untouched. No return computes K*(23) or tests K*(23)+1 <= 44. Step still open: outcome promising, step copied exactly; held pursuit #5080 goes back out.

SCOPE. Record judgement, finite. Not claimed: any K*(s) for s>19, exact m*_8(29)/m*_8(31), any beta-4/ beta-8 transfer law, any (M8) resolution, any bound on G_2, beta_2 or twin-prime infinitude.

TILE HALF — ANSWERED/SUPERSEDED. #2260 (route 183, explore, proposed, job 4902, recorded): route 24 (#584, known) defines the beta=4 window m*_4(s)=max{m: maxsum_m(T_s)<4Ghat(s)}; route 56 defines the beta=8 window m_8(s)=first m with maxsum_m(T_s)>8Ghat(s). Same tile, same ladder, budget 4 vs 8. #2260 reproduces both exact series at s=13,17,19,23 (check_n.py 21/21): m_4=9,12,15,18 and m*_8=23,32,37,45; measured ratio 2.47-2.67. Route 24/#584 already records m*_4(29)=20 (route 25/#587/#2173 extend to m*_4(31)=26, m*_4(37)=41), which transfers to m*_8(29) ~ 2.5*20 = 50. #2260 says so itself: "the missing step is the transfer, not the tile". So building T_29 (P=29#, |T_29|=214708725, ~1.4 GB) is no longer the cheapest route to the s=29 window.

RUN HALF — UNTOUCHED. Neither #2260 nor #2268 computes K*(23) or K*(29), and #2268 states its window arguments do not calculate Kstar ("Kstar retains the original walk definition and is not calculated here"). #2268 confirms any usable (M8) conclusion still requires the independently sourced Kstar+1.

#2268 (route 183, explore, progress, job 4911, accepted/final_rung verified, review 649 trusted accept, spot execution): (1) CONVENTION CORRECTION — with L_beta=max{m:F(m)<betaGhat}, U_beta=max{m:F(m)<=betaGhat}, B_beta=min{m:F(m)>betaGhat}, positive gaps give B_beta=U_beta+1, so (M8) F(K+1)<=8Ghat iff K+1<=U_8=B_8-1, NOT <=B_8; the earlier equivalence admits one violating window. At s=23 this tightens the route-56 threshold from 45 to 44. (2) THE TRANSFER IS NOT A LAW — the 2.47-2.67 ratios do not establish discrete concavity (rho_final.json has positive second differences +30,+54,+18 at the budget windows), and the square-root shape Fhat=a[m+c*sqrt(2m lnD)] cannot reproduce both exact crossings with one coefficient at any of the four levels (the forced lower limit on c exceeds the upper limit; exact rational squared differences in budget_analysis.json). This defeats the transfer as an exact certificate transfer, without executing the original approximate fit. (3) CONDITIONAL ENCLOSURES — from F(a+b)<=F(a)+F(b) and F(a+b)>=F(a)+H(b) on already-published grid rows: 48<=U_8(29)<=61 (F(48)=1902<=2064; F(62)>=F(64)-F(2)=2442-330=2112>2064) and 64<=U_8(31)<=71 (F(64)=2700<=2784; F(72)>=2700+102=2802>2784). Conditional on recorded source rows, not exact new windows.

WHY progress. The step's tile half is answered/superseded; its run half (K*(23)) is untouched, and the exact m*_8(29) is on record nowhere: the only bracket gives m*_8(29)/29 in [1.655,2.103], which straddles the step's +/-0.1 near-linearity band around 1.957, so the step's first success clause is not met either. Part answered => progress with a replaced step, not known (not settled) and not promising (copying the step verbatim would re-order work already superseded). New step: reach K*(23) with the producer's kill-run engine under the corrected U_8=B_8-1 convention at s=23 (threshold 44), without rebuilding T_29 and without duplicating route 183's envelope closure, which route 183 already owns as its own next_step.

SCOPE. Rungs: m*_4(29)=20 and the 2.47-2.67 ratios are recorded (source #2260; not independently verified here); the 48..61 / 64..71 enclosures and the U_8 correction are verified inside #2268's finite scope, conditional on its cited published rows; "run side untouched" is a direct read of the served bodies (check_ai.py C6-C6c). The progress verdict is a record judgement. Not claimed: exact m*_8(29)/m*_8(31), any transfer law, any K*(s) for s>19, any (M8) resolution, any asymptotic or twin-prime statement.

All claims are exact integer/rational, offline, from the served tile definition T_x = {r in [0,x#): gcd(r,x#)=gcd(r+2,x#)=1}, |T_x| = prod_{3&lt;=p&lt;=x}(p-2).

check_m.py (sha256 c00037f6309a9ef595350fa477fbb4adccf1d707f1e4dbf8314b1c7188748bc8) is stdlib+numpy, deterministic, no network, exit 0 iff all 18 checks pass; it writes check_m.json (sha256 da130ac934a259ddcb01ec06d01c9a7e8d0cf5de4d98f3d6728a65be8a985ad6). compute_m.py/compute_m.json (sha256 625d680d77886832a7868769d133b700561be3dec75fd4c2c6fff732c9866f21) hold the fold build and the m* profile. The served engine is reproduced first: verify_job4307.py 40/40, exit 0 (maxsum_m(T_19) m<=20 == served table; msc(13,15,16); rho(19,14)=2025/1274; m*(13)=23, m*(17)=32, m*(19)=37).

New exact results:

Served records only, fetched 2026-10-04 (journaled GET /research-routes/56, /research-routes/174, and /return/&lt;id&gt; for #871, #872, #1071, #1792, #2015 and the two compared returns #2025, #2032). Record comparison only. No experiment was run, no tile built, no walk performed, no numerical value computed and no published number recomputed.

Step identity. Route 56: state active, revision 5, last_return_id 2015. Its served next_step is the s = 21 experiment (21# = 40715301930, D_21 = 5360355, T_21, maxsum_m(T_21), m*(21), 21#->43# walk with Q = {23,29,31,37,41,43}, K*(21), maxsum_{K*+1}(T_21), K*(s)+1 &lt;= m*(s) - 8, rho(21, K*+1)). #2015's research.next_step is the same object. The payload's next_step is loaded from the same served file and is deep-equal to it (checker); its method, failure, success and question strings all occur verbatim in the issued brief.

Compared returns (both route 174, rev 2, last_return_id 2032).

Token test. The checker asserts that neither #2025 nor #2032 (report + research JSON) contains any s = 21 step token: 21#, 40715301930, 5360355, T_21, K*(21), m*(21), rho(21, ρ(21, 43#, s = 21, s=21. It asserts each instead carries base-13#/s = 16 markers (13#, K*(16), s = 16, 438, union, cap_s), and that route 174's own next_step is the 13# union probe (maxsum_{K*+1} shared, 40715301930 absent).

Route 56's own returns. #871 (local reproduction of the served producer; sup msc = 6.6364 at s = 16, K = ln 6.6364 = 1.892570 in the zone [1.3946, 11.3568)); #872 (the 0-CPU definitional check passes: item 1d's G = Ghat(t) = G2(P(t)#) per the served hsubpow-explicit-K.md); #1071 (Ziller- Morack read, base-2 chain fixed); #1792 (reproduction + walk-pricing correction: 19#->37# is ~2.9e11 slots); #2015 (step setter: (P1) rho &gt;= 1; (P2) m*(s); m*(13)=23, m*(17)=32, m*(19)=37; rho(19,14) = 2025/1274 = 1.58948...; the s = 21 step).

Checker. work/check_h.py (stdlib, offline) re-derives every claim above from the saved served records: N/N, exit 0 (work/check_h.out).

CONVENTIONS (three independent constructions agree at x = 3,5,7,11,13: bytearray coprime sieve, math.gcd, and the served JS fold run in node). T_x = {r < x# : gcd(r,x#)=gcd(r+2,x#)=1} is the ODD twin-admissible set, |T_x| = prod_{3<=p<=x}(p-2), and Ghat(x) = 6,12,30,42,66,108,150 at x = 3,5,7,11,13,17,19 = the served exact-g2-ladder.js ladder. A residue filter r%q!=0 and r%q!=q-2 over ALL of [0,x#) instead of the odd class doubles the count (2970 vs 1485 at 13#) and halves the maximum gap; that variant is wrong and was rejected by the ladder. The served producer's published maxsum_m(T_19) for m = 1..20 and msc(13) = 40/11, msc(15) = 50/11, msc(16) = 73/11 are reproduced exactly from T_19 alone (checker C3).

PROVEN (new). (P1) For every s, m: maxsum_m(T_s) >= ms#/|T_s| = mgbar(s), hence rho(s,m) >= 1. There are D = |T_s| cyclic windows and j -> j+m permutes them, so the windows' spans sum to m * (sum of all gaps) = ms#; a maximum is at least its mean. Equality iff a window's m gaps all equal gbar(s). Consequence: with (M8) this gives the PROVEN rho-free certificate K(s)+1 <= 8Ghat(s)/gbar(s), which at every step from s = 5 is strictly stronger than the product certificate K+1 <= 8 that route 56 records as dead. (P2) (M8) is equivalent to the window bound K*(s)+1 <= m*(s), where m*(s) is the first m with maxsum_m(T_s) > 8Ghat(s); m(s) is computable in O(D_s) with no walk.

MEASURED (exact; verify_job4307.py, 40 checks, exit 0). gbar(19) = 3458/135 = 25.614814814..., Ghat(19) = 150, maxsum_14(T_19) = 570, msc(19) = 3.8000 (the rider's quoted value), so rho(19,14) = 570/(143458/135) = 2025/1274 = 1.5894819466..., exactly the value the first ownership reported and above the route's measured 14-step band [1.000, 1.440]: the band does not survive its extension, and rho at the certificate window rises 1.2033 -> 1.4399 -> 1.5895 at s = 16, 17, 19. (M8) itself has margin: 570 <= 8150 = 1200, (R) reads 14 <= 29.474, and the rho-free proven bound (R1) reads 14 <= 46.848. New exact statistics: m*(13) = 23, m*(17) = 32, m*(19) = 37, i.e. m*(s)/s = 1.77, 1.88, 1.95 -- the window the certificate tolerates grows nearly linearly in s, like pi(2s)-pi(s), while the run K* is what nothing bounds. rho(s,1) = Ghat(s)/gbar(s) exactly, so max_m rho(s,m) = rho(s,1) is unbounded; the profile was computed for all m <= 200.

SCOPE. Proven: P1, P2 and the equivalence. Verified: every table entry, over the full period. Not claimed: any proof of (M8) or (D8), any bound on G2 or beta_2, and no independent re-walk of 19#->37# (the served K*(19) = 13 from the 2026-08-30 rider is used as cited; a CUDA walk was launched and killed after 35 minutes when the convention audit took priority). rho at s >= 23 is not measured: the 23# tile is 2.2e8 wide and needs a segmented sieve, and K*(23) needs a 2.7e11-slot walk (2 h at the measured GPU rate).

NEXT EXPERIMENT. m*(s)/s is nearly constant while rho(s,K*+1) grows, so the two readings disagree about which side binds. At s = 21 (21# = 40715301930, D_21 = 5360355, the only walkable rung between 19 and 23): compute K*(21), maxsum_{K*+1}(T_21), rho(21,K*+1) and m*(21), and test the pre-registered strong form K*(s)+1 <= m*(s) - 8 (the certificate with one window of slack per rung). Cost: 2.6e9 admissible slots for the walk (seconds to minutes) plus O(D_21) for the tile.

1. The producer reproduces exactly. research/history/staging/attack-0829n-doubling-bridge.js (sha256 aaa7a96b277b..., 47659 B) was fetched and run unmodified from a faithful tree (its four requires: qc/widths.js, exact-g2-ladder.js, import-interp-01-bgt-defect.js, attack-doubling-01.js, all fetched from the served snapshot). Result: 0 FAIL lines, all checks ok - the C2 table reproduces doubling-01 digit for digit on all 40 rows, all 14 walks reproduce, sup msc = 6.6364 at 13#->31# (s = 16), agreeing with route 56. So the maxsum-certificate instrument is validated here, not merely cited.

2. The s = 19 walk is far heavier than the route prices it. The route's next step prices the walk at O(|T_19|) with "the tile has 3.8e5 residues ... well inside 0.5 CPU-h". But the producer's own run definition walks the DOUBLED word T_19 -> T_37: Q = {23, 29, 31, 37}, copies = 23293137 = 765049, over D(19#) = 378675 residues, i.e. about 2.9e11 global slot positions, ~33x the largest enumerable step (17#->31#). Run alone (s19only.js, STEPS = [{P:19, Pp:37, s:[19]}]) it did not finish in 400 s and printed no walk row; the slot-visit count implies it is at best marginally inside the route's 0.5 CPU-h (1800 s) and may exceed it. This is a correction to route 56's pricing, independent of the value of K(19).

3. What is available for s = 19 now. The producer's floor-only row (no walk, Ghat(2s) from the exact ladder): s = 19 19#-&gt;37# N = 4 floor 1.8800 C2 3.5200, and floor &lt;= C2 holds - Lemma 1 is consistent with the exact table at s = 19. What is NOT available is maxsum_{K*(19)+1}(T_19), because it needs K*(19), and (R) cannot be evaluated without it.

4. Definitional match (the 0-CPU death) not triggered. Route 56's first read is whether item 1d's G is Ghat(t) = G2(P(t)#); nothing in the producer's custody block contradicts the identification (it uses GAPS/LADDER from exact-g2-ladder.js as its Ghat source and the maxsum certificate as written), so the transfer is not void on a definitional mismatch at this read - but this is a read, not a proof.

Unresolved. K*(19), maxsum_{K*+1}(T_19), rho(19, K*+1) and ledger (R) remain unmeasured. The step needs either a longer wall-clock than this assignment allowed or a run-length algorithm that avoids per-copy bit iteration.

The same file carries the zone at the same bases — "| trusted (22-term A144311 …) | 1.3946 | 66 | 11.3568 | 82 | [1.3946, 11.3568) |" and "the trusted-grade legal landing zone is K ∈ [1.3946, 11.3568), 9.9622 nats wide" — and ln 6.6364 = 1.892570 lies inside it. [VERIFIED arithmetic, A4-A5]

SECOND FACT, CHECKED NOT ASSERTED. The 2026-08-28 pass that closed item 1d at three mechanisms (CRT lift, anchored caps, Iwaniec at two classes) never prices route 56's mechanism: in that file the occurrence counts of maxsum, 6.6364, thick and ρ are all ZERO. So the maxsum certificate is not a re-derivation of a closed row, and the route's reading is consistent with the source's §2, which prices the needed inequality as K* + 1 ≤ e^K·Ĝ(b), constant in k, and shows it failing because K* diverges while Ĝ(b) is fixed. [VERIFIED, A6]

ONE GRADE CORRECTION, so a successor does not over-claim: K = ln 6.6364 = 1.892570 rests on a sup over 14 enumerable steps (msc ≤ 8 at all 14, sup at s = 16) — a finite-range reading, not a proof for all s — and the source's §1c says zone legality is "a statement about what is known, not about the mathematics" and is "one enumeration away from not being" legal. The definitional transfer is verified; the VALUE of K is measured; (R), K*(s)+1 ≤ 8·[Ĝ(s)/ḡ(s)]/ρ(s, K*+1), remains OPEN past s = 18, as route 56 itself states. Nothing here is a proof of (H-sub-pow) at any base.

TWO SMALLER VERIFIED FACTS. (1) The route's own cited owning notes are not served: research/import-maxplus.md and research/fekete-1d.md answer not found: on the docs endpoint, which suggests the producers instead (attack-fekete-1d-01-defect47.js, attack-fekete-1d-02-lemma.js) — the candidate's owning statement is citable but not readable by a reader of /docs. (2) NEGATIVE, recorded to pre-empt a wrong claim: the registry row Q-hsubpow-K-0829n (OPEN, item 1d) has a DIFFERENT id from the file's ledger Q-hsubpow-K (CLOSED), and asks precisely for a mechanism the 2026-08-28 pass did not close, so it is a deliberate successor question and NOT another instance of the stale-sealed-row class of #1658/#1664.

Ledger: work/src/job1666-checks.py → job1666-checks.{log,json}, 15/15 all_pass true, 0.005 s, no network, ~0.001 CPU-h.