eyeprolog 1.6.26 → 1.6.28

package/package.json

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

package/src/ARCHITECTURE.md

@@ -21,7 +21,10 @@ higher-level frontends.
    `datalog-common.js` owns what the two Datalog evaluators share: scalar row
    keying and the per-argument candidate-bucket narrowing both index their
    relations with. Their fixpoint algorithms and relation storage stay in their
-   own modules.
+   own modules. Positive Datalog compiles clause variables to numeric slots
+   and joins through array bindings; WFS retains its persistent Map bindings.
+   Candidate selection has a direct entry point for each binding representation
+   so their inner loops do not dispatch through a binding-store abstraction.
    `cleanup.js` owns lifecycle-aware disposal of protected builtin
    iterators and registers the normal-profile cleanup controls without making
    `solver.js` depend back on the language registry.

package/src/datalog-common.js

@@ -91,3 +91,17 @@ export function selectCandidateIndexes(indexes, args, bindings) {
   }
   return selected;
 }
+
+// Positive Datalog compiles clause variables to numeric slots. Keep its hot
+// path direct rather than introducing a binding-store dispatch in each lookup.
+export function selectCandidateIndexesForSlots(indexes, args, bindings) {
+  let selected = null;
+  for (let i = 0; i < args.length; i++) {
+    const value = args[i].type === VAR ? bindings[args[i].slot] : args[i];
+    if (value == null) continue;
+    const bucket = indexes[i].get(scalarKey(value)) ?? EMPTY_ARRAY;
+    if (selected == null || bucket.length < selected.length) selected = bucket;
+    if (selected.length === 0) break;
+  }
+  return selected;
+}

package/src/datalog.js

