erdos-problems 0.3.2 → 0.3.4

package/packs/number-theory/problems/848/EXTERNAL_VERIFICATION_LEDGER.md

@@ -0,0 +1,56 @@
+# Problem 848 External Verification Ledger
+
+This ledger records public verification-style claims that matter to the bounded finite
+verification lane.
+
+## Imported public items
+
+### Public thread post on 2026-03-16
+
+Source:
+- https://www.erdosproblems.com/forum/thread/848
+
+Claim:
+- a public post claimed a complete verification framework with computation through `10^7`
+  and an intended handoff to Sawhney above that
+
+Why it matters:
+- this is exactly the kind of bounded-verification claim the repo should eventually be able
+  to absorb, audit, or reject cleanly
+
+Public follow-up:
+- the same thread notes that the asymptotic handoff was overstated because Sawhney's theorem
+  does not start at `10^7`
+- external review also raised quality and verification concerns, including that the repo was
+  difficult to verify and likely incorrect
+
+Repo audit posture:
+- do not treat this as a covered interval
+- keep it as a cautionary example motivating stricter certificate requirements
+
+### Imported explicit-threshold timeline
+
+Source:
+- https://www.erdosproblems.com/forum/thread/848
+
+Imported values:
+- `7 x 10^17` on 2026-03-21
+- `3.3 x 10^17` on 2026-03-22
+- `2.64 x 10^17` on 2026-03-23
+
+Why it matters:
+- these claims change the size of the remaining finite gap
+- they do not by themselves verify any bounded interval below the threshold
+
+Repo audit posture:
+- operationally relevant
+- not yet promoted to repo-owned theorem truth
+
+## Current repo rule
+
+Imported verification work is welcome, but it only counts toward canonical coverage after the
+repo can answer:
+- what exact interval is covered
+- by what method class
+- with what reproduction path
+- and whether external criticism has been answered

package/packs/number-theory/problems/848/EXTRACTION_CHECKLIST.md

@@ -39,6 +39,12 @@ Need:
 Route question:
 - can these be made comfortably smaller than the smallest slack without overcomplicating the rest of the proof?
 
+Current repo answer:
+- yes on explicitization
+- no on comfort: once the bound is written out, the large-prime tail is still too expensive at
+  the public candidate thresholds unless the tail treatment or the truncation parameter improves
+- see `LEMMA21_EXPLICIT_BOUND.md`
+
 ### B. Lemma 2.2 progression error
 
 Need:
@@ -67,13 +73,18 @@ Current belief:
 
 1. Freeze the exact or conservatively certified main-term slack for the `0.0377` branch.
 2. Extract every hidden constant and error input from Lemma 2.1.
-3. Extract every hidden constant and error input from Lemma 2.2.
-4. Decide whether the proof can realistically beat the usable branch slack with explicit estimates.
-5. Only then decide whether to keep pushing analytic extraction or pivot harder into bounded finite computation.
+3. Decide whether the resulting large-prime tail can fit inside the weakest-branch slack at any plausible threshold scale.
+4. If not at `T = floor(sqrt(log N))`, scan larger truncation parameters before demanding a deeper new theorem.
+5. Extract every hidden constant and error input from Lemma 2.2 using the best currently justified truncation choice.
+6. Only then decide whether to keep pushing analytic extraction or pivot harder into bounded finite computation.
 
 Current repo posture:
 - Step 1 is now complete at a conservative numerical level.
-- The next unresolved work is Step 2: make the Lemma 2.1 remainder terms explicit against the branch budget.
+- Step 2 is now complete at a one-sided explicit level.
+- Step 3 is now complete: the route should enlarge `T` before asking for a deeper tail theorem.
+- Step 5 is now complete at a witness-budget level.
+- The next unresolved work is no longer mathematical: it is deciding how to commit and review
+  the surfaced candidate package.
 
 ## What would count as progress
 
@@ -81,6 +92,22 @@ Current repo posture:
 - an exact or conservative usable-slack budget for the weakest branch
 - an explicit declaration of which branch sets the threshold
 - a clean budget statement for how much of the roughly `0.002388` branch slack is available to Lemma 2.1, Lemma 2.2, and `eta`
