eyelang 4.0.7 → 4.0.8

package/docs/guide.md

@@ -604,7 +604,7 @@ path(a, Y).
 status(Case, accepted).
 ```
 
-Ground facts use a fast path that avoids freshening and copying a rule body. Recursive-predicate detection uses an explicit work stack, which keeps large predicate chains safer in the browser. eyelang automatically tables recursive helper groups, including dependencies reached through supported meta-goals. Directly materialized recursive relations and other goals use ordinary depth-first resolution; this preserves cyclic open-relation traversal. Fully open calls retain the ordinary path rather than materializing an entire relation. Authors do not need a search-control declaration.
+Ground facts use a fast path that avoids freshening and copying a rule body. Recursive-predicate detection uses an explicit work stack, which keeps large predicate chains safer in the browser. eyelang automatically tables positive recursive groups, including dependencies reached through supported meta-goals and directly materialized relations. Cyclic calls iterate to an answer fixed point before replay. Recursive components containing a negative dependency retain guarded ordinary resolution because positive fixed-point tabling is not a semantics for unstratified negation. The engine also infers common structurally decreasing input positions; calls with an unbound structural input and fully open calls retain ordinary resolution rather than trying to materialize a potentially infinite relation. Authors do not need a search-control declaration.
 
 Predicates can also carry advisory mode and determinism declarations for documentation and host tooling:
 

package/docs/language-reference.md

@@ -639,16 +639,20 @@ Declarations are written as ordinary facts, but the host treats them specially.
 eyelang automatically combines ordinary goal-directed resolution with tabled
 resolution. Predicate dependency cycles are detected when a program is loaded,
 including dependencies inside conjunctions, negation, `once/1`, `forall/2`, and
-aggregation goals. Recursive helper predicate groups are tabled automatically;
-directly materialized recursive relations and other groups use ordinary
-depth-first resolution and indexed fact lookup. This conservative boundary
-avoids prematurely completing bound subcalls when an open output relation walks
-cyclic data. Authors do not select an execution strategy in source code.
-
-For a tabled call with at least one bound argument, answers may be cached and
-reused within a solver run. Fully open calls continue with ordinary resolution
-so that tabling does not force the whole relation to be materialized. This is a
-search-control strategy and does not change the logical meaning of a program.
+aggregation goals. Positive recursive predicate groups, including directly
+materialized relations, are tabled automatically. Cyclic calls are evaluated to
+an answer fixed point, so a table is complete before its answers are replayed.
+Recursive components containing a negative dependency retain guarded ordinary
+resolution because positive least-fixed-point tabling does not define
+unstratified negation. Other groups use ordinary depth-first resolution and
+indexed fact lookup. Authors do not select an execution strategy in source code.
+
+For a tabled call with a ground input argument, answers may be cached and reused
+within a solver run. The engine infers common structurally decreasing input
+positions from recursive clause heads. Calls whose inferred structural input is
+not ground, and fully open calls, continue with ordinary resolution so that an
+infinite relation is not forced into a table. This is a search-control strategy
+and does not change the logical meaning of a program.
 
 ### 11.2 Default-output materialization
 

package/examples/output/chart-parser.pl

@@ -3,4 +3,4 @@ chart_parser_answer(parsed, ambiguous_pp).
 chart_parser_answer(parse_count, count(command, 1)).
 chart_parser_answer(parse_count, count(ambiguous_pp, 1)).
 chart_parser_answer(noun_phrase_count, count(command, 2)).
-chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 3)).
+chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4)).

package/examples/proof/chart-parser.pl

@@ -421,7 +421,21 @@ why(
 chart_parser_answer(parse_count, count(ambiguous_pp, 1)).
 why(
   chart_parser_answer(parse_count, count(ambiguous_pp, 1)),
-  no_proof
+  proof(
+    goal(chart_parser_answer(parse_count, count(ambiguous_pp, 1))),
+    by(rule("chart-parser.pl", clause(33))),
+    bindings([binding("Sentence", ambiguous_pp), binding("Count", 1), binding("Length", 8)]),
+    uses([
+      proof(
+        goal(sentence(ambiguous_pp, 8)),
+        by(fact("chart-parser.pl", clause(3)))
+      ),
+      proof(
+        goal(countall(span(ambiguous_pp, s, 0, 8), 1)),
+        by(builtin(countall, 2))
+      )
+    ])
+  )
 ).
 
 chart_parser_answer(noun_phrase_count, count(command, 2)).
@@ -448,20 +462,20 @@ why(
   )
 ).
 
-chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 3)).
+chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4)).
 why(
-  chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 3)),
+  chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4)),
   proof(
-    goal(chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 3))),
+    goal(chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4))),
     by(rule("chart-parser.pl", clause(34))),
-    bindings([binding("Sentence", ambiguous_pp), binding("Count", 3), binding("Length", 8)]),
+    bindings([binding("Sentence", ambiguous_pp), binding("Count", 4), binding("Length", 8)]),
     uses([
       proof(
         goal(sentence(ambiguous_pp, 8)),
         by(fact("chart-parser.pl", clause(3)))
       ),
       proof(
-        goal(countall(span(ambiguous_pp, np, _start, _end), 3)),
+        goal(countall(span(ambiguous_pp, np, _start, _end), 4)),
         by(builtin(countall, 2))
       ),
       proof(

package/index.d.ts

@@ -45,6 +45,7 @@ export interface EyelangPredicateGroup {
   mode: string[] | null;
   determinism: 'det' | 'semidet' | null;
   recursive: boolean;
+  tableInputPositions: number[];
   negationStratum: number | null;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "4.0.7",
+  "version": "4.0.8",
   "description": "A small reasoning language with ISO Prolog-compatible surface syntax.",
   "type": "module",
   "main": "./index.js",

package/src/program.js

@@ -44,6 +44,7 @@ export class Program {
       mode: null,
       determinism: null,
       recursive: false,
+      tableInputPositions: [],
       scalarFactsOnly: true,
       negationStratum: null,
     };
@@ -117,13 +118,18 @@ export class Program {
     const groups = [...this.groups.values()];
     const indexByGroup = new Map(groups.map((group, i) => [group, i]));
     const deps = groups.map(() => new Set());
+    const negativeEdges = [];
     for (const group of groups) {
       const groupIndex = indexByGroup.get(group);
       for (const clause of group.clauses) {
         for (const goal of clause.body) {
           for (const dependency of collectGoalDependencies(goal, false)) {
             const dep = this.groups.get(dependency.key);
-            if (dep) deps[groupIndex].add(indexByGroup.get(dep));
+            if (dep) {
+              const dependencyIndex = indexByGroup.get(dep);
+              deps[groupIndex].add(dependencyIndex);
+              if (dependency.negative) negativeEdges.push([groupIndex, dependencyIndex]);
+            }
           }
         }
       }
@@ -143,13 +149,14 @@ export class Program {
         }
       }
       group.recursive = recursive;
+      group.tableInputPositions = recursive
+        ? inferStructuralInputPositions(group)
+        : [];
       // Recursive predicates are proved with tabling automatically, keeping
-      // search control inside the engine.
-      // A directly materialized recursive relation is normally entered as a
-      // fully open call. Keep that relation on ordinary resolution: tabling its
-      // later bound subcalls can prematurely complete answers on cyclic data.
-      // Recursive helpers demanded by an output predicate are safe candidates.
-      group.tabled = recursive && !this.materializedGroups.has(`${group.name}/${group.arity}`);
+      // search control inside the engine. Cycles through negation retain
+      // guarded resolution because positive least-fixed-point tabling is not
+      // sound for an unstratified negative component.
+      group.tabled = recursive && !componentHasNegativeEdge(start, deps, negativeEdges);
     }
   }
 
@@ -275,8 +282,65 @@ export class Program {
   }
 }
 
+function componentHasNegativeEdge(start, deps, negativeEdges) {
+  const forward = reachableIndexes(start, deps);
+  const component = new Set([...forward].filter((index) => reachableIndexes(index, deps).has(start)));
+  return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
+}
+
+function reachableIndexes(start, deps) {
+  const seen = new Set();
+  const stack = [start];
+  while (stack.length) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    for (const next of deps[current]) if (!seen.has(next)) stack.push(next);
+  }
+  return seen;
+}
+
+function inferStructuralInputPositions(group) {
+  const patternedPositions = new Set();
+  const linkedInputPositions = new Set();
+  for (const clause of group.clauses) {
+    const recursiveGoals = clause.body.filter((goal) =>
+      goal.type === COMPOUND && goal.name === group.name && goal.arity === group.arity
+    );
+    if (recursiveGoals.length === 0) continue;
+    const clauseChangedPositions = new Set();
+    for (let index = 0; index < clause.head.args.length; index++) {
+      if (clause.head.args[index].type !== 'var') patternedPositions.add(index);
+      if (recursiveGoals.some((goal) => !sameClauseTerm(clause.head.args[index], goal.args[index]))) {
+        clauseChangedPositions.add(index);
+      }
+    }
+    for (let index = 0; index < clause.head.args.length; index++) {
+      const headArg = clause.head.args[index];
+      if (headArg.type !== 'var' || !clauseChangedPositions.has(index)) continue;
+      if (clause.head.args.some((pattern, patternIndex) =>
+        patternIndex !== index && pattern.type !== 'var' && termContainsVariable(pattern, headArg.name)
+      )) linkedInputPositions.add(index);
+    }
+  }
+  if (linkedInputPositions.size > 0) {
+    return [[...linkedInputPositions].sort((left, right) => left - right)[0]];
+  }
+  if (patternedPositions.size > 0) {
+    return [[...patternedPositions].sort((left, right) => left - right)[0]];
+  }
+  return Array.from({ length: group.arity }, (_, index) => index);
+}
 
+function termContainsVariable(term, name) {
+  if (term.type === 'var') return term.name === name;
+  return term.args.some((arg) => termContainsVariable(arg, name));
+}
 
+function sameClauseTerm(left, right) {
+  if (left.type !== right.type || left.name !== right.name || left.args.length !== right.args.length) return false;
+  return left.args.every((arg, index) => sameClauseTerm(arg, right.args[index]));
+}
 
 function termHasNoVariables(term) {
   if (!term || term.type === 'var') return false;

package/src/solver.js

@@ -19,6 +19,7 @@ export class Solver {
     this.solutionsSeen = 0;
     this.active = [];
     this.memo = new Map();
+    this.tableCoordinator = null;
     this.groundChainSuccess = new Set();
     this.stats = {
       completed_goal_lists: 0,
@@ -29,6 +30,7 @@ export class Solver {
       max_goal_count: 0,
       deterministic_builtin_successes: 0,
       deterministic_builtin_failures: 0,
+      table_fixpoint_rounds: 0,
     };
   }
 
@@ -58,6 +60,21 @@ export class Solver {
       const stack = [{ kind: 'goals', goals, env, depth, active: savedActive.slice() }];
       while (stack.length) {
       const frame = stack.pop();
+      if (frame.kind === 'completeTableFixpointRound') {
+        frame.entry.computing = false;
+        const answerCount = frame.entry.answers.length;
+        if (this.tableCoordinator?.cycleSeen && answerCount > frame.answerCountBefore) {
+          scheduleTableFixpointRound(stack, this, frame);
+        } else {
+          for (const entry of this.tableCoordinator?.entries ?? [frame.entry]) {
+            entry.computing = false;
+            entry.complete = true;
+          }
+          this.tableCoordinator = null;
+          pushMemoAnswerFrames(stack, frame.entry, frame.goal, frame.rest, frame.env, frame.depth, frame.active, this);
+        }
+        continue;
+      }
       if (frame.kind === 'completeMemo') {
         frame.entry.computing = false;
         frame.entry.complete = true;
@@ -91,6 +108,7 @@ export class Solver {
         }
         if (first?.kind === 'memoStore') {
           rememberMemoAnswer(first.entry, first.goal, env);
+          if (goals.length === 1) break;
           goals = goals.slice(1);
           continue;
         }
@@ -135,24 +153,35 @@ export class Solver {
         if (!group) break;
 
         if (group.tabled) {
-          const key = memoKey(goal, env);
+          const key = memoKey(goal, env, group);
           if (key.hasBound) {
             const mapKey = `${goal.name}/${goal.arity}:${key.text}`;
             let entry = this.memo.get(mapKey);
             if (!entry) {
-              entry = { computing: false, complete: false, answers: [], answerKeys: new Set() };
+              entry = makeMemoEntry();
               this.memo.set(mapKey, entry);
             }
+            if (this.tableCoordinator) this.tableCoordinator.entries.add(entry);
             if (entry.complete) {
               pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, this);
               break;
             }
             if (!entry.computing) {
-              entry.computing = true;
-              stack.push({ kind: 'completeMemo', entry });
-              pushUserGoalUncachedFrames(stack, this, group, goal, [{ kind: 'memoStore', entry, goal }, ...rest], env, depth, active);
+              if (!this.tableCoordinator) {
+                this.tableCoordinator = { entry, cycleSeen: false, entries: new Set([entry]) };
+                scheduleTableFixpointRound(stack, this, { entry, group, goal, rest, env, depth, active });
+              } else {
+                entry.computing = true;
+                stack.push({ kind: 'completeMemo', entry });
+                pushUserGoalUncachedFrames(stack, this, group, goal, [{ kind: 'memoStore', entry, goal }, ...rest], env, depth, active);
+              }
               break;
             }
+            if (this.tableCoordinator && activeVariantIn(goal, env, active)) {
+              this.tableCoordinator.cycleSeen = true;
+            }
+            pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, this);
+            break;
           }
         }
 
@@ -184,43 +213,7 @@ export class Solver {
   }
 
   *solveMemoizedGoal(group, goal, rest, env, depth) {
-    // Memoization only pays off when at least one argument is bound. A fully
-    // open call would require storing the entire relation and can mask useful
-    // goal-ordering behavior, so it falls back to the normal path.
-    const key = memoKey(goal, env);
-    if (!key.hasBound) {
-      yield* this.solveUserGoalUncached(group, goal, rest, env, depth);
-      return;
-    }
-    const mapKey = `${goal.name}/${goal.arity}:${key.text}`;
-    let entry = this.memo.get(mapKey);
-    if (!entry) {
-      entry = { computing: false, complete: false, answers: [] };
-      this.memo.set(mapKey, entry);
-    }
-    if (!entry.complete && !entry.computing) {
-      entry.computing = true;
-      const collector = this.cloneForInnerGoal();
-      for (const answerEnv of collector.solveUserGoalUncached(group, goal, [], env.clone(), depth)) {
-        entry.answers.push(goal.args.map((arg) => importResolved(arg, answerEnv)));
-      }
-      entry.computing = false;
-      entry.complete = true;
-    }
-    if (!entry.complete && entry.computing) {
-      yield* this.solveUserGoalUncached(group, goal, rest, env, depth);
-      return;
-    }
-    for (const answerArgs of entry.answers) {
-      const next = env.clone();
-      let ok = true;
-      for (let i = 0; i < goal.arity; i++) {
-        this.stats.unify_calls++;
-        if (!unify(goal.args[i], answerArgs[i], next)) { ok = false; break; }
-      }
-      if (ok) yield* this.solve(rest, next, depth + 1);
-      if (this.solutionsSeen >= this.solutionLimit) return;
-    }
+    yield* this.solve([goal, ...rest], env, depth);
   }
 
   *solveUserGoalUncached(group, goal, rest, env, depth) {
@@ -273,6 +266,42 @@ export class Solver {
 
 }
 
+function makeMemoEntry() {
+  return { computing: false, complete: false, answers: [], answerKeys: new Set() };
+}
+
+function scheduleTableFixpointRound(stack, solver, frame) {
+  solver.stats.table_fixpoint_rounds++;
+  solver.tableCoordinator.cycleSeen = false;
+  for (const entry of solver.tableCoordinator.entries) {
+    entry.computing = false;
+    entry.complete = false;
+  }
+  frame.entry.computing = true;
+  const nextFrame = {
+    kind: 'completeTableFixpointRound',
+    entry: frame.entry,
+    group: frame.group,
+    goal: frame.goal,
+    rest: frame.rest,
+    env: frame.env,
+    depth: frame.depth,
+    active: frame.active,
+    answerCountBefore: frame.entry.answers.length,
+  };
+  stack.push(nextFrame);
+  pushUserGoalUncachedFrames(
+    stack,
+    solver,
+    frame.group,
+    frame.goal,
+    [{ kind: 'memoStore', entry: frame.entry, goal: frame.goal }],
+    frame.env,
+    frame.depth,
+    frame.active,
+  );
+}
+
 
 function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solver) {
   for (let answerIndex = entry.answers.length - 1; answerIndex >= 0; answerIndex--) {
@@ -639,7 +668,8 @@ function rememberGroundChainSuccess(solver, seen) {
 
 function rememberMemoAnswer(entry, goal, env) {
   const answerArgs = goal.args.map((arg) => importResolved(arg, env));
-  const key = answerArgs.map((arg) => termToString(arg, new Env(), true)).join('\x1f');
+  const variables = new Map();
+  const key = answerArgs.map((arg) => canonicalTermKey(arg, new Env(), variables)).join('\x1f');
   if (entry.answerKeys.has(key)) return;
   entry.answerKeys.add(key);
   entry.answers.push(answerArgs);
@@ -689,16 +719,35 @@ function derefForLocal(term, env) {
   return current;
 }
 
-function memoKey(goal, env) {
+function memoKey(goal, env, group = null) {
   let hasBound = false;
+  const variables = new Map();
+  const required = group?.tableInputPositions ?? [];
   const parts = goal.args.map((arg) => {
     const value = derefForLocal(arg, env);
-    if (value.type !== 'var') hasBound = true;
-    return value.type === 'var' ? '_' : termToString(value, env, true);
+    if (termIsGround(value, env)) hasBound = true;
+    return value.type === 'var' ? '_' : canonicalTermKey(value, env, variables);
   });
+  if (required.length > 0) {
+    hasBound = required.some((index) => termIsGround(goal.args[index], env));
+  }
   return { hasBound, text: parts.join('|') };
 }
 
+function canonicalTermKey(term, env, variables) {
+  const value = derefForLocal(term, env);
+  if (value.type === 'var') {
+    let id = variables.get(value.name);
+    if (id == null) {
+      id = variables.size;
+      variables.set(value.name, id);
+    }
+    return `var:${id}`;
+  }
+  if (!value.args?.length) return `${value.type}:${value.name}`;
+  return `${value.type}:${value.name}(${value.args.map((arg) => canonicalTermKey(arg, env, variables)).join(',')})`;
+}
+
 function importResolved(term, env) {
   const { copyResolved } = termModuleCache;
   return copyResolved(term, env);

package/test/conformance/expected/automatic-tabling/automatic_left_recursion_path.pl

@@ -1 +1,2 @@
 answer(b).
+answer(c).

package/test/run-regression.mjs

@@ -757,6 +757,44 @@ function whiteBoxCases() {
         assertEqual(group.tabled, true, 'path/2 tabled automatically');
       },
     },
+    {
+      name: 'directly materialized recursive groups are tabled automatically',
+      run: () => {
+        const program = Program.parse('materialize(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\npath(X, Z) :- edge(X, Y), path(Y, Z).\n');
+        const group = program.findGroup('path', 2);
+        assertEqual(group.tabled, true, 'materialized path/2 tabled automatically');
+      },
+    },
+    {
+      name: 'cycles through negation retain guarded resolution',
+      run: () => {
+        const program = Program.parse('p(X) :- not(q(X)).\nq(X) :- p(X).\n');
+        assertEqual(program.findGroup('p', 1).recursive, true, 'p/1 recursive');
+        assertEqual(program.findGroup('q', 1).recursive, true, 'q/1 recursive');
+        assertEqual(program.findGroup('p', 1).tabled, false, 'p/1 not positively tabled');
+        assertEqual(program.findGroup('q', 1).tabled, false, 'q/1 not positively tabled');
+      },
+    },
+    {
+      name: 'cyclic tabling reaches a complete fixed point',
+      run: () => {
+        const result = run(Program.parse(`
+materialize(path, 2).
+edge(a, b).
+edge(b, c).
+edge(c, d).
+edge(d, a).
+path(X, Y) :- edge(X, Y).
+path(X, Z) :- edge(X, Y), path(Y, Z).
+`));
+        const answers = result.stdout.trim().split('\n');
+        assertEqual(answers.length, 16, 'four-node cycle transitive closure size');
+        for (const node of ['a', 'b', 'c', 'd']) {
+          assertIncludes(result.stdout, `path(${node}, ${node}).\n`, `${node} reaches itself`);
+        }
+        assertEqual(result.stats.table_fixpoint_rounds > 1, true, 'cyclic table required multiple rounds');
+      },
+    },
     {
       name: 'ordinary declaration-like facts do not table predicates',
       run: () => {
@@ -823,6 +861,8 @@ function whiteBoxCases() {
         assertEqual(Boolean(group), true, 'no_diagonal_attack/3 group exists');
         assertEqual(group.tabled, true, 'no_diagonal_attack/3 tabled');
         assertEqual(group.recursive, true, 'no_diagonal_attack/3 recursive');
+        assertEqual(group.tableInputPositions.join(','), '2', 'diagonal scan uses the remaining rows as input');
+        assertEqual(program.findGroup('perm', 2).tableInputPositions.join(','), '1', 'permutation output stays untabled while open');
       },
     },
     {
@@ -834,6 +874,7 @@ function whiteBoxCases() {
         assertEqual(Boolean(group), true, 'collatz/2 group exists');
         assertEqual(group.tabled, true, 'collatz/2 tabled');
         assertEqual(group.recursive, true, 'collatz/2 recursive');
+        assertEqual(group.tableInputPositions.join(','), '0', 'collatz uses its numeric seed as input');
       },
     },
     {