erdos-problems 0.1.0

package/problems/20/FORMALIZATION.md

@@ -0,0 +1,5 @@
+# Problem 20 Formalization
+
+Current posture:
+- formalization status: active
+- deep-harness sibling problem in the sunflower pack

package/problems/20/REFERENCES.md

@@ -0,0 +1,4 @@
+# Problem 20 References
+
+- Erdos Problems page: <https://www.erdosproblems.com/20>
+- Related sunflower problem: `857`

package/problems/20/STATEMENT.md

@@ -0,0 +1,7 @@
+# Problem 20 Statement
+
+Source: <https://www.erdosproblems.com/20>
+
+Normalized focus:
+- strong / uniform sunflower problem
+- deep-harness sibling to Problem 857

package/problems/20/problem.yaml

@@ -0,0 +1,16 @@
+problem_id: "20"
+display_name: "Erdos Problem #20"
+title: "Strong Sunflower Problem"
+source:
+  site: "erdosproblems.com"
+  url: "https://www.erdosproblems.com/20"
+  external_id: "20"
+status:
+  site_status: "open"
+  repo_status: "active"
+cluster: "sunflower"
+related_problems:
+  - "857"
+family_tags:
+  - "sunflower"
+  - "uniform-families"

package/problems/536/EVIDENCE.md

@@ -0,0 +1,3 @@
+# Problem 536 Evidence
+
+Current dossier placeholder.

package/problems/536/FORMALIZATION.md

@@ -0,0 +1,5 @@
+# Problem 536 Formalization
+
+Current posture:
+- formalization status: planned
+- dossier-first, not yet a deep harness

package/problems/536/REFERENCES.md

@@ -0,0 +1,4 @@
+# Problem 536 References
+
+- Erdos Problems page: <https://www.erdosproblems.com/536>
+- Related sunflower problem: `857`

package/problems/536/STATEMENT.md

@@ -0,0 +1,7 @@
+# Problem 536 Statement
+
+Source: <https://www.erdosproblems.com/536>
+
+Normalized focus:
+- LCM analogue related to weak sunflower structure
+- dossier-first seed problem in the sunflower cluster

package/problems/536/problem.yaml

@@ -0,0 +1,16 @@
+problem_id: "536"
+display_name: "Erdos Problem #536"
+title: "LCM Sunflower Analogue"
+source:
+  site: "erdosproblems.com"
+  url: "https://www.erdosproblems.com/536"
+  external_id: "536"
+status:
+  site_status: "open"
+  repo_status: "cataloged"
+cluster: "sunflower"
+related_problems:
+  - "857"
+family_tags:
+  - "sunflower-analogue"
+  - "number-theory"

package/problems/856/EVIDENCE.md

@@ -0,0 +1,3 @@
+# Problem 856 Evidence
+
+Current dossier placeholder.

package/problems/856/FORMALIZATION.md

@@ -0,0 +1,5 @@
+# Problem 856 Formalization
+
+Current posture:
+- formalization status: planned
+- dossier-first, not yet a deep harness

package/problems/856/REFERENCES.md

@@ -0,0 +1,4 @@
+# Problem 856 References
+
+- Erdos Problems page: <https://www.erdosproblems.com/856>
+- Related sunflower problem: `857`

package/problems/856/STATEMENT.md

@@ -0,0 +1,7 @@
+# Problem 856 Statement
+
+Source: <https://www.erdosproblems.com/856>
+
+Normalized focus:
+- harmonic or density-shaped LCM analogue linked to weak sunflower progress
+- dossier-first seed problem in the sunflower cluster

package/problems/856/problem.yaml

@@ -0,0 +1,16 @@
+problem_id: "856"
+display_name: "Erdos Problem #856"
+title: "Harmonic LCM Sunflower Analogue"
+source:
+  site: "erdosproblems.com"
+  url: "https://www.erdosproblems.com/856"
+  external_id: "856"
+status:
+  site_status: "open"
+  repo_status: "cataloged"
+cluster: "sunflower"
+related_problems:
+  - "857"
+family_tags:
+  - "sunflower-analogue"
+  - "number-theory"

package/problems/857/EVIDENCE.md

@@ -0,0 +1,9 @@
+# Problem 857 Evidence
+
+Current dossier placeholder.
+
+Track here:
+- route breakthroughs
+- formal theorem checkpoints
+- computational artifacts
+- failed-path summaries

package/problems/857/FORMALIZATION.md

