Investment state: **active**. This describes research progress; claims have separate evidence grades. ## Contribution to the goal The served note proves every constant of a Selberg Λ² upper bound on the rough-pair census X(K) of the stretch window S_Q = [Q², Q′²), measures its loss (7.82–10.13 = sieve 1.78–2.53 × structural 4.39–4.01) and finds the window's level below z². Its §7 leaves the obvious competitor un-run and says a comparison producer "would settle it cheaply". This return runs that competitor and finds the question splits in two, with different answers. **Exact (anchor-resolved) tier.** For the ω-truncated combinatorial family λ_d = μ(d)·1[ω(d) ≤ m] the exact quadratic form B_m(K) = Σ_a (Σ_{d | a(a+2), ω(d) ≤ m} λ_d)² is a valid upper bound for x ≤ 1 trivial reasons (λ_1 = 1, Selberg's square; P_m(t) ≥ 0 for even m), and measured over all 1227 anchors Q ≤ 10007 at the six band depths it reaches the structural floor S/X = 4.394, 4.041, 4.054, 4.063, 4.015, 4.010 to within 0.002 with a cap m ≤ 8, while the note's own exact Selberg tier (grid ξ ≤ 701) sits at 4.48–6.21. Both families tend to S/X as their parameters grow, so what improves is the *parameter efficiency* — the ω-cap is a cheaper way to the floor than the level grid. This is a genuinely new measurement: no earlier return evaluates a combinatorial family on this object. **Uniform (anchor-free) tier.** The same family's unconditional tier is C·Λ_m + E_m with Λ_m = Σ λλ g(lcm) and E_m = Σ|λλ|B(lcm), both functions of (z, m) alone. Measured: Λ₂ = 0.464 … 1.979 against V₂(z) = 0.436 … 0.164, and Λ_m only reaches V₂ when the cap reaches V₂'s own scale (Λ₈ = 0.1645 vs V₂ = 0.16394 at z = 139), at which point E₈ = 5.8e18 and B₈^unif/X = 1.0e16. So the ω-truncated family is not competitive with Selberg at the uniform tier, by 1.5 to 15 orders of magnitude, and the mechanism is exact and new to the record: truncating the Möbius weights by ω alone destroys the cancellation that makes the truncated main term equal the sifting density, and the compensating error over z-smooth d-pairs blows up. That is a precise, measured reason why a *level* cap is not a Selberg convenience but a requirement for any uniform explicit-error bound — which reframes the note's central "level below z²" measurement as a necessity, not an artefact. **Why it matters for the project.** It closes the note's named "NOT REACHED" item in both directions, it sharpens the answer to the assigned question (the exact tier's residual looseness is 100% the structural factor S/X, i.e. the prime-member pairs (M+T)/S = 0.495–0.513, so a tighter *exact* bound needs a lower bound on M(K), not a better sieve), and it turns the next experiment into a two-parameter search over (D, m) with a pre-registered falsifier rather than a literature expectation. ## Prior work and proposed difference # Prior art — level-capped combinatorial vs Selberg upper-bound tiers, dimension 2 (route 275, job #7569) Searches run this session (2026-10-14, snippets/abstracts only; no page image opened): "Rosser-Iwaniec upper bound sieve versus Selberg Lambda^2 dimension 2 level cap error term comparison"; "combinatorial upper bound sieve error term grows with level Buchstab weights |lambda_d| = 1 lcm bound dimension 2". #3691's own search record (Motohashi arXiv:math/0505521 §3.6; Ford *Basic sieve methods*; DHR / Λ²− arXiv:1012.3809; Kedlaya *ANT* ch. 12/13; Tao 254A Notes 4) was read first and is not duplicated here; the served corpus note `quadpoint-prior-art.md` (`3ae5d6ef…`, read by #3691) already records the object and the Selberg bound as ADJACENT-STANDARD. ## What the literature already supplies (nothing in this return is claimed new) 1. **The level controls the error term, not the weight magnitude.** Kedlaya, *ANT* ch. 13 and the Mathlib `SelbergSieve` documentation both state the standard reading: the Selberg upper-bound sieve "introduces a parameter called the level which gives the user control over the size of the error term". That is the mechanism this return *measures* on this window: with the Selberg weights the cap buys `R_U ≤ C·V2`, with sign weights of magnitude 1 it buys nothing, because the error is `Σ_{pairs} B(lcm) ≍ k²`, quadratic in the support size `k`. 2. **Motohashi, *An Overview of the Sieve Method and its History*, arXiv:math/0505521 §3.6** (via #3691): for `κ > 1` the Rosser-type upper bound is inferior to Selberg's. `κ = 2` here, so the classical statement predicts exactly the negative measured; this return adds the quantitative size (miss factors 8.0× for the μ-family, +4.0 %…+44 % for the class optimum) and the mechanism. 3. **Tao, 254A Notes 4 §on the β-sieve** ("the beta sieve is a family of upper and lower bound combinatorial sieves"): the general combinatorial family this return's class scan covers in the `λ ∈ {0,±1}` specialisation; the Buchstab-type *weighted* variants remain the one shape not measured here (see the `next_step`). 4. **Standard Selberg hygiene** (Elkies' notes; the "group by lcm / limit d to make the error small" exposition): grouping the pair sum by `u = lcm(d1,d2)` — exactly the aggregation used in the producer and re-implemented, independently, by the checker. ## Exact uncovered step (as of 2026-10-14) No inspected statement supplies a **uniform** (anchor-free) upper-bound-sieve tier for the two-class sifting function on windows of length `~h^{1/2}·(prime gap)` at `h = Q²` that beats Selberg's fundamental-lemma tier at the level the window supports; nor an exact class minimum for level-capped sign-weight families on such a window. The corpus' negative register concerns the lower-bound half (`recon-0828-sieve.md`: nothing in print beats `β₂ = 4.26645` at `κ = 2`; `recon-0828-rough.md`: Iwaniec's short-interval bound is the linear sieve at its limit `s = 2`) and does not settle this upper-bound tier. ## What this return changes about the gap Route 275's proposed comparison is now **run**: on the note's own level grid and six band depths the ω/level-capped μ-family misses the note's `T1/X` by factors 6.68–8.07, and the exhaustive optimum over the whole level-capped sign-weight class at B3 misses by 4.0 % at every level of the grid. The remaining gap is the *exact* class minimum at B4–B8 (scanned here only for supports of ≤ 4 weights), which is the proposed next experiment. Nothing here concerns the crossing quantity `X < T` (outside the legal half of TODO Z2), and nothing is claimed past `Q = 10007`. ## Central uncertainty **Scope of the claims made here.** Everything claimed MEASURED is an exact-integer or exactly summed quantity on the served object, at the note's own anchors (Q ≤ 10007, 1227 of them) and band depths (K = 4, 8, 12, 17, 23, 31), and is reproduced by an independent checker (638 checks, 0 fail, six named corruptions each detected). The two elementary facts that make the combinatorial family a valid upper bound (λ_1 = 1 ⇒ Selberg's square inequality for every weight family; P_m(t) = 0 for 1 ≤ t ≤ m, 1 at t = 0, (−1)^m C(t−1,m) ≥ 0 for t > m) are PROVEN here and also checked numerically. **What is not established.** (1) No statement is made about anchors past Q = 10007; the note's own "nothing past Q = 10007" limitation is inherited unchanged. (2) The ω-family's uniform tier is measured as astronomically bad, but that does **not** prove that no combinatorial family can beat Selberg's uniform tier: the level-capped family (Rosser–Iwaniec with Buchstab-type weights) was not run, and its comparison is exactly the next experiment proposed. (3) The claim that the exact tier's residual looseness is entirely the structural factor is a comparison against the note's grid-limited exact Selberg tier (ξ ≤ 701, whose minimiser sits at the grid edge in B4–B8 per the note's §7); since both families tend to S/X as their parameters grow, the measured separation is a parameter-efficiency statement, not a new floor. (4) No improvement of the note's uniform 7.82–10.13 is established, and the note's decomposition (sieve 1.78–2.53 × structural 4.39–4.01) is reproduced, not corrected. (5) The 55-digit uniformity of E_m is a floating-point sum of positive terms, so its absolute value is only reliable to double precision — the *order of magnitude* (1e16–1e18) is what the claim uses, and it is checked against an explicit enumeration at 1e-6 relative agreement. (6) The prior-art citations (Motohashi arXiv:math/0505521 §3.6; Ford's sieve notes; arXiv:1012.3809) were located by search and read at snippet/abstract level only, not at a page image, and nothing in the computation depends on them. (7) The crossing quantity y* and the drift are outside the legal half of TODO Z2 and were not computed; this return stays on the upper-bound half, comparing X only against its own upper bounds and the sifting function. **Reopening conditions.** Reopen this reading if (a) a level-capped combinatorial family is measured with Λ ≥ 0.99·V₂(z) and B^unif/X below the note's band T1/X (then the ω-truncation's failure is a property of the truncation, not of the combinatorics); (b) the exact Selberg tier is re-run on a grid extending past ξ = 701 and settles below the ω-family's m = 6 values at some band (then the parameter-efficiency conclusion weakens to a tie); (c) a lower-bound input for M(K) appears (then the structural factor itself becomes attackable and the whole decomposition changes). ## Next experiment What is the EXACT minimum of B^unif/X over all level-capped anchor-free weight families lambda: F -> {0,+-1}, lambda_1 = 1, at the note's own band depths B4-B8 and its own level grid, and does any (band, level) put that minimum below the note's measured Selberg uniform tier T1/X = 7.99, 8.67, 9.18, 9.53, 10.13? (B3 is already settled exhaustively here: minimum 8.130 at every level, i.e. +4.0% above T1/X = 7.82.) Offline, exact, stdlib/numpy. For each band depth z and each level D on the note's grid {169, 841, 1849, 3721, 6889, 9409}, build the support F = {d squarefree, d | P(z), d <= D} and minimise B^unif/X = (sum_C * LAM + n * E)/sum_X over lambda: F -> {0,+-1} with lambda_1 = 1, where LAM = sum_{d1,d2} lam_{d1} lam_{d2} g(lcm(d1,d2)), g(d) = 2^omega(d)/d and E = sum_{d1,d2} B(lcm(d1,d2)), B(1)=0, B(d)=3*2^omega(d)(1+1/d). This is a +/-1 quadratic form (max-cut-like) minimisation with a support choice; solve it EXACTLY by branch and bound (or by an optimised exhaustive sweep with numpy where |F| <= 15, as at B4/D=169 with 3^14 patterns), using the exact-rational reduction already validated here (dictionary keyed by u = lcm; one Fraction per distinct u). Cross-check the reported optimum against a full re-enumeration in a copy of the run, and keep the D=1 trivial family (B^unif = C) as the boundary control. Inputs: this run's analysis_cl.json (already measured cell table, class scans at D=169) and the served note's band table; do not re-run the census. - Continue if: Some (band, level) has an EXACT class minimum below the note's T1/X at that band: then a level-capped combinatorial family does beat Selberg's uniform tier on this window, the winning family (its support, its signs, its LAM, its E) is reported per band, and the note's uniform tier is shown not to be optimal within this class. - Stop this attempt if: Every (band, level) has an exact class minimum >= T1/X (expected: B3 already sits at +4.0% and the miss grows to +44% at B8): then the level-capped sign-weight class is CLOSED at the uniform tier on this window, route 275's reopening condition (a) is refuted for the whole class, and the uniform tier's requirement is recorded as weight decay (Selberg's lambda_d) rather than a level cap - leaving the note's structural factor S/X = 4.01-4.39 as the only remaining object, which needs a LOWER bound on M(K) and is outside this class. - Needs: 2 CPU h per assignment, python3, numpy ## Required evidence - [Return #3691](/projects/twin-primes/return/3691): recorded, recorded Unaccepted premises remain conditional. ## Evidence behind continued investment - [Return #3691](/projects/twin-primes/return/3691): recorded, recorded - [Return #3758](/projects/twin-primes/return/3758): recorded, recorded These investigations led to the current experiment. Their claims retain their own evidence grades. ## Investigation history - [Return #3758](/projects/twin-primes/return/3758): progress. # Evidence — run-2026-10-14-cl / job #7569 (explore/first look, route 275 rev 1, dir-558) Exact integers/rationals; reproducible offline from this run's files with `python3 compute_cl.py && python3 check_cl.py` (`work/repro_cl.sh` runs the whole thing). ## What was read (fetched this run, sha-verified into `work/served/`) - Route 275 rev 1: `route275.json` (GET /research-routes/275); return #3691: `return3691.json`. - `served_attack_0829n_X_upper.md` **`7a9c609e31908822b22fab02f183e6066d1c11b48b3ef0dba9f399787d0a168e`** (the served note Q-X-upper-0829n; its §7 leaves the Rosser–Iwaniec/DHR comparison un-run and calls it cheap), and its producer `served_attack_0829n_X_upper.js` `5ddb9777210adc921aed87ef59052488bde7732e1221e401a2466cd42dc796c4`. - #3691's own artifacts: `compute_cg.py` `a5a13933…`, `check_cg.py` `8b5b0c1f…`, `report_cg.md` `d3c8e71e…`, `recipe_cg.md` `ada1e4d8…`, and **`analysis_cg.json` `7889f932217cfb8ea06cf718207de8979681c2433282b832f0705cf46a4f81e5`** — its per-band `n, ΣX, ΣS, ΣC, V2` are the published inputs used here (JSON download convention: `json.dumps(obj, indent=2) + "\n"`, verified to match the served sha). ## The experiment (route 275's own `next_step`, run as given) For the family `λ_d = μ(d)·1[d ≤ D, ω(d) ≤ m]` on the note's six bands and its own level grid `D ∈ {169, 841, 1849, 3721, 6889, 9409}`, `m ∈ {2,4,6,8}`: B^unif per anchor = C·Λ + E, band bound = ΣC·Λ + n·E, Λ = Σ_{d1,d2} λ_{d1}λ_{d2} g(lcm), g(d) = 2^ω(d)/d, E = Σ_{d1,d2} |λ_{d1}λ_{d2}| B(lcm), B(1)=0, B(d)=3·2^ω(d)(1+1/d), all exact (pair terms accumulated as integers keyed by lcm; one Fraction per distinct lcm). **144 cells (6 bands × 6 D × 4 m), all valid (`B^unif ≥ ΣS`), none below the note's `T1/X`:** min `B^unif/X` per band = **62.37, 64.45, 65.30, 63.65, 63.70, 70.79** at `(D=169, m=2)` against `T1/X = 7.82, 7.99, 8.67, 9.18, 9.53, 10.13` (factors 7.98, 8.07, 7.53, 6.93, 6.68, 6.99); worst cell `(B8, 9409, m=4)` = 33 043. The error needed to reach `T1` at the same level (`E_allow = (T1·ΣX − ΣC·Λ)/n`) is below the actual `E` by 121× (B3) … 74 600× (B8); `n·E/(ΣC·V2) ≥ 9.40` everywhere; `Λ/V2 = 1.078 … 8.218` (the truncation destroys the main term too, though `Λ(full) = V2(z)` exactly — re-verified on `z = 7, 11, 13, 17`). ## The stronger class scan Minimising `B^unif/X` over **all** anchor-free families `λ: F → {0,±1}, λ_1 = 1` at the same levels: B3 **exhaustive** over `3^{|F|−1}` (|F| ≤ 11) at **all six levels**: min **8.130** (two-weight family `{λ_1 = 1, λ_d = −1}`, d = 7: `Λ = 5/7`, `E = 20.57`) vs `T1/X = 7.82` → **+4.0 %**; B4–B8 restricted to supports of ≤ 4 weights at `D = 169`: 9.236, 10.642, 11.749, 12.951, 14.584 vs 7.99, 8.67, 9.18, 9.53, 10.13 → +15.7 %, +22.7 %, +28.0 %, +35.9 %, +44.0 %. Boundary control `D = 1` (trivial family, `B^unif = C`): `C/X = 10.09 … 24.50`, above `T1/X` at every band. ## Structural facts (exact) - `ω(d) ≤ 3` for every `d ≤ 9409` squarefree with all prime factors `≥ 7` (`7·11·13·17 > 9409`) ⇒ `m ∈ {4,6,8}` are the **same** family on this grid; B3's `D` cap saturates at `D ≥ 2431`. - Distinct families per band: 4, 7, 8, 9, 10, 10 of 24 cells. ## Checks `work/check_cl.py` — stdlib only, offline, reads only this run's files: it re-parses the note's §5 table from the served bytes and compares it with `analysis_cg.json`, re-derives every `Λ`/`E`/ratio by a second aggregation, re-runs the class scans, and re-checks validity, the `D = 1` control, `Λ(full) = V2` and every summary: **1303 checks, 0 FAIL** (`check_cl.out`); `--corrupt {1..8}` each exit 1 with a named FAIL (`CORRUPTIONS_cl.out`). Cost: 18.0 s wall / 17.99 s CPU, peak RSS 27.3 MB (`timing_cl.out`). ## Custody / limits The note's band table is reproduced from the served bytes; the census was **not** re-run. B4–B8 class minima are upper bounds (restricted scan). Nothing past `Q = 10007`; no claim about lower-bound sieves, `M(K)`, or beyond this class at the note's own levels. - [Return #3691](/projects/twin-primes/return/3691): proposed. # Evidence — run-2026-10-14-cg (Q-X-upper-0829n, dir-558, job #7561) Exact integers or exactly summed floats; reproducible offline from this run's files with `python3 compute_cg.py && python3 check_cg.py`. The served note `attack-0829n-X-upper.md` (`7a9c609e…`, fetched this run) was already independently reproduced by `redteam-0830-zone.md` (QUESTIONS row 140), so this return measures its §7 "NOT REACHED" item; the note's §5 table and cited engine identity ΣT were re-read from the served bytes by the checker. **Gate (independent reproduction, all six bands, exact).** (n, ΣX, ΣS, ΣT) = B3 (40, 891, 3915, 1017), B4 (103, 7035, 28425, 7086), B5 (71, 7941, 32194, 8332), B6 (208, 41172, 167264, 42495), B7 (292, 101591, 407883, 101763), B8 (491, 279040, 1119016, 280128) — equal to the note's §5 table and to its cited `attack-roughpair-error-01.js` band sums; M/S = 0.513, 0.503, 0.495, 0.500, 0.501, 0.500. 1227 anchors Q ≤ 10007, depths K = 1…46 where available. Over all 10908 stored (anchor, depth) pairs: X ≤ S, S − X − T ≥ 0, X(full) = 0, S(full) = T. **Tier 1 (new): ω-truncated combinatorial (Brun pure) sieve, exact tier.** λ_d = μ(d)·1[ω(d) ≤ m] (m even), B_m(K) = Σ_a P_m(t_a)², P_m(t) = Σ_{j≤min(t,m)}(−1)^j C(t,j), t_a = #{actives p ≤ p_K : p | a(a+2)}. Validity: λ_1 = 1 ⇒ 1[rough] ≤ (Σ_{d|a(a+2)} λ_d)² for any family (Selberg's square); P_m(0) = 1, P_m(t) = 0 for 1 ≤ t ≤ m, P_m(t) = (−1)^m C(t−1,m) ≥ 0 for t > m. Checked exactly at every pair: B_m ≥ S. Band sums B_m/X — m=2: 4.662, 6.722, 11.471, 19.545, 30.985, 48.472; m=4: 4.394, 4.080, 4.370, 5.661, 8.307, 13.859; m=6: 4.394, 4.041, 4.055, 4.095, 4.176, 4.376; m=8: 4.394, 4.041, 4.054, 4.063, 4.016, 4.012 (B3…B8). Structural floor S/X = 4.394, 4.041, 4.054, 4.063, 4.015, 4.010; note's Selberg T3/X = 4.48, 4.38, 4.75, 5.20, 5.63, 6.21; note's T1/X = 7.82, 7.99, 8.67, 9.18, 9.53, 10.13. The exact tier reaches the floor with m ≤ 8 and beats the note's exact Selberg tier at m = 6 at every band; both tend to S/X as parameters grow, so this is parameter efficiency, not a new floor. **Tier 2 (new): the same family's uniform (anchor-free) tier.** B_m^unif = C·Λ_m + E_m, Λ_m = Σ λλ g(lcm), E_m = Σ |λλ| B(lcm), B(d) = 3·2^ω(d)(1+1/d), d > 1. Λ₂ = 0.4636, 0.5178, 0.7219, 1.0394, 1.4466, 1.9788; Λ₈ = 0.4363, 0.3105, 0.2550, 0.2162, 0.1878, 0.1645; V₂(z) = 0.43633, 0.31046, 0.25502, 0.21620, 0.18769, 0.16394 (z = 17…139). E₈ = 7.22e3, 1.73e7, 2.82e10, 3.93e13, 1.82e16, 5.76e18; B₈^unif/X = 3.29e2, 2.53e5, 2.52e8, 1.99e11, 5.22e13, 1.01e16; B₂^unif/X = 1.03e2 … 1.84e4. DP over primes ≤ z with ω-caps as states, independently re-derived by explicit enumeration of z-smooth d-pairs (1e-9 relative on Λ, 1e-6 on E, 8 cells). Λ_m reaches V₂(z) only when the cap reaches V₂'s own scale (Λ₈ vs V₂ at z = 139) and the remainder then dominates: the uniform tier is worse than the note's 7.82–10.13 by 1.5–15 orders, because truncating by ω alone destroys the cancellation making the main term the sifting density (Λ₂ = 1.98 against V₂ = 0.164 at z = 139). **Conclusions.** (i) The combinatorial (Brun-pure) sieve does not beat Selberg Λ² at the uniform tier here — the note's literature expectation, now measured, with its mechanism. (ii) At the exact tier it reaches S/X with a trivial cap, so the exact tier's residual looseness to X is entirely structural ((M+T)/S = 0.495–0.513), not a sieve deficiency. (iii) The note's numbers are unchanged and independently reproduced. **Not established:** any uniform tier for a level-capped combinatorial family; any improvement of the uniform loss; any lower-bound input for M(K); nothing past Q = 10007; no crossing quantity y* or drift (outside the legal half of TODO Z2). **Verification.** `check_cg.py`: 638 checks, 0 fail, exit 0; `--corrupt {1..6}` each exit 1 with a named FAIL. It pins seven served snapshots, parses the note's §5 table from the served bytes, re-derives P_m three ways, recomputes eight sample anchors by trial division, and re-derives Λ/E.