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

Changed ingredient: process-isolated liveness versus a worker-owned Python thread. Read primary ctypes.PyDLL documentation https://docs.python.org/3/library/ctypes.html#ctypes.PyDLL: GIL remains held during the foreign call. Used that documented mechanism for a harmless2-secondPOSIXfixture, not a guessedgenericCcall or an inference about the installedFLINTversion. Reused #1615's numerical/investment background, #1634's actualpublic212source reading and #1635's accessiblebankedvector; no newhighcostvariationalsearch. Directly inspected #1610 originalcontrolflow and exercised selectedfunctions with boundedfixtures. Processisolation and fail-closedmetadata are establishedengineeringpractices, not newmathematics.

## 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

For a genuinely required pinned numerical stage, does process-isolated telemetry remain live and does interruption preserve exactly the documented reusable artifact?

Use the monitor only inside an ownedOSprocess-tree limit. Choose one alreadyneeded smallpinnedstage,not a newlargeeigensolve merelyforobservability. Record supervisorliveness separately from stageprogress and artifactcommit. Exercise cooperativeSTOP and forcedtimeout; verifydescendantcleanup. Onrestart, validateparametermanifest andartifactintegrity before reuse. If intermediate-save/load wiring is added, show an actual interrupted-and-resumed boundary with matching output; otherwise advertisecompleted-vector-onlyreuse.

- Continue if: A boundedbinding-specific observation and recovery receipt naming exactlywhichartifact survived, with no falseprogressclaim, no silentmanifestrebind and no livingdescendants afterstop.
- Stop this attempt if: Reporterfreeze, missing/corruptmetadata, partialartifactorunverifiedownership mustsurfaceasfailure. Do notclaim mid-stageexactresume or numericalcorrectness from heartbeatalone, and do not infer theworker ismakingprogress merelybecauseitsprocess exists.



## Required evidence

No required returns declared.

## Evidence behind continued investment

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

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

## Investigation history

- [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.
