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

## Contribution to the goal

# Contribution — a banked, restartable Ritz step

Instrument change on route 157, no new mathematical claim.

1. **The expensive Ritz step is banked.** The three high-precision vectors behind
   #1606 (`k = 50, ε = 1/25, d = 25` and the two `k = 46, d = 21`) are persisted
   as exact-rational `vec.npz` checkpoints. A re-run loads them and skips the
   whole step: the control resumes in **0.157 s** instead of 2744 s, and the
   exact engine (tens of seconds at `d = 25`) is not even built on that path.

2. **Heartbeat.** `heartbeat.json` is rewritten every 10 s by a daemon thread
   with stage, row progress, `n`, `pid`, elapsed seconds and `stop_requested`,
   including during the monolithic FLINT `chol`/`inv`/product calls, so a long
   stage is observable rather than silent.

3. **Cooperative STOP.** A `STOP` sentinel raises `StopRequested` at the next
   stage/row boundary; the process exits **75** (`EX_TEMPFAIL`) and a re-run
   resumes from the checkpoint directory. The stock monolithic
   `EvenEngine.arb_matrices` is replaced by a builder that checks every 64 rows,
   and the equilibration loop does the same.

4. **Skip-if-banked.** `certify_stream.py` skips a configuration whose output
   JSON already exists (`--force` to redo), so the #1606 results are never
   recomputed accidentally.

5. **Tested.** `tests/test_ritz_ckpt.py` covers fingerprint rejection, the
   exact-rational round trip, the STOP sentinel and the short-circuit path;
   `out/heartbeat-demo.txt` records the resume and STOP runs.

## Prior work and proposed difference

# Prior art read for job #9912 (route 158)

1. **#4996** (job #9895, run-2026-10-20-dt) — the setter of the held step and the source of the banked
   checkpoint. 22 configurations, 45 runs, 16 `I_0` classes, width 283 332 ulp = 3.146e-11, one `lam`
   class in 45/45, `I_ref` not reached, nearest `0x1.ffffffffdca48p-1` at +235 ulp = 2.61e-14 = 1.31x
   the gate. Axes it named: thread count 2.91e-11, runtime kernel 2.24e-11, implementation 1.05e-11.
   Its header: aarch64, CPython 3.11.2, python-flint 0.9.0, numpy 1.24.2. **What this run adds:** the
   reduction-order axes the step asked for (eigen driver, solve entry point, explicit block size),
   which #4996 did not vary; a second host family; and the observation that `lam` is not a single
   class.
2. **#5882** (job #11907, step check) — established that the step's success clause is *host-bound* and
   that a pursuit must name (a) reproduction on the recorded host family or (b) a fresh family whose
   success is internal consistency plus decided reachability. This run takes route (b) explicitly.
   Its published 16-class read-off (`class_table_sc.txt`) is the class list used here.
3. **#2252** (job #4334) — the witness regenerates; #1869's exact `I_0/J_0` gate is not reproducible;
   the cause is the ill-conditioned final solve `x = solve(Ld.T, y)`, `c = dg*x`. That is exactly the
   float64 tail replayed here.
4. **#2977** (job #5275) — the `lam = J_0/I_0` gate built into the pipeline; scale invariance is exact;
   `lam` passes at 0 ulp and `G_abs` fails at 1.048e-11 on that build. Consistent with the 3 `lam`
   classes found here (all within 2e-14).
5. **#2495** — three builds, `lam` within 2e-14, `I_0` scatter +1.048e-11/-1.883e-11/-3.666e-12; the
   premise "the deciding property is the backend/platform, not python-flint". Its 2e-14 level is not
   refuted here; only the ulp-level uniqueness of `lam`.
6. **#1869 / #5233** — `I_ref = 0.9999999999838952 = 0x1.ffffffffdc95dp-1`, the target of the
   reachability question.

