erdos-problems 0.3.2 → 0.3.4

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

@@ -0,0 +1,89 @@
+# Problem 848 Verification Regimes
+
+This file partitions the finite remainder into regimes so the repo can track progress
+without pretending that one method fits the whole gap.
+
+## Trusted public asymptotic handoff
+
+- public theorem: Sawhney proves the statement for all sufficiently large `N`
+- imported explicit threshold timeline:
+  - `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
+- current repo posture:
+  - these thresholds are imported public claims
+  - they size the finite remainder operationally
+  - they are not yet promoted to canonical repo-owned theorem statements
+
+## Verification regime split
+
+### Regime A: exact small-`N` coverage
+
+Goal:
+- cover a small base interval by exact methods that can be rerun and independently checked
+
+Candidate methods:
+- direct search
+- pair-exchange lemmas
+- exact residue-structure enumeration
+- very small witness-prime case splits
+
+Desired certificate:
+- exact witness/counterexample status for each `N`
+- reproducible script or proof note
+
+### Regime B: structured breakpoint verification
+
+Goal:
+- cover a medium interval by checking a monotone or breakpoint-sufficient inequality rather
+  than every raw instance independently
+
+Candidate methods:
+- structural breakpoint tables
+- clique/exchange inequalities
+- monotonicity-ledger arguments
+
+Desired certificate:
+- exact breakpoint set definition
+- proof that breakpoint coverage implies interval coverage
+- machine-readable result table
+
+### Regime C: audited imported computation
+
+Goal:
+- record public computational claims without treating them as canonical until the repo has an
+  audit story
+
+Candidate inputs:
+- public repos
+- public verification notes
+- independently rerun scripts
+
+Desired certificate:
+- imported source URL
+- exact claimed interval
+- audit outcome: accepted, external-only, or blocked
+
+### Regime D: asymptotic handoff
+
+Goal:
+- state the point above which the public theorem takes over
+
+Desired certificate:
+- cited theorem source
+- exact threshold assumption being used operationally
+- note whether the threshold is imported-only or repo-audited
+
+## Current honest posture
+
+- Regime A: first exact interval `1..2000` is now frozen in the repo with a reproducible
+  maximum-clique certificate
+- Regime B: not frozen in this repo
+- Regime C: public attempts exist, but some were explicitly criticized on the forum as
+  difficult to verify or likely incorrect
+- Regime D: public asymptotic theorem exists; imported explicit thresholds are tracked but not
+  yet repo-audited
+
+So the next honest move is to decide whether exact-small-`N` coverage should be extended
+directly beyond `2000`, or whether the next gain comes from auditing imported computation or
+switching method class.

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

@@ -0,0 +1,109 @@
+# Problem 848 Weakest Branch Assembly at `T = 250`
+
+This note closes `N848.G1.A7`.
+
+Goal:
+- turn the `T = 250` weakest-branch witness budget into a line-by-line branch ledger
+- freeze an honest working `eta` value for this branch
+
+Scope:
+- this is only the weakest public `0.0377` branch
+- this is not yet a full explicit-threshold proof for Proposition 1.1
+- the remaining repo question is whether the same witness closes the other public branches
+
+## Branch setup
+
+Assume:
+- `N >= exp(1420)`
+- `eta > 0`
+- `|A| >= (1/25 - eta) * N`
+- the branch with an even element `b in A* = A \\ (A7 union A18)` is active
+- truncation witness `T = 250`
+
+## Line-by-line upper bound ledger
+
+### 1. `A*` main term
+
+From `WEAKEST_CASE_BUDGET.md`:
+- `A* / N <= 0.0251587645... + remainder`
+
+### 2. `A*` explicit remainder
+
+From `LEMMA21_TRUNCATION_SCAN.md`:
+- `A*` tail density at `T = 250`: about `0.0005641453`
+- `A*` discrete term: `23 * (3^23 - 1) / N`
+
+At `N >= exp(1420)`, the discrete term is astronomically small and far below the visible
+decimal budget.
+
+### 3. `A7 union A18` main term
+
+From `WEAKEST_CASE_BUDGET.md`:
+- `(A7 union A18) / N <= 0.0124525434... + remainder`
+
+### 4. `A7 union A18` explicit remainder
+
+From `LEMMA22_EXPLICIT_BOUND.md` and `LEMMA22_PRIME_COUNT_BOUND.md`:
+- Lemma 2.2 `N / p^2` tail density at `T = 250`: about `0.0000491054`
+- Lemma 2.2 prime-count term at `N >= exp(1420)`: at most `0.0014095427`
+- Lemma 2.2 discrete term: `2 * (2^51 - 1) / N`
+
+Again, the discrete term is astronomically small at `N >= exp(1420)`.
+
+## Combined explicit branch bound
+
+Collecting the frozen decimal contributions gives
+
+- branch main term: `0.0376113079`
+- `A*` tail: `0.0005641453`
+- Lemma 2.2 tail: `0.0000491054`
+- Lemma 2.2 prime-count term: `0.0014095427`
+
+So the visible explicit branch bound is
+
+- `0.0376113079 + 0.0005641453 + 0.0000491054 + 0.0014095427`
+- `= 0.0396341013` up to rounding in the displayed decimals
+
+This leaves visible room to `1/25 = 0.04` of about
+
+- `0.04 - 0.0396341013 = 0.0003658987`.
+
+## Working `eta` choice
+
+The branch contradiction only needs a positive margin after paying for `eta`.
+
+A conservative working choice is
+
+- `eta_work = 0.0001`.
+
+Then the remaining visible reserve is still about
+
+- `0.0003658987 - 0.0001 = 0.0002658987`.
+
+So with this working choice, the branch still retains about `2.66e-4` of visible room for
+the tiny discrete terms and any final rounding/bookkeeping losses.
+
+## Honest branch conclusion
+
+At the witness scale
+- `N >= exp(1420)`,
+- `T = 250`,
+- `eta = 10^-4`,
+
+the weakest public branch now appears explicitly contradictory.
+
+What this does **not** yet prove:
+- that `exp(1420)` is a fully verified threshold for the whole proposition
+- that the stronger public candidate thresholds are unnecessary
+- that every other public branch has already been checked with the same explicit witness
+
+What it **does** prove for the repo route:
+- the weakest public branch is no longer the blocker
+- the repo now has a concrete explicit branch witness with positive visible reserve
+
+## Next route consequence
+
+The next honest move is:
+- carry the same witness philosophy into the other public proof branches
+- check whether `T = 250`, `N >= exp(1420)`, and `eta = 10^-4` also close them
+- if one branch needs a different witness, record that precisely instead of forcing uniformity

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

@@ -0,0 +1,107 @@
+# Problem 848 Weakest Branch Budget at `T = 250`
+
+This note closes `N848.G1.A6` at a witness-budget level.
+
+Goal:
+- test whether the weakest public `0.0377` branch is still blocked once both Lemma 2.1 and
+  Lemma 2.2 use a larger witness truncation parameter
+
+Witness choice:
+- `T = 250`
+
+Reason for this choice:
+- it is large enough to shrink the live `A*` tail materially
+- it is still tiny compared with the public candidate scales `exp(1420)` and `exp(1958)`
+- the discrete inclusion-exclusion terms remain negligible at those scales
+
+## Frozen main-term branch data
+
+From `WEAKEST_CASE_BUDGET.md`:
+- `A*` main term: about `0.0251587645`
+- `A7 union A18` main term: about `0.0124525434`
+- combined weakest-branch main term: about `0.0376113079`
+- branch slack to `1/25 = 0.04`: about `0.0023886921`
+
+## Explicit remainder ledger at `T = 250`
+
+### 1. `A*` via Lemma 2.1
+
+From `LEMMA21_TRUNCATION_SCAN.md`:
+- `A*` tail density at `T = 250`: about `0.0005641453`
+- `A*` discrete term: `23 * (3^23 - 1) / N`
+
+At `N = exp(1420)`:
+- the `A*` discrete density is below about `exp(-1392)`
+
+### 2. `A7 union A18` via Lemma 2.2
+
+From `LEMMA22_EXPLICIT_BOUND.md`:
+- Lemma 2.2 tail density at `T = 250`: about `0.0000491054`
+- worst-case Lemma 2.2 discrete term: `2 * (2^51 - 1) / N`
+- prime-count term from `LEMMA22_PRIME_COUNT_BOUND.md`: at most `0.0014095427` for
+  every `N >= exp(1420)`
+
+At `N = exp(1420)`:
+- the Lemma 2.2 discrete density is below about `exp(-1384)`
+
+### 3. Combined explicit remainder
+
+Adding the two live tail terms gives
+
+- combined tail density about `0.0006132507`
+
+and the combined discrete terms are still negligible at the public candidate scales.
+
+What is still missing:
+- no further lemma-level tail term; the remaining work is branch assembly and `eta`
+
+## Combined weakest-branch budget
+
+Main term plus the live explicit tails:
+
+- `0.0376113079 + 0.0006132507 = 0.0382245586`
+
+So the remaining room to `0.04` is still about
+
+- `0.0017754414`
+
+before the final branch bookkeeping.
+
+After inserting the explicit Lemma 2.2 prime-count bound at `N >= exp(1420)`,
+
+- `0.0017754414 - 0.0014095427 ~= 0.0003658987`
+
+So the currently visible room for
+- the final `eta` choice
+- and any remaining line-by-line bookkeeping losses
+
+is about `3.66e-4`.
+
+## Honest reading
+
+This does **not** yet prove an explicit threshold.
+
+What it **does** show is:
+- once `T` is allowed to move, the weakest branch no longer looks blocked by the two lemma
+  `N / p^2` tails themselves
+- the discrete inclusion-exclusion losses are no longer the issue
+- the Lemma 2.2 prime-count term also fits inside the branch budget at the public candidate
+  threshold scale
+- the route now has a concrete surviving witness margin of about `3.66e-4` for final
+  `eta` and bookkeeping losses
+
+So the live unresolved work is narrower than before:
+- write the line-by-line full branch assembly with the larger `T`
+- record the exact `eta` room that survives that assembly
+- then turn that into a genuine explicit-threshold witness candidate
+
+## Route consequence
+
+This means the current proof skeleton now looks plausibly explicitizable in the weakest
+branch at the witness scale `N >= exp(1420)`, provided the remaining line-by-line assembly
+does not consume more than about `3.66e-4` of density.
+
+That is a materially stronger posture than the one the repo started with:
+- the route is no longer waiting on a mystery bottleneck
+- it has a concrete witness truncation value
+- and it has a concrete surviving witness margin after all currently frozen lemma-level costs

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

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const args = { min: 1, max: 100, jsonOutput: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--min') {
+      args.min = Number(argv[++i]);
+    } else if (token === '--max') {
+      args.max = Number(argv[++i]);
+    } else if (token === '--json-output') {
+      args.jsonOutput = argv[++i];
+    } else {
+      throw new Error(`Unknown argument: ${token}`);
+    }
+  }
+  if (!Number.isInteger(args.min) || args.min < 1) {
+    throw new Error('--min must be a positive integer');
+  }
+  if (!Number.isInteger(args.max) || args.max < args.min) {
+    throw new Error('--max must be an integer >= --min');
+  }
+  return args;
+}
+
+function isSquarefree(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;
+    while (x % p === 0) x /= p;
+  }
+  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 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 maximumClique(vertices, adjacency) {
+  let best = [];
+
+  function bronKerbosch(R, P, X) {
+    if (P.length === 0 && X.length === 0) {
+      if (R.length > best.length) best = [...R];
+      return;
+    }
+    if (R.length + P.length <= best.length) return;
+
+    let pivot = null;
+    let pivotNeighborsInP = -1;
+    for (const u of [...P, ...X]) {
+      let count = 0;
+      for (const v of P) {
+        if (adjacency[u].has(v)) count += 1;
+      }
+      if (count > pivotNeighborsInP) {
+        pivotNeighborsInP = count;
+        pivot = u;
+      }
+    }
+
+    const candidates = pivot === null
+      ? [...P]
+      : P.filter((v) => !adjacency[pivot].has(v));
+
+    for (const v of candidates) {
+      bronKerbosch(
+        [...R, v],
+        P.filter((u) => adjacency[v].has(u)),
+        X.filter((u) => adjacency[v].has(u)),
+      );
+      P = P.filter((u) => u !== v);
+      X = [...X, v];
+    }
+  }
+
+  bronKerbosch([], vertices.map((_, index) => index), []);
+  return best.map((index) => vertices[index]).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 maxSize = clique.length;
+    const residue7Size = residue7.length;
+    const residue18Size = residue18.length;
+    rows.push({
+      N,
+      maxCliqueSize: maxSize,
+      residue7Size,
+      residue18Size,
+      candidateAchievesMaximum: residue7Size === maxSize,
+      exampleMaximumClique: clique,
+      exampleMatchesResidue7: sameSortedSet(clique, residue7),
+      exampleMatchesResidue18: sameSortedSet(clique, residue18),
+    });
+  }
+  return rows;
+}
+
+function summarize(rows) {
+  return {
+    interval: `${rows[0].N}..${rows[rows.length - 1].N}`,
+    rows: rows.length,
+    allCandidateAchievesMaximum: rows.every((row) => row.candidateAchievesMaximum),
+    allExampleCliquesMatchCandidateClass: rows.every(
+      (row) => row.exampleMatchesResidue7 || row.exampleMatchesResidue18,
+    ),
+  };
+}
+
+const args = parseArgs(process.argv.slice(2));
+const rows = scanInterval(args.min, args.max);
+const payload = {
+  generatedAt: new Date().toISOString(),
+  method: 'exact_maximum_clique_scan',
+  problemId: '848',
+  parameters: {
+    min: args.min,
+    max: args.max,
+  },
+  summary: summarize(rows),
+  results: rows,
+};
+
+if (args.jsonOutput) {
+  fs.mkdirSync(path.dirname(args.jsonOutput), { recursive: true });
+  fs.writeFileSync(args.jsonOutput, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+console.log(JSON.stringify(payload.summary, null, 2));

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

@@ -2,40 +2,47 @@ 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.
+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..2000`.
 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.
