eyeprolog 1.6.37 → 1.6.39

package/examples/output/bayes-therapy.pl

@@ -10,7 +10,7 @@ expectedSuccess(oseltamivir, 0.28514101258814745).
 expectedSuccess(antihistamine, 0.10026891936485297).
 expectedSuccess(antibiotic, 0.1109525797960936).
 expectedSuccess(supportiveCare, 0.2915119539701381).
-expectedAdverse(paxlovid, 0.10).
+expectedAdverse(paxlovid, 0.1).
 expectedAdverse(oseltamivir, 0.08).
 expectedAdverse(antihistamine, 0.03).
 expectedAdverse(antibiotic, 0.07).

package/package.json

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

package/src/check-proof.js

@@ -212,6 +212,7 @@ export function readProofDocument(text, program, fail = () => {}) {
       doubleQuotes: program?.doubleQuotes ?? 'chars',
       operatorDefinitions: [...(program?.operators?.values() ?? [])],
       sourceMetadata: false,
+      generalParser: true,
     });
   } catch (error) {
     fail('C3', `the document does not read: ${error?.message ?? String(error)}`, null);

package/src/explain.js

@@ -54,6 +54,10 @@ let liveSolver = null;
 // sets an explicit `maxDepth` gets that depth as a hard limit instead.
 let chainBeyondDepth = true;
 
+// Proofs of ground goals already found while explaining one document, keyed by
+// module and goal; null outside such a document.
+let groundProofs = null;
+
 function hostSolver(program, registry) {
   return liveSolver && liveSolver.program === program ? liveSolver : new Solver(program, { registry });
 }
@@ -177,6 +181,23 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
     }
     return;
   }
+  // A goal that is already ground binds nothing when proved, so which of its
+  // proofs is used cannot matter to the goals after it. Within one proof
+  // document its first proof is therefore recorded once and reused: a run
+  // whose answers share subderivations -- tabled trajectories, closures --
+  // no longer replays the shared part once per answer. This stays inside one
+  // generator: a replay nests a generator per level, and one more frame per
+  // level would overflow the host stack on deep derivations.
+  const memoKey = groundProofs && termIsGround(goal, env)
+    ? `${group.module}\u0000${termToString(goal, env, true)}`
+    : null;
+  if (memoKey) {
+    const known = groundProofs.get(memoKey);
+    if (known) {
+      yield { env, node: known };
+      return;
+    }
+  }
   // Explanation replay does not use the solver's answer tables, so its cycle
   // guard applies even when normal execution tables this predicate.
   if (activeVariant(goal, env, active)) return;
