erdos-problems 0.3.6 → 0.3.7

package/package.json

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

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

@@ -0,0 +1,55 @@
+# Problem 848 Anchor Minimality Ledger
+
+This note summarizes the current search evidence for small anchor sets drawn from
+the first ten `7 mod 25` elements
+
+`7, 32, 57, 82, 107, 132, 157, 182, 207, 232`.
+
+Machine-readable packet:
+- `ANCHOR_SUBSET_SEARCH_PREFIX10_K3_K4.json`
+
+Reproduction:
+
+```bash
+node packs/number-theory/problems/848/compute/problem848_anchor_subset_search.mjs \
+  --max 10000 \
+  --candidate-count 10 \
+  --set-sizes 3,4 \
+  --top 15 \
+  --json-output packs/number-theory/problems/848/ANCHOR_SUBSET_SEARCH_PREFIX10_K3_K4.json
+```
+
+## Best three-anchor set found
+
+- anchors: `{32, 82, 132}`
+- failure count in `1..10000`: `41`
+- first fully covered tail found by this set: `n >= 3751`
+
+So a three-anchor statement may still exist asymptotically, but among the first
+ten natural candidates it does **not** produce the small startup threshold that
+the four-anchor set does.
+
+## Best four-anchor set found
+
+- anchors: `{7, 32, 57, 82}`
+- failure count in `1..10000`: `15`
+- exact covered tail: `n >= 30`
+
+Startup failures are exactly:
+
+`1, 2, 3, 4, 5, 6, 9, 13, 14, 17, 21, 23, 24, 25, 29`.
+
+Among the searched four-anchor subsets, this is the best tail start by a large
+margin. The next-best four-anchor sets only start covering everything from
+`n >= 70`.
+
+## Current read
+
+- The set `{7, 32, 57, 82}` is not just one working example.
+- In the current search window it appears genuinely special.
+- That makes it a serious theorem candidate rather than an arbitrary empirical
+  artifact.
+
+This is still search evidence, not a proof of minimality in the full infinite
+problem. But it is strong enough to justify prioritizing the four-anchor lemma
+over blind interval extension.

package/packs/number-theory/problems/848/ANCHOR_OBSTRUCTION_7_32_57_82.json