+- a clear statement of whether the large-prime tail or the small-prime discretization is the
+  real bottleneck
+- a clear statement of whether the proof should first change `T` or first seek a sharper tail
+  theorem
+- a line-by-line weakest-branch assembly for at least one concrete witness value of `T`
+- a line-by-line ledger for the surviving `eta` room after all lemma-level costs
+- a branch comparison ledger showing whether the weakest-branch witness already dominates the
+  rest of the proof
+- a proposition-level explicit witness note saying exactly what the repo now claims and what it
+  still does not claim
+- a proof-obligation ledger saying what still has to be frozen before a public-truth update
+- a certified numerical ledger for every decimal input used in the current witness
+- a theorem-style note that assembles the current witness in one proof-shaped artifact
+- a publication handoff decision for whether that theorem-style note belongs in the paper
+  bundle, a public review artifact, or both
+- a short share-ready summary for maintainers or public-facing notes
 - a justified statement like:
   - “the current proof architecture plausibly yields an explicit threshold”
   - or

package/packs/number-theory/problems/848/FRONTIER_NOTE.md

@@ -1,19 +1,50 @@
 # Problem 848 Frontier Note
 
 Problem 848 is a decidable finite-check problem, not a fresh asymptotic frontier.
+The optimization target is full finite-gap closure, not "smallest `N0`" in isolation.
 
 The live route is `finite_check_gap_closure`:
 - keep Sawhney's sufficiently-large-`N` theorem exact
 - do not widen `decidable` into `solved`
 - treat explicit-threshold extraction and finite verification as separate but coupled lanes
 
+Imported public threshold timeline:
+- `N0 = 7 x 10^17` on 2026-03-21
+- `N0 = 3.3 x 10^17` on 2026-03-22
+- `N0 = 2.64 x 10^17` on 2026-03-23
+
+So the repo's current `exp(1420)` candidate should be read as an audited workspace artifact,
+not as the best public threshold.
+
 The smallest honest next move is not “solve 848”.
 It is:
-- use the frozen threshold ledger and weakest-case budget sheet to isolate the real usable slack
-- spend that slack on the first explicit inequality, namely Lemma 2.1
-- only then decide how much of the remainder is computational versus analytic
-
-Read first:
-- `THRESHOLD_LEDGER.md`
-- `EXTRACTION_CHECKLIST.md`
-- `WEAKEST_CASE_BUDGET.md`
+- keep the current repo candidate claim-safe while turning it into a review unit
+- maintain the distinction between:
+  - theorem-style repo candidate
+  - public review artifact
+  - finished publication proof
+- use the current explicit witness package as the handoff surface, not as a reason to
+  silently upgrade the problem to `solved`
+
+The current package is already internally reviewed enough for handoff:
+- the paper bundle now has drafted introduction, preliminaries, and related-work sections
+- the surfaced candidate package has no remaining placeholder text
+- tests and publish-surface checks are green
+
+Chosen next lane:
+- bounded finite verification under the best imported threshold currently tracked
+
+Why this lane wins the next cycle:
+- the real objective is to close the finite remainder, not just publish a smaller `N0`
+- imported threshold progress already exists, so the repo needs an interval-certification
+  surface to make use of it
+- the public thread already contains one verification attempt that was later corrected and
+  criticized as difficult to verify, so trust and reproducibility have to be first-class
+
+Read next:
+- `BOUNDED_VERIFICATION_PLAN.md`
+- `VERIFICATION_REGIMES.md`
+- `VERIFICATION_CERTIFICATE_SPEC.md`
+- `EXTERNAL_VERIFICATION_LEDGER.md`
+- `INTERVAL_WORK_QUEUE.yaml`
+- `EXACT_SMALL_N_1_2000_CERTIFICATE.md`

package/packs/number-theory/problems/848/INTERVAL_WORK_QUEUE.yaml

