eyemind 0.1.28 → 0.1.30

package/README.md

@@ -18,7 +18,7 @@ JavaScript library, and a browser application, with no dependencies.
 - **[Examples](https://eyereasoner.github.io/eyemind/examples/)**:
   94 runnable programs, each with a card deck and saved conclusions, proofs
   and check reports.
-- **[Conformance suite](conformance/)**: 384 cases that test any
+- **[Conformance suite](conformance/)**: 398 cases that test any
   implementation of the specification through its command line.
 
 ```js

package/SPEC.md

@@ -2,7 +2,7 @@
 
 ```text
 Title:      The eyemind Rule Language and Proof Format
-Version:    eyemind 0.1.28
+Version:    eyemind 0.1.30
 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.28, for readers who want
+the language and formats as implemented by eyemind 0.1.30, 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.
@@ -272,7 +272,9 @@ name MAY have different ranks.
 Nested `implies(Body, Head)` and `implied_by(Head, Body)` calls construct rule
 templates. A rule value in a conclusion MUST occur as a top-level conjunct of
 an `implies` conclusion; in a body, `implies` and `implied_by` are inspection
-goals (Section 4.7). The
+goals (Section 4.7). A rule value anywhere else in a clause, such as an
+argument of an ordinary head or goal, or the template or result of `findall`,
+MUST be rejected. The
 conclusion MAY combine ordinary heads and several templates. Each template's
 body and head MAY themselves be conjunctions, written as arrays. A backward
 template with several heads defines one backward clause per head, sharing
@@ -1037,7 +1039,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.28, byte for byte,
+conclusions, proof documents and reports as eyemind 0.1.30, 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.28",
+  "version": "0.1.30",
   "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,7 +1,7 @@
 // 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';
@@ -221,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));
     }
@@ -247,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);
     }
@@ -717,12 +717,8 @@ export class Solver {
       // conclusion or captures still have variables an inspection could scope.
       if (relevant.length) {
         const scoped = scopedVariables(nodes, answerEnv);
-        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);
       }
@@ -873,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.28';
+export const VERSION = '0.1.30';