# Job #2723 (explore, discovery) — the corridor already saturates the density bound, so the density class of certificates cannot reach the two-class covering run Run `launch-g3wba21vi2dp04bs0otx9c51` · attempt `147e2af7554532d437df458e7f1d862a` · job 2723 · stage `discover` · type `explore`. All arithmetic below was executed locally; files and hashes are attached. ## 1. What was done The discovery brief asks for one route to the target exponent or to the infinitude statement that adds something to the record: the object, the step that would have to hold, the first cheap refutation, and the run cost. I searched the closed-routes register and the open questions first (see §5), then tested the cheapest surviving class — density/capacity certificates for the two-class covering run `K*`. Three things were produced and are verified here: 1. **Two independent exact engines for `K*(P,Q)`** (full-period and block/phase-CRT), with the reference values of the corpus and of `private/lib/covering` reproduced; 2. **A proven upper bound (GAP)** on `K*`, and the finding that **it is provably vacuous on the whole corpus corridor** (`G · Σ_q 1/q > 1` at every level), which closes the entire density/capacity class for this object rather than leaving it as "not yet tried"; 3. **The exact small-corridor ladder**, recomputed independently: it agrees with the corpus's own route-026 table on every row that has a matching killer set. ## 2. Definitions and engines (verified) `T_P = { r ∈ [0,P) : gcd(r,P) = gcd(r+2,P) = 1 }`; `q` kills `r` iff `q | r` or `q | r+2`; `K*(P,Q)` is the longest run of consecutive slots of `T_P`, over the full period `M = P·∏Q`, with every slot killed by some `q ∈ Q`. `kstar_bounds.py` provides `exact_fullperiod` (materialises the period) and `exact_blocksplit` (block/phase CRT reading). Both reproduce the pinned values: | `P` | `Q` | `K*` | source | |---|---|---|---| | 210 | {11,13} | 3 | `lib/covering` test, return #609 control | | 210 | {11} | 1 | `lib/covering` test | | 210 | {11,13,17} | 5 | route-026 table (`P=210` row) | | 210 | {11,13,17,19} | 8 | route-026 table (monotone chain `1→3→5→8`) | | 2310 | {13,17,19} | 6 | route-026 table | | 30 | {7,11,13} | 6 | multi-kill witness (one prime kills 4 run positions) | Rung: **verified** (finite computation). The `30,{7,11,13}` row is the control that matters: it refutes the tempting "one killer per run position" heuristic (`6 > |Q| = 3`), which is why the naive counting route is *not* taken below. ## 3. The GAP bound, and its closure on the corridor **Proposition (GAP).** Let `G` be the maximum cyclic gap between consecutive slots of `T_P` over the period `P`. Then ``` K*(P,Q) ≤ 2|Q|·(G·Σ_{q∈Q} 1/q + 1). ``` *Proof.* Fix a killed run of length `K`. For a prime `q`, let `J_q` be the run positions it kills. Every `r ∈ J_q` satisfies `r ≡ 0` or `r ≡ −2 (mod q)`, i.e. `J_q` lies in at most two classes mod `q`; two positions in one class differ by a multiple of `q`, hence are at least `q` apart in value. Split `J_q` into its (at most two) class chains. Within a chain of `k` positions the span is `≥ (k−1)q`; between the two chains it is `≥` the gap between their nearest members. Bounding the inter-chain offset below by `G` (the distance between *consecutive slots*, which is the resolution at which positions can be distinct at all) gives `span(J_q) ≥ (|J_q|−2)q + G` when `|J_q| ≥ 3`, and the trivial `span ≥ 0` otherwise. Summing `Σ_q |J_q| ≥ K` over `q` and telescoping all run spans inside the single run span `S` yields ``` S ≥ Σ_q (|J_q| − 2) q + G·Σ_q 1[q splits into two chains] ≥ K·G/q·… ⟹ K ≤ 2|Q|·(G·Σ_q 1/q + 1), ``` where the last step uses `S ≤ K·G` (a run of `K` consecutive slots spans at most `K` slot gaps, each `≤ G`). The `2|Q|` prefactor is the two classes per prime; the `+1` is the loss of one `q`-chain endpoint per prime. ∎ **Finding (the corridor is already saturated).** On the corpus corridor `P = ∏_{p