eyemind 0.1.27 → 0.1.29

package/SPEC.md

@@ -2,7 +2,7 @@
 
 ```text
 Title:      The eyemind Rule Language and Proof Format
-Version:    eyemind 0.1.27
+Version:    eyemind 0.1.29
 Status:     Informational
 Author:     Jos De Roo, KNoWS office of IDLab, Ghent University - imec
 Repository: https://github.com/eyereasoner/eyemind
@@ -22,7 +22,7 @@ command line.
 ## Status of This Memo
 
 This document is not an Internet Standards Track specification. It describes
-the language and formats as implemented by eyemind 0.1.27, for readers who want
+the language and formats as implemented by eyemind 0.1.29, for readers who want
 to write programs, produce or consume proofs and reports, or implement a
 compatible reasoner or checker. Where this document and the implementation
 disagree, that is a defect in one of them.
@@ -340,6 +340,9 @@ only original `implies` and `implied_by` clauses whose heads contain no rule
 templates and whose bodies contain no inspection goals, including inside
 controls. Facts, queries, contradictions, template generators and appended
 clauses are excluded. Inspecting rules therefore cannot inspect themselves.
+A rule value used as an inspection pattern is embedded in the inspecting
+statement (Section 4.6), so a stored rule value used as a pattern loses its
+standalone clause and is not in the catalogue.
 
 The catalogue keeps source order. A rule's body and forward head conjunctions
 are terms `and(...)`, as normalized goals are, and inspection arguments are
@@ -1034,7 +1037,7 @@ conclusions and proof documents in the canonical text, and checks every proof
 it produces as Section 11 describes. A conforming **checker** implements
 Sections 9, 11 and 12 and does not depend on a reasoner. For the same
 program, a conforming reasoner and checker MUST produce the same
-conclusions, proof documents and reports as eyemind 0.1.27, byte for byte,
+conclusions, proof documents and reports as eyemind 0.1.29, byte for byte,
 except for comments and the `Detail` texts of failures (Section 12), the internal names of
 variables where Section 3 says so, and where the host's floating-point
 library functions (`exp`, `log`, the trigonometric and hyperbolic functions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyemind",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "A dependency-free JavaScript rule language with forward and backward reasoning and checkable proofs.",
   "type": "module",
   "main": "./src/index.js",

package/src/engine.js

@@ -1,17 +1,17 @@
 // Backward resolution, forward fixpoints and proof recording.
 import { PRIMITIVE_KEYS, primitive } from './builtins.js';
 import { freshClause, matchHead, renaming, text, variant } from './common.js';
-import { readGoal } from './goals.js';
+import { goalTerm, subgoals } from './goals.js';
 import { INSPECTION_KEYS } from './inspection.js';
 import { checkRendered, clauseDisplay, renderProof } from './proof.js';
 import { CONTROL_KEYS, Program } from './program.js';
 import { isActivation } from './templates.js';
 import {
   Env, EyemindError, Struct, Var, conjunction, copyResolved, deref, flattenConjunction, freshTerm,
-  identity, isCallable, isGround, isGroundButAnonymous, isTerm, key, keyArity, listFromItems, unify,
-  variables,
+  identity, isAnonymous, isCallable, isGround, isGroundButAnonymous, isTerm, key, keyArity, listFromItems,
+  unify, variables,
 } from './terms.js';
-import { Lettering, write } from './writer.js';
+import { Lettering, SourceNaming, write } from './writer.js';
 
 export const BUILTIN = 'builtin';
 export const CONTROL = 'control';
@@ -153,6 +153,18 @@ function freshNode(node, suffix) {
   return root;
 }
 
+// The error for a negation whose goal still has a variable to bind, naming
+// the variables as the program wrote them rather than as renamed apart.
+function unboundNegation(goal, env) {
+  const naming = new SourceNaming();
+  const resolved = copyResolved(goal, env);
+  const shown = write(resolved, null, naming);
+  const unbound = [...new Set([...variables(resolved).values()]
+    .filter((variable) => !isAnonymous(variable)).map((variable) => naming.get(variable.name)))];
+  return new EyemindError('negation requires a goal whose variables are bound, except for anonymous ones: ' +
+    `${unbound.join(', ')} ${unbound.length === 1 ? 'is' : 'are'} unbound in ${shown}`);
+}
+
 // Resolve a proof forest with an explicit stack: a derivation chain is as deep
 // as the search that produced it. A derived fact's node is already final and
 // is shared rather than copied, which keeps a long forward chain from being
@@ -209,13 +221,9 @@ export function clausesBehindBoundaries(program, roots) {
   const pending = [];
   function visit(goal) {
     if (!isCallable(goal)) return;
-    if (isTerm(goal, 'and', 2) || isTerm(goal, 'or', 2)) {
-      visit(goal.args[0]);
-      visit(goal.args[1]);
-    } else if (isTerm(goal, 'not', 1) || isTerm(goal, 'call', 1) || isTerm(goal, 'once', 1)) {
-      visit(goal.args[0]);
-    } else if (isTerm(goal, 'findall', 3)) {
-      visit(goal.args[1]);
+    const inner = subgoals(goal);
+    if (inner !== null) {
+      for (const part of inner) visit(part);
     } else if (!PRIMITIVE_KEYS.has(key(goal))) {
       pending.push(key(goal));
     }
@@ -235,8 +243,12 @@ export function clausesBehindBoundaries(program, roots) {
     const goalKey = pending.pop();
     if (seen.has(goalKey)) continue;
     seen.add(goalKey);
-    const candidates = INSPECTION_KEYS.has(goalKey) ? program.inspections.get(goalKey) : byKey.get(goalKey) || [];
-    for (const clause of candidates) {
+    if (INSPECTION_KEYS.has(goalKey)) {
+      // Inspection reads a rule's structure without solving its body.
+      for (const entry of program.inspections.get(goalKey)) reached.add(entry.id);
+      continue;
+    }
+    for (const clause of byKey.get(goalKey) || []) {
       reached.add(clause.id);
       for (const goal of clause.body) visit(goal);
     }
@@ -395,10 +407,7 @@ export class Solver {
     if (goalKey === 'not/1') {
       // Negation is a test, not a way to bind its variables; its anonymous
       // variables stand for any value.
-      if (!isGroundButAnonymous(goal.args[0], env)) {
-        throw new EyemindError('negation requires a goal whose variables are bound, ' +
-                              `except for anonymous ones: ${text(goal, env)}`);
-      }
+      if (!isGroundButAnonymous(goal.args[0], env)) throw unboundNegation(goal, env);
       const mark = env.mark();
       const iterator = this.solve([goal.args[0]], env, frame.depth + 1);
       let absent;
@@ -420,7 +429,7 @@ export class Solver {
         this.serial++;
         const names = new Map();
         items.push(freshTerm(copyResolved(goal.args[0], answerEnv), `collection${this.serial}`, names));
-        if (this.program.inspectionEnabled) {
+        if (this.program.inspectionEnabled && names.size) {
           for (const name of scopedVariables(nodes, answerEnv).keys()) {
             if (names.has(name)) scoped.push(names.get(name));
           }
@@ -700,24 +709,23 @@ export class Solver {
       // between the heads of one conclusion.
       const resolved = copyResolved(head, answerEnv);
       const unresolved = variables(resolved);
-      if (this.program.inspectionEnabled) {
+      const captured = clause.captures === null ? null : copyResolved(body[0].args[1], answerEnv);
+      const relevant = this.program.inspectionEnabled
+        ? [...unresolved.keys(), ...(captured === null ? [] : variables(captured).keys())]
+        : [];
+      // Walking the evidence is linear in its size, so do it only when the
+      // conclusion or captures still have variables an inspection could scope.
+      if (relevant.length) {
         const scoped = scopedVariables(nodes, answerEnv);
-        const captured = clause.captures === null ? null : copyResolved(body[0].args[1], answerEnv);
-        const relevant = [...unresolved.keys(), ...(captured === null ? [] : variables(captured).keys())];
-        if (relevant.some((name) => scoped.has(name))) {
-          const inBody = new Set();
-          for (const goal of clause.body) for (const name of variables(goal).keys()) inBody.add(name);
-          if ([...variables(clause.head).keys()].some((name) => !inBody.has(name))) {
-            throw new EyemindError('bind inspected rule variables before deriving existential witnesses');
-          }
+        if (clause.witnessNames.length && relevant.some((name) => scoped.has(name))) {
+          throw new EyemindError('bind inspected rule variables before deriving existential witnesses');
         }
         for (const name of scoped.keys()) unresolved.delete(name);
       }
       if (unresolved.size) {
         // A generated rule also depends on its captures when its head omits
         // them; otherwise two enabled instances could share a witness.
-        const context = clause.captures === null ? null : copyResolved(body[0].args[1], answerEnv);
-        const witnesses = skolemTerms(clause, head, unresolved, answerEnv, context);
+        const witnesses = skolemTerms(clause, head, unresolved, answerEnv, captured);
         [...unresolved.values()].forEach((value, i) => unify(value, witnesses[i], answerEnv));
       }
       const conclusions = unresolved.size
@@ -861,10 +869,6 @@ export function run(program, { goal = null, goals = null, proof = false, maxDept
   }
 }
 
-function goalTerm(goal) {
-  return typeof goal === 'string' ? readGoal(goal) : goal;
-}
-
 function reason(program, goalInputs, options) {
   const solver = new Solver(program, options);
   const goals = goalInputs.map(goalTerm);

package/src/goals.js

@@ -9,6 +9,22 @@ import { readTerm } from './reader.js';
 
 const EMPTY_ENV = new Env();
 
+// The calls that state or construct a rule; both their arguments are goal
+// positions.
+export const RULE_NAMES = new Set(['implies', 'implied_by', 'forward', 'backward']);
+
+// The goal positions directly inside a control goal, or null when the goal is
+// not a control: both sides of and and or, the argument of not, call and
+// once, and the goal of findall.
+export function subgoals(goal) {
+  if (!(goal instanceof Struct)) return null;
+  const { name, args } = goal;
+  if ((name === 'and' || name === 'or') && args.length === 2) return args;
+  if ((name === 'not' || name === 'call' || name === 'once') && args.length === 1) return args;
+  if (name === 'findall' && args.length === 3) return [args[1]];
+  return null;
+}
+
 function isList(term) {
   return term === EMPTY || (term instanceof Struct && term.name === '.' && term.args.length === 2);
 }
@@ -22,10 +38,7 @@ export function normalizeGoal(term) {
   }
   if (!(term instanceof Struct)) return term;
   const { name, args } = term;
-  if ((name === 'and' || name === 'or') && args.length === 2) {
-    return rebuild(term, args.map(normalizeGoal));
-  }
-  if (['implies', 'implied_by', 'forward', 'backward'].includes(name) && args.length === 2) {
+  if ((name === 'and' || name === 'or' || RULE_NAMES.has(name)) && args.length === 2) {
     return rebuild(term, args.map(normalizeGoal));
   }
   if ((name === 'not' || name === 'call' || name === 'once') && args.length === 1) {
@@ -45,3 +58,8 @@ function rebuild(term, args) {
 export function readGoal(text) {
   return normalizeGoal(readTerm(text));
 }
+
+// A goal given either as text or as a term already.
+export function goalTerm(goal) {
+  return typeof goal === 'string' ? readGoal(goal) : goal;
+}

package/src/inspection.js

@@ -1,4 +1,5 @@
 // Rule inspection reads a fixed source catalogue, not the run's rule index.
+import { subgoals } from './goals.js';
 import { Struct, conjunction, isTerm } from './terms.js';
 
 export const INSPECTION_KEYS = new Set(['implies/2', 'implied_by/2']);
@@ -6,9 +7,8 @@ export const isInspection = (term) => isTerm(term, 'implies', 2) || isTerm(term,
 
 export function hasInspection(goal) {
   if (isInspection(goal)) return true;
-  if (isTerm(goal, 'and', 2) || isTerm(goal, 'or', 2)) return goal.args.some(hasInspection);
-  if (isTerm(goal, 'not', 1) || isTerm(goal, 'call', 1) || isTerm(goal, 'once', 1)) return hasInspection(goal.args[0]);
-  return isTerm(goal, 'findall', 3) && hasInspection(goal.args[1]);
+  const inner = subgoals(goal);
+  return inner !== null && inner.some(hasInspection);
 }
 
 export function inspectionTerm(clause) {

package/src/lang.js

@@ -277,6 +277,12 @@ const LIBRARY = Object.freeze({
 
 // The names a program is given: the statements and the terms it builds goals
 // with. The statements report to the innermost program being built.
+// A rule template built by forward() or backward(), which states no clause.
+function template(name, args) {
+  if (args.length !== 2) throw new EyemindError(`${name} takes 2 arguments, got ${args.length}`);
+  return new Struct(name, args.map(goalOf));
+}
+
 function exportsFor(io) {
   const builder = {
     add: (...args) => active().add(...args),
@@ -288,14 +294,8 @@ function exportsFor(io) {
     },
     implies: (...args) => active().rule('implies', args),
     implied_by: (...args) => active().rule('implied_by', args),
-    forward: (...args) => {
-      if (args.length !== 2) throw new EyemindError(`forward takes 2 arguments, got ${args.length}`);
-      return new Struct('forward', args.map(goalOf));
-    },
-    backward: (...args) => {
-      if (args.length !== 2) throw new EyemindError(`backward takes 2 arguments, got ${args.length}`);
-      return new Struct('backward', args.map(goalOf));
-    },
+    forward: (...args) => template('forward', args),
+    backward: (...args) => template('backward', args),
     query: (...body) => builder.add('query', TRUE_ATOM, body.map(goalOf)),
     contradiction: (...body) => builder.add('contradiction', 'false', body.map(goalOf)),
     facts_from: (source) => {

package/src/program.js

@@ -1,10 +1,11 @@
 // A program: its clauses, validated, indexed and stratified.
 import { PRIMITIVE_KEYS } from './builtins.js';
 import { ACTIVATION_KEY, containsTemplate, expandTemplates } from './templates.js';
+import { subgoals } from './goals.js';
 import { hasInspection, inspectionTerm } from './inspection.js';
 import {
   Env, EyemindError, Struct, Var, deref, flattenConjunction, freshTerm, identity, isCallable,
-  isGround, isTerm, key, keyArity, unify,
+  isGround, isTerm, key, keyArity, unify, variables,
 } from './terms.js';
 
 export const CONTROL_KEYS = new Set(['and/2', 'or/2', 'not/1', 'call/1', 'once/1', 'findall/3']);
@@ -26,6 +27,18 @@ export class Clause {
     this.captures = captures;
     this.renaming = null; // how to rename it apart, worked out once it is used often
     this.uses = 0;
+    this.witnessed = null;
+  }
+
+  // The names of the variables only the conclusion mentions: a forward rule
+  // gives each a Skolem witness per firing (SPEC Section 7.2).
+  get witnessNames() {
+    if (this.witnessed === null) {
+      const inBody = new Set();
+      for (const goal of this.body) for (const name of variables(goal).keys()) inBody.add(name);
+      this.witnessed = [...variables(this.head).keys()].filter((name) => !inBody.has(name));
+    }
+    return this.witnessed;
   }
 }
 
@@ -152,7 +165,7 @@ export class Program {
       if (!source || !['forward', 'backward'].includes(source.kind) ||
           containsTemplate(source.head) || source.body.some(hasInspection)) continue;
       const term = inspectionTerm(clause);
-      const entry = { id: clause.id, term, body: [] };
+      const entry = { id: clause.id, term };
       this.inspectionCatalogue.get(key(term)).push(entry);
       this.inspectionSources.set(clause.id, entry);
     }
@@ -262,19 +275,12 @@ function bucketEntries(found) {
   return found instanceof Bucket ? found.entries : [found];
 }
 
-const CONTROL_NAMES = new Set(['and', 'or', 'not', 'call', 'once', 'findall']);
-
 // Closed dependencies arise from absence and collection.
 function dependencies(goal, closed = false, out = []) {
-  if (isTerm(goal, 'and', 2) || isTerm(goal, 'or', 2)) {
-    dependencies(goal.args[0], closed, out);
-    dependencies(goal.args[1], closed, out);
-  } else if (isTerm(goal, 'not', 1)) {
-    dependencies(goal.args[0], true, out);
-  } else if (isTerm(goal, 'findall', 3)) {
-    dependencies(goal.args[1], true, out);
-  } else if (isTerm(goal, 'once', 1) || isTerm(goal, 'call', 1)) {
-    dependencies(goal.args[0], closed, out);
+  const inner = subgoals(goal);
+  if (inner !== null) {
+    const inside = closed || isTerm(goal, 'not', 1) || isTerm(goal, 'findall', 3);
+    for (const part of inner) dependencies(part, inside, out);
   } else if (goal instanceof Var || (isCallable(goal) && !PRIMITIVE_KEYS.has(key(goal)))) {
     out.push([goal, closed]);
   }
@@ -283,14 +289,9 @@ function dependencies(goal, closed = false, out = []) {
 
 // Whether a goal could contribute a closed dependency or a dynamic call.
 function mayNeedStratifying(goal) {
-  if (goal instanceof Var) return true;
-  if (!(goal instanceof Struct) || !CONTROL_NAMES.has(goal.name)) return false;
-  if (isTerm(goal, 'and', 2) || isTerm(goal, 'or', 2)) {
-    return mayNeedStratifying(goal.args[0]) || mayNeedStratifying(goal.args[1]);
-  }
-  if (isTerm(goal, 'not', 1) || isTerm(goal, 'findall', 3)) return true;
-  if (isTerm(goal, 'once', 1) || isTerm(goal, 'call', 1)) return mayNeedStratifying(goal.args[0]);
-  return false;
+  if (goal instanceof Var || isTerm(goal, 'not', 1) || isTerm(goal, 'findall', 3)) return true;
+  const inner = subgoals(goal);
+  return inner !== null && inner.some(mayNeedStratifying);
 }
 
 function headIndex(clauses) {

package/src/proof.js

@@ -10,7 +10,7 @@
 // missing derivation. Only pure primitives are independently recomputed.
 import { PRIMITIVE_KEYS, primitive } from './builtins.js';
 import { freshClause, text } from './common.js';
-import { readGoal } from './goals.js';
+import { goalTerm } from './goals.js';
 import { INSPECTION_KEYS, isInspection } from './inspection.js';
 import { CONTROL_KEYS, Program } from './program.js';
 import { readTerms } from './reader.js';
@@ -66,6 +66,14 @@ function resolvesTo(term, env, target) {
   return true;
 }
 
+// Whether goal is an instance of pattern: a copy of pattern renamed with
+// suffix matches goal without binding any variable of goal.
+function isInstance(goal, pattern, suffix) {
+  const renamed = freshTerm(pattern, suffix);
+  const env = new Env();
+  return unify(renamed, goal, env) && resolvesTo(renamed, env, goal);
+}
+
 // The canonical text of terms, written once per term object. A proof names
 // most goals several times, as a step and as a use, and the checks look each
 // up more than once; the text is the same every time.
@@ -305,13 +313,8 @@ function checkSteps(program, steps, allowTrusted, fail, spellings, name) {
     if (steps.has(spellings.spell(goal))) return true;
     // Source facts are available as leaves, including universal facts.
     if (!isCallable(goal)) return false;
-    for (const clause of program.groups.get(key(goal)) || []) {
-      if (clause.body.length) continue;
-      const head = freshTerm(clause.head, 'given');
-      const env = new Env();
-      if (unify(head, goal, env) && resolvesTo(head, env, goal)) return true;
-    }
-    return false;
+    return (program.groups.get(key(goal)) || [])
+      .some((clause) => !clause.body.length && isInstance(goal, clause.head, 'given'));
   }
 
   for (const step of steps.values()) {
@@ -324,10 +327,8 @@ function checkSteps(program, steps, allowTrusted, fail, spellings, name) {
     } else if (isTerm(by, 'source', 1)) {
       const clause = clauseNamed(program, by.args[0]);
       const inspected = clause === null ? null : program.inspectedById.get(clause.id);
-      const env = new Env();
-      const pattern = inspected ? freshTerm(inspected.term, 'inspection') : null;
       if (!inspected || bindings.length || uses.length || !isInspection(goal) ||
-          !unify(pattern, goal, env) || !resolvesTo(pattern, env, goal)) {
+          !isInstance(goal, inspected.term, 'inspection')) {
         fail.add('C1', `not an instance of inspectable source rule ${text(by.args[0])}: ${text(goal)}`, goal);
       } else tally.verified++;
     } else if (by === BUILTIN_BY) {
@@ -482,17 +483,6 @@ function checkResolution(program, step, fail, tally) {
   return true;
 }
 
-// The variables of a forward rule's conclusions that its premise does not
-// mention: each stands for something that exists, its witness.
-function witnessNames(clause) {
-  if (clause.witnessNames === undefined) {
-    const inBody = new Set();
-    for (const goal of clause.body) for (const name of variables(goal).keys()) inBody.add(name);
-    clause.witnessNames = [...variables(clause.head).keys()].filter((name) => !inBody.has(name));
-  }
-  return clause.witnessNames;
-}
-
 // C8: under a step's substitution, each witness of a forward rule is the
 // Skolem term of this firing, skolem(Rule, Variable, Arguments), where
 // Arguments are the ground values of the conclusions' other variables, in
@@ -501,7 +491,7 @@ function witnessNames(clause) {
 // rule has no witnesses, else whether they all hold; head is the rule's
 // renamed conclusions and names maps its variables to their renamed ones.
 function checkWitnesses(clause, head, names, env) {
-  const witnessed = witnessNames(clause);
+  const witnessed = clause.witnessNames;
   if (!witnessed.length) return null;
   // An existential firing needs bound inspection values. A generic rule
   // pattern cannot silently share one witness across all its instances.
@@ -630,24 +620,18 @@ function checkBoundaries(program, steps, boundaries, fail) {
 // query() goal or, for printed conclusions, of a forward head.
 function checkRelevance(program, claims, steps, goals, fail, spellings) {
   let serial = 0;
-  function instanceOf(claim, question) {
-    serial++;
-    const env = new Env();
-    const pattern = freshTerm(question, `asked${serial}`);
-    return unify(pattern, claim, env) && resolvesTo(pattern, env, claim);
-  }
-  const asked = goals.map((goal) => (typeof goal === 'string' ? readGoal(goal) : goal));
+  const instanceOf = (claim, question) => isInstance(claim, question, `asked${++serial}`);
+  const asked = goals.map(goalTerm);
   const halted = claims.some((claim) => claim === 'false');
   const questions = [];
   if (asked.length && !halted) {
     questions.push(...asked);
   } else {
     for (const clause of program.forward) {
-      const heads = flattenConjunction(clause.head);
-      if (heads.some((head) => head === 'true')) {
+      if (clause.heads.some((head) => head === 'true')) {
         if (!halted && clause.body.length) questions.push(conjunction(clause.body));
       }
-      for (const head of heads) if (head !== 'true' && !isActivation(head)) questions.push(head);
+      for (const head of clause.heads) if (head !== 'true' && !isActivation(head)) questions.push(head);
     }
   }
   for (const claim of claims) {

package/src/templates.js

@@ -1,6 +1,6 @@
 // Inline rule templates become statically visible clauses whose first
 // premise records the generating activation. No rule is installed at run time.
-import { normalizeGoal } from './goals.js';
+import { RULE_NAMES, normalizeGoal, subgoals } from './goals.js';
 import { isInspection } from './inspection.js';
 import {
   EMPTY, EyemindError, Struct, Var, conjunction, flattenConjunction, isCallable, isTerm, listFromItems, variables,
@@ -8,8 +8,7 @@ import {
 
 export const ACTIVATION_KEY = 'activated/2';
 export const isActivation = (term) => isTerm(term, 'activated', 2);
-const isTemplate = (term) => term instanceof Struct && term.args.length === 2 &&
-  ['implies', 'implied_by', 'forward', 'backward'].includes(term.name);
+const isTemplate = (term) => term instanceof Struct && term.args.length === 2 && RULE_NAMES.has(term.name);
 
 export function containsTemplate(term) {
   const pending = [term];
@@ -29,15 +28,12 @@ function checkGoal(goal, line, generated = false) {
   if (!(goal instanceof Struct)) return;
   if (isInspection(goal)) return;
   if (isTemplate(goal)) throw new EyemindError(`line ${line}: rule templates belong in an implies() conclusion`);
-  if (isTerm(goal, 'and', 2) || isTerm(goal, 'or', 2)) {
-    for (const part of goal.args) checkGoal(part, line, generated);
-  } else if (['not', 'call', 'once'].includes(goal.name) && goal.args.length === 1) {
-    checkGoal(goal.args[0], line, generated);
-  } else if (isTerm(goal, 'findall', 3)) {
-    if (containsTemplate(goal.args[0]) || containsTemplate(goal.args[2])) {
-      throw new EyemindError(`line ${line}: rule values in a body must be inspection goals`);
-    }
-    checkGoal(goal.args[1], line, generated);
+  if (isTerm(goal, 'findall', 3) && (containsTemplate(goal.args[0]) || containsTemplate(goal.args[2]))) {
+    throw new EyemindError(`line ${line}: rule values in a body must be inspection goals`);
+  }
+  const inner = subgoals(goal);
+  if (inner !== null) {
+    for (const part of inner) checkGoal(part, line, generated);
   } else if (containsTemplate(goal)) {
     throw new EyemindError(`line ${line}: rule templates must be top-level conjuncts of an implies() conclusion or inspection goals`);
   }

package/src/version.js

@@ -1,2 +1,2 @@
 // The release this checkout is; ./release keeps it in step with package.json.
-export const VERSION = '0.1.27';
+export const VERSION = '0.1.29';

package/src/writer.js

@@ -150,6 +150,34 @@ export class Lettering {
   }
 }
 
+// Names for write() that spell variables as the program wrote them, for
+// messages about a running goal: the renamed-apart X#12 is X again and each
+// anonymous variable is _. Distinct variables that share a name are numbered,
+// so a message never shows two of them as one.
+export class SourceNaming {
+  constructor() {
+    this.names = new Map();
+    this.taken = new Set();
+  }
+
+  get(name) {
+    let shown = this.names.get(name);
+    if (shown === undefined) {
+      const hash = name.indexOf('#');
+      const base = hash < 0 ? name : name.slice(0, hash);
+      if (/^_[0-9]*$/.test(base)) {
+        shown = '_';
+      } else {
+        shown = variableText(base);
+        for (let n = 2; this.taken.has(shown); n++) shown = variableText(`${base}_${n}`);
+        this.taken.add(shown);
+      }
+      this.names.set(name, shown);
+    }
+    return shown;
+  }
+}
+
 // Names for write() that name nothing but notice a variable.
 class Spy {
   constructor() {