@@ -0,0 +1,6 @@
+# Problem 857 Formalization
+
+Current posture:
+- formalization status: active
+- active route: anchored_selector_linearization
+- main upstream lab: sunflower-coda

package/problems/857/REFERENCES.md

@@ -0,0 +1,5 @@
+# Problem 857 References
+
+- Erdos Problems page: <https://www.erdosproblems.com/857>
+- Related problems: `20`, `536`, `856`
+- Repo note: this is the primary weak-sunflower deep-harness problem

package/problems/857/STATEMENT.md

@@ -0,0 +1,8 @@
+# Problem 857 Statement
+
+Source: <https://www.erdosproblems.com/857>
+
+Normalized focus:
+- weak sunflower problem
+- bound `m(n,k)` by `C(k)^n`
+- current deep-harness frontier lives in the sunflower pack

package/problems/857/problem.yaml

@@ -0,0 +1,23 @@
+problem_id: "857"
+display_name: "Erdos Problem #857"
+title: "Sunflower Conjecture"
+source:
+  site: "erdosproblems.com"
+  url: "https://www.erdosproblems.com/857"
+  external_id: "857"
+status:
+  site_status: "open"
+  repo_status: "active"
+cluster: "sunflower"
+related_problems:
+  - "20"
+  - "536"
+  - "856"
+family_tags:
+  - "sunflower"
+  - "extremal-set-theory"
+research_state:
+  open_problem: true
+  active_route: "anchored_selector_linearization"
+  route_breakthrough: true
+  problem_solved: false

package/src/atlas/catalog.js

@@ -0,0 +1,98 @@
+export const catalog = [
+  {
+    problemId: '20',
+    displayName: 'Erdos Problem #20',
+    title: 'Strong Sunflower Problem',
+    siteStatus: 'open',
+    repoStatus: 'active',
+    cluster: 'sunflower',
+    familyTags: ['sunflower', 'uniform-families'],
+    relatedProblems: ['857'],
+    sourceUrl: 'https://www.erdosproblems.com/20',
+    shortStatement:
+      'Determine the strong sunflower threshold for k-uniform set systems, with the k=3 lane as the immediate active frontier.',
+    harnessDepth: 'deep',
+    formalizationStatus: 'active',
+  },
+  {
+    problemId: '536',
+    displayName: 'Erdos Problem #536',
+    title: 'LCM Sunflower Analogue',
+    siteStatus: 'open',
+    repoStatus: 'cataloged',
+    cluster: 'sunflower',
+    familyTags: ['sunflower-analogue', 'number-theory'],
+    relatedProblems: ['857'],
+    sourceUrl: 'https://www.erdosproblems.com/536',
+    shortStatement:
+      'Number-theoretic analogue of the sunflower problem framed through least common multiples.',
+    harnessDepth: 'dossier',
+    formalizationStatus: 'planned',
+  },
+  {
+    problemId: '856',
+    displayName: 'Erdos Problem #856',
+    title: 'Harmonic LCM Sunflower Analogue',
+    siteStatus: 'open',
+    repoStatus: 'cataloged',
+    cluster: 'sunflower',
+    familyTags: ['sunflower-analogue', 'number-theory'],
+    relatedProblems: ['857'],
+    sourceUrl: 'https://www.erdosproblems.com/856',
+    shortStatement:
+      'A harmonic or density-shaped LCM analogue whose exponents are explicitly linked to progress on the weak sunflower problem.',
+    harnessDepth: 'dossier',
+    formalizationStatus: 'planned',
+  },
+  {
+    problemId: '857',
+    displayName: 'Erdos Problem #857',
+    title: 'Sunflower Conjecture',
+    siteStatus: 'open',
+    repoStatus: 'active',
+    cluster: 'sunflower',
+    familyTags: ['sunflower', 'extremal-set-theory'],
+    relatedProblems: ['20', '536', '856'],
+    sourceUrl: 'https://www.erdosproblems.com/857',
+    shortStatement:
+      'Bound the weak sunflower number m(n,k) by C(k)^n and sharpen the current active route toward asymptotic closure.',
+    harnessDepth: 'deep',
+    formalizationStatus: 'active',
+    researchState: {
+      openProblem: true,
+      activeRoute: 'anchored_selector_linearization',
+      routeBreakthrough: true,
+      problemSolved: false,
+    },
+  },
+];
+
+export function listProblems(filters = {}) {
+  const cluster = filters.cluster ? String(filters.cluster).toLowerCase() : null;
+  return [...catalog]
+    .filter((entry) => (cluster ? entry.cluster === cluster : true))
+    .sort((a, b) => Number(a.problemId) - Number(b.problemId));
+}
+
+export function getProblem(problemId) {
+  return catalog.find((entry) => entry.problemId === String(problemId));
+}
+
+export function getCluster(clusterName) {
+  const name = String(clusterName).toLowerCase();
+  const problems = listProblems({ cluster: name });
+  if (problems.length === 0) {
+    return null;
+  }
+  return {
+    name,
+    problems,
+    deepHarnessProblems: problems.filter((entry) => entry.harnessDepth === 'deep'),
+    dossierProblems: problems.filter((entry) => entry.harnessDepth === 'dossier'),
+  };
+}
+
+export function listClusters() {
+  const names = [...new Set(catalog.map((entry) => entry.cluster))].sort();
+  return names.map((name) => getCluster(name));
+}