+frontier_detail: The repo now has a verified exact interval `1..2000`; the next question is whether to extend that exact scan further or change method class.
 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.
+next_honest_move: Decide whether to extend the exact clique scan beyond `2000` or pivot to a different bounded-verification method.
 related_core_problems:
   - "844"
 literature_focus:
   - squarefree values
   - sieve bounds
   - explicit threshold extraction
+  - bounded verification
 artifact_focus:
   - STATEMENT.md
   - REFERENCES.md
   - EVIDENCE.md
   - FORMALIZATION.md
   - THRESHOLD_LEDGER.md
-  - EXTRACTION_CHECKLIST.md
-  - WEAKEST_CASE_BUDGET.md
+  - OPERATIONAL_THRESHOLD_POSTURE.md
+  - 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
 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?
+    - 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?
+    - 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.
-    - 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.
+    - 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.
   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`.
+    - 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..2000`.
   problem_solved: []

package/problems/848/CHECKPOINT_NOTES.md

@@ -13,7 +13,11 @@ Checkpoint prompts:
 - 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?
+- Are we optimizing the right thing right now: a smaller imported `N0`, or a smaller
+  remaining finite range to verify?
 - Is any new `N0` claim actually checked line-by-line against Sawhney's note, or is it still
   forum-level heuristic discussion?