@@ -14,7 +14,7 @@ import {
   predicateKey,
   sameScalar,
   scalarKey,
-  selectCandidateIndexes,
+  selectCandidateIndexesForSlots,
 } from './datalog-common.js';
 
 class DatalogRelation {
@@ -61,7 +61,7 @@ class DatalogRelation {
     const tuple = new Array(args.length);
     const parts = new Array(args.length);
     for (let i = 0; i < args.length; i++) {
-      const value = args[i].type === VAR ? bindings.get(args[i].name) : args[i];
+      const value = args[i].type === VAR ? bindings[args[i].slot] : args[i];
       if (value == null || value.type === VAR) return null;
       tuple[i] = value;
       parts[i] = scalarKey(value);
@@ -87,7 +87,7 @@ class DatalogRelation {
   }
 
   candidateIndexes(args, bindings) {
-    return selectCandidateIndexes(this.indexes, args, bindings);
+    return selectCandidateIndexesForSlots(this.indexes, args, bindings);
   }
 }
 
@@ -106,11 +106,21 @@ function compileProgram(program, rootGroup) {
   for (const group of groups) {
     const headKey = predicateKey(group.module, group.name, group.arity);
     for (const clause of group.clauses) {
-      const headArgs = clause.head.args ?? EMPTY_ARRAY;
       if (clause.body.length === 0) continue;
       const body = clause.body.map((goal) => directLiteral(goal, group.module));
       if (body.some((literal) => literal == null)) continue;
-      const rule = { headKey, headArgs, body };
+      // Variable names matter only within this source clause. Compile them to
+      // array slots once so each join can bind and undo without Map lookups.
+      const variables = new Map();
+      const compileArgument = (arg) => {
+        if (arg.type !== VAR) return arg;
+        let slot = variables.get(arg.name);
+        if (slot == null) variables.set(arg.name, slot = variables.size);
+        return { type: VAR, slot };
+      };
+      const headArgs = (clause.head.args ?? EMPTY_ARRAY).map(compileArgument);
+      for (const literal of body) literal.args = literal.args.map(compileArgument);
+      const rule = { headKey, headArgs, body, variableCount: variables.size };
       rules.push(rule);
       for (let index = 0; index < body.length; index++) {
         const key = body[index].key;
@@ -130,20 +140,20 @@ function matchTupleMutable(args, tuple, bindings) {
   for (let i = 0; i < args.length; i++) {
     const pattern = args[i];
     if (pattern.type === VAR) {
-      const current = bindings.get(pattern.name);
+      const current = bindings[pattern.slot];
       if (current != null) {
         if (!sameScalar(current, tuple[i])) {
-          for (let j = added.length - 1; j >= 0; j--) bindings.delete(added[j]);
+          undoBindings(bindings, added);
           return null;
         }
       } else {
-        bindings.set(pattern.name, tuple[i]);
-        added.push(pattern.name);
+        bindings[pattern.slot] = tuple[i];
+        added.push(pattern.slot);
       }
       continue;
     }
     if (!sameScalar(pattern, tuple[i])) {
-      for (let j = added.length - 1; j >= 0; j--) bindings.delete(added[j]);
+      undoBindings(bindings, added);
       return null;
     }
   }
@@ -151,7 +161,7 @@ function matchTupleMutable(args, tuple, bindings) {
 }
 
 function undoBindings(bindings, added) {
-  for (let i = added.length - 1; i >= 0; i--) bindings.delete(added[i]);
+  for (let i = added.length - 1; i >= 0; i--) bindings[added[i]] = undefined;
 }
 
 
@@ -234,7 +244,7 @@ export function evaluatePositiveDatalog(program, rootGroup) {
     const triggerEntries = compiled.triggers.get(event.key) ?? EMPTY_ARRAY;
     for (const { rule, literalIndex } of triggerEntries) {
       const fixed = rule.body[literalIndex];
-      const bindings = new Map();
+      const bindings = new Array(rule.variableCount);
       if (!matchTupleMutable(fixed.args, event.tuple, bindings)) continue;
       const remaining = [];
       for (let i = 0; i < rule.body.length; i++) if (i !== literalIndex) remaining.push(i);

package/src/explain.js

@@ -647,7 +647,18 @@ function originalVariableName(name) {
 function resolveForProof(term, env) {
   const resolved = deref(term, env);
   if (resolved.type === VAR) return new Term(VAR, originalVariableName(resolved.name), []);
-  return new Term(resolved.type, resolved.name, resolved.args.map((arg) => resolveForProof(arg, env)));
+  // Runtime terms are immutable. A ground subtree already is a proof snapshot,
+  // so copy only the ancestors of arguments changed by variable resolution.
+  // Allocate the argument array on the first changed child, keeping ground
+  // lists allocation-free even when many proof steps share their suffixes.
+  let args = null;
+  for (let index = 0; index < resolved.args.length; index++) {
+    const child = resolveForProof(resolved.args[index], env);
+    if (args == null && child !== resolved.args[index]) args = resolved.args.slice();
+    if (args != null) args[index] = child;
+  }
+  if (args == null && resolved.module == null) return resolved;
+  return new Term(resolved.type, resolved.name, args ?? resolved.args.slice());
 }
 
 function collectClauseSubstitutions(clause, freshHead, freshBody) {

package/test/regression/cases-white-box.mjs

@@ -10,6 +10,7 @@ import { compareTerms } from '../../src/term.js';
 import { checkProofDocument, verdict } from '../../src/check-proof.js';
 import { formatTermForWrite } from '../../src/write.js';
 import { selectClauseCandidates } from '../../src/program.js';
+import { evaluatePositiveDatalog, relationForDatalogGroup } from '../../src/datalog.js';
 import { assertEqual, assertIncludes, assertNotIncludes } from '../test-style.mjs';
 import { goalsFromSource } from '../goal-metadata.mjs';
 import {
@@ -770,6 +771,44 @@ export function whiteBoxCases() {
         assertEqual(ground.stats.datalog_evaluations, 0, 'ground query keeps the ordinary indexed chain path');
       },
     },
+    {
+      name: 'Datalog joins preserve clause-local variables and repeated arguments',
+      run: () => {
+        const program = Program.parse(`
+link(a,b,red).
+link(b,c,red).
+link(c,d,red).
+link(x,x,red).
+link(a,b,blue).
+link(c,c,blue).
+link(a,c,blue).
+reach(X,Y,C) :- link(X,Y,C).
+reach(X,Y,C) :- link(X,Z,C), reach(Z,Y,C).
+back(Y,X) :- reach(X,Y,red).
+back(X,Y) :- reach(X,Y,blue).
+diagonal(X) :- reach(X,X,C).
+marked(tag,X) :- reach(X,X,red).
+wide(X,marker,Y) :- reach(X,Y,red).
+ready :- diagonal(x).
+summary :- ready, back(X,Y), marked(tag,Z), wide(X,marker,Y).
+`);
+        const model = evaluatePositiveDatalog(program, program.findGroup('summary', 0));
+        const checkRows = (name, arity, expected) => {
+          const relation = relationForDatalogGroup(model, program.findGroup(name, arity));
+          const actual = relation.rows.map((row) => row.map((value) => value.name).join(':')).sort();
+          assertEqual(actual.join('|'), expected.sort().join('|'), `${name}/${arity} rows`);
+        };
+        checkRows('back', 2, ['b:a', 'c:b', 'd:c', 'x:x', 'c:a', 'd:a', 'd:b', 'a:b', 'c:c', 'a:c']);
+        checkRows('diagonal', 1, ['c', 'x']);
+        checkRows('marked', 2, ['tag:x']);
+        checkRows('wide', 3, [
+          'a:marker:b', 'b:marker:c', 'c:marker:d', 'x:marker:x',
+          'a:marker:c', 'a:marker:d', 'b:marker:d',
+        ]);
+        checkRows('ready', 0, ['']);
+        checkRows('summary', 0, ['']);
+      },
+    },
     {
       name: 'compact finite Datalog planning preserves lazy clause terms',
       run: () => {