package/src/cli/index.js

@@ -0,0 +1,41 @@
+import { runClusterCommand } from '../commands/cluster.js';
+import { runDossierCommand } from '../commands/dossier.js';
+import { runProblemCommand } from '../commands/problem.js';
+import { runWorkspaceCommand } from '../commands/workspace.js';
+
+function printUsage() {
+  console.log('erdos-problems CLI');
+  console.log('');
+  console.log('Usage:');
+  console.log('  erdos problem list [--cluster <name>]');
+  console.log('  erdos problem show <id>');
+  console.log('  erdos problem use <id>');
+  console.log('  erdos problem current');
+  console.log('  erdos cluster list');
+  console.log('  erdos cluster show <name>');
+  console.log('  erdos workspace show');
+  console.log('  erdos dossier show <id>');
+}
+
+const args = process.argv.slice(2);
+const [command, ...rest] = args;
+
+let exitCode = 0;
+
+if (!command || command === 'help' || command === '--help') {
+  printUsage();
+} else if (command === 'problem') {
+  exitCode = runProblemCommand(rest);
+} else if (command === 'cluster') {
+  exitCode = runClusterCommand(rest);
+} else if (command === 'workspace') {
+  exitCode = runWorkspaceCommand(rest);
+} else if (command === 'dossier') {
+  exitCode = runDossierCommand(rest);
+} else {
+  console.error(`Unknown command: ${command}`);
+  printUsage();
+  exitCode = 1;
+}
+
+process.exitCode = exitCode;

package/src/commands/cluster.js