@@ -0,0 +1,293 @@
+{
+  "generatedAt": "2026-04-05T11:59:54.427Z",
+  "method": "anchor_obstruction_scan",
+  "problemId": "848",
+  "parameters": {
+    "anchors": [
+      7,
+      32,
+      57,
+      82
+    ],
+    "threshold": 30,
+    "max": 10000
+  },
+  "summary": {
+    "failureCount": 0,
+    "tailStart": 30,
+    "allCoveredFromThreshold": true,
+    "witnessCounts": {
+      "7": 6187,
+      "32": 2941,
+      "57": 402,
+      "82": 42
+    }
+  },
+  "failures": [],
+  "residueStats": [
+    {
+      "residue": 0,
+      "witnessCounts": {
+        "7": 260,
+        "32": 122,
+        "57": 17,
+        "82": 0
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 1,
+      "witnessCounts": {
+        "7": 258,
+        "32": 122,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 2,
+      "witnessCounts": {
+        "7": 258,
+        "32": 122,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 3,
+      "witnessCounts": {
+        "7": 257,
+        "32": 122,
+        "57": 17,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 4,
+      "witnessCounts": {
+        "7": 255,
+        "32": 127,
+        "57": 16,
+        "82": 0
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 5,
+      "witnessCounts": {
+        "7": 260,
+        "32": 118,
+        "57": 18,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 6,
+      "witnessCounts": {
+        "7": 259,
+        "32": 121,
+        "57": 16,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 8,
+      "witnessCounts": {
+        "7": 256,
+        "32": 125,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 9,
+      "witnessCounts": {
+        "7": 258,
+        "32": 120,
+        "57": 19,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 10,
+      "witnessCounts": {
+        "7": 253,
+        "32": 123,
+        "57": 20,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 11,
+      "witnessCounts": {
+        "7": 257,
+        "32": 124,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 12,
+      "witnessCounts": {
+        "7": 258,
+        "32": 123,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 13,
+      "witnessCounts": {
+        "7": 258,
+        "32": 124,
+        "57": 14,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 14,
+      "witnessCounts": {
+        "7": 259,
+        "32": 121,
+        "57": 17,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 15,
+      "witnessCounts": {
+        "7": 258,
+        "32": 124,
+        "57": 15,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 16,
+      "witnessCounts": {
+        "7": 256,
+        "32": 124,
+        "57": 17,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 17,
+      "witnessCounts": {
+        "7": 258,
+        "32": 123,
+        "57": 17,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 18,
+      "witnessCounts": {
+        "7": 257,
+        "32": 122,
+        "57": 15,
+        "82": 5
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 19,
+      "witnessCounts": {
+        "7": 259,
+        "32": 121,
+        "57": 16,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 20,
+      "witnessCounts": {
+        "7": 257,
+        "32": 125,
+        "57": 17,
+        "82": 0
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 21,
+      "witnessCounts": {
+        "7": 260,
+        "32": 123,
+        "57": 13,
+        "82": 3
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 22,
+      "witnessCounts": {
+        "7": 261,
+        "32": 119,
+        "57": 19,
+        "82": 0
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 23,
+      "witnessCounts": {
+        "7": 259,
+        "32": 121,
+        "57": 18,
+        "82": 1
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    },
+    {
+      "residue": 24,
+      "witnessCounts": {
+        "7": 256,
+        "32": 125,
+        "57": 16,
+        "82": 2
+      },
+      "firstFailure": null,
+      "failureCount": 0
+    }
+  ]
+}

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

@@ -0,0 +1,82 @@
+# Problem 848 Anchor Obstruction Recon
+
+This note records the first strong structural pattern extracted from the exact
+bounded-verification packet through `N = 10000`.
+
+## Exact-data facts now frozen
+
+- The exact verifier currently certifies `alpha(G_N) = |{n <= N : n equiv 7 mod 25}|`
+  for every `1 <= N <= 10000`.
+- The stored witness is always the pure `7 mod 25` class.
+- The maximum-clique size only increases when `N equiv 7 mod 25`.
+- Equivalently, for every `N <= 10000`,
+
+  `alpha(G_N) = max(0, floor((N - 7) / 25) + 1).`
+
+So the exact packet is already showing a breakpoint law, not just isolated
+per-`N` confirmations.
+
+## Four-anchor obstruction pattern
+
+Let
+
+- `a1 = 7`
+- `a2 = 32`
+- `a3 = 57`
+- `a4 = 82`
+
+These are the first four members of the `7 mod 25` class.
+
+Empirical fact from the exact scan:
+
+- for every `30 <= n <= 10000` with `n not equiv 7 mod 25`,
+- at least one of
+  - `7n + 1`
+  - `32n + 1`
+  - `57n + 1`
+  - `82n + 1`
+  is squarefree.
+
+Equivalently, every outsider `n` in that range is incompatible with at least one
+of the four fixed anchors `{7, 32, 57, 82}`.
+
+The only failures to this four-anchor witness rule in `1..10000` are the tiny
+startup values
+
+`1, 2, 3, 4, 5, 6, 9, 13, 14, 17, 21, 23, 24, 25, 29`.
+
+So from `n >= 30` onward, the obstruction appears to be governed by a fixed
+finite anchor set.
+
+## Why this matters
+
+This does **not** yet prove optimality of the `7 mod 25` class by itself.
+An outsider being incompatible with one anchor only shows it cannot be added to
+the full anchor-containing clique unchanged.
+
+What it does suggest is a more proof-shaped route:
+
+1. Prove a four-anchor obstruction lemma beyond a finite startup range.
+2. Convert that obstruction into an exchange or packing inequality for cliques.
+3. Reduce the remaining work to a tiny finite stub plus a breakpoint argument.
+
+That route is much closer to a real theorem than “just keep brute-forcing
+larger `N`”.
+
+## Immediate research questions
+
+- Can the four-anchor obstruction be proved for all `n >= 30`?
+- Is there a smaller anchor set than `{7, 32, 57, 82}` that already works?
+- Can every large clique be shown to contain enough of these anchors that
+  outsider substitutions cannot preserve clique size?
+- Can the breakpoint law
+  `alpha(G_N) = alpha(G_{N-1})` for `N not equiv 7 mod 25`
+  be derived from the anchor obstruction plus a monotonicity argument?
+
+## Current best guess
+
+The exact verifier is now best used as a structure miner:
+
+- not mainly to chase larger raw intervals,
+- but to identify the smallest anchor and breakpoint statements that would turn
+  the finite-check lane into a short proof plus a bounded startup table.