eyemind 0.1.27 → 0.1.28

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.28
 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.28, 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.28, 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.28",
   "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

@@ -8,10 +8,10 @@ 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
@@ -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,10 +709,14 @@ 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);
@@ -716,8 +729,7 @@ export class Solver {
       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

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.28';

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() {