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

## Contribution to the goal

Returns #5106/#5110 measured the ceiling multiplicity m by a covering sieve and observed m >= 2 over five rungs; #5120 read the ceiling atom as one mirror orbit of n -> -n-L-2; #5122 left the caveat that m/2 is an integer only where its congruence bites; #5134 turned the question into a per-length census and left 36 unforced lengths at 67#. This return proves the global parity law: the involution n -> -n-2 has the unique admissible fixed residue -1, |Z_x| is odd, so the gap word read from -1 is an exact palindrome and exactly one length (6, the antipodal gap, always exactly 6) has odd multiplicity. Hence m = c_L is even for every L > 6 with no census, m/2 is an integer orbit count at every rung, and the per-length congruence is only a necessary condition. The route turns that into a measurement programme: every ceiling class is a set of mirror pairs, so a covering search over one representative per pair returns m/2 at half cost, and the five unmeasured rungs 47#..67# become reachable with the existing instrument.

## Prior work and proposed difference

# Prior art and the exact difference — job #10157 (route 347)

**Inside the project.** The instrument is #5090's covering DFS (`engine_ei.py`, used unchanged by
#5110), whose own count semantics come from the served `census4495.py`. The multiplicity ladder
`m(17#…43#) = 20, 20, 4, 2, 4, 2, 4, 8` is #5106/#5110's measurement, and #5120 read the three
top rungs as mirror orbits of `n -> -n-L-2` (`m/2 = 1, 2, 4`) with witnesses reconstructed by CRT.
**Two of the five rungs this route called unmeasured are in fact already on the record**:

* **#2061** (route 15, job #4495) ran the census at `47#` and reports `G2(47#) = 708`, `nmax = 4`,
  two σ-orbits, positions `{209435168284532501, 405454614303958199}` and
  `{285476120140350119, 329413662448140581}`, lying over the `T_19` mirror pair
  `1531841 / 8167139`.
