@josd/eyecode 0.0.0-stage → 0.1.4

package/src/cli.js

@@ -0,0 +1,126 @@
+// The eyecode command line.
+import { run, unusedClauses } from './engine.js';
+import { loadSources } from './lang.js';
+import { checkProof, checkReport, publicReport } from './proof.js';
+import { EyecodeError } from './terms.js';
+import { VERSION } from './version.js';
+
+export const HELP = `Usage: eyecode [OPTION ...] [FILE ...]
+Programs are JavaScript; forward rules run to a fixpoint.
+  --proof             Print the claims with clause(...) and step(...) records
+  --check-proof FILE  Print a C1-C7 check report of a proof (- for stdin)
+  --json              Print the check report as JSON instead
+  --goal GOAL         Ask a backward goal after forward reasoning; with
+                      --check-proof, the goal the proof answers
+  --strict-proof      Reject proofs relying on absence or collection
+  --unused            List the clauses that make no difference to the conclusions
+  --stats             Print reasoning statistics to stderr
+  --max-depth N       Bound backward recursion (default 1000000)
+  --max-iterations N  Bound forward rounds per stratum (default 1000)
+  --max-inferences N  Bound reasoning work (default 1000000)
+  --version           Print the version
+  --help              Print this help
+Source defaults to stdin; multiple files form one program.
+Exit codes: 0 success, 1 error, 2 invalid proof, 65 contradiction.
+`;
+
+const LIMITS = { '--max-depth': 'maxDepth', '--max-iterations': 'maxIterations', '--max-inferences': 'maxInferences' };
+
+class UsageError extends Error {}
+
+function readSource(path, io) {
+  return path === '-' ? io.stdin() : io.readFile(path);
+}
+
+// Run the command line; returns the exit code. io writes and reads: stdout,
+// stderr, stdin and readFile, and may check syntax (see node.js).
+export function main(argv, io) {
+  const stdout = (text) => io.stdout(text);
+  const stderr = (text) => io.stderr(text);
+  try {
+    const files = [];
+    const options = {};
+    const goals = [];
+    let proofFile = null;
+    let stats = false;
+    let strictProof = false;
+    let asJson = false;
+    let unused = false;
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg === '--help' || arg === '-h') {
+        stdout(HELP);
+        return 0;
+      }
+      if (arg === '--version' || arg === '-v') {
+        stdout(`eyecode v${VERSION}\n`);
+        return 0;
+      }
+      if (arg === '--proof' || arg === '-p') {
+        options.proof = true;
+      } else if (arg === '--stats') {
+        stats = true;
+      } else if (arg === '--strict-proof') {
+        strictProof = true;
+      } else if (arg === '--json') {
+        asJson = true;
+      } else if (arg === '--unused') {
+        unused = true;
+      } else if (arg === '--check-proof' || arg === '--goal' || Object.hasOwn(LIMITS, arg)) {
+        i++;
+        if (i >= argv.length) throw new UsageError(`${arg} needs a value`);
+        const value = argv[i];
+        if (arg === '--check-proof') {
+          proofFile = value;
+        } else if (arg === '--goal') {
+          goals.push(value);
+        } else {
+          const number = /^[0-9]+$/.test(value.trim()) ? Number(value.trim()) : 0;
+          if (number < 1) throw new UsageError(`${arg} needs a positive integer`);
+          options[LIMITS[arg]] = number;
+        }
+      } else if (arg.startsWith('-') && arg !== '-') {
+        throw new UsageError(`unknown option ${arg}`);
+      } else {
+        files.push(arg);
+      }
+    }
+    if (asJson && proofFile === null) throw new UsageError('--json requires --check-proof');
+    if (strictProof && proofFile === null) throw new UsageError('--strict-proof requires --check-proof');
+    if (proofFile !== null && options.proof) throw new UsageError('--check-proof cannot be combined with --proof');
+    if (unused && (proofFile !== null || options.proof)) {
+      throw new UsageError('--unused cannot be combined with --proof or --check-proof');
+    }
+    if (proofFile === '-' && (!files.length || files.includes('-'))) {
+      throw new UsageError('stdin holds the proof; name the program as files');
+    }
+    if (!files.length) files.push('-');
+    if (files.filter((file) => file === '-').length > 1) throw new UsageError('stdin can only be read once');
+    const program = loadSources(files.map((file) => [readSource(file, io), file === '-' ? '<stdin>' : file]), io);
+    if (proofFile !== null) {
+      const document = readSource(proofFile, io);
+      const report = checkProof(program, document, { goals, allowTrusted: !strictProof });
+      stdout(asJson ? `${JSON.stringify(publicReport(report), null, 2)}\n` : checkReport(report));
+      // An invalid proof is a result, not an error: it has its own exit code.
+      return report.valid ? 0 : 2;
+    }
+    if (unused) {
+      stdout(unusedClauses(program, { goals, ...options }));
+      return 0;
+    }
+    const result = run(program, { goals, ...options });
+    stdout(result.stdout);
+    if (stats) stderr(`${JSON.stringify(result.stats)}\n`);
+    return result.haltCode || 0;
+  } catch (error) {
+    if (error instanceof UsageError || error instanceof EyecodeError) {
+      stderr(`eyecode: ${error.message}\n`);
+      return 1;
+    }
+    if (error && (error.code === 'ENOENT' || error.code === 'EISDIR' || error.code === 'EACCES')) {
+      stderr(`eyecode: ${error.message}\n`);
+      return 1;
+    }
+    throw error;
+  }
+}