@@ -0,0 +1,52 @@
+import { getCluster, listClusters } from '../atlas/catalog.js';
+
+function printCluster(cluster) {
+  console.log(`Cluster: ${cluster.name}`);
+  console.log(`Problems: ${cluster.problems.map((problem) => problem.problemId).join(', ')}`);
+  console.log(`Deep harness: ${cluster.deepHarnessProblems.map((problem) => problem.problemId).join(', ') || '(none)'}`);
+  console.log(`Dossier-first: ${cluster.dossierProblems.map((problem) => problem.problemId).join(', ') || '(none)'}`);
+  console.log('Summary:');
+  if (cluster.name === 'sunflower') {
+    console.log('  Weak sunflower core: 857');
+    console.log('  Strong sunflower sibling: 20');
+    console.log('  Related analogues: 536, 856');
+  }
+}
+
+export function runClusterCommand(args) {
+  const [subcommand, value] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos cluster list');
+    console.log('  erdos cluster show <name>');
+    return 0;
+  }
+
+  if (subcommand === 'list') {
+    console.log('Clusters:');
+    for (const cluster of listClusters()) {
+      console.log(`- ${cluster.name}: ${cluster.problems.length} problems, ${cluster.deepHarnessProblems.length} deep-harness`);
+    }
+    return 0;
+  }
+
+  if (subcommand !== 'show') {
+    console.error(`Unknown cluster subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  if (!value) {
+    console.error('Missing cluster name.');
+    return 1;
+  }
+
+  const cluster = getCluster(value);
+  if (!cluster) {
+    console.error(`Unknown cluster: ${value}`);
+    return 1;
+  }
+
+  printCluster(cluster);
+  return 0;
+}

package/src/commands/dossier.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { getProblemDir } from '../runtime/paths.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+const sections = ['STATEMENT.md', 'REFERENCES.md', 'EVIDENCE.md', 'FORMALIZATION.md'];
+
+export function runDossierCommand(args) {
+  const [subcommand, value] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos dossier show <id>');
+    return 0;
+  }
+
+  if (subcommand !== 'show') {
+    console.error(`Unknown dossier subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const problemId = value ?? readCurrentProblem();
+  if (!problemId) {
+    console.error('Missing problem id and no active problem is selected.');
+    return 1;
+  }
+
+  const problem = getProblem(problemId);
+  if (!problem) {
+    console.error(`Unknown problem: ${problemId}`);
+    return 1;
+  }
+
+  const problemDir = getProblemDir(problem.problemId);
+  console.log(`${problem.displayName} dossier`);
+  console.log(`Directory: ${problemDir}`);
+  console.log('Sections:');
+  for (const section of sections) {
+    const filePath = path.join(problemDir, section);
+    const exists = fs.existsSync(filePath);
+    console.log(`- ${section}: ${exists ? 'present' : 'missing'}`);
+  }
+  const statementPath = path.join(problemDir, 'STATEMENT.md');
+  if (fs.existsSync(statementPath)) {
+    console.log('');
+    console.log('Statement preview:');
+    console.log(fs.readFileSync(statementPath, 'utf8').trim());
+  }
+  return 0;
+}

package/src/commands/problem.js

@@ -0,0 +1,124 @@
+import { getProblem, listProblems } from '../atlas/catalog.js';
+import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
+
+function parseListFilters(args) {
+  const filters = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === '--cluster') {
+      const cluster = args[index + 1];
+      if (!cluster) {
+        return { error: 'Missing cluster name after --cluster.' };
+      }
+      filters.cluster = cluster;
+      index += 1;
+      continue;
+    }
+    return { error: `Unknown list option: ${token}` };
+  }
+  return { filters };
+}
+
+function printProblemTable(rows, activeProblem) {
+  console.log('ID   Site   Repo       Cluster     Active  Title');
+  for (const row of rows) {
+    const id = row.problemId.padEnd(4, ' ');
+    const site = row.siteStatus.padEnd(6, ' ');
+    const repo = row.repoStatus.padEnd(10, ' ');
+    const cluster = row.cluster.padEnd(11, ' ');
+    const active = (row.problemId === activeProblem ? '*' : '-').padEnd(7, ' ');
+    console.log(`${id} ${site} ${repo} ${cluster} ${active} ${row.title}`);
+  }
+}
+
+function printProblem(problem) {
+  console.log(problem.displayName);
+  console.log(`Title: ${problem.title}`);
+  console.log(`Source: ${problem.sourceUrl}`);
+  console.log(`Site status: ${problem.siteStatus}`);
+  console.log(`Repo status: ${problem.repoStatus}`);
+  console.log(`Cluster: ${problem.cluster}`);
+  console.log(`Harness depth: ${problem.harnessDepth}`);
+  console.log(`Formalization: ${problem.formalizationStatus}`);
+  console.log(`Related: ${problem.relatedProblems.join(', ') || '(none)'}`);
+  console.log(`Tags: ${problem.familyTags.join(', ') || '(none)'}`);
+  console.log(`Statement: ${problem.shortStatement}`);
+  if (problem.researchState) {
+    console.log('Research state:');
+    console.log(`  open problem: ${problem.researchState.openProblem ? 'yes' : 'no'}`);
+    console.log(`  active route: ${problem.researchState.activeRoute}`);
+    console.log(`  route breakthrough: ${problem.researchState.routeBreakthrough ? 'yes' : 'no'}`);
+    console.log(`  problem solved: ${problem.researchState.problemSolved ? 'yes' : 'no'}`);
+  }
+}
+
+export function runProblemCommand(args) {
+  const [subcommand, value, ...rest] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos problem list [--cluster <name>]');
+    console.log('  erdos problem show <id>');
+    console.log('  erdos problem use <id>');
+    console.log('  erdos problem current');
+    return 0;
+  }
+
+  if (subcommand === 'list') {
+    const parsed = parseListFilters([value, ...rest].filter(Boolean));
+    if (parsed.error) {
+      console.error(parsed.error);
+      return 1;
+    }
+    printProblemTable(listProblems(parsed.filters), readCurrentProblem());
+    return 0;
+  }
+
+  if (subcommand === 'show') {
+    const problemId = value ?? readCurrentProblem();
+    if (!problemId) {
+      console.error('Missing problem id and no active problem is selected.');
+      return 1;
+    }
+    const problem = getProblem(problemId);
+    if (!problem) {
+      console.error(`Unknown problem: ${problemId}`);
+      return 1;
+    }
+    printProblem(problem);
+    return 0;
+  }
+
+  if (subcommand === 'use') {
+    if (!value) {
+      console.error('Missing problem id.');
+      return 1;
+    }
+    const problem = getProblem(value);
+    if (!problem) {
+      console.error(`Unknown problem: ${value}`);
+      return 1;
+    }
+    setCurrentProblem(problem.problemId);
+    console.log(`Active problem set to ${problem.problemId} (${problem.title})`);
+    return 0;
+  }
+
+  if (subcommand === 'current') {
+    const problemId = readCurrentProblem();
+    if (!problemId) {
+      console.log('No active problem selected.');
+      return 0;
+    }
+    const problem = getProblem(problemId);
+    if (!problem) {
+      console.error(`Active problem ${problemId} is not in the catalog.`);
+      return 1;
+    }
+    printProblem(problem);
+    return 0;
+  }
+
+  console.error(`Unknown problem subcommand: ${subcommand}`);
+  return 1;
+}

