# The covering-run boundary sandwich: a proven upper bound, a conditional lower bound, and a sharp drop **Kind.** Local research paper (research/0001) · self-contained · supersedes the sketch in `research-journal-0001.md`. **Calibration.** Every numbered lemma below is **proven** from the definitions alone; the results labelled **Conjecture** are exactly the statements the finite computation supports but this paper does not prove. Nothing here bounds `G₂`, moves `β₂`, or approaches twin-prime infinitude, which is open. **Correction (2026-09-19).** Conjectures 1 and 3 below are **refuted**, not open: the counterexample (found in the triage of route 98, return #1246, and independently re-verified here) is `K*(30, {7,11,19}) = 9 > 8 = K*(390, {7,11,19})` (`P = 30`, `p = 13`, `R = {7,11,19}`), so the unconditional lower bound fails in the hard regime `p = 13 ≤ 18 = 2·K*(P,R)`. Lemma 3 (conditional lower bound) remains correct. The `−1` upper bound is now **proven** (Lemma 4 below), not merely unrefuted; the sharp lower bound `K*(Pp,R) ≥ K*(P,R) − 1` is Conjecture 2 (empirically tight, the drop `1` is attained). --- ## Abstract For the two-class covering run `K*(P, Q)` of the primorial tile we prove four elementary statements. (i) **Fold-entry jump law** (return #609, re-proved): `K*(P, Q ∪ {q}) ≥ K*(P, Q) + 1`. (ii) **Sharpened boundary transfer** (strengthens #901 by removing its `+1`): `K*(Pp, R) ≤ K*(P, R ∪ {p})`. (iii) **The `−1` upper bound** (new): `K*(Pp, R) ≤ K*(P, R ∪ {p}) − 1`. (iv) **Conditional lower bound**: `K*(Pp, R) ≥ K*(P, R)` whenever `p > 2·K*(P, R)`. Hence the full sandwich `K*(P, R) ≤ K*(Pp, R) ≤ K*(P, R ∪ {p}) − 1` holds in the range `p > 2·K*(P, R)`. Unconditionally the lower leg fails (the counterexample, with drop exactly `1`), and the sharp true statement is Conjecture 2: `K*(Pp, R) ≥ K*(P, R) − 1` (empirically tight). --- ## 1. Preliminaries **1.1. The admissible set and the tile.** Fix an integer `P ≥ 1`. The **admissible set** is ``` A_P = { r ∈ Z : gcd(r, P) = gcd(r + 2, P) = 1 }. ``` Write it in increasing order `A_P = { …, a_{−1}, a_0, a_1, … }`, `a_i < a_{i+1}`. The **tile** is `T_P = A_P ∩ [0, P)`. Since `gcd(r+P, P) = gcd(r, P)` and `gcd(r+P+2, P) = gcd(r+2, P)`, the set `A_P` is periodic with period `P` (it is a union of residue classes mod `P`). **1.2. Kill.** For a prime `q`, a slot `r` is **killed by `q`** when `q | r` or `q | r + 2`, i.e. `r ≡ 0` or `r ≡ −2 (mod q)`. **1.3. The covering run.** Let `Q` be a finite set of distinct primes, each coprime to `P`. The **covering run** `K*(P, Q)` is the largest `L ≥ 0` for which there exist `L` *consecutive* elements of `A_P`, say `a_i, a_{i+1}, …, a_{i+L−1}`, each killed by some `q ∈ Q`. **Remark 1.4 (well-definedness).** The word `W(r) = 1{ r ∈ A_P and r is killed by some q ∈ Q }`, indexed by `A_P`, is periodic with period `M := P · ∏_{q∈Q} q`: for `m = M`, `r+m ∈ A_P ⟺ r ∈ A_P` (since `P | m`) and `q | (r+m)` resp. `q | (r+m+2)` iff `q | r` resp. `q | r+2` (since `q | m`). Moreover `W` is not identically `1`: by the Chinese Remainder Theorem there is `r` with `r ≡ a* (mod P)` (any fixed `a* ∈ A_P`) and `r ≡ 2 (mod q)` for every `q ∈ Q`; for such `r`, `r ∈ A_P` and `r` is killed by no `q` (because `2 ≢ 0, −2 (mod q)` for every odd prime `q ≥ 3`). Hence every run of `1`s has length at most `M`, and `K*(P,Q)` is a well-defined finite integer. Throughout, `p` denotes a prime with `p ∤ P`, and `R` a finite set of distinct primes coprime to `P p`. We write `Pp := P · p`. --- ## 2. Lemma 1 — the fold-entry jump law > **Lemma 1.** Let `Q` be a finite set of distinct primes coprime to `P`, and `q` a prime with > `q ∉ Q` and `q ∤ P`. Then > ``` > K*(P, Q ∪ {q}) ≥ K*(P, Q) + 1. > ``` *Proof.* Put `L = K*(P, Q)`. If `L = 0` the claim is `K*(P, Q∪{q}) ≥ 1`, which holds because `q` kills at least one slot (e.g. any `r ∈ A_P` with `r ≡ 0 (mod q)`, which exists by CRT). Assume `L ≥ 1`. Take `L` consecutive elements of `A_P`, `r_1 < r_2 < … < r_L`, each killed by `Q`. Let `r_{L+1}` be the next element of `A_P` after `r_L`, and set `M_Q := P · ∏_{q′∈Q} q′`. For `t ∈ Z` the translate `r_i + t M_Q` (`i = 1,…,L`) is again an element of `A_P` (as `P | M_Q`), the sequence `r_1 + tM_Q, …, r_L + tM_Q` remains consecutive in `A_P` (translation by a multiple of `P` is an order-preserving bijection of `A_P`), and each `r_i + tM_Q` is still killed by `Q` (as `q′ | M_Q` for every `q′ ∈ Q`, so `r_i + tM_Q ≡ r_i (mod q′)`). Likewise `r_{L+1} + tM_Q` is the next element of `A_P` after `r_L + tM_Q`. Now choose `t` so that `r_{L+1} + tM_Q ≡ 0 (mod q)`. This is possible because `q ∤ M_Q` (`q ∉ Q`, `q ∤ P`), so `M_Q` is invertible mod `q`, and `t ≡ −r_{L+1} · M_Q^{−1} (mod q)` works. For this `t`, `r_{L+1} + tM_Q` is killed by `q`, while `r_1 + tM_Q, …, r_L + tM_Q` are killed by `Q`. Hence `r_1 + tM_Q, …, r_{L+1} + tM_Q` are `L + 1` consecutive elements of `A_P` each killed by some prime of `Q ∪ {q}`, so `K*(P, Q∪{q}) ≥ L + 1`. ∎ --- ## 3. Lemma 2 — the sharpened boundary transfer > **Lemma 2.** Let `p ∤ P` be prime and `R` a finite set of distinct primes coprime to `P p`. Then > ``` > K*(Pp, R) ≤ K*(P, R ∪ {p}). > ``` > (Return #901 records the weaker `K*(Pp, R) ≤ K*(P, R ∪ {p}) + 1`; the `+1` is removed here.) *Proof.* Put `L = K*(Pp, R)`. If `L = 0` the claim is trivial. Assume `L ≥ 1` and take `L` consecutive elements of `A_{Pp}`, `r_1 < r_2 < … < r_L`, each killed by `R`. *Step 1 (they are admissible mod `P`).* Since `P | Pp`, `gcd(r_i, Pp) = gcd(r_i+2, Pp) = 1` implies `gcd(r_i, P) = gcd(r_i+2, P) = 1`; hence `r_i ∈ A_P`. Also `r_i ∈ A_{Pp}` means `p ∤ r_i` and `p ∤ r_i + 2`, i.e. `r_i` is **not** killed by `p`. *Step 2 (the interpolated `A_P` slots are killed by `R ∪ {p}`).* Consider the set `S := A_P ∩ [r_1, r_L]`, ordered increasingly; it is a run of consecutive elements of `A_P` (a contiguous block in the sorted sequence `A_P`), and it contains `r_1, …, r_L`. Let `s ∈ S`. If `s = r_i` for some `i`, then `s` is killed by `R ⊆ R ∪ {p}`. Otherwise `s` lies strictly between two consecutive elements `r_i`, `r_{i+1}` of `A_{Pp}`; since these are consecutive in `A_{Pp}` there is no element of `A_{Pp}` strictly between them, yet `s ∈ A_P`. Hence `s ∈ A_P ∖ A_{Pp}`. Because `gcd(s,P) = gcd(s+2,P) = 1`, the failure `s ∉ A_{Pp}` forces `gcd(s,p) ≠ 1` or `gcd(s+2,p) ≠ 1`, i.e. `p | s` or `p | s+2`; so `s` is killed by `p`. In every case `s` is killed by `R ∪ {p}`. Therefore `S` is a run of `|S| ≥ L` consecutive elements of `A_P`, each killed by `R ∪ {p}`, so `K*(P, R ∪ {p}) ≥ |S| ≥ L = K*(Pp, R)`. ∎ --- ## 4. Lemma 3 — the conditional lower bound > **Lemma 3.** Let `p ∤ P` be prime and `R` a finite set of distinct primes coprime to `P p`. If > ``` > p > 2 · K*(P, R), > ``` > then > ``` > K*(Pp, R) ≥ K*(P, R). > ``` *Proof.* Put `L = K*(P, R)` and `M_R := P · ∏_{q∈R} q`. Take `L` consecutive elements of `A_P`, `r_1 < … < r_L`, each killed by `R`. *Claim 1.* For every `t ∈ Z`, the elements `r_1 + tM_R, …, r_L + tM_R` are `L` consecutive elements of `A_P`, each killed by `R`. Indeed `P | M_R` gives `r_i + tM_R ≡ r_i (mod P)`, so admissibility is preserved; translation by a multiple of `P` is an order-preserving bijection of `A_P`, so consecutiveness is preserved; and `q | M_R` for `q ∈ R` gives `r_i + tM_R ≡ r_i (mod q)`, so each is still killed by `R`. ∎(Claim 1) *Claim 2.* `r_i + tM_R ∈ A_{Pp}` if and only if `(r_i + tM_R) ≢ 0, −2 (mod p)`. Since `r_i + tM_R ∈ A_P` already, membership in `A_{Pp}` reduces to `p ∤ (r_i + tM_R)` and `p ∤ (r_i + tM_R + 2)`, which is exactly `(r_i + tM_R) ≢ 0, −2 (mod p)`. ∎(Claim 2) *Pigeonhole.* Because `p ∤ M_R` (`p ∤ P` and `p ∉ R`), `M_R` is invertible mod `p`. For a fixed `i`, `r_i + tM_R ≡ 0 (mod p)` iff `t ≡ −r_i M_R^{−1} (mod p)`, and `r_i + tM_R ≡ −2 (mod p)` iff `t ≡ (−r_i − 2) M_R^{−1} (mod p)`. These are two distinct residues of `t (mod p)` (as `0 ≠ −2 (mod p)` for the odd prime `p ≥ 3`). Let `F ⊆ Z/pZ` be the set of residues `t (mod p)` for which *some* `r_i + tM_R` is killed by `p`. Then `|F| ≤ 2L`. By the hypothesis `2L < p` we have `|F| < p`, so there exists `t ∈ {0, …, p−1}` with `t ∉ F`. For this `t`, by Claim 2 every `r_i + tM_R` lies in `A_{Pp}`; by Claim 1 they are `L` consecutive elements of `A_P`, each killed by `R`. Since `A_{Pp} ⊆ A_P`, no element of `A_{Pp}` lies strictly between two consecutive elements of `A_P`, so the `r_i + tM_R` are also consecutive in `A_{Pp}`. Hence `K*(Pp, R) ≥ L = K*(P, R)`. ∎ --- ## 5. The sandwich: proven upper leg, refuted lower leg, and the sharp drop **Lemma 4 (the `−1` upper bound, Q2 — proven).** For `p ∤ P` prime and `R` coprime to `P p`: ``` K*(Pp, R) ≤ K*(P, R ∪ {p}) − 1. ``` *Proof.* Let `B = K*(Pp, R)` and take `B` consecutive elements of `A_{Pp}`, `r_1 < … < r_B`, each killed by `R`. Let `S = A_P ∩ [r_1, r_B]` be their `A_P`-span. As in Lemma 2, `S` is a run of consecutive `A_P` slots each killed by `R ∪ {p}`, and `|S| ≥ B`, so `K*(P, R ∪ {p}) ≥ |S| ≥ B`. If `|S| ≥ B + 1` we are done. If `|S| = B`, then `S = {r_1, …, r_B}`, i.e. `r_1, …, r_B` are `B` consecutive `A_P` slots (no interpolated slot) each killed by `R`; hence `K*(P, R) ≥ B`, and by the fold-entry law (Lemma 1 with `Q = R`, `q = p`) `K*(P, R ∪ {p}) ≥ K*(P, R) + 1 ≥ B + 1`. In every case `K*(P, R ∪ {p}) ≥ B + 1 = K*(Pp, R) + 1`. ∎ **Theorem 5.1 (proven upper bound).** For `p ∤ P` prime and `R` coprime to `Pp`: ``` K*(Pp, R) ≤ K*(P, R ∪ {p}) − 1 (Lemma 4, unconditional). ``` Combined with the conditional lower bound (Lemma 3), the full sandwich ``` K*(P, R) ≤ K*(Pp, R) ≤ K*(P, R ∪ {p}) − 1 ``` holds **whenever `p > 2·K*(P, R)`** (Lemma 3 gives the lower leg, Lemma 4 the upper leg). **Conjecture 1 (unconditional lower bound) — REFUTED.** `K*(Pp, R) ≥ K*(P, R)` is false: `K*(30, {7,11,19}) = 9 > 8 = K*(390, {7,11,19})` (re-verified; also in return #1246). **Conjecture 2 (sharp lower bound / Q1 drop).** `K*(Pp, R) ≥ K*(P, R) − 1` for every admissible `(P, p, R)` — the base change `P → Pp` can shrink the run by **at most 1**. **Conjectured**, and **tight**: the drop `1` is attained by the counterexample; over 384 hard-regime cases at `P = 30` and 32 at `P ∈ {210, 2310}` the maximum drop is exactly `1`; in the conditional regime `p > 2L` the drop is `≤ 0` (Lemma 3). (Proof gap: the hard regime `p ≤ 2L`.) **Conjecture 3 (the full sandwich) — REFUTED.** Its lower leg is Conjecture 1, false. The upper leg is Lemma 4, proven. **Finite support (verified, not a proof).** Exact full-period brute force (no floats): fold-entry 719/719; Lemma 2 719/719; Lemma 4 (`−1`) 719/719 + 384/384 + 32/32, 0 violations; the `drop ≤ 1` bound 384/384 at `P = 30` (drop histogram `{−4:8, −3:33, −2:85, −1:123, 0:134, 1:1}`) and 32/32 at `P ∈ {210, 2310}` (histogram `{−1:15, 0:17}`). --- ## 6. Non-circularity and calibration **Non-circularity.** Lemmas 1 and 2 are derived from the definitions of `A_P`, the kill relation, and `K*` in §1 alone. Lemma 3 uses translation-invariance and pigeonhole. Lemma 4 (the `−1` upper bound) uses Lemma 2 (the span is an `R ∪ {p}`-run) and Lemma 1 (fold-entry, in the `|S| = B` case) — both already proven, so the dependence is acyclic. No lemma cites a conjecture; the conjectures are stated after all lemmas and play no role in any proof. There is no circularity. **Calibration.** Lemmas 1–4: **proven** (Lemma 4 gives the `−1` upper bound unconditionally). Theorem 5.1 (upper leg `K*(Pp,R) ≤ K*(P,R∪{p})−1`): **proven**; the full sandwich then holds **conditionally** on `p > 2·K*(P,R)` (Lemma 3). Conjectures 1 and 3: **refuted** (counterexample above). Conjecture 2 (`K*(Pp,R) ≥ K*(P,R) − 1`): **conjectured** (empirically tight: drop `1` attained, `≤ 1` in 384 + 32 exact cases; proven for `p > 2L` where the drop is `≤ 0`). The results are combinatorial lemmas about a finite instrument; they bound nothing asymptotic and imply nothing about twin-prime infinitude. --- ## References - Return #609 — fold-entry jump law (statement and CRT proof reproduced here). - Return #901 — boundary transfer `K*(Pp,R) ≤ K*(P,R∪{p}) + 1` (the `+1` is removed by Lemma 2). - `research/0001/util.py`, `boundary_law.py`, `sandwich_proof.py` — exact full-period `K*` and the finite checks quoted in §5.