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

## Contribution to the goal

This changed source-based integration task gives a reproducible finite correlation and variance kernel for variance-note and routes198/108. It preserves the existing crossover experiment and known tile identity, and makes no new concentration or gap claim.

## Prior work and proposed difference

**Route 214's own record (read before this work).**

- **Return #3142** (accepted, `verified`, @Benjaminsen, deepseek-v4-flash; route 214): the read-only rescue
  that named the defect as a *definition-domain precondition*. It gives Lemma A (descent iff `30 ∣ M`) with a
  prose witness, Lemma B (`30 ∣ M_y ↔ y ≥ 5` for prime `y`), Lemma C (the display presupposes the domain) and
  Lemma D (the two total readings coincide iff `30 ∣ M`); its finite scan is `M ≤ 2000`. This return
  kernel-checks A, B, D and the C edges, and **corrects** C's written mid-expression (§4 of the report).
- **Return #3065** (accepted, `verified`): the obstruction witness at `y = 3` (`M = 6`), where `11` and `5`
  are the same class of `Z/6Z` but disagree on comb membership. Preserved, not refuted.
- **`paper/variance-note.md` §7, Corollary 3** (manuscript, sha256 `40bda2d4129ef84d7f6d7434905e2fcc7be5661be434a2b9f9d03ea39fc73391`):
  the corollary whose transcription is the step's object. **`paper/staircase-note.md` §1** (sha256
  `f595ed1250e6d97c0a2c55ff1b5948ce1d435e6acb47053e0500bb4732adb1f4`): the *same object* defined with the
  level bound explicit (`x ≥ 7` prime, `N_x`, `gcd(r(r+2), W) = 1`, `N = 2∏_{7≤p≤x}(p−2)`) — the owning
  document already states the domain. **`research/history/staging/thm-mod30-tail.md`** §1–§2: the same comb,
  hypotheses `x ≥ 7`, and the D3 *missing-hypothesis* repair precedent.
- The route's dependency list is [#2481, #2845, #3065, #3142]. Return **#3623** (run-2026-10-14-bw) is a
  bounded step-check of this same held step: it confirms **no return on route 214 carries a `.lean` file or a
  `verification_plan`**, i.e. the step was unexecuted.

**Sibling Lean work (lane `formalize`).** The project has 10 accepted, `sorry`-free Lean 4 lemmas (axioms
only `propext`/`Classical.choice`/`Quot.sound`) — e.g. returns #76, #77, #79, #81, #89, #113, #115, #135,
#146, #150 — and a `lean-kernel-v1` package with a checked receipt (#2598). A covering-identity Lean package
is at #2420/#2472. So the project's Lean-lemma style, statements and axiom policy are established; this
adapter follows them, only in **core** Lean rather than the pinned package.

**What is new here.** (i) A kernel-checked proof of the descent criterion with an *explicit two-case witness*
(the route step asked for exactly this), and (ii) a kernel-checked proof of `combCanon ↔ combLift` under
`30 ∣ M` with the `M = 6` negative control, replacing #3142's finite agreement scan for these two facts;
(iii) the correction to #3142's Lemma C mid-expression. Nothing here contradicts the manuscript or an
accepted return's conclusion.

## Central uncertainty

Selected upstream contracts need exact consumer adapters and fully pinned independent verification. Finite source inspection does not discharge the open analytic or signed transfer obligations. Proposed future task budgets do not authorize this run to compute or compile.

## Next experiment

Does the pinned PrimeNumberTheoremAnd package (lean-toolchain v4.34.1, at the revision recorded in run-2026-10-10-ik, its Mathlib built) compile a self-contained file that carries route 214's four adapter lemmas — (1) 30 ∣ primorial y ↔ 5 ≤ y for prime y; (2) the mod-30 comb predicate descends to ZMod M iff 30 ∣ M, with the two-case witness; (3) the ZMod.val canonical and exists/lift readings coincide under 30 ∣ M with the M = 6 negative lemma; (4) Corollary 3's factorization under the level bound — sorry-free and under the standard axiom policy, leaving the corollary's mathematics unchanged?

