erdos-problems 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # erdos-problems
 
-Maintained by Fractal Research Group (`frg.earth`).
+Maintained by SproutSeeds. Research stewardship: Fractal Research Group ([frg.earth](https://frg.earth)).
 
 > CLI and workspace for Paul Erdos problems.
 >
@@ -60,7 +60,7 @@ Install:
 npm install -g erdos-problems
 ```
 
-Bootstrap a seeded problem:
+If you already know the problem you want, the fastest path is:
 
 ```bash
 erdos bootstrap problem 857
@@ -69,7 +69,7 @@ erdos sunflower ready 857
 erdos workspace show --json
 ```
 
-Seed a new problem into the current workspace:
+If you want to start from a new local seed:
 
 ```bash
 erdos seed problem 25 --cluster number-theory
@@ -77,6 +77,179 @@ erdos problem show 25
 erdos checkpoints sync
 ```
 
+## Beginner Flow
+
+This is the zero-assumption path for a new user.
+
+### 1. Install the CLI once
+
+```bash
+npm install -g erdos-problems
+```
+
+This gives you a global `erdos` command. The workspace state it creates is local to the folder you are in.
+
+### 2. Make a clean working folder
+
+```bash
+mkdir erdos-work
+cd erdos-work
+```
+
+Later, the CLI will create a local `.erdos/` directory here for workspace state, checkpoints, ORP files, and pulled artifacts.
+
+### 3. Browse everything first
+
+```bash
+erdos problem list
+```
+
+Use this when you do not yet know a problem number or cluster.
+
+### 4. Inspect one problem in plain English
+
+```bash
+erdos problem show 857
+```
+
+This shows the title, status, cluster, short statement, and research-state posture for that problem.
+
+### 5. Learn the families only after that
+
+```bash
+erdos cluster list
+erdos cluster show sunflower
+```
+
+Once you know what a cluster is, you can narrow the atlas:
+
+```bash
+erdos problem list --cluster sunflower
+```
+
+### 6. Start a workspace on a well-packaged problem
+
+```bash
+erdos bootstrap problem 857
+```
+
+What this does:
+- creates `.erdos/` in the current folder
+- activates the problem locally
+- syncs the ORP kit
+- scaffolds the workspace for the next research move
+
+### 7. Orient yourself immediately
+
+```bash
+erdos workspace show
+erdos state show
+erdos problem artifacts 857 --json
+```
+
+Use these to understand the workspace layout, current route/frontier state, and the artifact surface that already exists for the problem.
+
+### 8. Run the first honest-state sync
+
+```bash
+erdos orp sync
+erdos state sync
+erdos preflight
+```
+
+This refreshes the protocol kit, recomputes local research state, and checks whether the workspace is in a sane posture to continue.
+
+### 9. Set your continuation mode
+
+```bash
+erdos continuation show
+erdos continuation use route
+```
+
+For most new users, `route` is the right default. It keeps the loop focused on the current route instead of bouncing between surfaces.
+
+### 10. Sync checkpoints before doing real work
+
+```bash
+erdos checkpoints sync
+```
+
+This writes the checkpoint shelf and keeps the workspace history honest.
+
+### 11. Look at the actual frontier
+
+```bash
+erdos sunflower status 857
+erdos sunflower frontier 857
+erdos sunflower ready 857
+```
+
+This is where the problem becomes actionable instead of just descriptive.
+
+### 12. Drill down to the next unit of work
+
+```bash
+erdos sunflower routes 857
+erdos sunflower ticket 857 T10
+erdos sunflower atom 857 T10.G3.A2
+```
+
+That is the real research loop:
+- inspect route
+- inspect ticket
+- inspect atom
+- do the next honest move
+
+### 13. Close the loop cleanly
+
+```bash
+erdos state sync
+erdos checkpoints sync
+erdos workspace show
+```
+
+If the problem is not already deeply packaged, use one-step local seeding instead of bootstrapping:
+
+```bash
+erdos seed problem 25 --cluster number-theory
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+erdos workspace show
+```
+
+In that flow, the seeded dossier is written under `.erdos/seeded-problems/<id>/` and enters the same state/checkpoint loop as packaged dossiers.
+
+## Daily Loop
+
+Once a workspace already exists, this is the main operating loop:
+
+```bash
+erdos state sync
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+erdos workspace show
+```
+
+Then inspect the current frontier and active unit of work:
+
+```bash
+erdos sunflower frontier 857
+erdos sunflower atom 857 T10.G3.A2
+```
+
+After a real step, sync checkpoints again:
+
+```bash
+erdos checkpoints sync
+```
+
+The guiding rule is simple:
+- inspect frontier
+- work the next honest move
+- checkpoint at honest boundaries
+
 Initialize or resume a paper bundle:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erdos-problems",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI atlas and workspace tools for Paul Erdos problems.",
   "type": "module",
   "bin": {

package/packs/number-theory/README.md

@@ -5,6 +5,7 @@ Light starter workspace for number-theory problems in `erdos-problems`.
 Current seeded pack problems:
 - `1`: open starter workspace around a distinct-subset-sum lower-bound route
 - `2`: counterexample/archive workspace for a disproved covering-systems problem
+- `848`: decidable finite-check workspace around explicit threshold extraction and bounded closure
 
 Useful commands:
 - `erdos number-theory status 1`

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

@@ -0,0 +1,8 @@
+# Problem 848 Checkpoint Template
+
+- Active route:
+- Threshold ledger update:
+- Finite-check range clarified:
+- Formalization coverage clarified:
+- Public-status wording rechecked:
+- Next honest move:

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

@@ -0,0 +1,11 @@
+# Problem 848 Number Theory Pack Context
+
+- Family role: finite_check_number_theory_workspace
+- Harness profile: decidable_gap_workspace
+- Active route posture: finite_check_gap_closure
+
+This pack slice exists because Problem 848 is no longer a generic open dossier.
+The honest posture is:
+- preserve the sufficiently-large-N theorem
+- isolate the finite unresolved gap
+- keep threshold extraction, finite computation, and formalization coverage distinct

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

@@ -0,0 +1,87 @@
+# Problem 848 Extraction Checklist
+
+This checklist turns the current threshold ledger into the next explicit route task.
+
+Goal:
+- identify exactly what must be made numerical before the existential `N0` in Sawhney's note becomes a usable explicit threshold
+
+## Margin ledger from the public note
+
+Target extremal density:
+- `1/25 = 0.04`
+
+Rounded case bounds recorded in the note:
+- Case 1: `0.0377`
+- Case 2: `0.0358`
+- Case 3: `0.0336`
+- Final mixed-class case: `0.0294`
+
+Current margin to the target:
+- Case 1 slack: `0.0400 - 0.0377 = 0.0023`
+- Case 2 slack: `0.0400 - 0.0358 = 0.0042`
+- Case 3 slack: `0.0400 - 0.0336 = 0.0064`
+- Final mixed-class slack: `0.0400 - 0.0294 = 0.0106`
+
+Immediate implication:
+- the weakest case is the `0.0377` branch
+- any fully explicit threshold extraction has to force the accumulated error terms in that branch below the available `0.0023 N` slack
+- before spending that full slack, the repo should freeze the exact main-term constants behind `0.0252` and `0.0125`, since the public note only records rounded decimals
+
+## Proof components to quantify
+
+### A. Lemma 2.1 tail and inclusion-exclusion error
+
+Need:
+- explicit control of the prime-square tail `sum_{T <= p <= N^(1/2)} N/p^2`
+- explicit control of the small-prime inclusion-exclusion remainder
+- an explicit version of the `N^(o(1))` term coming from the small-prime product
+
+Route question:
+- can these be made comfortably smaller than the smallest slack without overcomplicating the rest of the proof?
+
+### B. Lemma 2.2 progression error
+
+Need:
+- explicit control of the tail over primes dividing `ab+1`
+- a quantitative replacement for the `<< N / sqrt(log N)` term
+
+Route question:
+- is this the actual bottleneck, as the public forum discussion suggests?
+
+### C. Choice of `eta`
+
+Need:
+- identify where the proof requires a small absolute `eta`
+- determine whether the proof ever needs a specific lower ceiling on `eta`, or only that `eta` be less than the smallest surviving numerical slack after error absorption
+
+### D. Final case assembly
+
+Need:
+- for each case, record the exact main-term bound and the admissible total error budget
+- verify which branch determines the final threshold
+
+Current belief:
+- the `0.0377` case is the active bottleneck until a sharper calculation says otherwise
+
+## Work order
+
+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.
+
+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.
+
+## What would count as progress
+
+- a line-by-line list of every non-explicit estimate in Lemma 2.1 and Lemma 2.2
+- 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 justified statement like:
+  - “the current proof architecture plausibly yields an explicit threshold”
+  - or
+  - “the current proof architecture is too lossy without a new lemma or better error term”

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

@@ -0,0 +1,19 @@
+# Problem 848 Frontier Note
+
+Problem 848 is a decidable finite-check problem, not a fresh asymptotic frontier.
+
+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
+
+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`

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

@@ -0,0 +1,59 @@
+packet_id: nt848_ops_details_v1
+summary: Decidable-gap workspace packet for the squarefree ab+1 extremal set problem.
+routes:
+  - route_id: finite_check_gap_closure
+    title: Finite-Check Gap Closure
+    status: active
+    summary: Convert the sufficiently-large-N theorem into a complete all-N resolution without overstating what is already closed.
+    why_now: This is the honest live frontier after the public asymptotic result.
+    next_move: Spend the now-frozen weakest-branch slack on the first explicit Lemma 2.1 inequality.
+  - route_id: formalization_coverage_audit
+    title: Formalization Coverage Audit
+    status: support
+    summary: Determine exactly what the public Lean files certify and what finite remainder they leave open.
+    why_now: Formalization chatter is useful support evidence, but it should not be mistaken for full closure.
+    next_move: Keep this as support context until the threshold ledger is frozen.
+tickets:
+  - ticket_id: N848
+    title: Convert the frozen weakest-branch budget into explicit inequalities
+    route_id: finite_check_gap_closure
+    status: active
+    summary: The weakest branch and its conservative slack budget are now frozen; the next job is to quantify the explicit analytic losses against that budget.
+    current_blocker: Lemma 2.1 still hides its tail and inclusion-exclusion remainder behind `<<` and `N^(o(1))`.
+    next_move: Close `N848.G1.A4`.
+  - ticket_id: N848F
+    title: Audit public formalization coverage
+    route_id: formalization_coverage_audit
+    status: support
+    summary: Separate asymptotic Lean coverage from finite sample checks and full closure claims.
+    current_blocker: The current dossier only records public chatter, not a precise coverage map.
+    next_move: Keep as a support lane until the main threshold ledger is stable.
+atoms:
+  - atom_id: N848.G1.A1
+    title: Enumerate every sufficiently-large input in Sawhney's proof and classify it as explicit, weakly explicit, or existential
+    route_id: finite_check_gap_closure
+    ticket_id: N848
+    status: done
+    summary: The threshold ledger is now frozen in canonical pack notes.
+    next_move: Keep as support context for the extraction checklist.
+  - atom_id: N848.G1.A2
+    title: Record the weakest margin case and extract the checklist for making the threshold explicit
+    route_id: finite_check_gap_closure
+    ticket_id: N848
+    status: done
+    summary: The weakest branch and its first extraction checklist are now frozen in canonical pack notes.
+    next_move: Use the weakest-case budget sheet as the next source-backed frontier surface.
+  - atom_id: N848.G1.A3
+    title: Freeze the usable slack behind the `0.0377` branch before spending it on explicit error terms
+    route_id: finite_check_gap_closure
+    ticket_id: N848
+    status: done
+    summary: The branch budget is now numerically frozen in canonical pack notes.
+    next_move: Use the frozen branch slack as the target budget for explicit remainder extraction.
+  - atom_id: N848.G1.A4
+    title: Make the Lemma 2.1 remainder terms explicit against the frozen weakest-branch budget
+    route_id: finite_check_gap_closure
+    ticket_id: N848
+    status: ready
+    summary: The branch-level slack is now frozen; the next unresolved inequality is the Lemma 2.1 tail plus inclusion-exclusion remainder.
+    next_move: Write explicit upper bounds for the `N / T` tail and the small-prime inclusion-exclusion remainder with `T = floor(sqrt(log N))`.

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

@@ -0,0 +1,8 @@
+# Problem 848 Report Template
+
+- Route:
+- What changed:
+- Which part of the finite-check gap moved:
+- Which source line or artifact supports that movement:
+- Verification hook:
+- Next route action:

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

@@ -0,0 +1,9 @@
+# Problem 848 Route History
+
+- Initial repo posture: canonical dossier seeded from imported atlas data plus public site review.
+- First refinement: recast the problem from generic open seed into a decidable finite-check workspace.
+- Second refinement: freeze the first threshold ledger separating existential, weakly explicit, and tentative public threshold claims.
+- Third refinement: isolate the `0.0377` branch as the weakest public case and freeze a source-backed branch-budget note for it.
+- Fourth refinement: freeze the weakest-branch main term numerically at about `0.0376113`, with conservative slack about `0.0023887` before analytic error absorption.
+- Current public pack posture: active route `finite_check_gap_closure`, with asymptotic theorem already in hand and the remaining gap centered on explicit remainder extraction, threshold budgeting, and bounded finite verification.
+- Next maturity threshold: replace the Lemma 2.1 `<<` and `N^(o(1))` steps with explicit inequalities against the frozen branch budget.

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

@@ -0,0 +1,14 @@
+route_packet_id: nt848_finite_check_gap_closure_v1
+route_id: finite_check_gap_closure
+frontier_claim: Preserve the sufficiently-large-N theorem for Problem 848 while turning the remaining finite-check gap into an explicit threshold-plus-verification workspace.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which case in the proof has the smallest slack to 1/25?
+  - How much of the roughly `0.002388` weakest-branch slack can be safely assigned to Lemma 2.1?
+  - Can the Lemma 2.1 tail and inclusion-exclusion remainder be made explicit without exhausting the branch budget?
+verification_hook:
+  - erdos number-theory status 848
+  - erdos number-theory routes 848
+  - erdos problem show 848

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

@@ -0,0 +1,132 @@
+# Problem 848 Threshold Ledger
+
+This file records the exact shape of the remaining finite-check gap for Problem 848.
+
+It is intentionally conservative:
+- do not promote tentative forum bounds to canonical theorem claims
+- separate existential threshold statements from explicit ones
+- separate sample finite checks from full finite closure
+
+## Current route claim
+
+- Publicly established: there exists an integer `N0` such that the desired extremal statement holds for all `N >= N0`.
+- Not yet canonically established here: a complete explicit threshold `N0`, or a finished proof for every `N`.
+
+## Source-backed threshold map
+
+### 1. Proposition 1.1 in Sawhney's note
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 1
+
+Public statement:
+- There exists an integer `N0` such that for all `N >= N0`, if `A ⊆ [N]` and `ab+1` is never squarefree for all `a,b in A`, then
+  `|A| <= |{n in [N] : n ≡ 7 mod 25}|`.
+- Equality is achieved by the `7 mod 25` class and possibly the `18 mod 25` class.
+
+Classification:
+- `existential`
+
+Why:
+- The theorem statement is explicitly existential.
+- The note does not state a usable numerical `N0`.
+
+### 2. Lemma 2.1
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 1
+
+Public shape:
+- The lemma gives an asymptotic count with error `<< N (log N)^(-1/2)`.
+- The proof also uses an `N^(o(1))` style term through the product over small primes.
+
+Classification:
+- `weakly explicit`
+
+Why:
+- The proof architecture is explicit enough in principle to support numerical extraction.
+- The constants are not packaged in the note as a direct computational threshold.
+
+### 3. Lemma 2.2
+
+Source:
+- Sawhney, `Problem_848.pdf`, pages 1-2
+
+Public shape:
+- The lemma gives an asymptotic estimate for squarefree obstructions on arithmetic progressions with error `<< N / sqrt(log N)`.
+
+Classification:
+- `weakly explicit`
+
+Why:
+- The structure is explicit in principle.
+- The forum discussion repeatedly identifies this lemma as the harder place to sharpen if one wants a realistic explicit threshold.
+
+### 4. Final casework numerics in the proof
+
+Source:
+- Sawhney, `Problem_848.pdf`, pages 2-4
+
+Public shape:
+- The proof records rounded numerical bounds such as `0.0377`, `0.0358`, `0.0336`, and `0.0294`.
+- These are used after absorbing `o(1)` errors under the assumption that `N` is sufficiently large.
+
+Classification:
+- `explicit case numerics + existential threshold absorption`
+
+Why:
+- The local case splits and main-term constants are concrete.
+- The point where the error terms become small enough is still not canonically explicit in the note.
+
+## Public threshold-improvement chatter
+
+These are useful research leads, not canonical solved artifacts.
+
+### 5. Forum-level explicit thresholds
+
+Source:
+- `erdosproblems.com/forum/thread/848`
+
+Publicly mentioned:
+- `exp(1958)` from a GPT-assisted threshold-extraction effort discussed by Terence Tao
+- `exp(1420)` as a later plausible improvement discussed on the same thread
+
+Classification:
+- `tentative / not canonically frozen here`
+
+Why:
+- These values appear in forum discussion, not in the public theorem statement on the main problem page.
+- The thread itself treats them as intermediate and in need of verification or better writeup.
+
+## Public finite-verification coverage
+
+### 6. Finite checks discussed publicly
+
+Source:
+- `erdosproblems.com/forum/thread/848`
+
+Publicly mentioned:
+- straightforward approaches only checked the problem up to a few hundred in one discussion branch
+- the public Lean thread claims finite verification for `N = 50` and `N = 100`
+
+Classification:
+- `partial finite coverage`
+
+Why:
+- This is not a complete all-`N` finite closure.
+- It does, however, show that some finite verification machinery already exists in public.
+
+## Immediate implications
+
+- The cleanest honest next step is to turn the existential/weakly-explicit split above into a line-by-line extraction checklist from Sawhney's note.
+- The weakest branch is now isolated in `WEAKEST_CASE_BUDGET.md`, including the exact place where the proof spends rounded branch numerics without yet freezing the usable explicit slack.
+- The repo now also has a conservative numerical freeze of that weakest branch, suggesting the real main-term branch bound is about `0.0376113` with slack about `0.0023887` before analytic error absorption.
+- The second step is to decide whether the best near-term route is:
+  - improving Lemma 2.2 and related error terms enough to get a practical explicit `N0`, or
+  - treating the current explicit-threshold discussion as support context and investing in bounded finite computation.
+
+## What not to claim yet
+
+- Do not claim a canonical explicit threshold `N0`.
+- Do not claim the forum bounds `exp(1958)` or `exp(1420)` are fully verified repo truth.
+- Do not claim the public Lean files already close the entire finite remainder.

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

@@ -0,0 +1,183 @@
+# Problem 848 Weakest-Case Budget
+
+This note freezes the current best source-backed picture of the weakest branch
+in Sawhney's proof.
+
+Scope:
+- this is only the `0.0377` branch from the proof
+- this is not yet an explicit threshold proof
+- this is the budget sheet that the next explicit-threshold step must respect
+
+## Where the `0.0377` branch comes from
+
+Source:
+- Sawhney, `Problem_848.pdf`, Section 3, pages 2-3
+
+Branch description:
+- assume `A*` contains an even element
+- then bound `A*` using Lemma 2.1
+- bound `A7 ∪ A18` using Lemma 2.2
+- add the two contributions
+
+Public bound recorded in the note:
+- `|A| / N <= 0.0377`
+
+Target extremal density:
+- `1/25 = 0.04`
+
+Recorded slack to the target:
+- `0.04 - 0.0377 = 0.0023`
+
+## Main-term decomposition from the note
+
+### A. `A*` contribution
+
+Source:
+- Sawhney, `Problem_848.pdf`, pages 1-2, especially the proof lines leading to the first case split
+
+Displayed bound:
+- `|A*| / N <= (23/25) * (1 - prod_{p ≡ 1 mod 4, p >= 13} (1 - 2/p^2)) + o(1)`
+
+Rounded numerical contribution recorded in the note:
+- `0.0252`
+
+### B. `A7 ∪ A18` contribution
+
+Source:
+- Sawhney, `Problem_848.pdf`, pages 1-2, first Lemma 2.2 application in the proof
+
+Displayed bound:
+- `|A7 ∪ A18| / N <= (2/25) * (1 - prod_{p != 2,5} (1 - 1/p^2)) + o(1)`
+
+Rounded numerical contribution recorded in the note:
+- `0.0125`
+
+### C. Combined branch
+
+Displayed combination:
+- `|A| / N <= 0.0252 + 0.0125 = 0.0377`
+
+Important caution:
+- the note records four-decimal rounded numerics, not a repo-frozen exact Euler-product evaluation
+- therefore the currently usable slack is not yet a rigorously frozen `0.0023`
+- before spending the full `0.0023 N` on explicit error terms, the repo should freeze the exact main-term constants or adopt a deliberate safety reserve
+
+## Non-explicit inputs in this branch
+
+### 1. Lemma 2.1 large-prime tail
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 1
+
+Public proof move:
+- choose `T = floor(sqrt(log N))`
+- control the tail by
+  `sum_{T <= p <= N^(1/2)} N / p^2 << N / T`
+
+Current status:
+- structurally explicit
+- not numerically frozen here
+
+### 2. Lemma 2.1 small-prime inclusion-exclusion remainder
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 1
+
+Public proof move:
+- truncate to primes `p <= T`
+- note `prod_{p <= T} p^2 <= N^(o(1))`
+- conclude the inclusion-exclusion remainder is `N^(o(1))`
+
+Current status:
+- this is one of the main non-explicit steps in the branch
+- the proof architecture is clear, but the repo does not yet have a concrete bound replacing `N^(o(1))`
+
+### 3. Lemma 2.2 large-prime tail
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 2
+
+Public proof move:
+- again choose `T = floor(sqrt(log N))`
+- bound the tail by
+  `sum_{T <= p <= N} (N / p^2 + 1) << N / T`
+
+Current status:
+- structurally explicit
+- not numerically frozen here
+
+### 4. Lemma 2.2 reduction to Lemma 2.1
+
+Source:
+- Sawhney, `Problem_848.pdf`, page 2
+
+Public proof move:
+- for each prime `p <= T` with `(p, qb) = 1`, the condition `p^2 | (ab + 1)` determines one residue class
+- the remaining count is then handled by Lemma 2.1
+
+Current status:
+- this means the `0.0377` branch inherits the non-explicit part of Lemma 2.1 twice:
+  once directly for `A*`, and once indirectly through Lemma 2.2 for `A7 ∪ A18`
+
+### 5. The `eta` absorption step
+
+Source:
+- Sawhney, `Problem_848.pdf`, pages 1-2
+
+Public proof move:
+- assume `|A| >= (1/25 - eta) N` for a small absolute `eta`
+- absorb `eta` and the `o(1)` errors into the strict inequality between the branch bound and `1/25`
+
+Current status:
+- no explicit admissible `eta` is frozen here
+- explicit threshold extraction must budget for both the analytic error terms and the `eta` slack used in the contradiction
+
+## Honest current bottleneck
+
+The next true bottleneck is not yet “make Lemma 2.2 explicit.”
+
+The first bottleneck is:
+- freeze the exact main-term constants behind `0.0252` and `0.0125`
+- decide how much of the nominal `0.0023` slack is actually safe to spend on explicit error terms
+
+Until that is done, any explicit-threshold extraction remains numerically underdetermined at the branch level.
+
+## What this changes
+
+- The route no longer needs a generic “find the weakest branch” task; that is now done.
+- The next honest move is to replace rounded branch numerics with an exact or conservatively certified usable slack budget.
+
+## Repo numerical freeze
+
+Date:
+- April 5, 2026
+
+Method:
+- multiply the Euler-product factors directly over all primes up to `5,000,000`
+- use a crude tail envelope from `sum_{n > P} 1 / n^2 < 1 / P`
+- treat this as a conservative numerical budget note, not yet as a fully formal proof artifact
+
+Numerical outputs:
+- `A*` main-term contribution: `0.0251587645...`
+- `A7 ∪ A18` main-term contribution: `0.0124525434...`
+- combined weakest-branch main term: `0.0376113079...`
+- target density: `0.04`
+- numerical slack to the target: `0.0023886920...`
+
+Crude omitted-tail envelope from the `5,000,000` cutoff:
+- total branch-level tail contribution below about `3.84e-7`
+
+Conservative numerical reading:
+- the branch-level main term appears safely below `0.037612`
+- the real branch slack appears closer to `0.002389` than to the rounded `0.0023`
+- the rounded note therefore seems to hide roughly `8.8e-5` of additional branch slack
+
+What this still does **not** do:
+- it does not make Lemma 2.1 explicit
+- it does not make Lemma 2.2 explicit
+- it does not yet absorb the `eta` term
+- it does not produce a final explicit threshold `N0`
+
+What it **does** do:
+- it removes uncertainty about whether four-decimal rounding is eating a significant fraction of the apparent branch budget
+- it gives the next explicit-extraction step a more honest target: roughly `0.002388` of branch slack before analytic error absorption

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

@@ -0,0 +1,41 @@
+problem_id: "848"
+family_role: finite_check_number_theory_workspace
+harness_profile: decidable_gap_workspace
+default_active_route: finite_check_gap_closure
+bootstrap_focus: Freeze the explicit finite-check gap before choosing analytic threshold extraction or direct bounded computation.
+route_story: Problem 848 is already asymptotically resolved in public, but not yet packaged here as a full all-N resolution. The honest job is to map the finite remainder precisely.
+frontier_label: finite_check_gap_closure
+frontier_detail: Keep the route centered on explicit threshold extraction plus bounded finite verification, not on rediscovering the sufficiently-large-N theorem.
+checkpoint_focus: Preserve the distinction between existential N0, explicit N0, sample finite checks, and full closure.
+next_honest_move: Spend the frozen weakest-branch slack on the first explicit inequality, namely the Lemma 2.1 tail plus inclusion-exclusion remainder.
+related_core_problems:
+  - "844"
+literature_focus:
+  - squarefree values
+  - sieve bounds
+  - explicit threshold extraction
+artifact_focus:
+  - STATEMENT.md
+  - REFERENCES.md
+  - EVIDENCE.md
+  - FORMALIZATION.md
+  - THRESHOLD_LEDGER.md
+  - EXTRACTION_CHECKLIST.md
+  - WEAKEST_CASE_BUDGET.md
+question_ledger:
+  open_questions:
+    - Can the existing sufficiently-large-N proof be made explicit enough to give a practical threshold?
+    - How much of the remaining small-N range has actually been checked publicly?
+    - How much of the nominal `0.0023` weakest-branch slack survives once the rounded branch numerics are frozen exactly?
+    - Can Lemma 2.1 be made explicit without consuming most of the roughly `0.002388` frozen branch slack?
+  active_route_notes:
+    - Keep the asymptotic theorem separate from the unresolved finite closure.
+    - Treat public Lean claims as support evidence until the exact coverage is audited.
+    - Do not spend the full `0.0023` branch slack until the repo freezes the exact main-term constants behind `0.0252` and `0.0125`.
+    - The branch budget is now frozen numerically; the next uncertainty is analytic, not case-selection.
+  route_breakthroughs:
+    - Public asymptotic resolution by Sawhney is already in hand.
+    - The threshold ledger separating existential and explicit claims is now frozen.
+    - The weakest public branch is now isolated in a dedicated budget sheet.
+    - The weakest public branch is now numerically frozen at about `0.0376113`.
+  problem_solved: []

package/problems/848/AGENT_START.md

@@ -0,0 +1,33 @@
+# Agent Start
+
+Fast start:
+- `erdos problem show 848`
+- `erdos workspace show`
+- `erdos preflight`
+- `erdos continuation use route`
+- `erdos checkpoints sync`
+
+Working assumptions:
+- Open problem: no
+- Active route: finite_check_gap_closure
+- Repo status: active
+- Harness depth: dossier
+- Site status: decidable
+- Route breakthrough: yes
+- Problem solved: no
+
+Read in this order:
+- `STATEMENT.md`
+- `REFERENCES.md`
+- `EVIDENCE.md`
+- `FORMALIZATION.md`
+- `PUBLIC_STATUS_REVIEW.md`
+- `AGENT_WEBSEARCH_BRIEF.md`
+
+First honest move:
+- isolate the exact finite remainder left after Sawhney's sufficiently-large-`N` theorem
+- determine whether the missing closure is an explicit threshold extraction problem, a pure
+  finite computation problem, or a mixed lane
+- keep every note honest about the gap between `decidable` and fully `solved`
+- read the Sawhney note before touching the forum heuristics, then use the forum only to
+  map candidate threshold-improvement strategies and public finite-check coverage

package/problems/848/AGENT_WEBSEARCH_BRIEF.md

@@ -0,0 +1,21 @@
+# Erdős Problem #848 Agent Websearch Brief
+
+Why this exists:
+- do not rely on erdosproblems.com alone as the canonical public truth surface
+- compare the site status with current publicized discussion, literature, and formalization chatter
+
+Suggested queries:
+- "Erdos Problem #848"
+- erdos problem 848
+- "Erdos Problem #848" erdos
+- "Erdos Problem #848" explicit N0
+- "Erdos Problem #848" finite check
+- "Problem848.lean"
+- "Problem_848.pdf" Sawhney
+
+Review prompts:
+- Does the problem still appear publicly open?
+- Are there recent solution claims, partial claims, or major status updates?
+- Are there recent formalization artifacts, surveys, or project pages worth pulling into the dossier?
+- Has anyone publicly converted the existential threshold into a concrete usable `N0`?
+- Is there any public finite verification beyond the sample checks mentioned in the forum?

package/problems/848/CHECKPOINT_NOTES.md

@@ -0,0 +1,19 @@
+# Checkpoint Notes
+
+- Problem: 848
+- Repo status: active
+- Harness depth: dossier
+
+Checkpoint prompts:
+- What changed in the active route since the last honest checkpoint?
+- Which claim level is justified right now: Exact, Verified, Heuristic, or Conjecture?
+- Which upstream/public truth changed, if any?
+- What did the public-status review and agent websearch brief surface beyond erdosproblems.com?
+- Which artifact or literature bundle should the next agent read first?
+- What route, evidence, and formalization notes should be promoted out of scratch space into canonical dossier files?
+- Did we improve the explicit threshold side, the finite-computation side, or only our
+  understanding of the gap between them?
+- Is any new `N0` claim actually checked line-by-line against Sawhney's note, or is it still
+  forum-level heuristic discussion?
+- What exactly does the current public Lean development certify, and what does it still leave
+  open?

package/problems/848/EVIDENCE.md

@@ -0,0 +1,44 @@
+# Evidence
+
+- This dossier was seeded for Erdos Problem #848 from a pull bundle.
+- Imported record included: yes
+- Site snapshot included: yes
+- Public status review included: yes
+- Repo status at seed time: active
+- Harness depth at seed time: dossier
+- Imported status: `decidable`
+- Imported formalization state: `yes`
+
+Current public evidence captured locally:
+- The live site snapshot from 2026-04-05 states that the problem is resolved up to a finite
+  check.
+- The site records van Doorn's density upper bound and Weisenberg's slight refinement as
+  context for why the extremal density is constrained near `1/25`.
+- The site reports that Sawhney solved the problem for all sufficiently large `N`, with a
+  stability statement forcing near-extremal sets into the `7 mod 25` or `18 mod 25`
+  classes.
+- The public search review surfaced a current Lean formalization thread and a suggested
+  arXiv reference for the sufficiently-large-`N` result.
+- Sawhney's public four-page note proves the existence of an `N0`, but does not give an
+  explicit threshold in the statement of Proposition 1.1.
+- The public forum discussion says that straightforward threshold extraction is currently
+  huge, with one GPT-assisted route reaching `exp(1958)` and later discussion treating
+  `exp(1420)` as a plausible intermediate bound rather than a final clean resolution.
+- The same thread suggests the real technical bottleneck is improving the error terms in
+  Lemma 2.1 and especially Lemma 2.2 enough to make the explicit threshold and the finite
+  range practically closable.
+- The public Lean thread claims a formalization of the sufficiently-large-`N` theorem and
+  mentions finite verification for `N = 50` and `N = 100`, but not a full finite closure.
+
+Claim-safe local posture:
+- Exact: the public status is `decidable`, not `open` and not fully `solved`.
+- Exact: a formalized statement is publicly claimed by the imported atlas.
+- Exact: the remaining public gap is not a new asymptotic theorem, but the bridge from
+  existential `N0` to an explicit or fully checked all-`N` statement.
+- Heuristic: the lowest-friction route from here is to work both sides of the bridge:
+  sharpen the explicit threshold while separately understanding how far direct finite
+  verification can reasonably go.
+
+Next maintainer step:
+- keep the dossier centered on the finite-check gap rather than re-opening the asymptotic
+  theorem lane.

package/problems/848/FORMALIZATION.md

@@ -0,0 +1,16 @@
+# Formalization
+
+- Local status: statement-formalized
+- Imported formalized state: yes
+- Imported formalized last update: 2026-02-01
+- Public formalization chatter now includes a Lean development for the sufficiently-large-`N`
+  theorem discussed on the public problem thread.
+- Public forum claims indicate that the Lean work covers `∃ N0, ∀ N ≥ N0, Problem848Statement N`
+  and includes some sample finite checks (`N = 50`, `N = 100`), but not yet a publicly
+  stated full finite closure.
+
+Local formalization target:
+- keep the statement and the finite-check remainder cleanly separated
+- identify exactly which part of Sawhney's result is already formalized
+- decide whether this repo should mirror a public formal artifact, link it, or rebuild a
+  cleaner local version around the finite completion lane

package/problems/848/PUBLIC_STATUS_REVIEW.md

@@ -0,0 +1,16 @@
+# Erdős Problem #848 Public Status Review
+
+Fetched at: 2026-04-05T06:30:32.165Z
+Provider: duckduckgo
+
+Queries run:
+- "Erdos Problem #848"
+- erdos problem 848
+- "Erdos Problem #848" erdos
+
+Top public results:
+- [Erdős Problem #848 - erdosproblems.com](https://duckduckgo.com/l/?uddg=https%3A%2F%2Fwww.erdosproblems.com%2F848&rut=ab6658c984a06053ad3348d748646858fbf56e4f660020ca7ee7bfbfef6ff482)
+- [erdos-banger/formal/lean/Erdos/Problem848_FINAL.lean at main - GitHub](https://duckduckgo.com/l/?uddg=https%3A%2F%2Fgithub.com%2FThe%2DObstacle%2DIs%2DThe%2DWay%2Ferdos%2Dbanger%2Fblob%2Fmain%2Fformal%2Flean%2FErdos%2FProblem848_FINAL.lean&rut=6c864fa6a79183ffd94cce666451b7057530bd905d84b4213d80af6058f78dad)
+- [Problem #848: Is the maximum size of a set $A\subseteq \ {1,\ldots,N ...](https://duckduckgo.com/l/?uddg=https%3A%2F%2Fwww.dumbprime.com%2Ferdos%2Fproblem%2F848%2F&rut=cc6844492d2a1f0f0bc1cea1fa6dbd2c398f0734f7949a83f97a898ac20125fc)
+- [List of Erdős problems](https://duckduckgo.com/l/?uddg=https%3A%2F%2Fwww.math.ucsd.edu%2F~erdosproblems%2Ferdos%2F&rut=8e8ff012d3b3d9f37713038bf55c27bacfac0778281dbaa59eba31fb4ddce652)
+- [Erdos Problem Atlas — Interactive Exploration of 1,184 Classical Problems](https://duckduckgo.com/l/?uddg=https%3A%2F%2Ferdosatlas.org%2F&rut=9519b09e19680c6de399a4eb6980a1262a6b967ba8cca0f04fdab077275b7a8a)

package/problems/848/REFERENCES.md

@@ -0,0 +1,21 @@
+# References
+
+- Public problem page:
+  - <https://www.erdosproblems.com/848>
+- Original source pointer recorded on the public page:
+  - `[Er92b, p.239]`
+- Publicly linked sufficiently-large-`N` note:
+  - <https://www.math.columbia.edu/~msawhney/Problem_848.pdf>
+- Public discussion thread with explicit-threshold and finite-check remarks:
+  - <https://www.erdosproblems.com/forum/thread/848>
+- Publicly surfaced formalization discussion:
+  - <https://github.com/The-Obstacle-Is-The-Way/erdos-banger/blob/main/formal/lean/Erdos/Problem848.lean>
+- Public formalization milestone thread:
+  - <https://github.com/The-Obstacle-Is-The-Way/erdos-banger/blob/main/formal/lean/Erdos/Problem848_FINAL.lean>
+- Publicly suggested reference from the discussion thread:
+  - <https://arxiv.org/abs/2511.16072>
+- External imported atlas data:
+  - <https://github.com/teorth/erdosproblems>
+  - `data/problems.yaml`
+- Related problem:
+  - <https://www.erdosproblems.com/844>

package/problems/848/ROUTES.md

@@ -0,0 +1,59 @@
+# Routes
+
+## Status Ladder
+
+- Open problem: no
+- Active route: finite_check_gap_closure
+- Route breakthrough: yes
+- Problem solved: no
+
+## Active route
+
+- `finite_check_gap_closure`
+- Goal: convert the public sufficiently-large-`N` theorem into a complete all-`N`
+  resolution.
+- Current support:
+  - the public page reports an asymptotic solution by Sawhney
+  - the public page describes a stability statement near density `1/25`
+  - a public Lean formalization thread exists, but the exact finite closure surface still
+    needs review
+
+## Subroutes
+
+- `explicit_threshold_extraction`
+  - extract or improve an explicit `N0` from Sawhney's proof
+  - likely pressure points:
+    - sharpen Lemma 2.1 with better explicit squarefree-counting bounds
+    - sharpen Lemma 2.2, which the public thread identifies as the harder obstacle
+    - test whether Montgomery-Vaughan style large-sieve inputs materially beat the current
+      coarse error budget
+- `bounded_finite_verification`
+  - once an explicit `N0` is available, close `N < N0` by direct computation
+  - public evidence suggests that naive finite verification has only reached relatively
+    small ranges so far
+- `formalization_coverage_audit`
+  - determine exactly what the public Lean files certify
+  - separate:
+    - asymptotic theorem coverage
+    - sample finite checks
+    - genuine full finite closure, if any
+
+## Route discipline
+
+- Do not widen `decidable` into `solved` without an explicit finite completion artifact.
+- Count a route breakthrough only if we either:
+  - extract a fully explicit threshold that reduces the remainder to a bounded finite check, or
+  - finish the finite range directly.
+- Treat formalization progress as support evidence unless it clearly covers the exact
+  remaining finite gap.
+
+## Immediate next move
+
+- Read Sawhney's Proposition 1.1 and enumerate every place where `sufficiently large` enters
+  quantitatively.
+- Record whether each such place is:
+  - already explicit in the note
+  - explicit but very weak
+  - still purely existential
+- Only then decide whether the next serious lane is threshold extraction or direct finite
+  computation.

package/problems/848/STATEMENT.md

@@ -0,0 +1,28 @@
+# Problem 848 Statement
+
+Source: <https://www.erdosproblems.com/848>
+
+Normalized focus:
+- Let `A ⊆ {1, ..., N}` be such that `ab+1` is never squarefree for all `a, b in A`.
+- Ask whether the largest such sets are given by the residue class `n ≡ 7 (mod 25)`.
+- The public page records a stronger asymptotic statement: for sufficiently large `N`,
+  any near-extremal set is contained in either `{n ≡ 7 (mod 25)}` or `{n ≡ 18 (mod 25)}`.
+
+Current public posture:
+- Site status: `DECIDABLE`
+- Publicly reported route breakthrough: Sawhney proved the problem for all sufficiently
+  large `N`.
+- Remaining gap: close the finite-check range between the asymptotic theorem and a full
+  all-`N` resolution.
+- Public theorem shape:
+  - there exists an integer `N0` such that for all `N >= N0`, every admissible set has size
+    at most `|{n in [N] : n ≡ 7 (mod 25)}|`
+  - equality is achieved by the `7 mod 25` class and possibly also by the `18 mod 25`
+    class
+  - Sawhney's note also proves a stability statement for near-extremal sets
+
+Working interpretation for this repo:
+- Treat `848` as a finite-check completion problem, not as a fully open asymptotic frontier.
+- Keep the asymptotic theorem, the stability statement, and the unresolved finite remainder
+  separated in every claim.
+- Use related problem `844` only as support context unless a direct reduction is written down.

package/problems/848/problem.yaml

@@ -0,0 +1,52 @@
+problem_id: "848"
+display_name: "Erdos Problem #848"
+title: Squarefree ab+1 Extremal Set Problem
+source:
+  site: erdosproblems.com
+  url: https://www.erdosproblems.com/848
+  external_id: "848"
+external_source:
+  repo: https://github.com/teorth/erdosproblems
+  data_file: data/problems.yaml
+  number: "848"
+provenance:
+  seeded_at: 2026-04-05T06:31:37.131Z
+  seeded_from:
+    kind: pull_bundle
+    imported_record_included: true
+    site_snapshot_included: true
+    public_search_review_included: true
+status:
+  site_status: decidable
+  site_badge: DECIDABLE
+  repo_status: active
+  imported_status: decidable
+  imported_last_update: 2025-10-19
+cluster: number-theory
+prize:
+  display: no
+related_problems:
+  - "844"
+family_tags:
+  - squarefree
+  - extremal-sets
+  - number-theory
+harness:
+  depth: dossier
+statement:
+  short: Determine the largest subsets A of [N] for which ab+1 is never
+    squarefree, with the remaining public gap reduced to a finite check after
+    Sawhney's sufficiently-large-N theorem.
+  normalized_md_path: STATEMENT.md
+references_path: REFERENCES.md
+evidence_path: EVIDENCE.md
+formalization_path: FORMALIZATION.md
+formalization:
+  status: statement-formalized
+  imported_state: yes
+  imported_last_update: 2026-02-01
+research_state:
+  open_problem: false
+  active_route: finite_check_gap_closure
+  route_breakthrough: true
+  problem_solved: false