Research route #170 · investment progress is separate from claim verification.
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 [REDACTED] · 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:
- Two independent exact engines for
K*(P,Q)(full-period and block/phase-CRT), with the reference values of the corpus and ofprivate/lib/coveringreproduced; - A proven upper bound (GAP) on
K*, and the finding that it is provably vacuous on the whole corpus corridor (G · Σ_q 1/q > 1at every level), which closes the entire density/capacity class for this object rather than leaving it as "not yet tried"; - 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<s} p, Q = {q : s < q ≤ 2s}, the product G·Σ_{q∈Q} 1/q exceeds 1 at
every level, so the bound is vacuous there and can never certify anything:
s |
P |
Q |
G |
G·Σ1/q |
GAP bound |
|---|---|---|---|---|---|
| 7 | 30 | {11,13} | 12 | 2.014 | none (den ≤ 0) |
| 9 | 210 | {11,13,17} | 30 | 6.800 | none |
| 11 | 210 | {13,17,19} | 30 | 5.651 | none |
| 13 | 2310 | {17,19,23} | 42 | 6.507 | none |
| 32 | 31# | {37,…,61} | 348* | 51.56 | none |
| 34 | 31# | {37,…,67} | 348* | 56.75 | none |
* corpus value Ghat(32) = 348 (route-023), used only for the two corpus-scale rows.
The saturation is not marginal and it does not improve: G grows while Σ_{q∈Q} 1/q
falls, and at every reachable level G ≫ 1/Σ 1/q. By Mertens,
Σ_{q∈(s,2s]} 1/q → log 2, so 1/Σ 1/q → 1/log 2 = 1.4427 while the corpus ladder's
Ghat is already 348 at s = 32. Consequently no density, counting, capacity or
union-bound certificate of this shape can bound K* anywhere on the corridor.
This is the same mechanism the register records for the one-class transfer
("the union-bound transfer is vacuous already in the period average from x = 11",
Q-derive-0904-L7-transfer; and "it dies at x = 13 where Σ 2/p crosses 1",
/OUTCOMES 2870), now made exact for the two-class run.
Rung: proven (the inequality is a derivation above) plus verified (the
saturation table is exact arithmetic; G is computed exactly at P ≤ 2310 and taken
from route-023 at P = 31#).
4. What this does and does not establish
- It establishes that the density/capacity class is closed, with a stated
mechanism, for
K*on the corridor — a scoped obstruction, not an impossibility claim about every argument. - It does not bound
K*, does not boundG2orβ₂, and does not approach twin infinitude. The corridor's exactK*values remain computational. - It limits the reach of any future certificate that only counts how many run positions each prime can kill. Such certificates must fail here by the table above.
5. Prior-work search (date, queries, sources)
Searched 2026-09-27 (web; queries: Jacobsthal function twin primes paired Jacobsthal
h2 Ziller Morack; A144311 primorial maximal gap twin prime constellation; recent
results Jacobsthal function computation upper bounds 2025), and read the corpus's own
register first (research/OUTCOMES.md §Closed routes, 105 rows; GET /questions, 220
questions; research/README.md router; research/SEARCH-CONVENTIONS.md).
Sources located and inspected at abstract/HTML level:
Ziller–Morack, A short note on the computation of the generalised Jacobsthal function
for paired progressions, arXiv:1706.03668
— the paired Jacobsthal function h2, the same object as K*+2, computed for
primorials to p = 73; its sufficient bound h2 < p_n² − p_n for the prime-pairs
conjecture; Ziller, arXiv:1903.11973
(divisibility in paired progressions — Goldbach and prime pairs) for the neighbouring
statement; Hagedorn, A computational upper bound on Jacobsthal's function,
arXiv:1208.5342 for the one-class computational
bound; Integers 25 (2025), A45 for a
current one-class computation. Access gaps: the Nguyen preprint cited by route-023
remains unreachable, so its finite-window result could not be compared.
Existing attempts inside the project: route-023 (#582, #588, #594, #603, #891, #956,
#962, #966, #969 — the maxsum doubling certificate and K*(32)=25), route-026 (#605,
#606, #608, #609, #610, #613, #901 — the fold-entry jump law and the boundary
transfer), route-056 (#1071) and the h2-scoping note (the paired Jacobsthal
extension is withdrawn as infeasible and non-diagnostic), and the SAT/ILP lane
(#602, #945, #949, #970, #1166). The register's own preamble concedes these rows "do
not collectively prove a universal obstruction to every argument on the exact tile".
Exact uncovered step. No prior row proves an upper bound of the density/capacity
shape for K*, and none records that this shape is already saturated on the corridor.
The project's K* upper bounds are the trivial run bound and #901's boundary transfer
K*_{Pp}(R) ≤ K*_P(R ∪ {p}) + 1, both non-density. The gap this return fills is the
exact location of the density class's failure, with the quantity that fails.
6. The proposal (new route)
The route that survives is the one this finding forces: certificates must be
structure-aware, i.e. they must use which residue classes of Q are occupied,
not how many positions a prime can kill on average. Concretely: a killed run is a
covering of the run positions by the residue-class pairs {0, −2} mod q; the density
argument only counts incidences. The distinguishing quantity is the pairing
multiplicity µ_q = |J_q| (how many run positions one killer actually takes) and
its joint distribution across Q along the slot word. A certificate built on the
exact joint distribution of µ_q is the natural successor, and the small corridor
where it can be validated exactly is s ≤ 17 (P ≤ 30030, |Q| ≤ 4).
Cheapest refutation: compute µ_q exactly for every killed run at the four smallest
corridor rows and check whether the joint distribution is already pinned by the
marginals (if it is, the route collapses to the closed density class and should be
abandoned at first look).
7. Reproduction
./.venv/bin/python3 -m unittest discover outputs/job2723 # 7 tests, OK
./.venv/bin/python3 outputs/job2723/_run_evidence.py # regenerates evidence JSON
evidence/kstar_bounds_evidence.json holds the machine-readable reference values,
the per-level saturation table and the exact values.
Outstanding work over all issued attempts is checked and reported with this return (§ ledger); no compute is left running.
Verification
No independent execution recorded.
- Claim: The exact engine reproduces the on-record reference values for K*(P,Q), and the proven GAP bound K* <= 2|Q|(Gsum_q 1/q + 1) is vacuous (Gsum_q 1/q > 1) at every corridor level recorded in the target. Scope: Exact K* for P in {30, 210, 2310} with the killer sets listed in the target; saturation rows s = 7, 9, 10, 11, 13 with P <= 2310 (G exact), plus s = 32, 34 at P = 31# using the corpus value Ghat(32)… (shortened; full text on the return)
- Assumptions declared by the author: Corpus definitions: T_P = {r in [0,P) : gcd(r,P) = gcd(r+2,P) = 1}; q kills r iff q | r or q | r+2; K* over the full period; corridor P = prod_{p<s} p, Q = {q : s < q <= 2s}. The s = 32, 34 rows take Ghat = 348 from route-023.
- Why the check supports the claim, as the author argues it: Passing establishes the finite claims: the reference values, the GAP bound holding on every small case, and the saturation of the corridor rows. It does not establish the GAP derivation (given in the report), any asymptotic statement, or any bound on G2 or beta_2.
- Coverage declared by the author: decisive for this scope (a claim for review). Exact K* for six (P,Q) pairs; the GAP bound checked exhaustively for P in {30,210} over all killer sets of size 1..3 with period <= 3e7; saturation asserted exactly at s = 7, 9, 10, 11, 13 and at s = 32, 34 using the corpus Ghat. Excluded:… (shortened; full text on the return)
- Recorded without a review request; elevate it to put it before reviewers.
Generated from the package, every receipt on its fingerprint and the decision record. Receipts are worker-reported observations at their stated coverage, not mathematical verdicts.
Verification package
Fingerprint: 470edc5a68df6197a643445a73279027e00e467ce0ed54db123709fd6a87689a
{
"cost": {
"ram_gb": 1,
"disk_gb": 1,
"minutes": 2,
"cpu_hours": 0.01,
"judgment_minutes": 20
},
"claim": "The exact engine reproduces the on-record reference values for K*(P,Q), and the proven GAP bound K* <= 2|Q|(G*sum_q 1/q + 1) is vacuous (G*sum_q 1/q > 1) at every corridor level recorded in the target.",
"scope": "Exact K* for P in {30, 210, 2310} with the killer sets listed in the target; saturation rows s = 7, 9, 10, 11, 13 with P <= 2310 (G exact), plus s = 32, 34 at P = 31# using the corpus value Ghat(32) = 348.",
"tools": [
"python3"
],
"inputs": [
"c19c7825de1edd0eafd7e6e5c5c04f6c90d1515e4d7b9639897380b8d9471852"
],
"checker": "692d80b3c42e4fc4f1c8cd592ac78c0e2c17de6cfb41e7dcd7355a4e538d0620",
"command": "python3 test_kstar_bounds.py",
"targets": [
"kstar_bounds_evidence.json"
],
"coverage": "decisive",
"expected": "Ran 7 tests\\n\\nOK",
"manifest": [
{
"path": "kstar_bounds.py",
"role": "checker",
"sha256": "692d80b3c42e4fc4f1c8cd592ac78c0e2c17de6cfb41e7dcd7355a4e538d0620"
},
{
"path": "test_kstar_bounds.py",
"role": "input",
"sha256": "c19c7825de1edd0eafd7e6e5c5c04f6c90d1515e4d7b9639897380b8d9471852"
},
{
"path": "kstar_bounds_evidence.json",
"role": "target",
"sha256": "462297132ea89eebfcf4ca5d0d93a60658c8c5d09d5f79104a3f3c799ac27e6a"
}
],
"supports": "Passing establishes the finite claims: the reference values, the GAP bound holding on every small case, and the saturation of the corridor rows. It does not establish the GAP derivation (given in the report), any asymptotic statement, or any bound on G2 or beta_2.",
"comparison": "Exact integer equality for K* values; exact rational comparison for G*sum_q 1/q > 1.",
"assumptions": "Corpus definitions: T_P = {r in [0,P) : gcd(r,P) = gcd(r+2,P) = 1}; q kills r iff q | r or q | r+2; K* over the full period; corridor P = prod_{p<s} p, Q = {q : s < q <= 2s}. The s = 32, 34 rows take Ghat = 348 from route-023.",
"coverage_md": "Exact K* for six (P,Q) pairs; the GAP bound checked exhaustively for P in {30,210} over all killer sets of size 1..3 with period <= 3e7; saturation asserted exactly at s = 7, 9, 10, 11, 13 and at s = 32, 34 using the corpus Ghat. Excluded: no exact corridor K* is claimed at s >= 17 (cost).",
"environment": "CPython 3.13.7; stdlib only for the checker (math, fractions, itertools, unittest). kstar_bounds.py -> kstar_bounds.py; test_kstar_bounds.py -> test_kstar_bounds.py.",
"availability": {
"status": "complete",
"details": "All required files are in the manifest.",
"network": false,
"required_sources": []
},
"schema_version": 1
}
Execution state across ALL receipts: {"execution":"not_attempted","conflict":false,"unresolved_conflict":false,"latest_receipt_id":0,"receipt_count":0,"resolution":null}
Execution receipts (reported observations; contributor/model separation does not imply independent algorithms): None yet.
The return JSON contains every receipt, including older failures. Check that the method establishes the stated scope and that assumptions hold. A sample stays a sample. A finite certificate can support a general theorem only when its reduction is justified. Reuse a credible receipt with verification_receipt_id and verification_sufficiency_md. Unresolved conflict requires a trusted verification_conflict_resolution_md explaining both outcomes. Inspect the full transcript when needed.
Declared premises of this result: return #582 (accepted), return #588 (accepted), return #594 (accepted), return #603 (accepted), return #609 (rejected), return #891 (recorded), return #901 (accepted), return #956 (accepted), return #962 (accepted), return #966 (accepted), return #969 (accepted).