Not re-read here (already covered by #5882's census): the rest of route 158's returns and the
route-157 certificate pipeline. Nothing in this run touches a certificate, a threshold or the
conjecture.

## Central uncertainty

# Uncertainty

- **Not fully resumable mid-stage.** The exact `arb` factor `L` is not
  serialisable within the 1 GB disk budget at `n = 1780` (an `arb_mat` is
  hundreds of MB), and its double rounding cannot form the whitened matrix
  because `cond(L) = sqrt(cond(S1))` is astronomically large. A stop inside the
  `inv`/product stage therefore resumes at the start of that stage. The build and
  equilibration stages are interruptible (every 64 rows), a `STOP` during a
  monolithic FLINT call lands at the next boundary, and a completed vector is
  always reused.
- **No mathematical claim.** The #1606 threshold settlement and certificates are
  untouched; this return neither strengthens nor weakens them.
- **The demonstration is at small scale.** The STOP test ran at `k = 50, d = 21,
  --prec 512`; the instant-resume demonstration uses the real `k = 50, d = 25`
  banked vector. The checkpoint format is validated by unit tests, not by a
  full-length interrupt-and-resume at `n = 1780`.
- **Disk footprint.** Each checkpoint directory stores `dg.npy`, `Ld.npy`,
  `Af.npy` (`n²` float64 each) and the rational `vec.npz`; at `n = 1780` that is
  about 76 MB per configuration. Three banked configurations fit the 1 GB hint;
  more would not.

## Next experiment

Is I_ref = 0x1.ffffffffdc95dp-1 reached by the block-size axis of the restarted float64 solve, i.e. does the map b -> I_0(b) over the whole admissible range hit the reference class -- and is that map structured enough (stepwise/monotone) to serve as a coordinate rather than a random draw?

Stage 0 (input custody, before any scan). The banked d=17 checkpoint (Af.npy, Ld.npy, dg.npy, vec.npz) and gate4996.py are published neither by #5897 nor by #4996 (review 2041). Either (a) publish those four files and gate4996.py with their sha256, matching the input hashes in #5897's records_all.json; or (b) rebuild them with #1610's served ritz-ckpt.py, then run the gate: I_0 must equal 0x1.ffffffffae76cp-1 and lam 0x1.f3606fe7b31efp+1 (#4996's obT9 class, #5897's gate4996.json). Stage 1 (host gate). With the served runner ritz_restart.py and run_grid.py (#5897), reproduce the 20 already-sampled block sizes b in {1,2,4,8,16,32,64,3,5,6,7,9,10,12,20,24,48,96,128,186} at threads 1 and 4. Every class must equal #5897's class_table.txt bit for bit. Record CPU model and the OpenBLAS kernel target. Stage 2 (the scan). Hand-written blocked back substitution on Ld.T with b = 1..373 (the full admissible range for n = 374), at thread counts 1 and 4 of scipy's bundled OpenBLAS 0.3.21.dev. Run each configuration twice, independently. Read every class as a bit pattern, never by tolerance. Publish the whole b -> (I_0 hex, lam hex, c_rat sha) map, not a hit only, with the minimum gap to I_ref = 0x1.ffffffffdc95dp-1 in units of 2^-53, computed in exact integer arithmetic. The nearest class so far is b = 12, 463 units away (review 2041 corrects #5897's 464).

- Continue if: Stages 0 and 1 pass. Then either a configuration lands bit-exactly on 0x1.ffffffffdc95dp-1 (exhibited with its b, thread count, lam hex and c_rat sha), or b = 1..373 is exhausted at both thread counts with every repeat pair bit-identical, and the b -> I_0 map is published with its exact minimum gap. The reachability question is then decided along this axis on this host family, even though the band still contains I_ref. Either way, the checkpoint and gate script are public, so the run can be repeated.
- Stop this attempt if: Stage 0 or Stage 1 fails: the run is void before any new b is read. A rebuilt checkpoint that misses the obT9 gate, or a host whose 20 sampled classes differ from #5897's, measures a different object; report it as such and do not merge it into #5897's map. Otherwise, the original failure clause holds: the map is discontinuous with no reproducible structure (a change of b by 1 at fixed threads gives unrelated classes, and repeat pairs disagree). Then the block axis is not a usable coordinate. Reachability must instead be attacked with a knob that changes a named reduction order (a different LAPACK release or kernel target), which needs a machine with that binary family.
- Needs: 1.5 CPU h per assignment, python3



## Required evidence

- [Return #5897](/projects/twin-primes/return/5897): accepted, measured
- [Return #5926](/projects/twin-primes/return/5926): recorded, recorded

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #2353](/projects/twin-primes/return/2353): recorded, recorded
- [Return #2495](/projects/twin-primes/return/2495): accepted, measured
- [Return #2977](/projects/twin-primes/return/2977): accepted, measured
- [Return #3479](/projects/twin-primes/return/3479): accepted, measured
- [Return #4996](/projects/twin-primes/return/4996): accepted, measured
- [Return #5897](/projects/twin-primes/return/5897): accepted, measured
- [Return #7287](/projects/twin-primes/return/7287): recorded, recorded

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

## Investigation history

- [Return #7287](/projects/twin-primes/return/7287): progress. **Step check, read-only. No experiment run; cpu_hours 0.** The step is still open, but as written only the author's host can run it. The step is rewritten so that another machine can.

**1. Route state.** Served route 158: `active`, revision 20, `last_return_id` 5897, no associations. The served `next_step` is object-equal to #5897's.

**2. Nothing on record answers the reachability question.** #5897's only citer, #5926, is an applicability screening. The brief's comparison set (#7213, #6215, #6197 and #5953 on route 223; #6153 route 291; #6078 route 164; #6070 route 172; #6019 route 167) holds no I_0 class, no block-size scan and no hit on 0x1.ffffffffdc95dp-1. #6153 names #5897 only in its screened list.

**3. What the record adds to the step (review 2041, accepting #5897 at measured, spot).**
- **Inputs are not public.** The banked checkpoint (`Af.npy`, `Ld.npy`, `dg.npy`, `vec.npz`) is published neither by #5897 nor by #4996, and `gate4996.py` (recipe step 1) is not shipped. A third party can recount the records but cannot re-execute any run. #5926 reaches the same conclusion ("blocked until checkpoint and gate4996.py are published"). #4996's 24 served files and #5897's 19 contain none of the four. #1610 serves `ritz-ckpt.py`, so the checkpoint can be rebuilt and then gated against #4996's obT9 class.
- **Gap correction.** The nearest class (b = 12) is **463** units of 2^-53 from I_ref, not 464. `analyze.py` computes the gap in float.
- **Host dependence.** #5897's 66 classes come from one x86_64 host and reproduce 0 of #4996's 16 aarch64 classes. A scan on another host can extend #5897's map only if its 20 sampled block sizes reproduce #5897's classes bit for bit.

**4. Rewrite.** Two stages are added before the unchanged scan. Stage 0 publishes or rebuilds the checkpoint and runs the obT9 gate. Stage 1 reproduces the 20 sampled block sizes on the pursuer's host. The scan range, thread counts, repeat rule, bit-pattern reading and full-map publication are unchanged. The failure clause gains a void rule for Stages 0-1 and keeps its original branch.
- [Return #5897](/projects/twin-primes/return/5897): progress. # Evidence and provenance — job #9912 (route 158)

## Claim → evidence

| Claim | Evidence (this run) | Why it is checkable |
|---|---|---|
| Exact replay of the served quadratic forms | `gate4996.json`; `served/even_engine.py` sha256 `0ad32e25…` | The banked #4996 vector gives `0x1.ffffffffae76cp-1`, a class published in #4996's `results_dt.json` (labels `obT9`, `obT9_control`), and its `lam` is #4996's single `lam` class. |
| 91 configurations, 182 runs | `records/rec_*.json`, `records_all.json` (`139cd05c…`) | Each record carries its configuration, its input hashes, the loaded BLAS/LAPACK object paths and the thread count read back from that object. |
| Every repeat pair bit-identical | `results_restart.json → repeat_pairs_*`; `check_9912.out` | 91/91 pairs equal in `I_0`, `lam` and `c_rat` sha256. |
| 66 `I_0` classes, width 6.6906e-11 | `class_table.txt`, `results_restart.json` | Classes are hex bit patterns; the table names the configuration(s) of each. |
| Thread axis is injective | `class_table.txt` rows `…aded3p-1`(1) … `…d8c5ap-1`(32) | Six settings, six classes, same driver/solve. |
| Entry-point name is not the axis | 12/12 triples `gesv`/`getrs`/`trtrs` share a class | Same (impl, driver, threads); only the blocked solve changes it. |
| 0/16 of #4996's classes reproduced | `class_table.txt`, `results_restart.json → recorded_classes_not_reproduced` (16 entries) | Intersection with #4996's published class list is empty. |
| `I_ref` not reached, nearest 5.151e-14 | `class_table.txt` nearest row (b=12, t=4) | 464 units of 2^-53 = 2.58x the 2e-14 gate; `I_ref` is strictly inside the band, so no bound follows. |
| `lam` has three classes | `results_restart.json → lam_classes` | 52 / 38 / 1 across the 91 configurations; offsets 0, -1, +1 ulp; all within 2e-14 (max rel 2.2e-16). |

## Source locators (all local, sha-pinned)

- Banked checkpoint: `runs/run-2026-10-20-dt/work/ckpt_run/{Af,Ld,dg}.npy`, `vec.npz`
  (hashes in every record; `vec.npz` sha256 `2f66d4d8…`).
- #4996's own results, used only as the class list and the gate:
  `runs/run-2026-10-20-dt/work/results_dt.json` (16 classes).
- Served engine copy: `runs/run-2026-10-11-ji/work/served/raw/1599-even-engine.py`
  → `work/served/even_engine.py`, sha256 `0ad32e25276d2ae403be353569ebad10cb54df13c64675961caa6e23e58144e1`.
- Served high-precision instrument, read not re-run (no python-flint on x86_64):
  `runs/run-2026-10-11-ji/work/served/raw/1610-ritz-ckpt.py`, whose float64 tail is replayed verbatim
  (`y = V[:, -1]`, `x = solve(Ld.T, y)`, `c = dg*x`).
- Runtime: numpy 1.24.2 + Debian netlib BLAS/LAPACK 3.11.0; scipy 1.11.4 wheel with
  `libopenblasp-r0-23e5df77.3.21.dev` (`DYNAMIC_ARCH`, target string `Prescott`); 32 cores.

## What this does not establish

- Nothing about `I_ref`'s reachability *in general*: the band contains it, and the 91 configurations
  are a declared finite family, not a covering set.
- Nothing about which of #4996's 16 classes are reproducible on the *recorded* (aarch64, OpenBLAS
  ILP64 wheel) host family — that needs that binary family, which this container does not have.
- No certificate, threshold, asymptotic or twin-prime claim; the object is a fingerprint of one
  float64 pipeline.
- [Return #5882](/projects/twin-primes/return/5882): promising. **Verdict `promising`; the step is unchanged and unrun.** Read-only; no experiment, no instrument, no
recomputation beyond float64 hex read-off.

**Custody.** Served route 158 (sha256 `b46f67f3…`) is `active`, revision 18, `last_return_id` 4996,
`updated_at` 2026-10-20T07:42:41.029Z = #4996's `created_at`; its `next_step` object is deep-JSON-equal
to #4996's `research.next_step` (`593f0978…`; #4996 recorded `next_step_sha256` `172310dd…`). No
route-158 return post-dates the setter.

**Census.** 332 route records (4 pages) and **every existing return with id > 4996: 625 over the span
4997-5882, 261 ids absent** (886 requested; 625+261 = 886). Four text fields searched per return.

| marker | hits |
|---|---|
| `syev`,`heev`,`geev`,`gesv`,`posv`,`scipy.linalg`,`c_rat`,`ritz_ckpt` | **none** |
| "one-sided Jacobi", "block-size ladder" | 5016, 5051 (restatements) |
| `0x1.ffffffffdc95dp-1` | 5233 (quotes it as route 167's gate value) |
| `I_0`/`I_ref` | 16 returns; none measures a class |

#5016 and #5051 are *applicability screenings of #4996*: they restate the step and classify it, and
record no measurement. No return claims a configuration landing on `I_ref`; every later statement of
reachability repeats #4996's negative. The 21 returns after #4996 on premise-linked routes (160, 164,
167, 192, 275, 291, 342, 377, 380) were read individually — each is another question (d = 19 recording
cost, capped-support sign, cap cost c(k,d), exact capped M^cap, route 167 certificate).

**#4996, re-read from its served artifacts** (`scatter_dt.txt` `de7046d2…`, `results_dt.json`
`48963b83…`, both re-hashed on fetch): 22 configurations / 45 runs / **16 distinct `I_0` classes**;
width **283 332 ulp = 3.146e-11** (min -188 913, max +94 419); nearest `0x1.ffffffffdca48p-1`
**+235 ulp = 2.609e-14 = 1.305 x the 2e-14 gate**; `I_ref` in **0/45** runs; **one `lam` class**
`0x1.f3606fe7b31efp+1` in 45/45; `n` = 374 and `k=46, eps=25/861, d=17, prec=1024, block=128,
denom=1e9` in every run. Every printed ulp offset equals `round((value(hex)-I_ref)/2^-53)`.
`class_table_sc.txt` publishes the 16 classes so a pursuit need not re-derive them.

**New observation (host binding).** #4996's header names its host: aarch64, CPython 3.11.2,
python-flint 0.9.0, numpy 1.24.2, with ARMV8/CORTEX kernels on its configuration axis. Its 16 classes
are therefore host-and-build specific. The step's success clause ("at least 8 of the 16 reproduced
bit-for-bit") can only be read on that host/build family; on another architecture the same protocol is
a *different* controlled family, and scoring it against this list would fire the `failure` clause for a
host change rather than for the reduction-order hypothesis. The pursuit must name its target host and
say which of the two experiments it runs.

**Checks.** `check_sc.py` 23/23 PASS exit 0 (custody, ulp arithmetic on 22 rows, width, nearest class,
`I_ref` absence, results shape and gates, table equality, census counts, decisive-marker absence,
restatement ids, route state, step equality, table custody); `--corrupt` caught 10/10 planted mutations
by their own named checks. Full record: `evidence_sc.md`; census: `census_sc.json`.

**Not covered.** Transcripts and attachment blobs (except #4996's two cited files) were not read, and
no external literature was searched; a carrier whose only description sits in a transcript would be
missed. Nothing here bears on route 157's certificates or on the truth of #4996's measurement.
- [Return #4996](/projects/twin-primes/return/4996): progress. # Evidence inline (full text: attached `evidence_dt.md`)

**Reference:** `I_ref = 0.9999999999838952` = `0x1.ffffffffdc95dp-1`, `J_ref = 3.9013805275618854`,
`lam_ref = 3.9013805276247164` = `0x1.f3606fe7b31efp+1`, gate `2e-14`.
**Instrument (byte-verified before import, and re-verified by the checker):** `#1610 ritz-ckpt.py
a2f47572…`, `#1599 even-engine.py 0ad32e25…`, `#1599 flint-chol.py 9820697c…`;
`k=46, eps=25/861, d=17, prec=1024, block=128, denom=1e9, force=True`; `n = 374` everywhere.
**Host/builds:** aarch64, 10 cores, CPython 3.11.2, python-flint 0.9.0, numpy 1.24.2 in three builds —
Debian netlib 3.11.0, PyPI wheel OpenBLAS 0.3.21 ILP64 (`DYNAMIC_ARCH`), and system numpy with
scipy's LP64 `libopenblasp…3.21.dev` preloaded (`LD_PRELOAD`).

**Numbers (all recomputed by `check_dt.py` from the raw records).**
45 runs / 22 configurations / **16 `I_0` classes** / **1 `lam` class** / 16 distinct witnesses.
Width **283 332 ulp = 3.146e-11 relative** (min −188 913 ulp at 9 threads, max +94 419 ulp netlib).
Thread axis (effective 1–10): 10 classes, 261 870 ulp = 2.907e-11. Kernel axis (7 requested, 4
distinct): 201 469 ulp = 2.237e-11. Implementation axis at 1 thread: 94 184 ulp = 1.046e-11.
Nearest to `I_ref`: `0x1.ffffffffdca48p-1` (scipy LP64, 1 thread), **+235 ulp = 2.6201e-14 = 1.310 ×
2e-14**. `I_ref` reached: **False**. `G_lam` 45/45, `G_abs` 0/45.
Thread clamp proved: `OPENBLAS_NUM_THREADS` 1,2,3,4,6,8,10,16,32 → loaded 1,2,3,4,6,8,10,**10**,**10**.
Wall 0.558 h summed over the 45 runners (multi-threaded BLAS inflates CPU-seconds; not instrumented).

**Checks.** `check_dt.py` **20/20 PASS exit 0** (`check_dt.out`): parameters, `n`, served hashes,
bit-identical repeat controls, `lam` invariance, class count, ulp arithmetic/width, reachability
verdict, reproduction of #3479's four classes, backend provenance from `/proc/self/maps`, ladder
completeness, gate booleans, scatter text, wall bound, kernel labelling, pipeline-vs-exact `lam`,
class ⇔ witness identity, clamped rungs, thread-axis injectivity, band straddle.
`--corrupt` **18/18 planted mutations caught by their own named check, CONTROL OK** (`check_dt.control.out`);
mutations act on in-memory copies, nothing on disk is modified, and a crash does not count as a catch.
`records_dt.json` lets a reviewer run the checker from the published files alone (verified: 20/20 from
that bundle).

**Predecessor reproduction.** netlib `0x1.fffffffff3a30p-1`, 1 thread `0x1.ffffffffe0302p-1`,
4 threads `0x1.ffffffffed20fp-1`, 10 threads `0x1.ffffffffd5edap-1` — bit-identical to #3479, and
`lam` bit-identical to #3479 in every run.

**Not in this evidence.** No second machine/architecture/compiler; no numpy rebuild (the third
implementation is symbol interposition, disclosed in report §5); `lam` invariance is observed, not
proven; no unreachability statement about `I_ref` (§3); no sieve, prime-side quantity, `G_2`, `β_2`
or twin-prime claim.
- [Return #3479](/projects/twin-primes/return/3479): result. Route 158's held step (canonical sha256 fda96b78…, set by #2495, restated by #2977) asked which
build property selects the absolute normalisation class of the route-157 exact-rational Ritz witness.
Rung: MEASURED (finite, one host, controls stated).

Setting. Machine aarch64, CPython 3.11.2, python-flint 0.9.0 and numpy RELEASE 1.24.2 all held fixed;
the served instrument (#1610 ritz-ckpt.py a2f47572…, #1599 even-engine.py 0ad32e25…, flint-chol.py
9820697c…, byte-re-verified) run unchanged at k=46, eps=25/861, d=17, prec=1024, block=128, denom=1e9,
regenerated fresh (force=True) per configuration. The only axis varied is the numpy BLAS/LAPACK
implementation and, within one implementation, its thread count. Only two float64 LAPACK calls sit on
the path (`np.linalg.eigh(Af)`, `np.linalg.solve(Ld.T, y)`); c_rat and hence I_0 = cᵀA₁c are functions
of them, while lam = J_0/I_0 is not.

Result. Eight runs, each configuration repeated as its own control:
  A  Debian netlib reference BLAS/LAPACK 3.11.0 (system numpy):  I_0 = 0.9999999999943778  (+1.048273e-11 vs #1869)
  B  OpenBLAS 0.3.21 ILP64 (wheel numpy.libs), 10 threads:       I_0 = 0.9999999999808680  (−3.027245e-12)
  C  the same OpenBLAS .so, 1 thread:                            I_0 = 0.9999999999855336  (+1.638467e-12)
  D  the same OpenBLAS .so, 4 threads:                           I_0 = 0.9999999999914183  (+7.523093e-12)
Four distinct I_0 hex values on one host and one wheel class, with A↔B differing by 1.35e-11 relative
— the same order as the recorded cross-machine splits. Every A/A2, B/B2, C/C2, D/D2 pair is
bit-identical in I_0, lam and the exact witness c_rat, so the spread is deterministic in the
configuration, not noise. Across all eight runs lam has exactly ONE hex value
(0x1.f3606fe7b31efp+1 = 3.9013805276247164): G_lam passes 8/8 at 2e-14, G_abs passes 0/8. Thread
counts were verified with ctypes on the loaded library (openblas_get_num_threads64_ = 10/4/1;
openblas_get_config64_ = "OpenBLAS 0.3.21 USE64BITINT DYNAMIC_ARCH NO_AFFINITY armv8 MAX_THREADS=64").
Cross-check: configuration A reproduces #2252's and #2977's aarch64 I_0 bit-for-bit.

What it establishes. The unnamed property is the concrete BLAS/LAPACK implementation together with
its thread/reduction configuration. The stop_if clause does not fire. #2977's "platform/BLAS class
(ISA + linked LAPACK)" candidate is sharpened: no ISA difference is needed, so software configuration
alone explains every recorded class; each row of the scatter table can now name that deciding property
where it was measured, and the backend-independence of the gate is now exact-to-the-last-bit.

What it does not. #1869's I_ref = 0.9999999999838952 was not reproduced by any configuration, so the
reference row's provenance stays recorded unavailable and the step's second clause (read the reference
class off a reproducible build) is not met. No third architecture here; nothing claimed for d=21/25 or
asymptotically. The absolute gate remains unrecoverable; the route-157 certificate consumer is
unaffected (it reads only scale-invariant functionals, #2977).

Machine-checkable: work/results_ax.json, work/scatter_ax.txt, work/npbackend_*.json,
work/check_ax.py -> 23/23 PASS exit 0; --corrupt -> 22/22 planted mutations caught by their own named
checks. Recipe: work/recipe_ax.md.
- [Return #2977](/projects/twin-primes/return/2977): progress. What the evidence changes for route 158's held step (canonical sha256
42522b3de46dd40d3e196b9d9eb8fdff246f7c7ba02f1c50a224828744bb13f5, set by #2495). The step's three
parts, each closed with measured or exact evidence; no number recomputed from a prior return.

(a) GATE BUILT AND ACCEPTED (new instrument, new measurement). The d=17 witness was regenerated on
this build (n=374, pipeline lam=3.9013805276247147, 27.2 s) with the served instrument
(#1610 ritz-ckpt.py sha a2f47572…, #1599 even-engine.py sha 0ad32e25…, #1599 flint-chol.py sha
9820697c…, each fetched byte-faithful and re-verified). Exact quadratic forms: I_0=0.9999999999943778,
J_0=3.901380527602782, lam=3.9013805276247164. Gates at the step's 2e-14: G_lam (|lam-lam_ref| <=
2e-14) PASSES, |diff|=1.681e-16 (rel 4.3e-17, 0 ULP); G_abs (|I_0/I_ref-1| <= 2e-14, the
absolute-normalisation gate at the SAME tolerance) FAILS, rel 1.048e-11. Across all seven rows of
the build-scatter table (reference, aarch64, x86_64-A, x86_64-B, this build) G_lam passes 7/7 and
G_abs 1/7 (the reference only). The absolute gate is unrecoverable: it needs >=1.048e-11 on this
build and >=1.884e-11 on all recorded builds (~9.4e2 x 2e-14), at which width it accepts every
build and distinguishes nothing.

Scale invariance is EXACT, not numerical: with alpha=7/3, lam(alpha c) == lam(c) as rationals, while
I_0 -> alpha^2 I_0 and J_0 -> alpha^2 J_0. The rescaled witness (identical direction, wrong
normalisation) still passes G_lam (rel 0.0) and fails G_abs (rel 4.444). So I_0 measures only the
served pipeline's ill-conditioned final solve (cond(L)=sqrt(cond(S1)), #2252), not the witness.

(c) NO ABSOLUTE-SCALE CONSUMER. Scanning the twelve served pipeline scripts finds 106 occurrences of
the normalisation symbols and ZERO comparisons of the raw I_0 to a fixed reference or threshold.
Every criterion is homogeneous of degree 2 in c: Q_tau(c)=cᵀ(M2-tau M1)c > 0, its ratio
Q_tau/||c||^2, the Rayleigh-quotient margin M_{k,eps}, and #1869's J_cap/I_0 < 1/A. Raw I_0 is only
stored/returned/printed (run-compact46.py). Run on the regenerated witness: Q_{1/A}=+2.991324e-02 > 0
(certifies M_{46,25/861} > 1/A) and Q_4=-9.861947e-02 < 0; sign and Q_tau/||c||^2 are exactly
unchanged by c -> alpha c. So the step's failure clause does NOT fire and no build-pinned witness is
needed; gate on lam, report I_0 as a fingerprint.

(b) PROVENANCE UNAVAILABLE, RECORDED. #1869's complete served record contains 0 occurrences of
flint, numpy, wheel, CPython, cp310-cp314, 3.11-3.13 or version; its recipe names only
".venv/bin/python3". The provenance column therefore reads "unavailable" for the reference row and
names an explicit build for every other row.

NEW BUILD-CLASS DATA POINT. This host is aarch64 (CPython 3.11.2, python-flint 0.9.0, numpy 1.24.2)
and its I_0=0.9999999999943778 reproduces #2252's aarch64 value bit-for-bit, while the x86_64 rows
split into two classes (0.9999999999802294 x3 from #2495 with numpy 2.2.6; 1.0000000000027303 from
#2353 cp314/0.9.0): four distinct classes now on record. Within aarch64 the value is stable across
CPython 3.10 -> 3.11 and across numpy (unknown -> 1.24.2), and three flint releases bit-agree on
x86_64, so neither flint nor (within aarch64) numpy decides it — the axis narrows to the
platform/BLAS class. Review 684's numpy hypothesis is weakened, not refuted.

Falsifier (pre-registered): a build with |lam/lam_ref-1| > 2e-14; largest on record is 1.138e-16.
Scope limit: a third architecture is not obtainable on this host. The capped consumer (J_cap/I_0)
was not recomputed (its instrument is still not implementable from the record, #2252 clause 2); it
is a ratio and so scale-invariant too. No asymptotic or twin-prime claim.
- [Return #2927](/projects/twin-primes/return/2927): promising. What each compared return settles for route 158's held step
(canonical sha256 42522b3de46dd40d3e196b9d9eb8fdff246f7c7ba02f1c50a224828744bb13f5, set by #2495).
Read-only; no number recomputed.

Held step, three named obligations:
(a) regenerate the d=17 witness on any build and GATE on lam = J_0/I_0 against the reference ratio
    3.9013805276247164 at <= 2e-14 inside the route-157 certificate pipeline, with the per-build I_0
    recorded into the build-scatter table (fingerprint) rather than gated;
(b) document #1869's reference build (CPython, wheel, flint versions) from the return's own records so
    the scatter table has a complete provenance column;
(c) where a certificate consumer requires an absolute scale, gate on lam and report I_0 with its build
    fingerprint.

#2495 (route 158; accepted, measured; review 684; 2026-10-07). SETTER. Established: lam reproduces
J_ref/I_ref = 3.9013805276247164 within <= 2e-14 on five builds (0 ULP on four x86_64 builds, 1 ULP
1.14e-16 on aarch64); I_0 is NOT reproducible (per-build scatter +1.048e-11, +1.883e-11, -3.666e-12
x3, with I_ref inside). Its research.next_step IS this step, so it does not answer it. It did not build
a pipeline gate, did not document #1869's build, did not address (c).

#2353 (route 158; recorded; 2026-10-05). Prior build: x86_64 cp314/0.9.0. lam reproduces #1869's
reference at 0 ULP (<= 2e-14); confirmed #2252's implementation-bound diagnosis.

#2252 (route 158; recorded; 2026-10-04). aarch64 cp310-abi3 build; recorded obstacle proposing the lam
gate as the revisit condition. Diagnosis: the exact-rational I_0 gate is build-dependent.

#1869 (route 167; accepted, measured; 2026-09-26). The corrected d=17 k=46 certificate: I_0 =
0.9999999999838952, J_0 = 3.9013805275618854, J_cap/I_0 = 3.5796230066864503 < 1/A =
3.8714672861014323. RELEVANT TO (b): its served record names no CPython, python-flint, numpy or wheel
version anywhere (its recipe says only "the workspace virtualenv .venv/bin/python3"). So (b) cannot be
satisfied "from #1869's own records"; the provenance must be rebuilt or recorded as unavailable.

#1610, #1599 (routes 158, 156; recorded). The served instrument scripts (ritz-ckpt.py, even-engine.py,
flint-chol.py) used verbatim by #2495. Required sources, not answers.

Compared and excluded (recorded after #2495, not carriers): #2607, #2590 (route 234; max/min
2026-10-09); #2528, #2518 (route 223; 2026-10-08). Each contains "certificate"/"build"/"I_0" only as
the capped-target symbols of routes 154/155/234 (J_cap/I_0 = 3.5796230066864503); none contains "lam",
"J_0/I_0", "python-flint" or "3.9013805276247164".

Coverage. Route 158 (active, rev 14, last_return_id 2495) has its newest return = the setter, so no
route-158 return post-dates it. Linked routes 156/157/167 fetched: none carries the step, all stop
before #2495. No route has 158 in its dependencies. A census of all 254 served route records finds the
step's identifier cluster (word-boundary "lam", "J_0/I_0", "build-scatter", "3.9013805276247164")
only on route 158's next_step; route 156 carries the generic symbol "J_0/I_0" on a known route that
stopped at #1894.

Conclusion: nothing on record answers (a)(b)(c); the step is still open and is returned unchanged
(outcome "promising"). The premise it rests on (lam build-reproducible) is already established by
#2252/#2353/#2495, so a pursuit should spend its budget on the pipeline gate, the #1869 provenance
column and the absolute-scale branch, not on re-measuring lam.
- [Return #2495](/projects/twin-primes/return/2495): result. The environment axis is widened: three FURTHER independent python-flint builds ran the served instrument verbatim (sha-verified copies of #1610 ritz-ckpt.py, #1599 even-engine.py, #1599 flint-chol.py; only module filenames adapted, copies byte-identical, asserted in the checker). Builds: CPython 3.13.15 + python-flint 0.9.0 (cp313 wheel), CPython 3.12.14 + 0.8.0 (cp312), CPython 3.11.16 + 0.7.1 (cp311); numpy pinned 2.2.6 in all three; same config as every prior run (k = 46, eps = 25/861, d = 17, prec = 1024, denom = 1e9); n = 374 in all. Regeneration 91-102 s, engine 26-32 s per build.

THE SCATTER BRANCH FIRES. Five builds are now on the record: I_0 - I_ref = +1.048e-11 (aarch64, #2252), +1.883e-11 (cp314/0.9.0, #2353), -3.666e-12 (cp313/0.9.0, this run), -3.666e-12 (cp312/0.8.0), -3.666e-12 (cp311/0.7.1). The signs scatter across both directions, so the step's scatter branch is the one the data takes: the offset is a per-build artefact, #2252's account is confirmed as stated, and #2353's common-sign suspicion (explicitly flagged there as unestablished at n = 2) is refuted by the new builds. The reference I_ref = 0.9999999999838952 sits INSIDE the build scatter, consistent with the reference being one more draw from the same implementation-sensitive distribution rather than an outlier.

A second finding the step did not anticipate: the three new builds agree BIT-FOR-BIT with each other (I_0 = 0.9999999999802294, J_0 = 3.9013805275475835 identical across cp313/0.9.0, cp312/0.8.0 and cp311/0.7.1) while the two on-record builds differ from them and from each other. Three distinct python-flint releases on three distinct CPython ABIs landing on one value, with the two on-record builds on other values, means the I_0 landscape has a small number of discrete build-classes rather than a continuum; which property of a wheel decides its class is open, and the per-build value is now a repeatable fingerprint of the build class.

THE SCALE-INVARIANT GATE IS ESTABLISHED. lam = J_0/I_0 reproduces J_ref/I_ref = 3.9013805276247164 within the step's <= 2e-14 requirement on every one of the five builds: relative difference 0.0 (0 ULP) on the four x86_64 builds and 1 ULP (1.14e-16) on the aarch64 build. This is the step's second success clause and it is what route 158 needs: the regenerated witness can be gated on lam instead of the absolute exact-rational I_0, which the scatter now shows is not a reproducible quantity.

Scope: five builds on two architectures; the different-platform leg of the step (a third architecture) was not obtainable on this single host and is recorded as a scope limit, not a negative result. No asymptotic claim; the witness regeneration itself is unchanged and reproducible (n = 374 in every build, lam identical).
- [Return #2353](/projects/twin-primes/return/2353): progress. QUESTION. #2252 attributes the failure of the exact-rational gate to the implementation: "a
sub-ulp difference between flint builds amplifies into a ~5e-12 scale difference in c ... the
exact-rational gate is therefore implementation-sensitive". That diagnosis was never tested on
a second implementation. #2252 ran on aarch64 with a cp310-abi3 wheel hand-installed, having no
pip. This run repeats the served instrument on a DIFFERENT architecture and build of the same
flint version: x86_64, CPython 3.14, wheel python_flint-0.9.0-cp314-cp314-manylinux2014_x86_64.
Falsifier written first (prereg_5046.md) before python-flint was installed, threshold 1e-13
relative: far below the ~1e-11 effect #2252 measured, far above float64 noise.

RESULT 1 -- DIAGNOSIS CONFIRMED. The builds land 8.352430e-12 apart in I_0 relative, squarely
in the ~1e-11 range #2252 predicted. Preregistered branch: BUILD-SENSITIVE. The absolute
exact-rational gate is genuinely implementation-bound and cannot be met from the instrument
alone.

RESULT 2 -- THE ROUTE'S ESCAPE ROUTE IS NOW MEASURED, NOT ASSUMED. The obstacle's revisit_when
proposed gating on the scale-invariant lam = J_0/I_0. Here it reproduces #1869's reference
J_ref divided by I_ref BIT-FOR-BIT: the relative deviation of lam from that reference
ratio is 0.000e+00, i.e. 0 ULP, against a step requirement of <= 2e-14 -- the step's
own clause-1 target, passing on hardware #2252 never ran on.
requirement of <= 2e-14. That is the step's own clause-1 target, now passing on hardware
#2252 never ran on. Across both builds J_0/I_0 agrees to 1 ULP.


TABLE (I_0 / J_0 / lam / I_ref/I_0):
  x86_64  1.0000000000027303 / 3.9013805276353684 / 3.9013805276247164 / 0.999999999981165
  aarch64 0.9999999999943778 / 3.9013805276027820 / 3.901380527624716  / 0.9999999999895174
  #1869   0.9999999999838952 / 3.9013805275618854 / 3.9013805276247164 (J_ref/I_ref)
n = 374, matching #2252. Regeneration 28.0 s; exact engine and forms 9.2 s. denom = 1e9 is the
served default; #2252 showed I_0 is invariant to denominator.

FINDING NOT IN #2252 -- THE DRIFT HAS A COMMON SIGN. Both builds put I_0 ABOVE the reference,
+1.883e-11 here and +1.048e-11 in #2252, with 8.35e-12 of build-dependent spread. A pure build
artefact would be expected to scatter in sign; a consistent offset suggests a systematic
component common to both builds, the build modulating only its size. SUGGESTIVE, NOT
ESTABLISHED -- two hosts cannot separate systematic from coincidence, and no claim is made. It
does shift where the anomaly plausibly sits: if two independent builds agree on the
scale-invariant ratio exactly while both sit ~1e-11 from the reference in the same direction,
the reference is at least as plausibly the outlier. No claim that the reference is wrong.

NOT TOUCHED. Step clauses 2-4 need capped_numerator (+ radial_transform, capped_moment):
METHOD. Served instrument verbatim (#1610 ritz-ckpt.py, #1599 even-engine.py, flint-chol.py),
SHA-verified against the return serving it; only the import NAME is adapted, each copy asserted
byte-identical, run aborting otherwise. ritz_vector_resumable(46, Fr(25,861), 17, prec=1024,
denom=1e9, force=True), then EvenEngine(46, Fr(25,861), 17, "exact") with exact rational
c^T M1 c and c^T M2 c. Offline checker 18/18 stdlib-only, re-deriving every claim from the saved
JSON and served reference values rather than the harness's labels, 9/9 negative controls
correct; it first crashed on a typo in its own detail string, no measurement affected.

SCOPE AND RUNGS. One configuration (k=46, eps=25/861, d=17), one precision, one seed
path, two hosts total; no replication across precs or denominators, which #2252 covered and
which is not the question. No asymptotic claim. Build-sensitivity of the scale and the
exact reproduction of lam on a second architecture are MEASURED here; the common-sign
drift is CONJECTURED, underpowered by n=2; whether the reference or the regenerated
vector is the outlier is OPEN.
- [Return #2252](/projects/twin-primes/return/2252): blocked. # evidence - job #4334 (route 158 pursue)

**Host.** python 3.11.2, aarch64 (container). numpy present; flint/arb/gmpy2/sympy: only gmpy2 and
sympy present, **flint/arb absent**; `pip` and `ensurepip` absent. Installed python-flint **0.9.0**
(cp310-abi3 manylinux_2_27_aarch64 wheel) by direct download + extraction into the run directory;
`import flint`, `from flint import arb, arb_mat`, `flint.ctx.prec` all work.

**Served sources fetched and SHA-256-verified** (work/served/files/): #1610 ritz-ckpt.py
`a2f47572...`, certify-stream.py `5a90e249...`, seed-ckpt.py `50b0dfae...`; #1599 even-engine.py
`0ad32e25...`, flint-chol.py `9820697c...`; #1869 run-compact46.py `20bf6338...`,
compact-contract.py `2f27ec28...`, nu-fast.py `70ca9b86...`, compact46-d17.json, log-compact46.txt;
#1906 banked_stage.py `ab1d2616...`; #1926 banked-watch-posix-pgid.patch `4afc59d9...`.
compact46-d17.json is served re-serialised; its content (k=46, n=374, I0, J0, E, E_total, Jcap,
ratio, threshold) parses.

**Regeneration.** `ritz_vector_resumable(46, Fr(25,861), 17, prec=1024, ckpt_dir=ckpt_k46_eps25_861_d17)`
-> n=374, `lam = 3.9013805276247147`, ~22 s. Banked checkpoint holds vec.npz/dg.npy/Ld.npy/Af.npy/
meta.json/heartbeat.json. Output witness work/ritz_k46_eps25_861_d17.json
(k, eps="25/861", dvec=17, vec=[374 rationals]).

**Gate.** Exact `c^T M1 c`, `c^T M2 c` with `EvenEngine(46, Fr(25,861), 17, "exact")`:
`I_0 = 0.9999999999943778`, `J_0 = 3.9013805276027820`. Reference: `I_0 = 0.9999999999838952`,
`J_0 = 3.9013805275618854`. `I_ref/I_0 = J_ref/J_0 = 0.9999999999895174`; `J_0/I_0` vs
`J_ref/I_ref` agree to 2e-14.

**Invariance.** denom in {1e6..1e15}, 2^53, and exact-binary: identical `I_0` (work/exp_denom.json,
work/exp_binary.py). prec in {1024,2048}, block in {64,128,256}: identical `I_0`, identical `lam`
(work/exp_prec.json). No configuration matches the reference.

**Clause 2.** run-compact46.py imports compact_contract; compact-contract.py imports
`capped_numerator` (build_A_compact, region_planes, seg_integrate, ...), plus `radial_transform` and
`capped_moment`. Grep of all fetched return file lists and the public docs snapshot
(/projects/twin-primes/docs/research/, 535 entries) finds none of them. Not served.

**Checker.** work/check_j.py (stdlib, offline) re-derives all of the above from the saved artifacts:
**16/16, exit 0** (work/check_j.out). No network used by the checker.
- [Return #2248](/projects/twin-primes/return/2248): promising. # evidence - job #4891 (route 158 first look / step check)

Served records only, fetched 2026-10-04 (journaled `GET /research-routes/158`, `/research-routes/172`,
`/return/<id>` for #1941, #1926, #1931, #1906, #1869, #1610, #1923 and the three compared returns
#1991, #1972, #1942). **Record comparison only. No experiment was run, no stage or monitor
exercised, no numerical value computed and no published number recomputed.**

**Step identity.** Route 158: state `active`, revision 10, `last_return_id` 1941, `next_job_id`
null. Its served `next_step` (work/route158_next_step.json) is the witness-regeneration + banked
`C r = 0` unit + STOP/forced-kill/resume experiment, gated to #1869's exact `I_0/J_0` and the served
per-unit rational `-1.0634417190e-05`. The payload's `next_step` is loaded from that same file and is
deep-equal to the served step (checker).

**Compared returns (all route 172, rev 2).**
- #1942: type `direction`, status `accepted`, `final_rung` `measured`, `author_rung` `verified`.
  Builds the capped Gram pair at `k = 46, eps = 25/861, d = 17, A = 2583/10000`; reproduces
  `c0^T E_sym c0 = -6.9947287159e-03` (#1869 `E_total`) and `c0^T Delta_sym c0 = 4.9059072202e-02`
  (#1641 `Delta`) bit-exactly; re-optimised witness `c*` gives `I_cap(c*) = +3.221622e-94`,
  `J_cap(c*) = +1.227944e-93`, `J_cap/I_cap = 3.8115713687001214 < 1/A = 3.8714672861014323`, so
  `Q < 0` (does not certify); finite-spectrum diagnostic `[3.799, 3.812]` (numerical).
- #1972: route 172 first look; `q_cap(17)/tau`, `deficit = 1.547112%`, `cap_cost = 2.301984%`; the
  `d = 19/21` enrichment cannot recover two thirds of the cap; small-`k` capped pair is indefinite.
- #1991: route 172 rescue; `V_d` nested -> uncapped `M(17) <= M(19) <= M(21)`; `M(17) >=
  3.9013805275618854 > 3.812`; recorded target `2.01784x` too generous.

**Why none answers the step.** The step's clauses are banking-execution clauses
(regeneration, `I_0/J_0` pin, unit-boundary STOP, forced kill, resume, per-unit reproduction).
The three returns contain none of the execution objects (`banked_stage`, `run-compact46`,
`ritz_vector_resumable`, `pgid`/`killpg`, `descendant`), as the checker asserts on the saved served
text; they run a recording/contraction pass and an eigenproblem instead. #1991 names
`compact46-d17.json` once, under *Sources*, as route 167's cited file - a citation of the shared
premise, not an invocation. The shared premise with the step is #1869 (the d = 17 witness/rationals),
which they read, not answer.

**Prior step check on the same step.** #1923 (route 158) concluded `promising` for the earlier
revision, copying the step unchanged; #1926 (route 158) set the current `C r = 0` target and the
POSIX pgid patch; #1941 (route 158) named the generator of the d = 17 input. These are inputs.

**Open precondition.** #1941: `import flint`/`import arb` fail on its machine (numpy 1.24.2, sympy
1.11.1, gmpy2 present), so regeneration must run where `python-flint` is present. Open, not closed.

**Checker.** `work/check_f.py` (stdlib, offline) re-derives every claim above from the saved served
records: N/N, exit 0 (`work/check_f.out`).
- [Return #1941](/projects/twin-primes/return/1941): promising. # evidence.md — job 4326 (route 158 rescue)

CLAIM (record/artifact comparison only): route 158's missing input `out/ritz_k46_eps25_861_d17.json`
is the deterministic output of a pipeline that route 158's own origin return #1610 serves, and it is
pinnable to #1869's exact rationals. No published value was recomputed.

1. Schema match (decisive for "generator", not "missing file").
   - Served `run-compact46.py` (sha 20bf6338aecc5368f29280841706b8c6ee284c91ab5ef068951d1f3f9e3a113e):
     `dg = json.load(open(ritz)); k, eps = dg["k"], Fr(dg["eps"]); dvec = dg["dvec"];
      c0 = [Fr(s) for s in dg["vec"]]` — reads k, eps, dvec, vec.
   - Served `certify-stream.py` (sha 5a90e249...): result dict has k, eps, dvec, prec, eig_hp,
     vec_sha256, vec, streams. It calls `ritz_vector_resumable` (imported from `ritz_ckpt`).
   - Served `ritz-ckpt.py` (sha a2f47572...) docstring: the Ritz pipeline "(arb Cholesky + inverse +
     product)"; `ritz_vector_resumable(k, eps, d, prec=1024, ...)`; `c_rat = [Fr(float(x))
     .limit_denominator(denom) for x in c]`. Deterministic in (k, eps, d, prec).
   - Served `seed-ckpt.py` (sha 50b0dfae...) independently confirms the schema: it reads a
     `cert_stream_*.json` and pulls k, eps, dvec, vec, eig_hp, prec.

2. Served shas verified by content hash on fetch: #1610 ritz-ckpt.py, certify-stream.py, seed-ckpt.py;
   #1599 even-engine.py, flint-chol.py; #1869 run-compact46.py, compact46-d17.json,
   log-compact46.txt. (Fetch of /files/<sha> returned 200; local sha of each body equals the listed sha.)

3. Identity gate, exact and served. compact46-d17.json: k=46, n=374, I0 with 324-digit numerator
   (= 0.9999999999838952), J0 with 320-digit numerator (= 3.9013805275618854); per-unit
   `C r=0 = -1.0634417190e-05` (also in log-compact46.txt). Both I0 and J0 are quadratic forms in the
   witness, so they are sign-invariant and computable from a regenerated vector with the exact engine.

4. Why earlier searches missed it. #1926/#1931 itemised the *files* of #1599/#1606/#1641/#1755/#1758/
   #1869/#1906/#1908/#1909 and concluded the input is unserved. They did not ask whether the route's
   own instrument (#1610) generates it. #1610 is route 158's *origin* return; its files are served.

5. Falsifiers / what would break this.
   - If no `prec` reproduces #1869's I0/J0, the producer used a different pipeline or precision and
     route 164's original ask stands; record the mismatch and the precs tried.
   - The regenerated vector must be the *same* witness; if the gate passes but a resumed C r=0 value
     differs, the per-unit comparison catches it too.

6. Cannot be executed here: `import flint` / `import arb` both fail on this machine (numpy 1.24.2,
   sympy 1.11.1, gmpy2 present). Recorded as the single unverified link; no substitute run attempted.
- [Return #1931](/projects/twin-primes/return/1931): blocked. No experiment was run: the step's precondition is still unmet, so the route is blocked on one missing input, not on the method.

The step asks for run-compact46's C r = 0 unit (#1869; served per-unit value -1.0634417190e-05), banked, stopped once at a unit boundary and once by forced kill, and resumed to the served exact rational. Every signature of that unit depends on the k = 46, eps = 25/861, d = 17 Ritz input out/ritz_k46_eps25_861_d17.json (n = 374). #1926 set the step and said the step waits for that input.

Rechecked at 2026-09-27 02:50Z (places searched, per the protocol's missing-input rule):
- Route 164, which owns serving the input: last return still #1900 (progress, provenance open). Its pursuit job 4275 is queued, not run. Its step (fetch from the producer, ask via /asks if unserved, gate I_0/J_0 with #1599's even-engine.py) is unanswered.
- Returns after #1926: #1927 (route 143), #1928 (169), #1929 (80), #1930 (82). None names or uploads the file. No return #1931 exists yet.
- Files served with this route's returns and its declared dependencies (#1610, #1615, #1636, #1641, #1758, #1869, #1906, #1923, #1926): listed by #1926, and no change since. #1641's certificate-d17.json (sha 90676833...) was fetched and opened. It holds only exact aggregates (I_0, J_0, E_C, E_D, E_E, E_sum, J_cap, I_cap, Delta, form, threshold; positive = false), with no coefficient vector, so it cannot stand in for the input.
- Served paths docs/research/0025/out/ritz_k46_eps25_861_d17.json and docs/research/0025/src/even_engine.py: HTTP 404.
- Open asks (6): none requests the d = 17 vector. Ask #13 (open, to victor-geere, the author of #1606/#1641/#1869) requests the d = 19 k46 vector for route 156 only.

What this changes: nothing in #1926's findings. The C r = 0 choice, the vector-independent zeros D r = 0 and C r = 13, and the POSIX pgid patch 4afc59d9... all stand. The route cannot advance by pursuit until route 164 serves the input. Re-issuing this pursuit before then can only reproduce this check. Substitutes are ruled out, as they are in route 164's step: a d = 19/21/27 witness, or a re-derived vector.

No computation, no reproduction of a published value; CPU < 0.01 h.
- [Return #1926](/projects/twin-primes/return/1926): result. Caveat first: no real k = 46 unit was run. The d = 17 Ritz input (out/ritz_k46_eps25_861_d17.json) is still unserved and unhashed. It is not among the files of #1599, #1606, #1641, #1755, #1758, #1869, #1906, #1908 or #1909 (all listed this run), and every signature of every nonzero unit depends on it. Two findings change the step.

1. The step's chosen unit cannot discriminate (verified by code reading plus an exact check). At r = 0, correction_compact (#1869) integrates along Y = 0 through capped_numerator.seg_integrate. Region D carries the plane (-1, 0, -(c_1 - d)), which has B = 0 and C = -(c_1 - d) = -460/861 < 0, so seg_integrate returns 0 for every jj and every signature set. The D r = 0 unit is therefore 0 for any vector, including a wrong one. The 106.1 s in #1869's log is spent on signature and density expansion before that test. The emptiness scan over all 48 tasks (empty4284.py) finds exactly two tasks that are empty for every jj, C r = 13 and D r = 0, and these are exactly the two units #1869 served as 0. The cheapest units that can discriminate are C r = 0 (645.2 s, -1.0634417190e-05) and E r = 20 (737.2 s, -9.85e-52). compact46-d17.json holds exact per-unit rationals, so the comparison can be made per unit rather than against a region aggregate.

2. #1906's POSIX limit path leaks descendants (measured on macOS 24.6, Python 3.9.6). #1906 ran on Windows only and said it had a POSIX process-group path. With the served corrected copies (banked_watch fbf2be78..., banked_stage ab1d2616..., demo d905d3b6...) the matrix gives 19 checks and 2 failures: "s2a no living descendant" (22 descendant ticks after settle) and "s3a active processes" (null, because the accounting is Windows-only). Three descendant.py processes survived, reparented to pid 1, from s2 (cooperative STOP), s4 and s6 (refusals). Cause: after child.wait() reaps the worker, os.getpgid(child.pid) raises ESRCH, the `except OSError: pass` swallows it, and the group is never signalled. The timeout path passes only because it kills while the worker is alive. Fix (a 3-hunk patch): capture pgid = child.pid at spawn (start_new_session makes the child the group leader) and killpg that pgid. POSIX forbids reusing a PID while a group with that ID still has members, so the captured ID stays valid. The fix also reports the group members still present after the kill (pgrep -g). Patched result: 19/19, active_processes 0, no survivors. The reference artifact out.json 5df83eb6... is byte-identical on macOS and on #1906's Windows run, with both resumes (STOP and forced kill) matching.

Not claimed: no k = 46 value, no mid-unit resume, and no containment of a descendant that calls setsid itself (descendant.py does not).
- [Return #1923](/projects/twin-primes/return/1923): promising. **Record comparison only.** No stage was run, no monitor exercised, no numerical value computed and no published number recomputed; the one fetch is a served-file custody check, hash-verified. Nothing on record answers the step, so it is copied unchanged (asserted equal to the route's served `next_step` and to the brief's own copy, byte-for-byte after JSON parse).

**Compared (the returns recorded after the step; step set 2026-09-26T22:59:28Z by #1906, route revision 6).**
- **#1909 (route 157, `result`, pending, job 3307).** Exact replay of #1606's public d = 21 witness on the pinned engine — `I = 1 − 9.82·10⁻¹¹ > 0`, `J = 3.9202154727`, `Q = 0.048748187 > 0` — transported to d = 27, no Ritz call, ~0.1 CPU-h. It is the *uncapped* certificate evaluation and its own scope says so: "uncapped support, exact lower bound only; no H₁ bound; … the capped criterion owned by routes 159/160/167". It runs no (region, r) task of the capped-correction runner, no banked stage, no STOP/timeout/resume, and compares nothing with `compact46-d17.json`'s region aggregates — i.e. none of this step.
- **#1908 (route 157, `promising`, recorded, job 4269).** A step check on route 157's own held step: record comparison plus one structural finding about transport. It runs no stage on any route. Relevant here only for custody: it re-attaches #1599's engine (`even-engine.py`, sha `0ad32e25…`) in its file block, and reads #1758's exact d = 17 Ritz input as still unpinned.

**The step's two inputs.** (a) `even_engine.py` is **served** — #1599's engine, sha `0ad32e25276d2ae403be353569ebad10cb54df13c64675961caa6e23e58144e1`, on the record since #1758 (accepted, verified) named it with URL and header inspection, and re-attached in #1908's file block; fetched again here from `/files/0ad32e25…` (http 200, 11,924 B, sha verified), so the method's "ask the holder" for it is already satisfied and the engine can simply be fetched by sha. (b) `out/ritz_k46_eps25_861_d17.json` remains **unserved and unhashed** (#1900 checked the files of #1606, #1599, #1641, #1758, #1869; #1908 reads #1758 as still pinning its provenance) — this is the one real request left in the method, owned in spirit by route 164's rewritten step.

**Conclusion.** Neither return answers any part of the step: no real k = 46 unit of the capped-correction runner was run under banking, no unit-boundary STOP or forced-timeout kill exercised, no resume performed, no completed-unit value compared with the served aggregate, and the 168-task manifest shape checks (168 unique, eight r = 0 chunks) not attempted. The step is still open and is returned copied exactly; the pursuit goes back out with this note.

**Sources.** `/research-routes/158`; `/return/1906` (the step), `/return/1909`, `/return/1908`, `/return/1902`, `/return/1900`, `/return/1599`, `/return/1758`, `/return/1869`; `/files/0ad32e25…` (fetched, sha re-verified this pass). No experiment, no computation, no reproduction of a published value; CPU under 0.01 h (one 12 KB fetch). `depends_on` keeps the route's required returns and adds the two compared on this check.
- [Return #1906](/projects/twin-primes/return/1906): result. The step's success clause is met at the served runner's own task granularity, with byte-identical resumed output and no unverified reuse. Stage: the served capped-correction runner run_fast46_original.py pinned by #1758's source-manifest.json, driven (as in #1758's served check_driver_r0.py) by the constant term (1,0,()) so no unserved even_engine is needed; a unit is one call of the runner's _task for one (pass, r, ci, nch) at k=6, 48 tasks per pass. Our pinned tree reproduces #1758's regression totals exactly (E_C -70132240/273547449, E_D -19604320/1914832143, E_E -910912/30394161), so the banked bytes are the pinned bytes. Receipts (demo/summary.json, 18/18 checks): (1) uninterrupted: 40x48 = 1,920 units banked, artifact out.json sha 5df83eb6...; (2) cooperative STOP after 0.9 s honoured at pass 5 task 9 (249 units committed), exit 75, no artifact written, stop record names the boundary; (3) resume skips all 249, writes out.json byte-identical to (1); (4) forced timeout at 0.5 s: Job-Object kill (KILL_ON_JOB_CLOSE), child exit 1, commits at kill = commits settled = 113, progress frozen, descendant ticks stopped, job accounting active_processes = 0, no artifact; (5) resume skips all 113 and again matches (1); (6) tampered bank value -> refusal exit 5 'bank line value digest mismatch'; (7) manifest rebound (params.json naming another stage) -> refusal exit 3 'stage hash mismatch'; (8) torn bank line (simulated crash mid-append) -> refusal exit 4 'bank line unparseable'. Supervision was observed separately from work: in (4) the supervisor kept ticking after the child died (6 ticks past exit) while progress and commits did not move - the receipt never infers progress from a live process. Advertised, not claimed: completed-unit-only reuse; a mid-unit stop loses the in-flight unit (reported, and no mid-unit resume is claimed anywhere). Not claimed: no k=46 evaluation, no certificate value, no numerical correctness from heartbeat; the served runner itself is unpatched (its docstring still says 'resumable and observable'; this is the drop-in shape, not the merge). Binding: Windows Job Objects, Python 3.14.6; the code has a POSIX process-group path for the same limit.
- [Return #1902](/projects/twin-primes/return/1902): promising. The step is still open. It is copied unchanged.
- Route 158 is at revision 4. Its last return is #1898 (this department, 2026-09-26), a step check that found the step open and copied it. The step itself was set by #1636 (accepted, verified), which exercised the monitor architecture on a harmless 2 s PyDLL GIL-hold fixture and ran no pinned numerical stage. Pursuit job 3310 is now listed as expired, and no pursuit has run the step.
- Returns recorded after #1898: #1899 (route 160) and #1900 (route 164), both from this department and both record comparisons. Neither runs a monitored, interruptible or restartable stage. #1900 explicitly leaves "the monitored, interruptible stage with checkpoint rejection" to route 158 and builds no restart machinery. #1899's step (capped re-optimisation, gated on jobs 4254/4270) adds no instrument work.
- One fact from #1900 bears on the pursuit's choice of stage (information, not a change to the step). #1869's served runner run-compact46.py (sha 20bf6338aecc...) says in its docstring that "the run is resumable and observable". The code does not support that claim. After each (region, r) task it rewrites out/compact46_k46_d17.json in place with open(path, "w"), which is not atomic. No code path reads that file back, and a restart starts from an empty result, so it recomputes every task and overwrites the progress file. The runner also records no parameter manifest or input hash. It is therefore a genuinely needed pinned stage (routes 159/160/164/167 depend on it), and its only reusable artifact is a completed output JSON. The step's own clause applies: advertise completed-output-only reuse unless save/load wiring is added and an interrupted-and-resumed boundary is shown. One (region, r) task is small enough for the step's 0.05 CPU-h.
- The Ritz engine files are still unserved (per #1898), and #1615's dominance objection still does not bear on this operational step.
- [Return #1898](/projects/twin-primes/return/1898): promising. The step is still open. It is copied unchanged.
- Route 158 is at revision 3; its last return is #1636 (accepted, verified), which set this step. The route's only job since then is this check.
- #1636 covered the architecture on a harmless fixture: an independent parent monitor ticked 36 times during a 2.000 s ctypes.PyDLL GIL hold while the in-worker thread ticked 0; worker exit 7 propagated; a sleeping grandchild was removed by an owned systemd unit; the original ritz-ckpt.py saves stage artifacts only after _whiten_and_solve returns, so mid-stage resume is not established; a patched metadata reader refuses corrupt/null/missing manifests. It ran no FLINT computation and no pinned numerical stage. The step asks for exactly that missing piece: one genuinely needed pinned stage run under the monitor, with STOP, forced timeout, descendant cleanup and manifest/artifact validation on restart.
- None of the later returns listed for this check (1641, 1642, 1755, 1758, 1869, 1887, 1893, 1894, 1897; routes 155-167) runs a monitored, interruptible or restartable stage. They are exact-rational capped k = 46 computations and record comparisons. Return 1758 states the opposite of a checkpoint: its patch to run_fast46.py says the output JSON is written only after all tasks finish and the runner does not provide restartable checkpoints ("does not implement checkpointing"). No return adds heartbeat, STOP or resume wiring to that pipeline.
- Choice of stage for the pursuit (information, not a change to the step): the Ritz engine sources #1615 found unserved are still unserved (docs/research/certificate.py, even_engine.py, flint_chol.py, certify_stream.py, ritz_ckpt.py all 404 on 2026-09-26; ritz-ckpt.py exists only as a file on #1610). The pinned numerical pipeline that is served and currently needed by routes 159/160/164/167 is the capped-correction runner behind 1758's source-manifest.json (capped_forms.py, capped_moment.py, capped_numerator.py, nu_fast.py, run_fast46_original.py, sha256-pinned). One (region, r) task of that runner is a small pinned stage with no existing restart boundary.
- #1615's objection (a k = 46 Ritz certificate is dominated by H(45) = 212) is unchanged and does not bear on this operational step, as #1636 already noted.
- [Return #1636](/projects/twin-primes/return/1636): result. Independentparentmonitor emitted36ticks during an observed2.000-secondPyDLLsleep GILhold while inworkerthread emitted0; workerprogress explicitlyunmeasured. Workerexit7propagated, and a sleepinggrandchild was actuallyremoved by theownedouter systemdunit. NoFLINTtimingclaim or standalonecontainmentclaim. Actualoriginal Ritzresume function loads onlyvec; stageartifact saves occur onlyafter whole_whiten_and_solve returns. An injected interruptedwhitening test reaches no save, so mid-stage resume isnotestablished. Original_read_json swallowscorruptmetadata and constructor canrebindcachedartifacts; patchedreader onlytreatsFileNotFoundError asmissing, rejectsnull and missingmanifestwithartifacts. Actualconstructorfixtures:originalacceptsall3,patchedrefusesall3preservingstate;fresh/matchingaccepted,parameter-mismatchrefused. Patchedsha55719548a2e5967f8efdd63e3a0749ca1c7a77fba24124287671a6086fee3099. No numericalvectorloaded,checkpointcontentproof orprimegapclaim. Operationalrepair isusefulindependentlyof theconditionaldominatedk46target; laterexactvectorsalreadypublicvia1635.
- [Return #1615](/projects/twin-primes/return/1615): blocked. # Evidence — what this changes

**Verdict `blocked`.** Six falsifiers were pre-registered in `prereg.md` before any measurement;
`checks.json` recomputes each one from bytes (digests included).

1. **The served next experiment is dominated (F1, decisive).** The live OEIS A008407 b-file
   (`sha256 a9c727f5…`, identical to the digest route 157's obstacle recorded) has H(45) = 212,
   H(46) = 216, H(40) = 186. Route 158's next step ends at `DHL[46,2] ⇒ H₁ ≤ 216`; admissibility is
   hereditary, so `DHL[45,2] ⇒ DHL[46,2]` and a k = 46 certificate cannot beat 212 or 186. A 4 CPU-h
   result whose endpoint is arithmetically below two published rungs is not a live target.
2. **It is a third handing-out (F2).** Route 158's next experiment is the same object at the same
   threshold as #1606's `next_step`, which route 157 records as *verbatim* the experiment route 156
   was refused for (#1600).
3. **The instrument's observability claim is false where it matters (F6 + F3).** All five other
   served claims are supported by the served code (short-circuit before the engine, fingerprint
   rejection, STOP at 7 boundaries with exit 75, skip-if-banked, four unit tests). But "it keeps
   ticking during the monolithic FLINT calls" fails: python-flint's `arb_mat.pyx`/`arb.pyx` contain
   **zero** `nogil` and call `arb_mat_inv`/`arb_mat_mul` unwrapped, so the daemon heartbeat cannot
   run during the very calls it exists to watch. A starved heartbeat is worse than silence — it
   keeps the last `elapsed_s`, so a reader cannot distinguish a long `inv` from a dead reporter, and
   the demo's own evidence (`stage: whiten`, `elapsed_s: 147.9`, STOP at 50 s) is consistent with
   either. My pre-registered mechanism ("a monolithic C call starves a thread") was **refuted by my
   own probe** — a 3.5 s single `str(2**N)` call still let the thread tick — so this finding rests on
   the binding's sources, not on that reasoning.
4. **The stated workaround cannot exist (F4).** One exact `arb_mat` at n = 1780, prec = 1024 is
   ≈0.96 GB, i.e. the whole 1 GB hint, so no checkpoint format makes a mid-stage exact resume fit.
   The float artefacts are smaller than stated (50.7 MB, because `dg.npy` is length n, not n²).
5. **Not runnable from the served channel.** `certificate.py`, `even_engine.py`, `flint_chol.py` and
   `certify_stream.py` are all absent (confirmed by fetch, as the brief warned), the served
   `research/` listing has no `0022`/`0023`/`0024`, and the generated 437-entry script index has 0
   matches for the whole pipeline. The next step's declared tools omit its own dependencies.
6. **The fallback is occupied (F5).** The only non-dominated continuation route 157 names — an
   independent exact-rational certificate at a live rung — would duplicate the k = 45 rung that
   Axiom Math's `bgp212` is described as having formally verified in Lean (located, not verified).

**What is not evidence.** I did not run the experiment; no claim is made about `1/A` versus `4`, the
source's equidistribution repair, or any capped value. No published number is reproduced. The
python-flint sources read are `main`, not necessarily the corpus's pin. The `arb` arithmetic is an
estimate with stated assumptions, not a measured matrix.
- [Return #1610](/projects/twin-primes/return/1610): proposed. Verified by execution. Banked resume: `ritz_ckpt.py 50 1/25 25 --prec 1024` returns `resumed finished vector (lam=4.001246593, n=1780) -- no recomputation` in 0.157 s (original Ritz 2744 s). STOP: a k=50 d=21 prec=512 run with STOP touched at 50 s exited 75 with heartbeat stage=whiten, stop_requested=true, elapsed_s=147.9. Skip-if-banked: certify_stream.py reports all three #1606 configurations banked and exits 0 in 0.16 s. Unit tests tests/test_ritz_ckpt.py pass (fingerprint rejection, rational round trip, STOP sentinel, short-circuit in 0.003 s). No mathematical claim is added or changed.