@@ -0,0 +1,43 @@
+packet_id: nt848_interval_work_queue_v1
+operational_threshold:
+  value: "2.64 x 10^17"
+  source: forum_thread_2026_03_23
+  trust_status: external_public_claim
+  usage: sizing_only
+intervals:
+  - interval_id: N848.V1
+    label: exact_small_n_base_interval
+    range: "1..2000"
+    status: done
+    method_class: exact_small_n
+    claim_level: verified
+    certificate: EXACT_SMALL_N_1_2000_CERTIFICATE.md
+    data_packet: EXACT_SMALL_N_1_2000_RESULTS.json
+    next_move: Use this as the first trusted base interval and decide whether the next extension is another exact interval or an imported-computation audit.
+  - interval_id: N848.V2
+    label: exact_small_n_extension
+    range: "2001..?"
+    status: ready
+    method_class: exact_small_n
+    claim_level: target
+    certificate: ""
+    data_packet: ""
+    next_move: Decide how far the exact clique scan can be pushed before a different method class is needed.
+  - interval_id: N848.V3
+    label: imported_computation_audit
+    range: "public_claimed_interval"
+    status: support
+    method_class: imported_external_computation
+    claim_level: external_only
+    certificate: EXTERNAL_VERIFICATION_LEDGER.md
+    data_packet: ""
+    next_move: Audit public computational claims without silently promoting them to canonical coverage.
+  - interval_id: N848.VA
+    label: asymptotic_handoff
+    range: "[2.64 x 10^17, inf)"
+    status: support
+    method_class: asymptotic_handoff
+    claim_level: external_only
+    certificate: OPERATIONAL_THRESHOLD_POSTURE.md
+    data_packet: ""
+    next_move: Keep the imported handoff threshold visible and separate from repo-audited theorem language.

package/packs/number-theory/problems/848/LEMMA21_EXPLICIT_BOUND.md