@@ -199,7 +220,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
       const substitutions = collectClauseSubstitutions(clause, freshHead, freshBody);
 
       if (freshBody.length === 0) {
-        yield {
+        const proved = {
           env: next,
           node: {
           raw: goal,
@@ -215,6 +236,11 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
             children: [],
           },
         };
+        if (memoKey) {
+          yield rememberGroundProof(memoKey, proved);
+          return;
+        }
+        yield proved;
         continue;
       }
 
@@ -224,7 +250,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
         for (const proved of proveGoalsAll(program, freshBody, next, depth + 1, maxDepth, registry, active, detail)) {
           active.pop();
           activePushed = false;
-          yield {
+          const result = {
             env: proved.env,
             node: {
           raw: goal,
@@ -237,6 +263,11 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
               children: proved.children,
             },
           };
+          if (memoKey) {
+            yield rememberGroundProof(memoKey, result);
+            return;
+          }
+          yield result;
           active.push({ goal, env });
           activePushed = true;
         }
@@ -472,6 +503,59 @@ function sourceMethod(clause, kind) {
   };
 }
 
+// Built-in and library steps whose replay has no effect beyond its bindings:
+// arithmetic, comparison, term inspection, and pure list relations. Anything
+// else -- I/O, database updates, constraint stores, generated names -- keeps a
+// derivation from being reused across answers.
+const PURE_REPLAY_STEPS = new Set([
+  'true/0', 'is/2', '=:=/2', '=\\=/2', '</2', '>/2', '=</2', '>=/2',
+  '=/2', '\\=/2', '==/2', '\\==/2', '@</2', '@>/2', '@=</2', '@>=/2', 'compare/3',
+  'var/1', 'nonvar/1', 'atom/1', 'number/1', 'integer/1', 'float/1', 'atomic/1',
+  'compound/1', 'callable/1', 'ground/1', 'is_list/1',
+  'functor/3', 'arg/3', '=../2', 'copy_term/2', 'succ/2', 'plus/3',
+  'char_code/2', 'atom_codes/2', 'atom_chars/2', 'atom_length/2', 'atom_concat/3',
+  'sub_atom/5', 'number_codes/2', 'number_chars/2', 'atom_number/2',
+  'sort/2', 'msort/2', 'keysort/2', 'between/3', 'length/2',
+  'member/2', 'memberchk/2', 'append/3', 'append/2', 'reverse/2', 'nth0/3', 'nth1/3',
+  'last/2', 'select/3', 'sum_list/2', 'max_list/2', 'min_list/2', 'list_to_set/2',
+  'once/1', 'findall/3', 'forall/2', '\\+/1',
+]);
+
+// Settle a ground goal's first proof while its environment still holds every
+// binding inside it, and keep it for reuse when replaying it has no effects:
+// a proof that writes a stream or updates the database must perform those
+// effects again, so it is not recorded.
+function rememberGroundProof(key, proved) {
+  const node = settleProofNode(proved.node, proved.env);
+  if (replayIsPure(node)) groundProofs.set(key, node);
+  return { env: proved.env, node };
+}
+
+// The answer is cached on the node, so a deep derivation whose every level is
+// remembered asks it once per level rather than once per level per descendant.
+function replayIsPure(root) {
+  if (root.pureReplay !== undefined) return root.pureReplay;
+  const stack = [root];
+  let pure = true;
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node !== root && node.pureReplay !== undefined) {
+      if (node.pureReplay) continue;
+      pure = false;
+      break;
+    }
+    const method = node.method;
+    if (method && typeof method === 'object' && (method.type === 'builtin' || method.type === 'library') &&
+        !PURE_REPLAY_STEPS.has(`${method.name}/${method.arity}`)) {
+      pure = false;
+      break;
+    }
+    for (const child of node.children ?? []) stack.push(child);
+  }
+  root.pureReplay = pure;
+  return pure;
+}
+
 function goalMethod(type, goal) {
   return {
     type,
@@ -946,12 +1030,18 @@ export function clauseNumbering(program) {
     offset += span;
   }
 
+  // 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.
   const bySource = new Map();
   const byNumber = new Map();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause) || isUnnumberedDeclaration(clause)) continue;
-    const number = (offsets.get(clause.source.filename) ?? 0) + clause.source.clause;
-    bySource.set(`${clause.source.filename}\u0000${clause.source.clause}`, number);
+    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());
+    numbers.set(position, number);
     byNumber.set(number, { head: clause.head, body: clause.body ?? [] });
   }
   return { bySource, byNumber };
@@ -971,7 +1061,7 @@ export function isLibraryClause(clause) {
 }
 
 function clauseNumberFor(numbering, method) {
-  return numbering.bySource.get(`${method.filename}\u0000${method.clause}`) ?? null;
+  return numbering.bySource.get(method.filename)?.get(method.clause) ?? null;
 }
 
 // The conclusion a node contributes, which is how a step names what it used.