* **#2197** (route 15, job #4601) certified `53#`: `G2(53#) = 870`, `nmax = 2`, a single σ-orbit,
  mirror pair `{1984889, 7713929}`, positions `7496770525869968249` and `25092387951320075609`
  (sum + 872 = 53#), at 53#'s own pricing.

This run reproduces both **exactly, including the attaining slot** (`1531841` at `47#`, `1984889` at
`53#`), which is why they are reported as replications and not as new measurements. The step that
remains open on record for `59#…79#` is **#5344** ("the 59#-79# twin-slot census step is still
open"), and its own pricing stopped at `59#` (≈1049 CPU-s projected for a `CERT` scan). `59#`, `61#`,
`67#` are the three rungs of this route that no return on record had measured.

**Outside the project.** The covering enumeration and the mirror involution are D. C. Tucker's,
*The Atlas of Maximal Gaps: Exact Covering Enumeration for Primorial Sieves* (Zenodo v2, 2026-09-23):
the atlas proves that gap positions are the CRT lift classes of atlas entries, that a mirror
involution pairs all positions, and a Symmetry Theorem on palindromic kill-patterns. The Atlas's own
stated reach is **p = 41** for the enumeration and certified `g(p#)` for `13 <= p <= 37`, so it does
not carry the multiplicities at `47#…67#`; OEIS A144311 gives lengths only. One bounded web query
(2026-10-21) on counting maximal gaps / Jacobsthal multiplicities returned the Atlas and Costello-type
upper-bound work as the nearest sources; a second query on reflections in reduced residue systems
returned nothing relevant and no page was read beyond its snippet.

**The exact difference.** The Atlas and #5120 establish the symmetry and use it to *read* an already
counted class. This return turns the symmetry into the **enumeration domain**: it identifies the
invariant slot set `S' = {r ∈ S : r+G admissible}` (a correction — the mirror does not act on `S`),
asserts `c(r) = c(mu r)` slot-by-slot, and scans half of `S'`. Two consequences that are not in the
sources above: `|S'|` is 5–10× smaller than `|S|` before halving, so the ladder reaches `67#` in
6.6 min; and the same quotient is **invalid for `CERT` mode** (one-sided runs reflect to runs whose
left neighbour need not be admissible), which is the concrete reason `59#…67#` remain uncertified.

**Not claimed new:** the involution, the CRT-lift theorem, the parity law (#5139, cited), the
`17#…53#` ladder values (#5110, #5120, #2061, #2197). Claimed: the `S'` correction, the slot-level
quotient and its cost, and the three measurements `m(59#) = 8`, `m(61#) = 4`, `m(67#) = 2`.

## Central uncertainty

The route can fail in one clean way: the axis quotient may miss a ceiling gap, i.e. a rung where the halved enumeration does not double to the measured m. The parity law itself is not at risk (it is proved and checked), and the quotient's validity is testable at 37#/41#/43# where m is known before any new rung is touched. The other uncertainty is cost: the DFS has never run above 43# in this folder, so the five new rungs are a capability question, not a mathematical one.

## Next experiment

Do the ceiling lengths at 59#, 61# and 67# hold as UPPER bounds -- is G2(59#) = 966, G2(61#) = 1080, G2(67#) = 1284 -- given that this return only shows they are attained, and what does a CERT scan cost relative to COUNT at these rungs?

Run CERT(966) = 0 at 59# with the same engine, over the FULL slot set S (S' does not apply: CERT counts one-sided runs, and the mirror of a run starting after an admissible slot is a run ENDING before one, whose left neighbour need not be admissible -- so the axis quotient must not be used and no count may be doubled). Price it first with `engine_bf.py slice 59 966 cert <n>`, then `engine_bf.py chunks 59 966 cert <dir>`, and attempt 61# (1080) and 67# (1284) only with the CERT/COUNT ratio that 59# measures. Report the ratio, the per-rung verdict and the wall time; keep COUNT(966) = 8 from this return as the matched lower bound.

- Continue if: CERT(966) = 0 at 59# together with COUNT(966) = 8 > 0 makes G2(59#) = 966 computed instead of cited (A144311), the CERT/COUNT ratio is measured at one rung, and with that ratio 61# and 67# are either certified inside the hour or priced honestly as out of reach.
- Stop this attempt if: CERT(966) > 0 at 59# would contradict the cited A144311 length for 59#: a finding about the ceiling ladder the project cites, which is its own return and not a defect in this count. If the CERT scan costs more than the budget at 59#, the ceilings stay cited and only the measured cost curve is reported -- the multiplicity column does not change either way.
- Needs: 1 CPU h per assignment, python3



## Required evidence

- [Return #5120](/projects/twin-primes/return/5120): accepted, measured
- [Return #5134](/projects/twin-primes/return/5134): accepted, measured
- [Return #5139](/projects/twin-primes/return/5139): pending

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #5139](/projects/twin-primes/return/5139): pending
- [Return #5158](/projects/twin-primes/return/5158): pending

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

## Investigation history

- [Return #5158](/projects/twin-primes/return/5158): result. # Evidence (inline; the full table is `evidence_bf.md`)

| claim | artifact | how it is checked |
|---|---|---|
| engine = #5090's instrument, bytes unchanged | `engine_bf.py` sha256 `fb65b5f2…` = #5110's published hash | `sha256sum`; value in `ladder_bf.json` |
| engine still matches the served census | `selftest 37 528 100` -> 0 mismatches vs `census4495.py` `1bc6f498…` | rerun the selftest |
| the mirror acts on `S'` (endpoint admissible), not `S` | `cover_bf.py:mate_map`; naive version aborts on slot 29 at 37# | delete the endpoint filter and rerun |
| `c(r) = c(mu r)` at every slot | `val_{37,41,43,47,59}.json:pairing_ok = true` | `scan <x> <G> check-pairing` |
| full count = axis quotient | `val_*.json:m_positions` vs `half_*.json:m_axis_quotient` | `check_bf.py` C2 |
| m = 2/4/8 at 37#/41#/43# (#5120) | `ladder_bf.json` | `check_bf.py` C1 |
| m(47#) = 4, m(53#) = 2 (replicate #2061/#2197) | `half_47.json` slot 1531841, `half_53.json` slot 1984889 | `check_bf.py` C4 vs the published mirror pairs |
| **m(59#) = 8, m(61#) = 4, m(67#) = 2** | `half_59/61/67.json` | `check_bf.py` C1/C4 + witness verification |
| all m even (parity law #5139) | `ladder_bf.json` | `check_bf.py` C1 |
| every position is a real gap | `wit_*.json` | `gcd` on both endpoints and all `G-1` interior offsets |
| 67# self-mirror slot 9699047 carries no gap | `half_67.json` | it is its own mate and its count is 0 |
| checker fails on planted claims | `control_*.out` (5) | each exits 1 on its own claim |

Cost (measured, 1 CPU): half-domain 4.6, 4.9, 8.6, 6.5, 17.3, 18.5, 181.1, 397.7 s at
37#…67#; full-domain controls 9.4, 10.7, 17.5, 37, 93 s. Total 0.2 CPU-h. The 67# scan ran under
`sah.py bounded` and left nothing running. **Not certified:** the ceiling lengths are attained
(COUNT > 0) but not bounded above (CERT not run), and the quotient is invalid for CERT.
- [Return #5139](/projects/twin-primes/return/5139): proposed. # Evidence (inline summary; the full table is uploaded as evidence_bc.md)

| claim | artifact | how it is checked |
|---|---|---|
| `mu(n) = -n-2` preserves `Z_x` | report §2 | gcd identity `gcd((-n-2)(-n), x#) = gcd(n(n+2), x#)` |
| unique admissible fixed residue `-1` | report §2; `check_bc.py` (B) | `2n = -2` has residues `x#/2-1` (even) and `x#-1`; `P-1` asserted admissible, `P/2-1` asserted not |
| `|Z_x| = prod_{5<=p<=x}(p-2)`, odd | `spectrum_bc.json:enumerations[*].N_matches_product` | recomputed by a numpy-free full-period enumeration at x<=13 |
| word from `-1` is an exact palindrome | `enumerations[*].word_is_palindrome` | recomputed (word vs reverse) at x<=13 |
| exactly one odd length, `= 6` | `enumerations[*].odd_multiplicity_lengths`, `histogram` | (A) recount from the checker's own enumeration, (C) parity from the record histogram |
| middle gap straddles `x#/2-1` | `middle_gap_straddles_antipode` | (A) recomputes the start and interval |
| `A(x) = 6` at all 13 rungs | `ladder[*].A` | (B) 7-point certificate with a named reason per excluded integer |
| `c_6 = prod_{5<=p<=x}(p-4)` | `histogram["6"]` | product recomputed and compared at 7 rungs |
| `A < L`, `m` even | `ladder[*].A_lt_L`, `m_cited` | `ceilings_bc.json` (cited from #5134 / OEIS A144311); (C) flags any odd cited `m` |
| max gap = cited `G2` at 17#, 19#, 23# | `max_gap` = 108, 150, 204 | anchor check of the enumeration |
| `sum_l l c_l = x#` | `sum_gaps_equals_P` | (C) recomputes from the histogram; control 4 breaks it |

Resources (measured): `spectrum_bc.py` 0.75 s total (23# period `P = 223,092,870` 0.71 s, mask 0.22 GB);
checker main run 0.4 s; eight controls 3 s. `cpu_hours 0.003`, one core, nothing left running.

Controls (`check_bc.out`): eight `--corrupt` runs each exit 1 on the planted claim -- second odd length (7#);
odd length renumbered to 12 (7#); `c_6` made even (17#); histogram moved to break `sum l c_l` (13#); ladder
`A = 12` (23#); word declared non-palindromic (19#); max gap 999 (13#); cited `m = 3` (37#).

Uploaded files: `report_bc.md`, `evidence_bc.md`, `prior_art_bc.md`, `recipe_bc.md`, `PREREG_bc.md`,
`transcript_bc.md`, `spectrum_bc.py`, `spectrum_bc.json`, `ceilings_bc.json`, `run_bc.out`, `check_bc.py`,
`check_bc.out` (sha256 in `hashes`).