eyeprolog 1.6.39 → 1.6.41

package/examples/output/dependency-depth-10000.pl

@@ -0,0 +1 @@
+chain9998(ready).

package/examples/output/dependency-preparation-5000.pl

@@ -0,0 +1 @@
+chain4998(ready).

package/examples/proof/dependency-depth-10000.pl

@@ -0,0 +1,8 @@
+chain9998(ready).
+
+clause(9999, chain9998(var('X')), chain9999(var('X'))).
+clause(10000, chain9999(ready), !).
+
+step(chain9998(ready), rule(9999), ['X' = ready], [chain9999(ready)]).
+step(chain9999(ready), rule(10000), [], "!").
+step(!, builtin, [], []).

package/examples/proof/dependency-preparation-5000.pl

@@ -0,0 +1,7 @@
+chain4998(ready).
+
+clause(4999, chain4998(var('X')), chain4999(var('X'))).
+clause(5000, chain4999(ready), true).
+
+step(chain4998(ready), rule(4999), ['X' = ready], [chain4999(ready)]).
+step(chain4999(ready), fact(5000), [], []).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.39",
+  "version": "1.6.41",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -504,6 +504,8 @@
           "defeasible-reasoning",
           "delfour",
           "deontic-logic",
+          "dependency-depth-10000",
+          "dependency-preparation-5000",
           "derived-backward-rule",
           "derived-rule",
           "diamond-property",

package/src/check-proof.js

@@ -152,8 +152,19 @@ function isAtom(term, name) {
   return term?.type === ATOM && term.name === name;
 }
 
+// While a proof is checked, each term is spelled once: a step's conclusion is
+// also the use of the step that rests on it, and the coverage, relevance and
+// well-foundedness checks each look it up.
+let keyMemo = null;
+
 function key(term) {
-  return termToString(term, new Env(), true);
+  if (keyMemo == null || term === null || typeof term !== 'object') return termToString(term, new Env(), true);
+  let spelled = keyMemo.get(term);
+  if (spelled === undefined) {
+    spelled = termToString(term, new Env(), true);
+    keyMemo.set(term, spelled);
+  }
+  return spelled;
 }
 
 // A term is identical to another when it needs no further instantiation to