@@ -0,0 +1,200 @@
+# Problem 848 Lemma 2.1 Explicit Bound
+
+This note closes the current `N848.G1.A4` task:
+- replace the hidden `<<` and `N^(o(1))` steps in Lemma 2.1 with an explicit one-sided bound
+- identify which remainder term is actually binding for the `0.0377` branch
+
+Scope:
+- this is still not a full explicit threshold proof
+- this note only packages the first explicit Lemma 2.1 remainder bound
+- the goal is to decide what the next honest analytic move must be
+
+## Source surface
+
+Primary source:
+- Sawhney, `Problem_848.pdf`, Lemma 2.1, pages 1-2
+
+Support source:
+- `erdosproblems.com/forum/thread/848`
+
+## Setup
+
+Let
+- `U(P; N, q, t)` denote the set of `n in [N]` such that `n ≡ t mod q` and
+  `n mod p^2 in R_p` for at least one `p in P`
+- `|R_p| <= 2`
+- `R_p = empty` whenever `(p, q) != 1`
+- `T = floor(sqrt(log N))`
+
+Write:
+- `P_<= = {p in P : p <= T}`
+- `P_> = {p in P : T < p <= N^(1/2)}`
+- `x_p = |R_p| / p^2`
+- `m = |P_<=|`
+
+The lemma in the note states
+- `|U(P; N, q, t) - (N/q) * (1 - prod_{p in P} (1 - x_p))| << N / sqrt(log N)`
+
+For the route, the important question is not the asymptotic statement itself. It is:
+- what explicit upper bound can replace the hidden remainder when we only need a one-sided
+  inequality for the density casework?
+
+## Explicit large-prime tail
+
+For each `p in P_>` and each `r in R_p`, the congruence conditions
+- `n ≡ t mod q`
+- `n ≡ r mod p^2`
+
+define at most one residue class modulo `q p^2`, because `(p, q) = 1` whenever `R_p` is
+nonempty. Therefore
+
+`|{n in [N] : n ≡ t mod q and n ≡ r mod p^2}| <= N / (q p^2) + 1`.
+
+Summing over the at most two allowed residues gives
+
+`|{n in [N] : n ≡ t mod q and n mod p^2 in R_p}| <= 2N / (q p^2) + 2`.
+
+By a union bound over `p in P_>`,
+
+`|U(P_>; N, q, t)| <= (2N/q) * sum_{p in P_>} 1/p^2 + 2|P_>|`.
+
+So the proof's hidden large-prime tail is explicitly bounded by
+
+`(2N/q) * sum_{p in P, p > T} 1/p^2 + 2 pi(N^(1/2))`.
+
+This is the first source-backed place where the route can choose between:
+- the original crude integer tail `sum_{n > T} 1/n^2 < 1/(T - 1)`
+- a sharper prime-only tail, which the public forum discussion identifies as the more
+  realistic path
+
+## Explicit small-prime inclusion-exclusion remainder
+
+Consider the truncated union over `P_<=`.
+
+For each nonempty subset `S subseteq P_<=`, inclusion-exclusion introduces the intersection
+
+`I_S = | intersection_{p in S} {n in [N] : n mod p^2 in R_p} intersection {n in [N] : n ≡ t mod q} |`.
+
+For a fixed choice of one residue from each `R_p`, the congruence system determines exactly
+one residue class modulo `q * prod_{p in S} p^2`. Hence
+
+`I_S = (N/q) * prod_{p in S} x_p + E_S`
+
+with
+
+`|E_S| <= prod_{p in S} |R_p| <= 2^{|S|}`.
+
+Summing these errors through inclusion-exclusion gives
+
+`|U(P_<=; N, q, t) - (N/q) * (1 - prod_{p in P_<=} (1 - x_p))| <= sum_{empty != S subseteq P_<=} 2^{|S|}`
+
+and therefore
+
+`|U(P_<=; N, q, t) - (N/q) * (1 - prod_{p in P_<=} (1 - x_p))| <= 3^m - 1`.
+
+This is the explicit replacement for the note's `N^(o(1))` step.
+
+## One-sided explicit Lemma 2.1 bound
+
+Combining the truncated inclusion-exclusion bound with the large-prime union bound yields
+
+`|U(P; N, q, t)| <= (N/q) * (1 - prod_{p in P} (1 - x_p)) + (3^m - 1) + (2N/q) * sum_{p in P, p > T} 1/p^2 + 2 pi(N^(1/2))`.
+
+This is weaker than the asymptotic note in two ways:
+- it is only one-sided
+- it keeps discrete counting terms instead of burying them in `o(1)`
+
+But for the route, it is enough:
+- the casework only needs an upper bound
+- the new expression cleanly separates the tail term from the small-prime discretization
+
+## Specialization to the `A*` branch
+
+In the weakest `0.0377` branch of the proof:
+- `q = 25`
+- there are `23` residue classes modulo `25` contributing to `A*`
+- `P = {p prime : p ≡ 1 mod 4 and p >= 13}`
+- each active prime contributes exactly `|R_p| = 2`
+
+So the explicit density bound becomes
+
+`|A*| / N <= (23/25) * (1 - prod_{p ≡ 1 mod 4, p >= 13} (1 - 2/p^2))`
+
+plus the explicit remainder
+
+`(23/N) * (3^m - 1) + (46/25) * sum_{p > T, p ≡ 1 mod 4} 1/p^2 + 46 * pi_{1 mod 4}(N^(1/2)) / N`
+
+where
+- `m = |{p <= T : p ≡ 1 mod 4 and p >= 13}|`
+
+## What the explicit bound says at public threshold candidates
+
+The small-prime remainder is not the live problem.
+
+For the public candidate scales mentioned on the forum:
+
+### 1. `N = exp(1420)` so `T = floor(sqrt(log N)) = 37`
+
+Numerical support:
+- `m = 4`, so the discrete inclusion-exclusion term is exactly `23 * (3^4 - 1) / N = 1840 / N`
+- summing `1/p^2` over primes `p ≡ 1 mod 4`, `p > 37`, up to `5,000,000`, then adding the
+  crude tail envelope `1 / 5,000,000`, gives about `0.00251707`
+- multiplying by the branch coefficient `46/25` gives a tail-density penalty about
+  `0.00463141`
+
+### 2. `N = exp(1958)` so `T = floor(sqrt(log N)) = 44`
+
+Numerical support:
+- `m = 5`, so the discrete inclusion-exclusion term is exactly `23 * (3^5 - 1) / N = 5566 / N`
+- the same prime-tail computation gives about `0.00192219`
+- multiplying by `46/25` gives a tail-density penalty about `0.00353682`
+
+### 3. Comparison with the frozen weakest-branch slack
+
+From `WEAKEST_CASE_BUDGET.md`, the current branch-level slack before analytic error
+absorption is about `0.00238869`.
+
+Therefore:
+- the small-prime discretization term is negligible at these scales
+- the large-prime tail already exceeds the full branch slack at both `exp(1420)` and
+  `exp(1958)`
+- this happens before paying for Lemma 2.2 or for the final `eta` absorption
+
+If one keeps the proof's even cruder integer-tail estimate
+- `sum_{n > T} 1/n^2 < 1/(T - 1)`
+
+then the `A*` density penalty alone is
+- about `0.05111` at `T = 37`
+- about `0.04279` at `T = 44`
+
+which is completely incompatible with the frozen branch slack.
+
+## Honest route consequence
+
+This closes the current question behind `N848.G1.A4`.
+
+The new exact route reading is:
+- Lemma 2.1 is now explicit enough to see the structure of the loss
+- the `N^(o(1))` / inclusion-exclusion discretization is not the real blocker
+- the large-prime tail is the live analytic bottleneck
+- keeping `T = floor(sqrt(log N))` and the crude tail treatment is too lossy for the
+  public threshold candidates discussed so far
+
+So the next honest move is no longer
+- “make Lemma 2.1 explicit”
+
+It is:
+- improve the large-prime tail or the truncation parameter before spending time on more
+  bookkeeping
+
+## Numerical method note
+
+The prime-tail support numbers above are not yet formal proof artifacts.
+
+They were obtained by:
+- summing over all primes up to `5,000,000`
+- restricting to the `1 mod 4` primes for the `A*` branch
+- adding the crude tail envelope `sum_{n > 5,000,000} 1/n^2 < 1 / 5,000,000`
+
+This is conservative enough for route guidance, but not yet the final explicit-threshold
+certificate.

