erdos-problems 0.3.5 → 0.3.7

package/packs/number-theory/problems/848/compute/problem848_small_n_exact_scan.mjs

@@ -26,52 +26,34 @@ function parseArgs(argv) {
   return args;
 }
 
+const squarefreeCache = new Map();
+
 function isSquarefree(n) {
+  if (squarefreeCache.has(n)) return squarefreeCache.get(n);
   let x = n;
   for (let p = 2; p * p <= x; p += 1) {
     if (x % p !== 0) continue;
     x /= p;
-    if (x % p === 0) return false;
+    if (x % p === 0) {
+      squarefreeCache.set(n, false);
+      return false;
+    }
     while (x % p === 0) x /= p;
   }
+  squarefreeCache.set(n, true);
   return true;
 }
 
-function residueClass(N, residue) {
-  const result = [];
-  for (let n = 1; n <= N; n += 1) {
-    if (n % 25 === residue) result.push(n);
-  }
-  return result;
-}
-
-function sameSortedSet(left, right) {
-  if (left.length !== right.length) return false;
-  const a = [...left].sort((x, y) => x - y);
-  const b = [...right].sort((x, y) => x - y);
-  return a.every((value, index) => value === b[index]);
+function residueClassSize(N, residue) {
+  if (N < residue) return 0;
+  return Math.floor((N - residue) / 25) + 1;
 }
 
-function buildGraph(N) {
-  const vertices = [];
-  for (let a = 1; a <= N; a += 1) {
-    if (!isSquarefree(a * a + 1)) vertices.push(a);
-  }
-  const adjacency = Array.from({ length: vertices.length }, () => new Set());
-  for (let i = 0; i < vertices.length; i += 1) {
-    for (let j = i + 1; j < vertices.length; j += 1) {
-      const a = vertices[i];
-      const b = vertices[j];
-      if (!isSquarefree(a * b + 1)) {
-        adjacency[i].add(j);
-        adjacency[j].add(i);
-      }
-    }
-  }
-  return { vertices, adjacency };
+function isPureResidueClass(clique, N, residue) {
+  return clique.length === residueClassSize(N, residue) && clique.every((value) => value % 25 === residue);
 }
 
-function maximumClique(vertices, adjacency) {
+function maximumCliqueIndices(adjacency, candidateIndices, lowerBound = 0) {
   let best = [];
 
   function bronKerbosch(R, P, X) {
@@ -79,7 +61,7 @@ function maximumClique(vertices, adjacency) {
       if (R.length > best.length) best = [...R];
       return;
     }
-    if (R.length + P.length <= best.length) return;
+    if (R.length + P.length <= Math.max(best.length, lowerBound)) return;
 
     let pivot = null;
     let pivotNeighborsInP = -1;
@@ -109,29 +91,63 @@ function maximumClique(vertices, adjacency) {
     }
   }
 
-  bronKerbosch([], vertices.map((_, index) => index), []);
-  return best.map((index) => vertices[index]).sort((a, b) => a - b);
+  bronKerbosch([], [...candidateIndices], []);
+  return best.sort((a, b) => a - b);
 }
 
 function scanInterval(minN, maxN) {
   const rows = [];
-  for (let N = minN; N <= maxN; N += 1) {
-    const residue7 = residueClass(N, 7);
-    const residue18 = residueClass(N, 18);
-    const { vertices, adjacency } = buildGraph(N);
-    const clique = maximumClique(vertices, adjacency);
+  const vertices = [];
+  const adjacency = [];
+  let bestCliqueIndices = [];
+
+  for (let N = 1; N <= maxN; N += 1) {
+    const residue7Size = residueClassSize(N, 7);
+    const residue18Size = residueClassSize(N, 18);
+
+    if (!isSquarefree(N * N + 1)) {
+      const newIndex = vertices.length;
+      const neighbors = [];
+      for (let i = 0; i < vertices.length; i += 1) {
+        if (!isSquarefree(vertices[i] * N + 1)) {
+          adjacency[i].add(newIndex);
+          neighbors.push(i);
+        }
+      }
+      adjacency.push(new Set(neighbors));
+      vertices.push(N);
+
+      if (neighbors.length + 1 > bestCliqueIndices.length) {
+        const neighborClique = maximumCliqueIndices(
+          adjacency,
+          neighbors,
+          Math.max(0, bestCliqueIndices.length - 1),
+        );
+        if (neighborClique.length + 1 > bestCliqueIndices.length) {
+          bestCliqueIndices = [...neighborClique, newIndex].sort((a, b) => a - b);
+        }
+      }
+    }
+
+    const clique = bestCliqueIndices.map((index) => vertices[index]);
     const maxSize = clique.length;
-    const residue7Size = residue7.length;
-    const residue18Size = residue18.length;
+    if (N < minN) continue;
+    const exampleResidueClass = isPureResidueClass(clique, N, 7)
+      ? 7
+      : isPureResidueClass(clique, N, 18)
+        ? 18
+        : null;
+
     rows.push({
       N,
       maxCliqueSize: maxSize,
       residue7Size,
       residue18Size,
       candidateAchievesMaximum: residue7Size === maxSize,
-      exampleMaximumClique: clique,
-      exampleMatchesResidue7: sameSortedSet(clique, residue7),
-      exampleMatchesResidue18: sameSortedSet(clique, residue18),
+      exampleResidueClass,
+      exampleMaximumClique: exampleResidueClass === null ? clique : undefined,
+      exampleMatchesResidue7: exampleResidueClass === 7,
+      exampleMatchesResidue18: exampleResidueClass === 18,
     });
   }
   return rows;
@@ -153,6 +169,7 @@ const rows = scanInterval(args.min, args.max);
 const payload = {
   generatedAt: new Date().toISOString(),
   method: 'exact_maximum_clique_scan',
+  resultEncoding: 'residue_class_when_possible',
   problemId: '848',
   parameters: {
     min: args.min,

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

@@ -3,11 +3,11 @@ family_role: finite_check_number_theory_workspace
 harness_profile: decidable_gap_workspace
 default_active_route: finite_check_gap_closure
 bootstrap_focus: Treat Problem 848 as a finite-gap closure problem and freeze the certificate surface before claiming bounded verification progress.
-route_story: Problem 848 is already asymptotically resolved in public, but not yet closed here for all N. The honest job is to shrink the finite remainder with audited threshold tracking and reproducible bounded verification, beginning from the verified base interval `1..3000`.
+route_story: Problem 848 is already asymptotically resolved in public, but not yet closed here for all N. The honest job is to shrink the finite remainder with audited threshold tracking and reproducible bounded verification, and then turn the exact packet into a short structural theorem.
 frontier_label: finite_check_gap_closure
-frontier_detail: The repo now has a verified exact interval `1..3000`; an attempted jump to `5000` did not clear quickly enough to count as cheap progress, so the next question is whether to extend exact coverage in smaller steps or change method class.
+frontier_detail: The repo now has a verified exact interval `1..10000`, a four-anchor obstruction candidate with no failures in `30..10000`, and evidence that this is the first serious theorem route. The next question is how to prove that obstruction and convert it into a breakpoint law.
 checkpoint_focus: Preserve the distinction between existential N0, explicit N0, sample finite checks, and full closure.
-next_honest_move: Decide whether to extend the exact clique scan beyond `3000` in smaller certified steps or pivot to a different bounded-verification method.
+next_honest_move: Promote the four-anchor obstruction from recon to a proof-shaped lemma candidate with explicit proof obligations.
 related_core_problems:
   - "844"
 literature_focus:
@@ -27,22 +27,29 @@ artifact_focus:
   - VERIFICATION_CERTIFICATE_SPEC.md
   - EXTERNAL_VERIFICATION_LEDGER.md
   - INTERVAL_WORK_QUEUE.yaml
-  - EXACT_SMALL_N_1_3000_CERTIFICATE.md
+  - EXACT_SMALL_N_1_10000_CERTIFICATE.md
+  - ANCHOR_OBSTRUCTION_RECON.md
+  - ANCHOR_MINIMALITY_LEDGER.md
+  - FOUR_ANCHOR_LEMMA_CANDIDATE.md
 question_ledger:
   open_questions:
     - Which imported threshold value is trusted enough to size the finite remainder operationally?
     - What certificate format is strong enough to prevent repeat low-trust verification claims?
-    - How far can the exact clique scan be pushed before a different method class is needed?
+    - Can the four-anchor obstruction be proved for all `n >= 30`?
+    - Can the four-anchor obstruction be converted into a breakpoint law for clique growth?
     - Which public verification attempts are worth auditing rather than rebuilding from scratch?
   active_route_notes:
     - Keep the asymptotic theorem separate from the unresolved finite closure.
     - Keep imported threshold claims separate from repo-owned audited claims.
     - Prefer interval certificates to raw "checked up to X" claims.
     - Use past public verification criticism as a design constraint, not just background chatter.
+    - Treat the exact verifier as a structure miner, not just a brute-force machine.
   route_breakthroughs:
     - Public asymptotic resolution by Sawhney is already in hand.
     - The threshold ledger separating existential and explicit claims is now frozen.
     - The repo now has an audited explicit candidate package distinct from the imported public threshold timeline.
     - The repo has now chosen bounded finite verification as the next closure lane.
-    - The repo now has an exact verified base interval `1..3000`.
+    - The repo now has an exact verified base interval `1..10000`.
+    - The exact verifier now uses an incremental update rule rather than rebuilding every instance from scratch.
+    - The repo now has a four-anchor obstruction candidate with no failures in `30..10000`.
   problem_solved: []

package/problems/848/EVIDENCE.md

@@ -74,9 +74,16 @@ Current public evidence captured locally:
   values to size the finite remainder without being silently promoted to canonical theorem
   truth.
 - A reproducible exact maximum-clique scan now verifies the expected extremal size for every
-  `N` in `1..3000`, giving the bounded-verification lane a larger trusted covered interval.
-- An exploratory jump to `1..5000` no longer looks cheap enough to treat blind brute-force
-  extension as the default next move.
+  `N` in `1..10000`, giving the bounded-verification lane a much larger trusted covered interval.
+- The exact verifier has been rebuilt incrementally, so the old post-`3000` cost wall is now
+  understood to have been mostly a tooling artifact rather than a serious mathematical barrier.
+- The exact packet now exposes a structural clue: every maximum witness through `10000` is the
+  pure `7 mod 25` class, the clique size only jumps when `N equiv 7 (mod 25)`, and the fixed
+  anchor set `{7, 32, 57, 82}` obstructs every outsider `n >= 30` found so far.
+- A small-anchor search over the first ten `7 mod 25` values suggests that the four-anchor set
+  `{7, 32, 57, 82}` is unusually strong: no tested three-anchor set gets a comparable startup
+  threshold, while this four-anchor set already covers everything from `30` onward in the
+  current scan window.
 
 Claim-safe local posture:
 - Exact: the public status is `decidable`, not `open` and not fully `solved`.
@@ -116,5 +123,6 @@ Next maintainer step:
 - preserve the current claim-safe package as a clean review unit
 - treat imported threshold improvements as external progress markers unless they are
   re-audited inside the repo
-- decide whether exact verified coverage should be extended beyond `3000` in smaller steps
-  or whether the next gain now needs a different method class
+- turn the four-anchor obstruction into a proof-shaped lemma candidate with explicit proof
+  obligations
+- use that lemma candidate to attack the breakpoint law suggested by the exact packet

package/problems/848/ROUTES.md

@@ -74,9 +74,9 @@
   - a regime split for the finite remainder
   - a certificate format for bounded interval claims
   - an audit ledger for imported verification work
-  - an exact verified base interval `1..3000`
-- The next concrete task is to decide whether the exact clique scan should be extended
-  directly beyond `3000` in smaller steps or whether the next gain now needs a different
-  method class.
+  - an exact verified base interval `1..10000`
+  - an incremental verifier that makes larger exact tranches practical
+- The next concrete task is to turn the four-anchor obstruction clue into a proof-shaped
+  lemma candidate and then use it to attack the breakpoint law.
 - The right optimization target remains the size of the remaining finite gap, not the
   threshold race in isolation.

package/problems/848/SHARE_READY_SUMMARY.md

@@ -23,7 +23,8 @@ What is ready now:
 - supporting explicit ledgers for the branch bounds and numerical witness
 - a bounded finite-verification lane with regimes, certificate requirements, and external
   audit notes
-- an exact verified base interval `1..3000`
+- an exact verified base interval `1..10000`
+- a four-anchor obstruction candidate and minimality ledger for the first theorem-style route
 
 What is not being claimed:
 - not full all-`N` closure in the repo