@@ -455,7 +466,17 @@ export function checkProofDocument(program, text, options = {}) {
 // its own proofs this way before writing them (SPEC.md, Section 7.1); that the
 // text it writes reads back as the same structures is what checking the
 // packaged documents establishes.
-export function checkProof(program, { claims, records = [], steps: allSteps }, options = {}, failures = []) {
+export function checkProof(program, document, options = {}, failures = []) {
+  const outer = keyMemo;
+  keyMemo ??= new WeakMap();
+  try {
+    return checkProofWithKeys(program, document, options, failures);
+  } finally {
+    keyMemo = outer;
+  }
+}
+
+function checkProofWithKeys(program, { claims, records = [], steps: allSteps }, options, failures) {
   const writeOptions = {
     doubleQuotes: program?.doubleQuotes ?? 'chars', doubleBar: true, quoted: true,
     operators: [...(program?.operators?.values() ?? [])],
@@ -472,7 +493,13 @@ export function checkProof(program, { claims, records = [], steps: allSteps }, o
   for (const record of records) {
     const number = record.args[0]?.type === NUMBER ? Number(record.args[0].name) : NaN;
     const clause = Number.isInteger(number) ? numbering.get(number) : null;
-    if (!clause || !identical(normalizedClauseRecord(record), normalizedClauseRecord(clauseRecordTerm(number, clause)))) {
+    if (!clause) {
+      fail('C1', 'clause record differs from source', record);
+      continue;
+    }
+    // A record that is the rebuilt record itself restates the clause.
+    const rebuilt = clauseRecordTerm(number, clause);
+    if (record !== rebuilt && !identical(normalizedClauseRecord(record), normalizedClauseRecord(rebuilt))) {
       fail('C1', 'clause record differs from source', record);
     }
   }

package/src/explain.js

@@ -1009,6 +1009,7 @@ function resolvedSubstitutions(substitutions, env) {
 // would displace the real clause and every step citing it would stop
 // resolving. Such a declaration is never what a rule(N) or fact(N) cites.
 function isUnnumberedDeclaration(clause) {
+  if (clause?.compactBinary === true) return false;
   const head = clause?.head;
   if (head?.type !== COMPOUND || head.name !== ':-' || head.arity !== 1) return false;
   const directive = head.args[0];
@@ -1016,7 +1017,36 @@ function isUnnumberedDeclaration(clause) {
   return ['module', 'use_module', 'meta_predicate', 'attribute'].includes(directive.name);
 }
 
+// A Map from small positive integers, kept in an array.
+class NumberedTable {
+  constructor() {
+    this.items = [];
+  }
+
+  get(number) {
+    return Number.isInteger(number) && number >= 0 ? this.items[number] : undefined;
+  }
+
+  set(number, value) {
+    this.items[number] = value;
+  }
+}
+
+// A proof is numbered when it is flattened and again when it is checked, and
+// both see the same program; the numbering is kept until the program's
+// clauses change.
+const numberings = new WeakMap();
+
 export function clauseNumbering(program) {
+  const clauses = program.clauses ?? [];
+  const cached = numberings.get(program);
+  if (cached && cached.clauses === clauses && cached.length === clauses.length) return cached.numbering;
+  const numbering = computeClauseNumbering(program);
+  numberings.set(program, { clauses, length: clauses.length, numbering });
+  return numbering;
+}
+
+function computeClauseNumbering(program) {
   const spans = new Map();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause)) continue;
@@ -1032,17 +1062,19 @@ export function clauseNumbering(program) {
 
   // Keyed by file, then by clause position: one string key per clause cost
   // more than the numbering itself on programs with hundreds of thousands of
-  // clauses.
+  // clauses. Positions and numbers count up from 1, so arrays hold them.
   const bySource = new Map();
-  const byNumber = new Map();
+  const byNumber = new NumberedTable();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause) || isUnnumberedDeclaration(clause)) continue;
     const { filename, clause: position } = clause.source;
     const number = (offsets.get(filename) ?? 0) + position;
     let numbers = bySource.get(filename);
-    if (!numbers) bySource.set(filename, numbers = new Map());
+    if (!numbers) bySource.set(filename, numbers = new NumberedTable());
     numbers.set(position, number);
-    byNumber.set(number, { head: clause.head, body: clause.body ?? [] });
+    // The clause itself, not a copy of its head and body: a compact clause
+    // builds those terms only when a proof cites it.
+    byNumber.set(number, clause.compactBinary === true || clause.body != null ? clause : { head: clause.head, body: [] });
   }
   return { bySource, byNumber };
 }

package/src/parser.js

@@ -1504,8 +1504,8 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   let operatorState = null;
   // With source metadata, this path numbers clauses exactly as the general
   // parser does: one number per clause and per counted directive, none for a
-  // query or a quad. Compact binary clauses carry no source, so they are not
-  // used then.
+  // query or a quad. A compact binary clause is numbered the same way, through
+  // the clause object its builder hands back.
   const trackSource = options.sourceMetadata === true;
   const sourceFilename = options.filename ?? '<input>';
   let clauseNumber = 0;
@@ -1774,18 +1774,20 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     if (rule < 0) {
       if (!parseBinaryRawRange(text, start, termEnd, rawHead)) return false;
       reportFastBinarySingletonWarnings(rawHead, null, line);
-      emitBinary(rawHead.name,
+      const clause = emitBinary(rawHead.name,
         rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
         null, null, null, null, null);
+      if (clause) numbered(clause, line);
       return true;
     }
     if (findRuleInRange(text, rule + 2, termEnd) >= 0 ||
         !parseBinaryRawRange(text, start, rule, rawHead) ||
         !parseBinaryRawRange(text, rule + 2, termEnd, rawBody)) return false;
     reportFastBinarySingletonWarnings(rawHead, rawBody, line);
-    emitBinary(rawHead.name,
+    const clause = emitBinary(rawHead.name,
       rawHead.arg0Type, rawHead.arg0Name, rawHead.arg1Type, rawHead.arg1Name,
       rawBody.name, rawBody.arg0Type, rawBody.arg0Name, rawBody.arg1Type, rawBody.arg1Name);
+    if (clause) numbered(clause, line);
     return true;
   };
 
@@ -1851,12 +1853,14 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     // subsequent source character must pass through the full tokenizer. The
     // compact parser deliberately operates on raw source ranges, so using it
     // here would silently bypass Convc for otherwise simple clauses.
+    const anonymousBefore = anonymous;
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
       reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
       accept(numbered(simple, sourceLine));
       return true;
     }
+    anonymous = anonymousBefore;
     try {
       const nestedWarning = typeof options.onWarning === 'function'
         ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
@@ -1912,14 +1916,19 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     contentEnd = trimRangeEnd(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
-        if (!trackSource && emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
+        // A reader that declines a clause may have named some of its
+        // anonymous variables already; the next one starts the count again.
+        const anonymousBefore = anonymous;
+        if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
+          anonymous = anonymousBefore;
           const simple = parseFastRange(source, contentStart, contentEnd);
           if (simple) {
             reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
             accept(numbered(simple, lineNumber));
           } else {
+            anonymous = anonymousBefore;
             chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';
             if (!flush()) return null;

package/src/program-analysis.js

@@ -44,8 +44,12 @@ export function componentHasCut(start, deps, groups) {
 
 
 export function reachableIndexes(start, deps) {
+  return reachableFromRoots([start], deps);
+}
+
+function reachableFromRoots(roots, deps) {
   const seen = new Set();
-  const stack = [start];
+  const stack = [...roots];
   while (stack.length) {
     const current = stack.pop();
     if (seen.has(current)) continue;
@@ -55,6 +59,49 @@ export function reachableIndexes(start, deps) {
   return seen;
 }
 
+// Classify the whole dependency graph once. Repeating a reachability walk for
+// every predicate makes loading a long acyclic chain quadratic, even though
+// recursion and cut propagation are properties of its components and edges.
+export function analyzeDependencyGraph(deps, cutDeps, groups, multiplicityRoots, wfsEdges) {
+  const components = stronglyConnectedComponents(deps);
+  const componentByIndex = new Int32Array(groups.length);
+  const componentCuts = new Uint8Array(components.length);
+  const reverse = groups.map(() => []);
+  const reverseCuts = groups.map(() => []);
+  const cutRoots = [];
+  for (let component = 0; component < components.length; component++) {
+    for (const index of components[component]) {
+      componentByIndex[index] = component;
+      const group = groups[index];
+      if (!group.hasCut) continue;
+      // Preserve the distinction between a cut in a base clause and a cut
+      // in a directly recursive clause used by the solver's recursion plans.
+      const directRecursive = group.clauses.some((clause) => clauseIsDirectRecursive(clause, group));
+      if (group.clauses.some((clause) =>
+        (!directRecursive || clauseIsDirectRecursive(clause, group)) && clauseHasCut(clause))) {
+        componentCuts[component] = 1;
+      }
+    }
+  }
+  for (let from = 0; from < groups.length; from++) {
+    for (const to of deps[from]) reverse[to].push(from);
+    for (const to of cutDeps[from]) reverseCuts[to].push(from);
+    if (groups[from].hasCut) cutRoots.push(from);
+  }
+  const wfsRoots = [];
+  for (const [from, to] of wfsEdges) {
+    if (componentByIndex[from] === componentByIndex[to]) wfsRoots.push(from, to);
+  }
+  return {
+    components,
+    componentByIndex,
+    componentCuts,
+    cutReachable: reachableFromRoots(cutRoots, reverseCuts),
+    multiplicitySensitive: reachableFromRoots(multiplicityRoots, deps),
+    wfsReachable: reachableFromRoots(wfsRoots, reverse),
+  };
+}
+
 // Returns the set of nodes in `candidates` that can reach `target` by
 // traversing `deps` in reverse.  This is equivalent to asking which nodes
 // in the forward-reachable set from `target` also have `target` in their
@@ -509,36 +556,47 @@ export function stronglyConnectedComponents(adjacency) {
   const lowlinks = new Map();
   const components = [];
 
-  function visit(v) {
+  function enter(v) {
     indexes.set(v, index);
     lowlinks.set(v, index);
     index++;
     stack.push(v);
     onStack.add(v);
 
-    for (const w of adjacency[v]) {
-      if (!indexes.has(w)) {
-        visit(w);
-        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
-      } else if (onStack.has(w)) {
-        lowlinks.set(v, Math.min(lowlinks.get(v), indexes.get(w)));
-      }
-    }
-
-    if (lowlinks.get(v) === indexes.get(v)) {
-      const component = [];
-      while (true) {
-        const w = stack.pop();
-        onStack.delete(w);
-        component.push(w);
-        if (w === v) break;
-      }
-      components.push(component);
-    }
+    return { node: v, edges: adjacency[v][Symbol.iterator]() };
   }
 
   for (let v = 0; v < adjacency.length; v++) {
-    if (!indexes.has(v)) visit(v);
+    if (indexes.has(v)) continue;
+    // Explicit DFS frames keep preparation safe for dependency chains deeper
+    // than the JavaScript stack, including large generated taxonomies.
+    const frames = [enter(v)];
+    while (frames.length > 0) {
+      const frame = frames[frames.length - 1];
+      const next = frame.edges.next();
+      if (!next.done) {
+        const w = next.value;
+        if (!indexes.has(w)) frames.push(enter(w));
+        else if (onStack.has(w)) lowlinks.set(frame.node, Math.min(lowlinks.get(frame.node), indexes.get(w)));
+        continue;
+      }
+      const node = frame.node;
+      if (lowlinks.get(node) === indexes.get(node)) {
+        const component = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          component.push(w);
+        } while (w !== node);
+        components.push(component);
+      }
+      frames.pop();
+      if (frames.length > 0) {
+        const parent = frames[frames.length - 1].node;
+        lowlinks.set(parent, Math.min(lowlinks.get(parent), lowlinks.get(node)));
+      }
+    }
   }
   return components;
 }

package/src/program.js

@@ -32,7 +32,7 @@ import {
 export { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import {
 
-  componentHasNegativeEdge, componentHasCut, reachableIndexes, datalogDependencyClauseCount, isFiniteDatalogGroup, isRangeRestrictedFiniteDatalogGroup, isFiniteWfsDatalogGroup, inferStructuralInputPositions, hasStrictListTailRecursion, hasLinearNumericRecursion, isPiAccumulator, isPortableBetweenGenerator, directGoalDependencyKey, collectGoalDependencies, stronglyConnectedComponents, computeNegationStrata,
+  analyzeDependencyGraph, datalogDependencyClauseCount, isFiniteDatalogGroup, isRangeRestrictedFiniteDatalogGroup, isFiniteWfsDatalogGroup, inferStructuralInputPositions, hasStrictListTailRecursion, hasLinearNumericRecursion, isPiAccumulator, isPortableBetweenGenerator, directGoalDependencyKey, collectGoalDependencies, stronglyConnectedComponents, computeNegationStrata,
 } from './program-analysis.js';
 
 const RE_DECIMAL_INT = /^\d+$/;
@@ -434,7 +434,6 @@ export class Program {
     const deps = groups.map(() => new Set());
     const cutDeps = groups.map(() => new Set());
     const multiplicitySensitiveRoots = new Set();
-    const negativeEdges = [];
     const wfsNegativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
@@ -465,7 +464,6 @@ export class Program {
               const dependencyIndex = indexByGroup.get(dep);
               deps[groupIndex].add(dependencyIndex);
               if (dependency.negative) {
-                negativeEdges.push([groupIndex, dependencyIndex]);
                 if (dependency.wfs === true) wfsNegativeEdges.push([groupIndex, dependencyIndex]);
               }
             }
@@ -480,6 +478,7 @@ export class Program {
         cutDeps[groupIndex].add(dependencyIndex);
       }
     }
+    const graph = analyzeDependencyGraph(deps, cutDeps, groups, multiplicitySensitiveRoots, wfsNegativeEdges);
     const finiteDatalogCache = new Map();
     const rangeRestrictedDatalogCache = new Map();
     for (const group of groups) {
@@ -487,19 +486,10 @@ export class Program {
       const standardLibraryModule = group.module !== 'user' &&
         this.modules.get(group.module)?.filename?.startsWith('src/lib/');
       group.bundledLibrary = standardLibraryModule === true;
-      group.cutReachable = [...reachableIndexes(start, cutDeps)].some((index) => groups[index].hasCut);
-      const seen = new Set();
-      const stack = [start];
-      let recursive = false;
-      while (stack.length && !recursive) {
-        const current = stack.pop();
-        if (seen.has(current)) continue;
-        seen.add(current);
-        for (const next of deps[current]) {
-          if (next === start) { recursive = true; break; }
-          if (!seen.has(next)) stack.push(next);
-        }
-      }
+      group.cutReachable = graph.cutReachable.has(start);
+      const component = graph.componentByIndex[start];
+      const componentSize = graph.components[component].length;
+      const recursive = componentSize > 1 || deps[start].has(start);
       // Bundled libraries use their written ISO control directly. User modules
       // are analyzed for recursion, but tabling itself is strictly opt-in.
       const plannedRecursive = recursive && !standardLibraryModule;
@@ -509,18 +499,16 @@ export class Program {
       group.tableInputPositions = explicitlyTabled && plannedRecursive
         ? inferStructuralInputPositions(group)
         : [];
-      group.cutRecursive = plannedRecursive && componentHasCut(start, deps, groups);
+      group.cutRecursive = plannedRecursive && graph.componentCuts[component] === 1;
       const linearNumeric = plannedRecursive && !explicitlyTabled && hasLinearNumericRecursion(group) &&
         (isPiAccumulator(group) || isPortableBetweenGenerator(group));
       group.linearNumeric = linearNumeric;
       group.fastPi = linearNumeric && isPiAccumulator(group);
-      const directRecursiveComponent = plannedRecursive && [...deps[start]].every((dependency) =>
-        dependency === start || !reachableIndexes(dependency, deps).has(start)
-      );
+      const directRecursiveComponent = plannedRecursive && componentSize === 1;
       group.listTailRecursive = directRecursiveComponent && !group.cutRecursive &&
         hasStrictListTailRecursion(group);
       const cutTailRecursion = plannedRecursive && hasDirectCutTailRecursion(group);
-      const multiplicitySensitive = [...multiplicitySensitiveRoots].some((root) => reachableIndexes(root, deps).has(start));
+      const multiplicitySensitive = graph.multiplicitySensitive.has(start);
       group.cutTailRecursion = cutTailRecursion;
       group.multiplicitySensitive = multiplicitySensitive;
       group.depthFirstRecursive = plannedRecursive && !explicitlyTabled;
@@ -542,17 +530,10 @@ export class Program {
     // not silently change ordinary Prolog programs.  A group is WFS-backed when
     // its dependency cone reaches an SCC containing an edge introduced by
     // tnot/1 and the whole cone is range-restricted finite Datalog.
-    const wfsCycleNodes = new Set();
-    for (const [from, to] of wfsNegativeEdges) {
-      if (!reachableIndexes(to, deps).has(from)) continue;
-      wfsCycleNodes.add(from);
-      wfsCycleNodes.add(to);
-    }
     const finiteWfsCache = new Map();
     for (const group of groups) {
       const start = indexByGroup.get(group);
-      const reachable = reachableIndexes(start, deps);
-      const reachesWfsCycle = [...wfsCycleNodes].some((index) => reachable.has(index));
+      const reachesWfsCycle = graph.wfsReachable.has(start);
       group.wfsDatalog = reachesWfsCycle && isFiniteWfsDatalogGroup(this, group, finiteWfsCache);
     }
   }
@@ -1288,18 +1269,27 @@ function collectAutoloadClosureDependencies(closure, extraArguments, out, module
 
 function expandAutoloadMetaDependencies(program, dependencies, module = 'user') {
   const seen = new WeakMap();
+  // Most dependencies name a predicate without closure arguments; look each
+  // predicate up once instead of once per call site.
+  const closureModes = new Map();
   for (let i = 0; i < dependencies.length; i++) {
     const dependency = dependencies[i];
     if (dependency.goal == null) continue;
     const caller = dependency.module ?? module;
     const visitKey = `${caller}\u0000${dependency.key}`;
+    let modes = closureModes.get(visitKey);
+    if (modes === undefined) {
+      const group = program.findGroup(dependency.name, dependency.arity, caller);
+      modes = (group?.metaArgumentModes ?? []).filter((mode) =>
+        mode.kind === 'closure' && Number.isSafeInteger(mode.extraArguments) && mode.extraArguments >= 0);
+      closureModes.set(visitKey, modes);
+    }
+    if (modes.length === 0) continue;
     const visits = seen.get(dependency.goal) ?? new Set();
     if (visits.has(visitKey)) continue;
     visits.add(visitKey);
     seen.set(dependency.goal, visits);
-    const group = program.findGroup(dependency.name, dependency.arity, caller);
-    for (const mode of group?.metaArgumentModes ?? []) {
-      if (mode.kind !== 'closure' || !Number.isSafeInteger(mode.extraArguments) || mode.extraArguments < 0) continue;
+    for (const mode of modes) {
       collectAutoloadClosureDependencies(dependency.goal?.args[mode.index], mode.extraArguments, dependencies, caller);
     }
   }
@@ -1735,13 +1725,17 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
   if (fast) {
     const acceptBinary = (headName, head0Type, head0Name, head1Type, head1Name,
         bodyName, body0Type, body0Name, body1Type, body1Name) => {
-      batch.push(new CompactBinaryClause(
+      if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
+      const clause = new CompactBinaryClause(
         headName, head0Type, head0Name, head1Type, head1Name,
         bodyName, body0Type, body0Name, body1Type, body1Name,
-      ));
-      batch[batch.length - 1].module = context.module;
-      batch[batch.length - 1].textUnit = context.textUnit;
-      if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
+      );
+      clause.module = context.module;
+      clause.textUnit = context.textUnit;
+      batch.push(clause);
+      // The parser numbers the clause for its source metadata once it is
+      // returned, so the batch is flushed at the next clause, not here.
+      return clause;
     };
     const parsed = tryParseClausesFastInto(source, processClause, acceptBinary, options);
     if (parsed) flush();

package/src/result-format.js

@@ -158,11 +158,24 @@ function renameMinted(value, minted) {
       if (!minted.has(key)) minted.set(key, minted.size + 1);
       return compound('$stream', [numberTerm(BigInt(minted.get(key)))]);
     }
-    return compound(value.name, value.args.map((arg) => renameMinted(arg, minted)));
+    return sameOrRebuilt(value, (arg) => renameMinted(arg, minted));
   }
   return value;
 }
 
+// A compound with `rewrite` applied to its arguments: the compound itself
+// when no argument changes, so ground subterms are shared, not copied.
+function sameOrRebuilt(value, rewrite) {
+  let args = null;
+  for (let i = 0; i < value.args.length; i++) {
+    const arg = value.args[i];
+    const rewritten = rewrite(arg);
+    if (args == null && rewritten !== arg) args = value.args.slice(0, i);
+    if (args != null) args.push(rewritten);
+  }
+  return args == null ? value : compound(value.name, args);
+}
+
 function templateTerm(value, anonymous, minted) {
   if (value.type === VAR) {
     if (value.name !== '_' && !value.name.startsWith('_')) {
@@ -172,7 +185,7 @@ function templateTerm(value, anonymous, minted) {
     if (!anonymous.has(value.name)) anonymous.set(value.name, anonymous.size + 1);
     return compound('anonymous', [numberTerm(BigInt(anonymous.get(value.name)))]);
   }
-  if (value.type === COMPOUND) return compound(value.name, value.args.map((arg) => templateTerm(arg, anonymous, minted)));
+  if (value.type === COMPOUND) return sameOrRebuilt(value, (arg) => templateTerm(arg, anonymous, minted));
   return value;
 }
 
@@ -192,8 +205,16 @@ function clauseTerm(number, clause, minted) {
 
 // The `clause/3` record a proof writes for clause `number`, which a checker
 // rebuilds from the source to compare with the document's (C1).
+// The record is kept with the clause, so a proof checked as it is written
+// compares its records with the very terms the checker rebuilds.
+const clauseRecords = new WeakMap();
+
 export function clauseRecordTerm(number, clause) {
-  return clauseTerm(number, clause, new Map());
+  const cached = clauseRecords.get(clause);
+  if (cached?.number === number) return cached.record;
+  const record = clauseTerm(number, clause, new Map());
+  clauseRecords.set(clause, { number, record });
+  return record;
 }
 
 // A `clause/3` record with its minted variable names renumbered from the

package/src/write.js

@@ -250,7 +250,11 @@ function printableReadVariableNames(term, env, explicit) {
   const used = new Set(names.values());
   const suffixes = new Map();
   const seenVariables = new Set();
-  const seenTerms = new Set();
+  // A subterm shared many times over is walked once. Most terms are small
+  // trees, where walking a subterm again changes nothing, so the set is only
+  // kept once a term turns out to be large.
+  let seenTerms = null;
+  let walked = 0;
   const stack = [term];
 
   while (stack.length) {
@@ -268,8 +272,12 @@ function printableReadVariableNames(term, env, explicit) {
       used.add(candidate);
       continue;
     }
-    if (current.type !== COMPOUND || seenTerms.has(current)) continue;
-    seenTerms.add(current);
+    if (current.type !== COMPOUND) continue;
+    if (seenTerms == null && ++walked > 4096) seenTerms = new Set();
+    if (seenTerms != null) {
+      if (seenTerms.has(current)) continue;
+      seenTerms.add(current);
+    }
     for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
   }
 

package/test/README.md

@@ -58,4 +58,8 @@ deliberately, and say why, never to make a transient failure disappear.
 There is no separate wall-clock benchmark harness: `npm test`'s own elapsed
 time is the project's performance indicator.
 
+Example, proof-example, and proof-checking tests print results as they finish,
+so long-running proofs do not hide completed tests behind alphabetical order.
+Every test still compares its results with the same golden files.
+
 See the [conformance guide](conformance/README.md) for report maintenance.