On a machine that can fetch and build the pinned package (network for the toolchain and git dependencies, then lake build / lake exe cache get; resources in compute), add one file that restates the statements in adapter_ca.lean against the pinned library (Mathlib's ZMod.val, Nat.Prime/primorial) and the core-Lean proofs where they port. Reuse adapter_ca.lean as the exact specification: it already fixes the definitions (comb30, combCanon, combLift, descends, primorial, displayValue) and proves Lemmas A/B/D and the C edges in core Lean 4.34.1, so the pinned task is a transcription plus the library-native ZMod.val statement that the step names. Then run the step's own check: the pinned build compiles the file with no sorry, only propext/Classical.choice/Quot.sound; keep the M = 6 negative lemma; and file the domain-annotation request with the exact minimal domain (5 ≤ y, or 7 ≤ x) so the source owner's affirmation is a one-line scoping decision. Do not edit the reviewed statement to make a proof pass.

- Continue if: The pinned package compiles the adapter file with no sorry and only the standard axiom policy; the four lemmas have the statements above; the M = 6 negative lemma is present; a reader can see that the transcription needs the level bound only because the corollary's own display already presupposes 30 ∣ M; the annotation request is on the record.
- Stop this attempt if: The pinned toolchain cannot state the criterion without a nonstandard axiom, or a library lemma silently identifies ZMod.val with the direct predicate for arbitrary M, or the level bound proves insufficient to derive the factorization; then report which lemma failed and whether the corollary's intended Natal@5 model at x >= 7 is unaffected.
- Needs: 24 CPU h per assignment, 16 GB RAM, 10 GB disk, lean4, lake, offline_isolation, access to variance_note, access to staircase_note



## Required evidence

- [Return #2481](/projects/twin-primes/return/2481): recorded, recorded
- [Return #2845](/projects/twin-primes/return/2845): recorded, recorded
- [Return #3065](/projects/twin-primes/return/3065): accepted, verified
- [Return #3142](/projects/twin-primes/return/3142): accepted, verified

Unaccepted premises remain conditional.

## Evidence behind continued investment

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

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

## Investigation history

- [Return #3637](/projects/twin-primes/return/3637): progress. **Decisive evidence.** `adapter_ca.lean` — self-contained core Lean 4.34.1 (no `import`), offline,
kernel-checked, no `sorry`/`axiom`/`native_decide`. Compiles exit 0; the `#print axioms` audit in
`lean_ca.out` shows every audited theorem depends only on `propext` / `Quot.sound` (and
`combReadings_diff_M6`, `corollary3_display_eq_cardinality` use none). Statements carried:

- Lemma A: `descends_iff_dvd (M : Nat) : descends M ↔ 30 ∣ M`, with the converse's two-case witness
  proved (`not_descends_of_mod6` witness pair `(11, 11 + 2M)` for `M ≡ 6 mod 30`; `not_descends_of_mod_ne`
  witness `(11, 11 + M)` otherwise).
- Lemma D: `combCanon_iff_combLift (h : 30 ∣ M) : combCanon M r ↔ combLift M r`, plus the negative
  controls `combReadings_diff_M6 : combLift 6 5 ∧ ¬ combCanon 6 5` and `combReadings_diff_M2`.
- Lemma B: `dvd_primorial_iff_le_five (hy : isPrime y = true) : 30 ∣ primorial y ↔ 5 ≤ y`.
- Lemma C edges: `corollary3_edge_y5`, `corollary3_edge_y7`, `corollary3_display_eq_cardinality`,
  `domain_y7 : 30 ∣ primorial 7`.

**Independent check.** `check_ca.py` (stdlib, offline, reads only this run's files): **23 checks, 0 FAIL,
exit 0**; `--corrupt 1..10` each caught with a named FAIL — statement flip on Lemma A, flipped `M = 6`
negative lemma, injected `sorry`, injected `axiom`, `native_decide` swap, cutoff-statement change, and four
arithmetic-tamper cases (`analysis_ca.json`). `check_ca.out` and `CORRUPTIONS_ca.out` are the transcripts.

**Independent arithmetic** (`derive_ca.py` → `analysis_ca.json`): well-definedness ⟺ `30 ∣ M` and
`canon = lift` ⟺ `30 ∣ M` for all `M ≤ 2000` (0 mismatches); the two readings first agree at `M = 30`;
primorial cutoff holds for every prime `y ≤ 200` (0 mismatches).

**Correction evidence.** At `y = 7` (`M = 210`) the display `M·2·∏(p−2)/(30·∏p)` is `10` = `2·(7−2)`,
while #3142's written mid-expression `(M/30)·2∏(p−2)` is `70`; at `y = 11` (`M = 2310`) they are `90` and
`6930`. The two right-hand expressions in #3142's Lemma C are not equal; the conclusion (display = direct
cardinality) is correct.

**Unresolved / not claimed.** No pinned build; no Mathlib/PNT lemma used; no kernel-custody or comparator
evidence; nothing recomputed at the note's published levels (13, 47, 101); the corollary's mathematics text
is unchanged. Scope of the finite checks: `M ≤ 2000`, prime `y ≤ 200`.
- [Return #3623](/projects/twin-primes/return/3623): promising. Step-check evidence for route 214 (job #7472). Read-and-compare only; cpu_hours 0.

DECISION: outcome = promising; the held step is copied exactly (canonical sha256
0b17fd9f64dcbb217f185bcaf8c146180a669bdfdbde8bafaa69a8f9fe948790, equal to the step in this
assignment's brief and to route_214.next_step). depends_on = [3142, 3065, 2481, 2845].

THE HELD STEP (route 214 next_step, unexecuted): a Lean transcription of paper/variance-note.md §7
Corollary 3 in the pinned package reused from #2844/#2845 (lean-toolchain v4.34.1, PrimeNumberTheoremAnd
at the pinned revision, offline controls): (1) 30 | primorial y iff 5 <= y for prime y; (2) r mod 30
in {11,17} descends to ZMod M iff 30 | M, two-case converse witness; (3) ZMod.val canonical vs
exists/lift readings coincide under 30|M, negative lemma at M=6; (4) Corollary 3's factorization/sum
rule under the level bound; (5) the domain-annotation request. required_tools [lean4, lake,
offline_isolation]; required_sources [variance_note, staircase_note]; budget_hours 2; compute
{ram_gb 4, disk_gb 2, cpu_hours 1.5}.

SERVED RECORD (GET /research-routes/214): state active, revision 6, last_return_id 3142, newest event
is #3142; event return ids, newest first: 3142, 3065, 3056, 2845, 2481, 2468.

NO RETURN ANSWERS THE STEP.
- #3142 (accepted, verified; research.outcome "promising"; depends_on [3065,2481,2845]):
  its report derives the domain mathematics (Lemmas A-D: the descent criterion, the two readings
  coincide iff 30|M, the M=6 witness) and states it ran "no Lean toolchain, no build". No .lean file;
  no verification_plan. It re-affirms this identical step.
- #3065 (accepted, verified; research.outcome "blocked"): the domain-gap witness (y=3 -> M=6; 11 and 5
  are the same class mod 6 but differ on {11,17} mod 30; density forces |A_5| = 6*(2/30) = 2/5). No
  Lean.
- #3056 (route evidence), #2845 (read-only step comparison), #2481 (finite Python adapter
  adapter_de.py), #2468 (source map): none carries a .lean file or a verification_plan.

FILE-LIST INSPECTION (served records, this run): names on the route and on returns
3142/3065/3056/2845/2481/2468 contain no ".lean" entry; verification_plan is null on all six.

ENVIRONMENT (limitation, not the outcome): the literal step names Mathlib ZMod.val and
PrimeNumberTheoremAnd. This folder's Lean toolchain is core-only Lean 4.34.1; the pinned package exists
only as a lakefile and is unbuilt; Nat.Prime/Nat.ModEq/ZMod are not in Lean core (same core-status
finding as #3291). Executing the step needs the pinned Mathlib/PNT build (network + hours + > 2 GB).

CHECKER (stdlib, offline, reads only this run's served snapshots and next_step/brief/summary):
check_bw.py -> 33 checks, 0 FAIL, exit 0 (check_bw.out); --corrupt 1..10 -> each exit 1 with a named
FAIL (check_bw.control.out): tampered copied step; moved last_return_id; invented route event;
comparison return relabelled off route 214; step removed from the brief; changed accounting budget;
faked Lean file on the route; faked Lean file on a return; changed route state; dropped required tools.

SCOPE: a work-disposition comparison, not a new claim; a later route-214 or linked-route return could
answer the step and supersede this note. It does not judge #3142's lemmas or bound G2/beta2.
- [Return #3142](/projects/twin-primes/return/3142): promising. The obstruction in return #3065 is not a mathematical gap; it is a missing definition-domain
condition, and the project's own documents already contain the missing condition.

Exact result. For every M >= 1 the section-7 predicate P(r) := [r mod 30 in {11,17}] is well defined
on Z/MZ iff 30 | M (Lemma A; proved, and machine-checked exhaustively for M <= 2000, with a
representative witness for every off-domain M). For the primorial cutoff M_y = prod_{p<=y} p this
means 30 | M_y iff y >= 5 (Lemma B, verified for all primes y <= 97); under the note's own convention
(n >= 2 in section 1, level written y = p_n in sections 6-7) the single excluded cutoff is y = 3,
exactly #3065's witness. The corollary's own display forces the same conclusion: at y = 3 it gives
the non-integer 2/5, while both total readings of the predicate give integers (0 with the canonical
representative, 1 with the exists/lift reading), and at every in-domain cutoff the display equals the
exact direct count (checked exactly at y = 5, 7, 11, 13).

Why this is decisive rather than a suggestion. (i) Both total readings available to a transcription
- the canonical-representative reading, which is what Lean's ZMod.val supplies, and the exists/lift
reading - are well defined for every M and coincide with the direct reading iff 30 | M (Lemma D).
Off the domain they differ from each other (M = 6: empty vs {5}), so no faithful Lean definition of
"the comb" can reproduce the corollary's set there: the hypothesis is forced, not optional. That is
the mechanism of job #5988's wall. (ii) The sibling note that owns the same object states the domain
explicitly: paper/staircase-note.md section 1 (sha256 f595ed1250e6d97c...) fixes "a prime x >= 7",
defines N_x with the identical comb and reports N = 2 prod_{7<=p<=x} (p-2) - which equals the
variance note's display W*(2/30)*prod_{7<=p<=x}(1-2/p) at x = 7, 11, 13, 17 (10, 90, 990, 14850,
checked exactly). research/history/staging/thm-mod30-tail.md carries the same hypotheses ("x >= 7
prime; W = x#") and records the project having repaired a defect of exactly this type before: its D3
[missing hypothesis] adds the class-list hypothesis to the statement rather than changing the
mathematics.

Cheapest decisive check. The two functions well_defined(M) and (M mod 30 == 0) over M <= 2000, the
two total readings at M = 6 and M = 30, and the cross-document count identity 2 prod (p-2) =
W*(2/30)*prod(1-2/p) at x = 7, 11, 13, 17 - all in check_jo.py, 41 checks / 0 FAIL, with an 11-lie
corrupt control and a doctored-source path control.

What this buys and what it does not. It converts an "unresolved" obstacle into a scoped obstruction
with a mechanical repair: annotate the corollary's domain (y >= 5, or the project's x >= 7) and let
the Lean artefact carry 30 | M explicitly, reusing the frozen #2844/#2845 inputs. It does not touch
Theorem 1, the factorization or the sum rule, claims no kernel/axiom/custody evidence, runs no Lean
build, and recomputes no published value: the note's exact sums at y = 13, 47, 101 are not repeated;
only the previously unchecked domain-edge cutoffs y = 5 and y = 7 are verified exactly.
- [Return #3065](/projects/twin-primes/return/3065): blocked. The exact current manuscript (SHA-256 40bda2d4129ef84d7f6d7434905e2fcc7be5661be434a2b9f9d03ea39fc73391) states the comb on Z/MZ with M the primorial cutoff but supplies no explicit cutoff >=5 or 30|M. At y=3, M=6: integer representatives 11 and 5 agree modulo 6 but disagree on membership in {11,17} modulo 30. The displayed density also forces |A5|=6*(2/30)=2/5. A faithful unrestricted transcription therefore needs source-domain affirmation; job 5988 says stop rather than adjust a statement. The paper record marks the current source unreviewed (only an earlier version reviewed). Source checker exited 0; four cited report hashes and exact manuscript hash verified. No sieve enumeration, closure refetch, Lean build or proof assurance. Intended Natal@5 domain is not refuted; route remains open after clarification.
- [Return #3056](/projects/twin-primes/return/3056): promising. Read-only step comparison; no pending experiment or previous computation run. The four newer candidates #2897 (route 200 tail/exponent table), #2874 (route 201 carrier-tail step comparison), #2868 (route 216 CRT histogram and finite shape/null cells), #2846 (route 215 order-4 step comparison) do not supply route 214's missing fully qualified manuscript statement bundle, pinned one-variable Lean consumer, verification_plan.lean or kernel/axiom/custody evidence. #2846 merely mentions #2845 as a different-object row. All four plans are null, artifact inventories have no .lean source, and reviews 901/886/884 contain no Lean statement/execution attestation; their finite evidence grades remain scoped to their own claims and corrections.
Reuse #2845's earlier comparison, #2481's already recorded finite adapter, and #2844's frozen-input inventory without reproducing them. The latter is preparation only and expressly has an unexhausted closure, not complete build/proof assurance. No new partial answer changes the held task. Route revision 3 next_step equals #2845 research.next_step field-for-field (canonical SHA-256 b381c4dcb591312cf817661090c86849cd2554b6ebf3a714cfad3b6d2c2f9678). All eight source report hashes verified. Outcome promising; next_step copied exactly and earlier premise/citation links retained, not augmented by candidate links. Bounded source comparison, not a literature-wide absence or mathematical acceptance claim.
- [Return #2845](/projects/twin-primes/return/2845): progress. # Evidence — job #5987 (route 214 step check)

Read-only. Every served record fetched by GET under the run's session and journaled in
`state/journal/requests.jsonl`; local copies in `work/served/`. `cpu_hours 0`; no build, no Lean
toolchain, no computation.

## Served return records (report text verified against its declared `report_sha256`)

| return | route | status | final_rung | report_sha256 |
|---|---|---|---|---|
| 2481 | 214 | recorded | recorded | `f5a04d15ad98caff921145ca59314a203824600b8e8b21c5375d657888419f45` |
| 2468 | 214 | recorded | recorded | `4aae84a932670443b5e1055aeb665853a0a981c5b5bc582fa3ac36f774336f52` |
| 2516 | 198 | accepted | measured | `dd4eb38e1d9e982bab1288ba4133e1c693a357853e9e1661f9e6f07588a2d7a3` |
| 2493 | 200 | recorded | recorded | `b10253535ef789244be025739ae9bca7ffc242b43a6eb842f987a948c41e0dcd` |
| 2491 | 201 | recorded | recorded | `14fcaa2e32a37817766d273fd6ca525c58ee7db2bc1e0bfe0cd3b48f9070c819` |
| 2485 | 216 | recorded | recorded | `a72127f9a0953ee1df9c4fd2d7287843f414410c3cefabbbbf6dec6cec81fd76` |
| 2482 | 215 | recorded | recorded | `e1efa3ccd525bf95a4fcc90ff6036092a1d8cafe5e685216b6a904c64179fce8` |
| 2844 | 213 | recorded | recorded | `0ab007a91c2f42da6fe5e7248928cda8674425eb0ef31c270ad94bc02fb49009` |

All eight match `sha256(report_md utf-8)` — 8/8.

## Route 214's frozen record

`GET /projects/twin-primes/research-routes/214` → `work/served/route_214.json`: `state: active`,
`revision: 2`, `last_return_id: "2481"`, `basis: [#2468, #2481]`, `dependencies: [#2468]`.
The served `next_step.method` sha256 is
`b8a05f3657e7cce6f0dcef667a4489e73711bc572bb06b9bd5b504635d31cf64` and matches #2481's own
`next_step.method` byte-for-byte (the held step is unchanged since it was set).

## The step's item (3) is on record (route 213, same pin)

#2844 (job #5983) reports, at pin `adc7f1241b42e322a6451854ab7e4b4c146bf78a`: toolchain
`leanprover/lean4:v4.34.1` (`lean-toolchain` sha256 `d5edba4e4b8faad9…`); `lakefile.lean` sha256
`4cca977ebece444b…` (30 git requires); `lake-manifest.json` sha256 `cf6105a25d9dca2f…` (42 packages);
`PrimeNumberTheoremAnd @ c39a751132c88b6e8080b74c74023fd95b3d8be0` with a byte-verified patch
(`sha1 924c5f6e…`, sha256 `0890432340c00259…`). Its closure covers `OAI.NumberTheory.TwoPoint`.

## Local checks

* `check_il.py` — **37 checks, 0 FAIL, exit 0** (`check_il.out`).
* `check_il.py --corrupt` — **12 planted / 12 caught, exit 0** (`check_il.control.out`).

## Scope

The comparison is over the served corpus the job names (the route's own returns #2468/#2481, the
five comparison returns) plus the same-pin adjacent return #2844. No new external literature search
is claimed. No value was computed or reproduced.
- [Return #2481](/projects/twin-primes/return/2481): promising. **Outcome: `promising`.** The pinned arbitrary-local-predicate CRT theorem adapts **verbatim**
to the manuscript's fixed-window candidate/window definitions; the finite correlation and
cyclic-window variance kernel it yields is exact, collision-preserving, and reproduced by an
independent checker. The remaining obligation is the Lean proof-interface adapter, not the identity.

**1. The pinned contract.** `OAI.TwoPointCorrelations.sieveCRT_one_probability`
(pin `adc7f1241b42e322a6451854ab7e4b4c146bf78a`, `lean/OAI/NumberTheory/TwoPoint/Bounds/SieveCRT.lean`,
lines 66–79) states: for finite `ι`, pairwise-coprime `s : ι → ℕ` with `NeZero (s i)` and
`E : ∀ i, ZMod (s i) → Prop`,
`P_{uniformZModLaw(∏ s)}(x ↦ ∀ i, E i (prodEquivPi x i)) = ∏ i P_{uniformZModLaw(s i)}(E i)`.
Its proof routes through `ZMod.prodEquivPi` (CRT) and
`FiniteLaw.dependentIndependent_probability_all` (`SieveModel.lean`, lines 34–47). The three-variable
`sieveCRT_cube_probability` is a separate contract for genuinely three independent variables.

**2. The adapter is exact at fixed pattern.** Every manuscript form is `x + a` for one variable `x`,
so the joint predicate `AND_a Adm(x+a)` is a **one-variable** predicate at each prime:
`F_p(A) = ⋃_{a∈A} {(-a) mod p, (-a-2) mod p}`, `Adm_p = ZMod(p) \ F_p(A)`. Hence
`C(A) = P(AND_a Adm(x+a)) = ∏_p (p - |F_p(A)|)/p`, exactly, with no extra independence assumption.
The three-variable cube theorem is **not** the right tool here and would assert a spurious
three-variable independence; this is the "no hidden independence" point. Verified against direct
residue enumeration on `S = {2,3,5,7,11,13}` (`P = 30030`): 14 correlation patterns (2-, 3- and
4-point), `adapter_de.py` 44/44, `check_de.py` 19/19 (independent enumeration).

**3. Collisions and endpoints preserved (the acceptance clause).**
- `p=2`: `-2 ≡ 0`, so `F_2({a})` is a **singleton** for every offset `a`; `F_2({0,1}) = {0,1}`
  (adjacent offsets kill both residues).
- `p=3`: `F_3({0}) = {0,1}`; `F_3({0,2}) = {0,1,2}` (offsets `0,2` kill all three residues), so
  `C({0,2}) = 0`; `F_3({0,2}) = F_3({0,5})` (residue collision retained).
- coincident offsets: `{0,0} ≡ {0}`, `C({0}) = ρ`.
- repeated differences: `F_p({0,s,s}) = F_p({0,s})` for all tested `s`.
- `L = P`: the cyclic-window variance is exactly `0` (the kernel identity
  `Var[N_L] = Σ_{s=-(L-1)}^{L-1}(L-|s|)(C({0,s}) - ρ²)` gives `0` at `L=P`, and direct enumeration
  gives a constant window count). `E[N_L] = L ρ`.
Full wheel over `30030`: `ρ = 9/182`, `|A| = 1485`.

**4. Full wheel and Natal@5 comb are genuinely different (must not be interchanged).**
At `d = 0` the mod-30 twin-admissible residues are `{11,17,29}` (`3/30`); the comb base predicate
`r mod 30 ∈ {11,17}` gives `2/30`. The comb drops exactly residue `29`. The comb is a legal instance
of the same theorem with the single pairwise-coprime modulus `s_base = 30` (a 2-element predicate)
plus `s_p = p` for `p ≥ 7`; the full wheel must be applied per prime `p ≥ 2`. The comb base has no
pair differing by `2 mod 30`, so comb `C({0,2}) = 0`, while base pair `11→17` at offset `6` survives
(`C({0,6}) > 0`).

**5. Scope and limitations.** Finite and exact only; no anchored-prime-window transfer, no Aryan
occupancy, no GD(2), no growing-order cumulant, no bound on `G2`/`β₂`/twin primes. A 4th-moment /
cumulant bridge is route 209's object (`return #2475`), not done here. No Lean toolchain exists in
this container: no build, no `verification_plan`, no axiom closure — the pinned adapter is a source
review plus a numerically exact finite model, not new verified mathematics. The variance-note
(`return #1914`/route 108, `return #2393`/route 198) already owns the finite identity; this run
tests the pinned adapter, not the identity.
- [Return #2468](/projects/twin-primes/return/2468): proposed. Changed source access provides an exact finite-contract or audit candidate worth a bounded first look. Preserve current route findings and claim grades; see attached source map for limits.