+- Have we cleanly separated the best imported threshold claim from the repo's own audited
+  explicit candidate?
 - What exactly does the current public Lean development certify, and what does it still leave
   open?

package/problems/848/EVIDENCE.md

@@ -21,24 +21,98 @@ Current public evidence captured locally:
   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 public forum discussion records an explicit-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
+- The same thread also records earlier larger threshold exploration, including
+  `exp(1958)`-scale discussion and `exp(1420)` as a plausible intermediate explicit route
+  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.
+- The local number-theory pack now has a one-sided explicit Lemma 2.1 remainder ledger.
+  It shows that, at the public threshold candidates `exp(1420)` and `exp(1958)`, the
+  small-prime inclusion-exclusion remainder is negligible while the large-prime tail still
+  exceeds the frozen weakest-branch slack.
+- The local truncation scan also shows that the one-sided explicit route no longer needs
+  `T = floor(sqrt(log N))`; larger choices of `T` leave the discrete term negligible while
+  materially shrinking the live `A*` tail.
+- The local weakest-branch witness budget at `T = 250` now shows that, after the explicit
+  Lemma 2.1 and Lemma 2.2 tail terms are paid, the branch still appears to retain about
+  `0.001775` slack before the Lemma 2.2 prime-count term is inserted, and about `0.000366`
+  witness margin after that term is bounded with a Dusart-style explicit prime-count estimate.
+- The local weakest-branch assembly note now fixes a working witness
+  `T = 250`, `N >= exp(1420)`, `eta = 10^-4`, with about `0.000266` visible reserve left in
+  that branch after all currently frozen lemma-level costs.
+- The local branch-comparison ledger now indicates that the same witness also closes the
+  public branches with rounded bounds `0.0358`, `0.0336`, and `0.0294` at the repo's current
+  explicit level.
+- The local proposition-level candidate note now packages that shared witness as the current
+  repo candidate for an explicit stability statement, while still refusing to mark the problem
+  fully solved.
+- The local proof-obligation ledger now identifies the next real blocker as numerical
+  certification of the displayed decimal inputs, not another branch estimate.
+- The local certified numerical ledger now replaces the main displayed decimal inputs with
+  conservative machine-interval bounds, leaving a certified visible reserve of about
+  `0.000266` after the working `eta = 10^-4`.
+- The local theorem-style note now assembles the current explicit candidate into a single
+  proof-shaped artifact suitable for paper-writer mode and future public review.
+- The current candidate is now surfaced in both the paper bundle and a dossier-level public
+  review note, with a short share-ready summary.
+- The local paper bundle now has drafted introduction, preliminaries, and related-work
+  sections, and the bundle has been refreshed so that no placeholder paper text remains.
+- The current repo candidate is weaker than the best imported threshold value currently
+  visible on the public thread, so its main value is auditability and handoff structure,
+  not "best known `N0`" status.
+- The repo has now chosen bounded finite verification as the next closure lane and frozen
+  first-pass notes for verification regimes, certificate requirements, and imported
+  verification audit.
+- The repo now has an operational threshold posture note that allows imported `N0`
+  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..2000`, giving the bounded-verification lane its first trusted covered interval.
 
 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.
+- Exact: as of 2026-03-23, the best imported public-thread threshold visible in the dossier
+  is `N0 = 2.64 x 10^17`.
+- Exact: the repo's own audited candidate is currently weaker than that imported threshold,
+  so it should not be described as the best-known public bound.
+- Exact: the current repo explicitization of Lemma 2.1 isolates the large-prime tail as the
+  live analytic blocker in the weakest branch.
+- Exact: within the one-sided explicit route, enlarging `T` is now justified and appears to
+  be the right next analytic move.
+- Exact: a concrete witness value `T = 250` now survives the live tail bookkeeping in the
+  weakest branch at an explicit witness-budget level.
+- Exact: the weakest branch now has a concrete working `eta` witness, not just a floating
+  slack budget.
+- Exact: no other public branch currently appears to outrun that witness in the repo ledger.
+- Exact: the repo now has a proposition-level explicit candidate, but not yet a publication-
+  ready explicit theorem artifact.
+- Exact: the next real mathematical hardening step is numerical certification of the displayed
+  decimal inputs.
+- Exact: the current repo candidate is now numerically hardened at the ledger level.
+- Exact: the repo now also has a theorem-style proof artifact for the current candidate.
+- Exact: the current candidate package is now surfaced for both paper-writing and public
+  review workflows.
+- Exact: the paper bundle for the current candidate is now fully drafted at the section-shell
+  level and no longer depends on placeholder text in its public-facing sections.
 - 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.
+  theorem lane
+- 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 `2000` or whether the
+  next gain now needs a different method class