package/src/common.js

@@ -0,0 +1,120 @@
+// Helpers shared by the engine and the proof checker.
+import { Struct, Var, freshTerm } from './terms.js';
+import { write } from './writer.js';
+
+// The canonical spelling of a term, which also serves as its identity.
+export function text(term, env = null) {
+  return write(term, env);
+}
+
+// Rename a clause apart: head and body share one set of fresh variables,
+// listed in the order the clause is written (a forward rule's body first).
+export function freshClause(clause, suffix) {
+  const renamed = renaming(clause);
+  if (renamed === null) {
+    const names = new Map();
+    let head;
+    let body;
+    if (clause.forward) {
+      body = clause.body.map((goal) => freshTerm(goal, suffix, names));
+      head = freshTerm(clause.head, suffix, names);
+    } else {
+      head = freshTerm(clause.head, suffix, names);
+      body = clause.body.map((goal) => freshTerm(goal, suffix, names));
+    }
+    return [head, body, names];
+  }
+  const tag = String(suffix);
+  const values = renamed.prefixes.map((prefix) => new Var(prefix + tag));
+  let names = new Map(renamed.names.map((name, i) => [name, values[i]]));
+  if (renamed.written !== null) names = new Map(renamed.written.map((name) => [name, names.get(name)]));
+  return [renamed.head(values), renamed.body(values), names];
+}
+
+// How to rename a clause apart quickly, or null while it has been used too
+// seldom to be worth working out: most clauses of a large program are used
+// once, and renaming those directly is cheaper.
+export function renaming(clause) {
+  let renamed = clause.renaming;
+  if (renamed === null) {
+    clause.uses++;
+    if (clause.uses < WORK_OUT_AFTER) return null;
+    renamed = clause.renaming = workOut(clause);
+  }
+  return renamed;
+}
+
+const WORK_OUT_AFTER = 3;
+
+function collectNames(terms, index) {
+  for (const term of terms) {
+    const pending = [term];
+    while (pending.length) {
+      const item = pending.pop();
+      if (item instanceof Var) {
+        if (!index.has(item.name)) index.set(item.name, index.size);
+      } else if (item instanceof Struct) {
+        for (let i = item.args.length - 1; i >= 0; i--) pending.push(item.args[i]);
+      }
+    }
+  }
+}
+
+// The clause's variables are numbered in order of first occurrence, head
+// first; head(values) and body(values) build the renamed head and body from
+// fresh variables in that order, the first headCount of them sufficing for
+// the head. Subterms without variables are shared.
+function workOut(clause) {
+  const index = new Map();
+  collectNames([clause.head], index);
+  const headCount = index.size;
+  collectNames(clause.body, index);
+  const names = [...index.keys()];
+  let written = null;
+  if (clause.forward) {
+    // A forward rule is written premise first, implies(Body, Head), and its
+    // variables are listed in that order.
+    const order = new Map();
+    collectNames([...clause.body, clause.head], order);
+    written = [...order.keys()];
+  }
+  return {
+    names,
+    prefixes: names.map((name) => `${name}#`),
+    headCount,
+    written,
+    head: (values) => substitute(clause.head, index, values),
+    body: (values) => clause.body.map((goal) => substitute(goal, index, values)),
+  };
+}
+
+function substitute(term, index, values) {
+  if (term instanceof Var) return values[index.get(term.name)];
+  if (!(term instanceof Struct)) return term;
+  const args = term.args;
+  let copied = null;
+  for (let position = 0; position < args.length; position++) {
+    const arg = args[position];
+    const copy = arg instanceof Var || arg instanceof Struct ? substitute(arg, index, values) : arg;
+    if (copied === null) {
+      if (copy === arg) continue;
+      copied = args.slice(0, position);
+    }
+    copied.push(copy);
+  }
+  return copied === null ? term : new Struct(term.name, copied);
+}
+
+// A key that preserves sharing while forgetting variable names.
+export function variant(term) {
+  const names = new Map();
+  function visit(t) {
+    if (t instanceof Var) {
+      if (!names.has(t.name)) names.set(t.name, new Var(`V${names.size}`));
+      return names.get(t.name);
+    }
+    if (t instanceof Struct) return new Struct(t.name, t.args.map(visit));
+    return t;
+  }
+  return text(visit(term));
+}