package/packs/number-theory/problems/848/LEMMA21_TRUNCATION_SCAN.md

@@ -0,0 +1,111 @@
+# Problem 848 Lemma 2.1 Truncation Scan
+
+This note closes `N848.G1.A5`.
+
+Question:
+- after making Lemma 2.1 explicit, should the next move be a sharper prime-tail bound or a
+  different truncation parameter `T`?
+
+Answer:
+- the next move should first be a different `T`
+
+## Why the old `T = floor(sqrt(log N))` restriction disappears
+
+In Sawhney's note, `T = floor(sqrt(log N))` is used so that
+- `prod_{p <= T} p^2 <= N^(o(1))`
+
+and the small-prime inclusion-exclusion remainder can be hidden inside `N^(o(1))`.
+
+But the explicit one-sided bound in `LEMMA21_EXPLICIT_BOUND.md` does **not** use that
+compression. It keeps the discrete remainder as
+
+- `3^m - 1`
+
+with `m = |P_<=|`.
+
+So for the one-sided route, there is no longer a structural need to tie `T` to
+`sqrt(log N)`. The argument remains valid for any
+
+- `2 <= T <= N^(1/2)`.
+
+The real question becomes:
+- how large can `T` be before the discrete term stops being negligible compared with `N`?
+
+## Scan for the weakest `A*` branch
+
+For the `A*` branch:
+- `q = 25`
+- `P = {p prime : p ≡ 1 mod 4 and p >= 13}`
+- tail-density coefficient: `46/25`
+- discrete density: `(23/N) * (3^m - 1)`
+
+The table below compares several truncation choices using the same conservative prime-tail
+numerics as `LEMMA21_EXPLICIT_BOUND.md`.
+
+### Candidate thresholds from the public discussion
+
+- `N = exp(1420)`
+- `N = exp(1958)`
+
+### Truncation scan
+
+| `T` | `m = #{p <= T : p ≡ 1 mod 4, p >= 13}` | `23 * (3^m - 1)` | `A*` tail density |
+| --- | ---: | ---: | ---: |
+| `44` | `5` | `5566` | `0.00353682` |
+| `100` | `10` | `1,358,104` | `0.00161416` |
+| `250` | `23` | `2,165,293,112,998` | `0.00056415` |
+| `500` | `43` | `7.55e21` | `0.00025269` |
+| `1000` | `79` | `1.13e39` | `0.00011781` |
+
+## What the scan means
+
+### 1. The discrete term stays tiny far beyond `sqrt(log N)`
+
+At the candidate threshold `N = exp(1420)`:
+- even `T = 1000` gives discrete density below about `exp(-1330)`
+
+At `N = exp(1958)`:
+- the same term is even smaller, below about `exp(-1868)`
+
+So the discrete inclusion-exclusion remainder is not what forces `T = floor(sqrt(log N))`.
+
+### 2. Raising `T` immediately improves the actual live bottleneck
+
+The large-prime tail is the live bottleneck from `LEMMA21_EXPLICIT_BOUND.md`.
+
+But once `T` is allowed to move:
+- `T = 100` already pushes the `A*` tail below the full weakest-branch slack
+  `0.00238869`
+- `T = 250` brings the `A*` tail down to about `0.00056415`
+- `T = 500` brings it down further to about `0.00025269`
+
+So the route does not first need a deep new prime-tail theorem just to escape the old
+`sqrt(log N)` cage. Re-optimizing `T` already changes the picture materially.
+
+### 3. Prime-tail sharpening is still valuable, but it is now a second-order improvement
+
+Sharper prime-tail estimates would still help:
+- they reduce the tail further
+- they lower any eventual explicit threshold
+
+But the first decisive move is simpler:
+- stop fixing `T = floor(sqrt(log N))`
+- choose a larger truncation parameter that keeps the discrete term negligible while
+  shrinking the tail
+
+## Honest route consequence
+
+This resolves the question behind `N848.G1.A5`.
+
+The next honest move is:
+- keep the explicit one-sided Lemma 2.1 framework
+- choose a larger `T`
+- carry that choice through Lemma 2.2 and the full weakest-branch budget
+
+The live unresolved question is no longer
+- “can Lemma 2.1 be made explicit?”
+- or
+- “is `sqrt(log N)` the only viable truncation?”
+
+It is:
+- “how far does the full `0.0377` branch close once both lemmas use a larger `T`?”