package/src/commands/workspace.js

@@ -0,0 +1,24 @@
+import { getWorkspaceSummary } from '../runtime/workspace.js';
+
+export function runWorkspaceCommand(args) {
+  const [subcommand] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos workspace show');
+    return 0;
+  }
+
+  if (subcommand !== 'show') {
+    console.error(`Unknown workspace subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const summary = getWorkspaceSummary();
+  console.log(`Workspace root: ${summary.workspaceRoot}`);
+  console.log(`State dir: ${summary.stateDir}`);
+  console.log(`Initialized: ${summary.hasState ? 'yes' : 'no'}`);
+  console.log(`Active problem: ${summary.activeProblem ?? '(none)'}`);
+  console.log(`Updated at: ${summary.updatedAt ?? '(none)'}`);
+  return 0;
+}

package/src/runtime/paths.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const repoRoot = path.resolve(here, '..', '..');
+
+export function getWorkspaceRoot() {
+  return process.cwd();
+}
+
+export function getWorkspaceDir() {
+  return path.join(getWorkspaceRoot(), '.erdos');
+}
+
+export function getWorkspaceStatePath() {
+  return path.join(getWorkspaceDir(), 'state.json');
+}
+
+export function getCurrentProblemPath() {
+  return path.join(getWorkspaceDir(), 'current-problem.json');
+}
+
+export function getProblemDir(problemId) {
+  return path.join(repoRoot, 'problems', String(problemId));
+}

package/src/runtime/workspace.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  getCurrentProblemPath,
+  getWorkspaceDir,
+  getWorkspaceRoot,
+  getWorkspaceStatePath,
+} from './paths.js';
+
+function writeJson(filePath, payload) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2) + '\n');
+}
+
+export function readWorkspaceState() {
+  const filePath = getWorkspaceStatePath();
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function ensureWorkspaceState() {
+  const existing = readWorkspaceState();
+  if (existing) {
+    return existing;
+  }
+  const now = new Date().toISOString();
+  const state = {
+    workspaceRoot: getWorkspaceRoot(),
+    createdAt: now,
+    updatedAt: now,
+  };
+  writeJson(getWorkspaceStatePath(), state);
+  return state;
+}
+
+export function setCurrentProblem(problemId) {
+  const existing = ensureWorkspaceState();
+  const now = new Date().toISOString();
+  writeJson(getCurrentProblemPath(), {
+    problemId: String(problemId),
+    selectedAt: now,
+  });
+  writeJson(getWorkspaceStatePath(), {
+    workspaceRoot: getWorkspaceRoot(),
+    createdAt: existing.createdAt ?? now,
+    updatedAt: now,
+    activeProblem: String(problemId),
+  });
+}
+
+export function readCurrentProblem() {
+  const filePath = getCurrentProblemPath();
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const payload = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  return payload.problemId ?? null;
+}
+
+export function getWorkspaceSummary() {
+  const state = readWorkspaceState();
+  return {
+    workspaceRoot: getWorkspaceRoot(),
+    stateDir: getWorkspaceDir(),
+    hasState: Boolean(state),
+    activeProblem: readCurrentProblem(),
+    updatedAt: state?.updatedAt ?? null,
+  };
+}