@@ -1125,6 +1215,10 @@ function settleProofNode(root, env) {
   const stack = [root];
   while (stack.length) {
     const node = stack.pop();
+    // A settled node was settled with its whole subtree; a remembered ground
+    // proof reached again from a deeper level need not be walked again.
+    if (node.settled) continue;
+    node.settled = true;
     if (node.raw) {
       node.goal = resolve(node.raw);
       if (node.method?.type === 'builtin' || node.method?.type === 'library') node.sourceHead = node.goal;
@@ -1210,6 +1304,7 @@ function settlingResolver(env) {
 export function proofNodeFor(program, goal, options = {}) {
   liveSolver = options.solver ?? null;
   chainBeyondDepth = options.maxDepth == null;
+  groundProofs = options.groundProofs ?? null;
   const maxDepth = options.maxDepth ?? 256;
   const registry = options.registry ?? getEyePrologRegistry();
   const env = options.env ?? new Env();

package/src/parser.js

@@ -51,10 +51,14 @@ function scanFastRangeToken(text, i, end) {
   return i;
 }
 
+// The Unicode property tests below are needed only past ASCII: for a code
+// under 128 the plain code tests give exactly the same answer, and these
+// helpers run once per source character.
 function isWhitespaceCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return isWhitespaceCode(code) || /\p{White_Space}/u.test(character);
+  if (code < 128) return isWhitespaceCode(code);
+  return /\p{White_Space}/u.test(character);
 }
 
 function isUnicodeUpperCharacter(character) {
@@ -82,21 +86,24 @@ function isNameContinueCode(code) {
 }
 
 function isNameContinueCharacter(character) {
-  return Boolean(character) && (isNameContinueCode(character.charCodeAt(0)) ||
-    isUnicodeNameContinueCharacter(character));
+  if (!character) return false;
+  const code = character.charCodeAt(0);
+  if (code < 128) return isNameContinueCode(code);
+  return isUnicodeNameContinueCharacter(character);
 }
 
 function isVariableStartCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return code === 95 || (code >= 65 && code <= 90) || isUnicodeUpperCharacter(character);
+  if (code < 128) return code === 95 || (code >= 65 && code <= 90);
+  return isUnicodeUpperCharacter(character);
 }
 
 function isPlainAtomStartCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return (code >= 97 && code <= 122) ||
-    (isUnicodeLetterCharacter(character) && !isUnicodeUpperCharacter(character));
+  if (code < 128) return code >= 97 && code <= 122;
+  return isUnicodeLetterCharacter(character) && !isUnicodeUpperCharacter(character);
 }
 
 const graphicAtomChars = '#$&*+-./<=>?@^~\\:';
@@ -311,13 +318,20 @@ function isCodePointOutOfRange(code) {
   return code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff);
 }
 
+const PUNCTUATION_TOKENS = new Map([
+  ['(', TOK.LPAREN], [')', TOK.RPAREN], ['[', TOK.LBRACKET], [']', TOK.RBRACKET],
+  ['{', TOK.LBRACE], ['}', TOK.RBRACE], [',', TOK.COMMA], ['|', TOK.BAR], ['.', TOK.DOT],
+]);
+
 class Parser {
   constructor(source, options = {}) {
     this.source = String(source ?? '');
     this.filename = options.filename ?? '<input>';
     this.pos = 0;
     this.line = 1;
-    this.anonymous = 0;
+    // Anonymous variables are numbered through a whole text; a caller parsing
+    // one text in pieces continues the count.
+    this.anonymous = options.anonymousStart ?? 0;
     this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
     this.onWarning = typeof options.onWarning === 'function' ? options.onWarning : null;
@@ -346,8 +360,10 @@ class Parser {
     this.token = this.nextToken();
   }
   convertCharacter(character) {
-    if (this.parserFlagState.charConversion !== 'on' || !character) return character;
-    return this.parserFlagState.charConversions.get(character) ?? character;
+    const state = this.parserFlagState;
+    // Almost no text installs a conversion; skip the map lookup per character.
+    if (state.charConversions.size === 0 || state.charConversion !== 'on' || !character) return character;
+    return state.charConversions.get(character) ?? character;
   }
   rawPeek(offset = 0) {
     // The processor character set is an implementation-defined processor
@@ -364,6 +380,7 @@ class Parser {
     return ch;
   }
   convertedSlice(start, end) {
+    if (this.parserFlagState.charConversions.size === 0) return this.source.slice(start, end);
     let out = '';
     for (const ch of this.source.slice(start, end)) out += this.convertCharacter(ch);
     return out;
@@ -610,13 +627,10 @@ class Parser {
       return { type: TOK.ATOM, text: ';', line };
     }
 
-    const punct = {
-      '(': TOK.LPAREN, ')': TOK.RPAREN, '[': TOK.LBRACKET, ']': TOK.RBRACKET,
-      '{': TOK.LBRACE, '}': TOK.RBRACE, ',': TOK.COMMA, '|': TOK.BAR, '.': TOK.DOT,
-    };
-    if (punct[ch]) {
+    const punctuation = PUNCTUATION_TOKENS.get(ch);
+    if (punctuation) {
       this.take();
-      return { type: punct[ch], text: ch, line, precededByLayout };
+      return { type: punctuation, text: ch, line, precededByLayout };
     }
     if (ch === ':' && this.peek(1) === '-' &&
         !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
@@ -667,7 +681,9 @@ class Parser {
     // A signed numeric literal is only recognized where a term may start.
     // Otherwise the minus is the standard infix operator, so compact ISO
     // syntax such as `X-1` must not be read as `X` followed by `-1`.
-    const previousEndsTerm = this.previousToken && (
+    // Whether the previous token ends a term matters only for a minus sign
+    // before a digit, so it is decided only then.
+    const previousEndsTerm = () => this.previousToken && (
       [TOK.VAR, TOK.NUMBER, TOK.STRING, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE].includes(this.previousToken.type) ||
       (this.previousToken.type === TOK.ATOM &&
        (this.postfixOperators.has(this.previousToken.text) ||
@@ -675,7 +691,7 @@ class Parser {
          !this.prefixOperators.has(this.previousToken.text))))
     );
     if (isDigitCode(ch.charCodeAt(0)) ||
-        (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm)) {
+        (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm())) {
       const start = this.pos;
       const negative = this.peek() === '-';
       if (negative) this.take();
@@ -1431,7 +1447,10 @@ export function parseClauses(source, options = {}) {
   const parserOptions = ownsParserFlagState
     ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes, charConversion: 'on', charConversions: new Map() } }
     : options;
-  if (options.sourceMetadata === false && options.readTermEnd == null) {
+  // `generalParser` reads with the general parser from the start: a text of
+  // large, nested terms, such as a proof document, gains nothing from the
+  // line-oriented fast path and pays for a parser per term in it.
+  if (options.sourceMetadata === false && options.readTermEnd == null && options.generalParser !== true) {
     const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
     if (ownsParserFlagState) {
@@ -1482,6 +1501,18 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   let anonymous = 0;
   let chunk = '';
   let chunkStartLine = 1;
+  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.
+  const trackSource = options.sourceMetadata === true;
+  const sourceFilename = options.filename ?? '<input>';
+  let clauseNumber = 0;
+  const numbered = (clause, line) => {
+    if (trackSource) clause.source = { filename: sourceFilename, line, clause: ++clauseNumber };
+    return clause;
+  };
 
   const cached = (cache, key, create) => {
     const existing = cache.get(key);
@@ -1491,22 +1522,19 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return value;
   };
 
-  // SIMPLE_NUMBER-matched text is already lexically valid Prolog number
-  // syntax, and this fast path deliberately leaves a numeric literal's
-  // spelling otherwise untouched (test/conformance/cases/arithmetic/
-  // 024_numeric_literal_readback.pl: decimal and exponent literals retain
-  // their lexical form here, so e.g. 6.02e23 must not become 6.02e+23).
-  // Two things still cannot be left as raw matched text, though: an integer
-  // is never left non-canonical anywhere else in the language (a leading
-  // zero, or the "-0" from issue #114, must collapse the same way the
-  // scanner's own adjacent-minus BigInt construction already does), and a
-  // float whose value is exactly zero must never print with a stray minus --
-  // this implementation deliberately never produces -0.0 (term.js
-  // numberTextFromDouble) -- without reformatting any non-zero float.
+  // A number is a value, not a spelling (ISO 7.1.3), so the fast path writes
+  // numbers exactly as the general parser does: an integer in canonical
+  // decimal (a leading zero or "-0" collapses, issue #114), and a float as the
+  // shortest text that reads back to the same double (term.js
+  // numberTextFromDouble), so 0.10 is 0.1 and 6.02e23 is 6.02e+23 whichever
+  // parser read the literal. A run therefore prints the same numbers with and
+  // without --proof.
   const canonicalFastNumberText = (text) => {
-    if (text.includes('.') || text.includes('e') || text.includes('E')) {
-      return (text.charCodeAt(0) === 45 && Number(text) === 0) ? text.slice(1) : text;
+    if (text.includes('.')) {
+      const value = Number(text);
+      return Number.isFinite(value) ? numberTextFromDouble(value) : text;
     }
+    if (text.includes('e') || text.includes('E')) return text;
     const first = text.charCodeAt(0);
     if (first !== 45 && (text.length === 1 || first !== 48)) return text;
     return BigInt(text).toString();
@@ -1826,15 +1854,46 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
       reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
-      accept(simple);
+      accept(numbered(simple, sourceLine));
       return true;
     }
     try {
       const nestedWarning = typeof options.onWarning === 'function'
         ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
         : null;
-      const parsed = new Parser(text, { ...options, sourceMetadata: false, onWarning: nestedWarning }).parseProgram();
-      for (const clause of parsed) accept(clause);
+      // One operator table serves every clause of this source: building it
+      // per clause dominated the parse of large generated programs, and an
+      // op/3 directive in one clause must govern the clauses after it anyway.
+      operatorState ??= options.operatorState ?? createParserOperatorState(
+        options.operatorDefinitions ?? [],
+        options.includeDefaultOperators !== false,
+        { isoStrict: options.isoStrict === true },
+      );
+      const parser = new Parser(text, {
+        ...options,
+        operatorState,
+        sourceMetadata: trackSource,
+        filename: sourceFilename,
+        onWarning: nestedWarning,
+        anonymousStart: trackSource ? anonymous : 0,
+      });
+      const parsed = parser.parseProgram();
+      if (trackSource) anonymous = parser.anonymous;
+      // The nested parser numbers lines and clauses from the start of this
+      // chunk; place them in the whole source.
+      let counted = 0;
+      for (const clause of parsed) {
+        if (trackSource && clause.source) {
+          const relative = clause.source.clause;
+          clause.source = { ...clause.source, line: clause.source.line + sourceLine - 1 };
+          if (relative != null) {
+            clause.source.clause = relative + clauseNumber;
+            if (relative > counted) counted = relative;
+          }
+        }
+        accept(clause);
+      }
+      clauseNumber += counted;
       return true;
     } catch (_) {
       return false;
@@ -1853,13 +1912,13 @@ 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 (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
+        if (!trackSource && emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
           const simple = parseFastRange(source, contentStart, contentEnd);
           if (simple) {
             reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
-            accept(simple);
+            accept(numbered(simple, lineNumber));
           } else {
             chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';

package/src/program.js

@@ -958,6 +958,19 @@ function buildProgramFromSources(sources, options) {
     const builder = new ProgramBuilder(options);
     if (loadSourcesIntoBuilder(builder, sources, options, 'hybrid')) return builder.finish();
   }
+  // With source metadata the compact parser still applies; it numbers clauses
+  // as the general parser does, and falls back to it for anything it cannot
+  // read. Strict ISO keeps the general parser throughout, and so does a text
+  // with a `?-` outside a comment: a quad's indented answer lines are layout
+  // the line-oriented compact parser does not read.
+  const hasQueries = sources.some((source) => {
+    const text = typeof source === 'string' ? source : source?.text ?? source?.source ?? '';
+    return /^[^%\n]*\?-/m.test(text);
+  });
+  if (options.sourceMetadata !== false && !hasModuleDirectives && !hasQueries && options.isoStrict !== true) {
+    const builder = new ProgramBuilder(options);
+    if (loadSourcesIntoBuilder(builder, sources, options, true)) return builder.finish();
+  }
 
   const builder = new ProgramBuilder(options);
   loadSourcesIntoBuilder(builder, sources, options, false);

package/src/proof-document.js

@@ -36,8 +36,9 @@ export function checkedProofBlocks(program, claimed, { registry, proofDetail = '
   const roots = [];
   const unexplained = [];
   const questions = goals.filter((goal) => typeof goal !== 'string');
+  const groundProofs = new Map();
   for (const fact of claimed) {
-    const node = proofNodeFor(program, fact, { registry, proofDetail, solver, questions });
+    const node = proofNodeFor(program, fact, { registry, proofDetail, solver, questions, groundProofs });
     if (node) roots.push(node);
     else unexplained.push(fact);
   }

package/src/source-expansion.js

@@ -62,10 +62,27 @@ function copyHookResult(term, env, inputNames) {
   return copy(term);
 }
 
+// Whether some clause of a hook could unify with `input` as its first
+// argument. A clause whose first argument has another type, name or arity
+// cannot, so when none can the hook does not run at all: a library such as
+// CLP(Z) expands only its own goals, and asking a fresh solver about every
+// other clause and goal of a program cost more than loading it.
+function hookMayApply(group, input) {
+  if (input?.type === VAR) return true;
+  for (const clause of group.clauses) {
+    const first = clause.head?.args?.[0];
+    if (first == null || first.type === VAR) return true;
+    if (first.type !== input.type || first.name !== input.name) continue;
+    if (first.type !== COMPOUND || first.args.length === input.args.length) return true;
+  }
+  return false;
+}
+
 function runHook(program, module, name, input, loadContext = null) {
   for (const owner of hookModules(module)) {
     const group = exactHookGroup(program, owner, name);
     if (group == null || group.clauses.length === 0) continue;
+    if (!hookMayApply(group, input)) continue;
 
     const output = variable(`\u0000source-expansion:${++expansionFresh}`);
     const goal = compound(name, [input, output]);

package/src/write.js

@@ -211,7 +211,18 @@ function operatorName(name) {
   return quoteAtom(name);
 }
 
+// Writers pass the same definitions array for every term of a run, so build
+// its lookup table once instead of once per written term.
+const operatorTables = new WeakMap();
+
 function operatorTable(definitions) {
+  if (!definitions) return buildOperatorTable(definitions);
+  let table = operatorTables.get(definitions);
+  if (!table) operatorTables.set(definitions, table = buildOperatorTable(definitions));
+  return table;
+}
+
+function buildOperatorTable(definitions) {
   const table = new Map();
   for (const definition of definitions ?? []) {
     if (!definition || definition.priority === 0) continue;

package/test/conformance/cases/arithmetic/024_numeric_literal_readback.pl

@@ -1,4 +1,4 @@
-% Reference 3.3, 11: signed, decimal, and exponent numeric literals retain lexical form.
+% Signed, decimal, and exponent numeric literals read back as their values (ISO 7.1.3, 7.10.5 c).
 raw(negative_decimal, -3.5).
 raw(positive_exp, 6.02e23).
 raw(negative_exp, -1.0e-3).

package/test/conformance/expected/arithmetic/024_numeric_literal_readback.pl

@@ -1,3 +1,3 @@
 answer(negative_decimal, -3.5).
-answer(positive_exp, 6.02e23).
-answer(negative_exp, -1.0e-3).
+answer(positive_exp, 6.02e+23).
+answer(negative_exp, -0.001).

package/test/conformance/expected/terms/003_terms_and_readback.pl

@@ -5,7 +5,7 @@ value(empty_atom, '').
 value(char_list, "line\nquote: \"ok\"").
 value(integer, -42).
 value(decimal, 0.25).
-value(scientific, 1.25e-3).
+value(scientific, 0.00125).
 value(compound, pair(3, nested(atom, "xy"))).
 value(arity_zero_atom, nil).
 value(empty_list, []).

package/test/parallel-tasks.mjs

@@ -1,7 +1,10 @@
 // A small ordered worker pool for the suites that do the same work once per
 // file: run every example, prove every example, check every packaged proof.
 //
-// Results are reported in task order however the workers finish, so a parallel
+// Tasks are handed to workers most expensive first when the caller can
+// estimate a task's cost: a suite whose slowest task starts late spends its
+// last seconds running that one task alone. Results are still reported in task
+// order however the workers finish, so a parallel
 // suite numbers its tests exactly as the sequential one did and a failure still
 // stops the run at the same test. Each suite compares inside its worker, so
 // only a name, an elapsed time, an optional failure, and a small plain-data
@@ -17,6 +20,7 @@ export async function runTasksInParallel({
   maxWorkers,
   runLocally,
   onResult,
+  cost = null,
 }) {
   if (names.length === 0) return;
   const parallelism = os.availableParallelism?.() ?? os.cpus().length;
@@ -35,6 +39,13 @@ export async function runTasksInParallel({
   }
 
   const completedResults = new Map();
+  // Dispatch order: task indexes by descending estimated cost, ties in task
+  // order. Reporting still follows the task order itself.
+  const dispatch = names.map((_, index) => index);
+  if (typeof cost === 'function') {
+    const costs = names.map((name) => cost(name));
+    dispatch.sort((left, right) => costs[right] - costs[left] || left - right);
+  }
   let nextTask = 0;
   let nextReport = 0;
   let completed = 0;
@@ -72,7 +83,8 @@ export async function runTasksInParallel({
 
     const assign = (worker) => {
       if (nextTask >= names.length || settled) return;
-      worker.postMessage({ ...message, id: nextTask, name: names[nextTask++] });
+      const id = dispatch[nextTask++];
+      worker.postMessage({ ...message, id, name: names[id] });
     };
 
     for (const worker of workers) {

package/test/regression/cases-regression.mjs

@@ -6013,21 +6013,16 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
           const stdout = run(program, { goal }).stdout;
           assertEqual(stdout.split('\n')[0], expected, `${program.trim()}: ${goal}`);
         }
-        // The fast loader also deliberately retains a numeric literal's exact
-        // lexical spelling otherwise (test/conformance/cases/arithmetic/
-        // 024_numeric_literal_readback.pl): the zero-canonicalization above
-        // must not turn into a general reformatting pass that rewrites a
-        // non-zero float's notation.
-        assertEqual(
-          run('raw(a, 6.02e23).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
-          '6.02e23',
-          'non-zero exponent notation is preserved, not reformatted to 6.02e+23',
-        );
-        assertEqual(
-          run('raw(a, -1.0e-3).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
-          '-1.0e-3',
-          'non-zero negative exponent notation is preserved, not reformatted to -0.001',
-        );
+        // A float is a value, not a spelling (ISO 7.1.3, 7.10.5 c): the fast
+        // loader writes it as the general parser does, so a run prints the same
+        // number with and without --proof. A three-argument fact is outside the
+        // compact shape and so is read by the general parser.
+        for (const [literal, expected] of [['6.02e23', '6.02e+23'], ['-1.0e-3', '-0.001'], ['0.10', '0.1']]) {
+          const fast = run(`raw(a, ${literal}).\n`, { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0];
+          const general = run(`raw(a, b, ${literal}).\n`, { goal: 'raw(_, _, B), write_canonical(B), nl' }).stdout.split('\n')[0];
+          assertEqual(fast, expected, `${literal} through the fast loader`);
+          assertEqual(general, expected, `${literal} through the general parser`);
+        }
       },
     },
     {

package/test/run-examples.mjs

@@ -50,6 +50,16 @@ const exampleTaskKinds = {
 };
 
 
+// A packaged proof grows with the derivation it records, so its size is a
+// cheap estimate of how long an example takes to run, prove, and check.
+export function exampleCost(name) {
+  try {
+    return fs.statSync(path.join(expectedProofDir, name)).size;
+  } catch {
+    return 0;
+  }
+}
+
 function runExampleTasks(names, kind, reporter) {
   return runTasksInParallel({
     names,
@@ -57,6 +67,7 @@ function runExampleTasks(names, kind, reporter) {
     workerData: { exampleWorker: true },
     message: { kind },
     maxWorkers: 3,
+    cost: exampleCost,
     runLocally: (name) => exampleTaskKinds[kind](name),
     onResult: (name, result) => reporter.testResult(name, result),
   });

package/test/run-proof-checking.mjs

@@ -15,7 +15,7 @@ import { isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { Program } from '../src/index.js';
 import { checkProofDocument, checkReportTerms, sourceGoals, verdict } from '../src/check-proof.js';
 import { TestReporter, assertEqual, isMainModule, runStandalone } from './test-style.mjs';
-import { proofExamples } from './run-examples.mjs';
+import { exampleCost, proofExamples } from './run-examples.mjs';
 import { runTasksInParallel, serveTasks } from './parallel-tasks.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -37,6 +37,7 @@ export async function runProofChecking(reporter = new TestReporter()) {
     workerUrl: new URL(import.meta.url),
     workerData: { proofCheckingWorker: true },
     maxWorkers: 3,
+    cost: exampleCost,
     runLocally: (name) => checkPackagedProof(name),
     onResult: (name, result) => {
       for (const field of Object.keys(totals)) totals[field] += result.value?.[field] ?? 0;