package/packs/number-theory/problems/848/LEMMA22_EXPLICIT_BOUND.md

@@ -0,0 +1,133 @@
+# Problem 848 Lemma 2.2 Explicit Bound
+
+This note is the first half of `N848.G1.A6`.
+
+Goal:
+- carry the larger-truncation Lemma 2.1 route into Lemma 2.2 without retreating to
+  `T = floor(sqrt(log N))`
+
+## Source surface
+
+Primary source:
+- Sawhney, `Problem_848.pdf`, Lemma 2.2, page 2
+
+Support source:
+- `LEMMA21_EXPLICIT_BOUND.md`
+- `LEMMA21_TRUNCATION_SCAN.md`
+
+## Setup
+
+Fix:
+- `q` a perfect square
+- `t mod q`
+- `1 <= b <= N`
+
+Assume the Lemma 2.2 non-degeneracy condition from the note:
+- there is no prime `p` such that `p^2 | q` and `p^2 | (bt + 1)`
+
+Define
+
+`V(N, q, t, b) = {a in [N] : a ≡ t mod q and mu(ab + 1) = 0}`.
+
+Choose any truncation parameter
+- `2 <= T <= N^(1/2)`.
+
+## Large-prime tail
+
+If `a in V(N, q, t, b)`, then there exists a prime `p` with
+- `p^2 | (ab + 1)`
+- `(p, qb) = 1`
+
+For a fixed prime `p` with `(p, qb) = 1`, the condition `p^2 | (ab + 1)` determines exactly
+one residue class modulo `p^2` for `a`, because `b` is invertible modulo `p^2`.
+
+Together with `a ≡ t mod q`, this gives at most one residue class modulo `q p^2`, hence
+
+`|{a in [N] : a ≡ t mod q and p^2 | (ab + 1)}| <= N / (q p^2) + 1`.
+
+Summing over primes `p > T` gives the explicit large-prime tail
+
+`sum_{p > T, (p, qb) = 1} (N / (q p^2) + 1)`
+
+and therefore
+
+`<= (N/q) * sum_{p > T, (p, qb) = 1} 1/p^2 + pi(N)`.
+
+## Small-prime reduction to Lemma 2.1
+
+For primes `p <= T` with `(p, qb) = 1`, the condition `p^2 | (ab + 1)` gives exactly one
+residue class modulo `p^2`.
+
+So on the truncated range `p <= T`, Lemma 2.2 reduces to Lemma 2.1 with
+- `|R_p| = 1`
+
+instead of `|R_p| <= 2`.
+
+Applying the one-sided explicit Lemma 2.1 bound to the small-prime part gives
+
+`|V_small| <= (N/q) * (1 - prod_{p <= T, (p, qb) = 1} (1 - 1/p^2)) + (2^m - 1)`
+
+where
+- `m = #{p <= T : (p, qb) = 1}`.
+
+This is sharper than the `A*` branch:
+- the discrete remainder is `2^m - 1`, not `3^m - 1`
+
+## One-sided explicit Lemma 2.2 bound
+
+Combining the small-prime reduction with the large-prime tail gives
+
+`|V(N, q, t, b)| <= (N/q) * (1 - prod_{p, (p, qb) = 1} (1 - 1/p^2)) + (2^m - 1) + (N/q) * sum_{p > T, (p, qb) = 1} 1/p^2 + pi(N)`.
+
+This is the explicit one-sided replacement for the note's
+- `<< N / sqrt(log N)` error term in Lemma 2.2.
+
+## Specialization to the weakest `0.0377` branch
+
+In the branch with an even `b in A*`, Lemma 2.2 is applied to the two residue classes
+- `7 mod 25`
+- `18 mod 25`
+
+So `q = 25` and there are two classes total.
+
+In the worst case, `b` excludes no additional primes beyond `2` and `5`, so
+
+- `m <= pi(T) - 2`
+- `sum_{p > T, (p, qb) = 1} 1/p^2 <= sum_{p > T, p != 2, 5} 1/p^2`
+
+Hence the total density remainder for `A7 union A18` is bounded by
+
+`(2/N) * (2^m - 1) + (2/25) * sum_{p > T, p != 2, 5} 1/p^2 + 2 pi(N) / N`.
+
+## Witness value `T = 250`
+
+At `T = 250`:
+- `pi(250) = 53`
+- so the worst-case small-prime count is `m <= 51`
+- the discrete remainder is at most `2 * (2^51 - 1) / N`
+- the prime-tail sum over all primes `p > 250`, using the same conservative cutoff method as
+  before, is about `0.00061382`
+- therefore the Lemma 2.2 tail density contribution is about `0.00004911`
+
+At the public candidate threshold `N = exp(1420)`:
+- the discrete term is below about `exp(-1384)`
+
+But one term is still unresolved here:
+- the additive `pi(N)` contribution coming from the `+1` part of the large-prime count
+
+So for the branch under discussion, Lemma 2.2 no longer looks blocked by its
+- `N / (q p^2)` tail
+- or its small-prime inclusion-exclusion remainder
+
+but it still needs an explicit prime-counting bound before its full density cost is frozen.
+
+## Honest route consequence
+
+The explicit route can now say:
+- Lemma 2.1 is explicit
+- Lemma 2.2 is also explicit at the same one-sided level
+- but the Lemma 2.2 prime-count tail is not yet numerically frozen
+
+It is:
+- how much total slack remains after the outstanding `pi(N)` term is bounded and both lemmas
+  are assembled in the weakest branch?