eyelang 4.0.6 → 4.0.8

package/examples/proof/intuitionistic-logic-kripke.pl

@@ -3,30 +3,30 @@ why(
   intuitionistic_truth(monotone_p_reaches_both, both, atom(p)),
   proof(
     goal(intuitionistic_truth(monotone_p_reaches_both, both, atom(p))),
-    by(rule("intuitionistic-logic-kripke.pl", clause(24))),
+    by(rule("intuitionistic-logic-kripke.pl", clause(22))),
     uses([
       proof(
         goal(forces(both, atom(p))),
-        by(rule("intuitionistic-logic-kripke.pl", clause(17))),
+        by(rule("intuitionistic-logic-kripke.pl", clause(15))),
         bindings([binding("World", both), binding("Prop", p), binding("Someworld", left)]),
         uses([
           proof(
             goal(leq(left, both)),
-            by(rule("intuitionistic-logic-kripke.pl", clause(16))),
+            by(rule("intuitionistic-logic-kripke.pl", clause(14))),
             bindings([binding("From", left), binding("To", both), binding("Mid", both)]),
             uses([
               proof(
                 goal(step(left, both)),
-                by(fact("intuitionistic-logic-kripke.pl", clause(11)))
+                by(fact("intuitionistic-logic-kripke.pl", clause(9)))
               ),
               proof(
                 goal(leq(both, both)),
-                by(rule("intuitionistic-logic-kripke.pl", clause(15))),
+                by(rule("intuitionistic-logic-kripke.pl", clause(13))),
                 bindings([binding("World", both)]),
                 uses([
                   proof(
                     goal(world(both)),
-                    by(fact("intuitionistic-logic-kripke.pl", clause(8)))
+                    by(fact("intuitionistic-logic-kripke.pl", clause(6)))
                   )
                 ])
               )
@@ -34,7 +34,7 @@ why(
           ),
           proof(
             goal(base(left, p)),
-            by(fact("intuitionistic-logic-kripke.pl", clause(13)))
+            by(fact("intuitionistic-logic-kripke.pl", clause(11)))
           )
         ])
       )
@@ -47,16 +47,16 @@ why(
   intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q)))),
   proof(
     goal(intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q))))),
-    by(rule("intuitionistic-logic-kripke.pl", clause(25))),
+    by(rule("intuitionistic-logic-kripke.pl", clause(23))),
     uses([
       proof(
         goal(forces(root, implies(atom(p), or(atom(p), atom(q))))),
-        by(rule("intuitionistic-logic-kripke.pl", clause(21))),
+        by(rule("intuitionistic-logic-kripke.pl", clause(19))),
         bindings([binding("World", root), binding("Left", atom(p)), binding("Right", or(atom(p), atom(q)))]),
         uses([
           proof(
             goal(world(root)),
-            by(fact("intuitionistic-logic-kripke.pl", clause(5)))
+            by(fact("intuitionistic-logic-kripke.pl", clause(3)))
           ),
           proof(
             goal(not(bad_implication(root, atom(p), or(atom(p), atom(q))))),
@@ -73,21 +73,21 @@ why(
   intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q))))),
   proof(
     goal(intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q)))))),
-    by(rule("intuitionistic-logic-kripke.pl", clause(26))),
+    by(rule("intuitionistic-logic-kripke.pl", clause(24))),
     uses([
       proof(
         goal(forces(root, neg(neg(or(atom(p), atom(q)))))),
-        by(rule("intuitionistic-logic-kripke.pl", clause(22))),
+        by(rule("intuitionistic-logic-kripke.pl", clause(20))),
         bindings([binding("World", root), binding("Formula", neg(or(atom(p), atom(q))))]),
         uses([
           proof(
             goal(forces(root, implies(neg(or(atom(p), atom(q))), bottom))),
-            by(rule("intuitionistic-logic-kripke.pl", clause(21))),
+            by(rule("intuitionistic-logic-kripke.pl", clause(19))),
             bindings([binding("World", root), binding("Left", neg(or(atom(p), atom(q)))), binding("Right", bottom)]),
             uses([
               proof(
                 goal(world(root)),
-                by(fact("intuitionistic-logic-kripke.pl", clause(5)))
+                by(fact("intuitionistic-logic-kripke.pl", clause(3)))
               ),
               proof(
                 goal(not(bad_implication(root, neg(or(atom(p), atom(q))), bottom))),
@@ -106,7 +106,7 @@ why(
   intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q))),
   proof(
     goal(intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q)))),
-    by(rule("intuitionistic-logic-kripke.pl", clause(27))),
+    by(rule("intuitionistic-logic-kripke.pl", clause(25))),
     uses([
       proof(
         goal(not(forces(root, or(atom(p), atom(q))))),
@@ -121,7 +121,7 @@ why(
   intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p)))),
   proof(
     goal(intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p))))),
-    by(rule("intuitionistic-logic-kripke.pl", clause(28))),
+    by(rule("intuitionistic-logic-kripke.pl", clause(26))),
     uses([
       proof(
         goal(not(forces(root, or(atom(p), neg(atom(p)))))),

package/examples/route-planning.pl

@@ -6,7 +6,6 @@
 % route can be inspected, stored, or used by later rules.
 
 materialize(route_to_nantes, 2).
-table(path, 2).
 mode(path, 2, [in, out]).
 
 oneway(paris, orleans).

package/examples/stirling-bell-numbers.pl

@@ -7,10 +7,6 @@
 % The table declarations memoize the smaller helper relations used by both formulas.
 materialize(stirling_bell_answer, 2).
 
-table(factorial, 2).
-table(binomial, 3).
-table(stirling2, 3).
-table(bell, 2).
 
 factorial(0, 1).
 factorial(N, Value) :-

package/examples/totient-summatory.pl

@@ -1,12 +1,10 @@
-% Euler totients and coprimality by tabled Euclidean gcd.
+% Euler totients and coprimality by automatically tabled Euclidean gcd.
 %
 % phi(N) is modeled directly as the count of integers K in 1..N with gcd(N,K)=1.
 % The summatory query reuses many gcd/totient subgoals, so memoization keeps the
 % example responsive while preserving the relational presentation.
 materialize(totient_answer, 2).
 
-table(gcd, 3).
-table(totient, 2).
 
 % Euclid's algorithm is expressed recursively over remainders.
 gcd(A, 0, A) :- ge(A, 0).

package/examples/truth-maintenance-system.pl

@@ -10,7 +10,6 @@ materialize(tmsJustification, 3).
 materialize(tmsInconsistent, 1).
 materialize(tmsConclusion, 2).
 
-table(supported, 2).
 
 % Candidate environments.
 environment(clear_only, [sensor_clear]).

package/examples/type-inference.pl

@@ -9,7 +9,6 @@
 materialize(type_answer, 2).
 materialize(type_reason, 2).
 
-table(type_expr, 3).
 
 % Tiny expression language: int_lit/1, bool_lit/1, var/1, lam/3, app/2,
 % add/2, if/3, pair/2, fst/1, and snd/1.

package/examples/web-names.pl

@@ -7,7 +7,6 @@
 materialize(affiliated_with, 2).
 materialize(project_contact, 3).
 
-table(parent_organization, 2).
 
 % A tiny graph using absolute IRI atoms directly.
 triple('<https://data.ugent.be/id/josd>', '<https://schema.org/name>', "Jos De Roo").

package/examples/weighted-interval-scheduling.pl

@@ -1,11 +1,10 @@
-% Weighted interval scheduling via tabled dynamic programming.
+% Weighted interval scheduling via automatically tabled dynamic programming.
 %
 % Intervals are ordered by finish time.  best_from(I,Best) compares the two
 % choices at position I: skip it, or take it and jump to the next compatible
-% interval.  chosen_from/2 then walks the tabled decisions to report a schedule.
+% interval.  chosen_from/2 then walks the cached decisions to report a schedule.
 materialize(weighted_interval_answer, 2).
 
-table(best_from, 2).
 
 last_interval(8).
 sentinel(9).

package/examples/wolf-goat-cabbage.pl

@@ -10,7 +10,6 @@ materialize(solution, 2).
 materialize(solved, 2).
 
 % Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-table(solve, 4).
 
 % Derivation rules: each rule below contributes one logical step toward the displayed results.
 solution(Moves) :-

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.6",
+  "version": "4.0.8",
   "description": "A small reasoning language with ISO Prolog-compatible surface syntax.",
   "type": "module",
   "main": "./index.js",

package/src/explain.js

@@ -69,7 +69,9 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active) {
 
   const group = program.findGroup(goal.name, goal.arity);
   if (!group) return;
-  if (!group.tabled && activeVariant(goal, env, active)) return;
+  // Explanation replay does not use the solver's answer tables, so its cycle
+  // guard applies even when normal execution tables this predicate.
+  if (activeVariant(goal, env, active)) return;
 
   const candidates = selectClauseCandidates(group, goal, env);
   for (const pass of [candidates.primary, candidates.fallback]) {

package/src/program.js

@@ -44,6 +44,7 @@ export class Program {
       mode: null,
       determinism: null,
       recursive: false,
+      tableInputPositions: [],
       scalarFactsOnly: true,
       negationStratum: null,
     };
@@ -84,9 +85,7 @@ export class Program {
         const indicator = declarationIndicator(h.args[0], h.args[1]);
         if (!indicator) continue;
         const group = this.groups.get(indicator.key);
-        if (h.name === 'table') {
-          if (group) group.tabled = true;
-        } else if (h.name === 'materialize') {
+        if (h.name === 'materialize') {
           this.hasMaterialize = true;
           this.materializedGroups.add(indicator.key);
         } else if ((h.name === 'det' || h.name === 'semidet') && group) {
@@ -105,7 +104,10 @@ export class Program {
         }
       }
     }
-    if (options.markRecursive !== false) this.markRecursivePredicates();
+    // Hybrid planning is part of normal execution, so dependency analysis is
+    // always performed. `markRecursive` is retained as a compatible parse
+    // option but no longer disables the engine's automatic table decisions.
+    this.markRecursivePredicates();
     if (options.analyzeNegation === true || options.strictNegation === true) this.analyzeNegationStratification();
     if (options.strictNegation === true) this.assertStratifiedNegation();
   }
@@ -116,14 +118,19 @@ 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) {
-        const bodyGoals = clause.body.flatMap((goal) => goal.type === COMPOUND && goal.name === ',' && goal.arity === 2 ? flattenConjunction(goal) : [goal]);
-        for (const goal of bodyGoals) {
-          if (goal.type !== COMPOUND) continue;
-          const dep = this.findGroup(goal.name, goal.arity);
-          if (dep) deps[groupIndex].add(indexByGroup.get(dep));
+        for (const goal of clause.body) {
+          for (const dependency of collectGoalDependencies(goal, false)) {
+            const dep = this.groups.get(dependency.key);
+            if (dep) {
+              const dependencyIndex = indexByGroup.get(dep);
+              deps[groupIndex].add(dependencyIndex);
+              if (dependency.negative) negativeEdges.push([groupIndex, dependencyIndex]);
+            }
+          }
         }
       }
     }
@@ -142,6 +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. 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);
     }
   }
 
@@ -267,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;
@@ -295,6 +367,13 @@ function collectGoalDependencies(goal, negated) {
       ...collectGoalDependencies(goal.args[1], negated),
     ];
   }
+  if ((goal.name === 'findall' || goal.name === 'sumall') && goal.arity === 3) {
+    return collectGoalDependencies(goal.args[1], negated);
+  }
+  if (goal.name === 'countall' && goal.arity === 2) return collectGoalDependencies(goal.args[0], negated);
+  if ((goal.name === 'aggregate_min' || goal.name === 'aggregate_max') && goal.arity === 5) {
+    return collectGoalDependencies(goal.args[2], negated);
+  }
   return [{ key: `${goal.name}/${goal.arity}`, negative: negated }];
 }
 

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/cases/{table/038_table_declaration.pl → automatic-tabling/038_automatic_tabling.pl}

@@ -1,6 +1,5 @@
-% Reference 10.1: table/2 is a declaration and does not change answers.
+% Reference 11.1: recursive predicates are tabled automatically without changing answers.
 materialize(reach, 2).
-table(reach_any, 2).
 edge(a, b).
 edge(b, c).
 reach_any(X, Y) :- edge(X, Y).

package/test/conformance/cases/{table/102_table_declaration.pl → automatic-tabling/102_recursive_inference.pl}

@@ -1,6 +1,5 @@
-% Reference 11.1: table/2 is the preferred spelling for tabled predicates.
+% Reference 11.1: recursive predicate groups are detected automatically.
 materialize(reach, 2).
-table(reach_any, 2).
 
 edge(a, b).
 edge(b, c).

package/test/conformance/cases/{table/tabled_left_recursion_path.pl → automatic-tabling/automatic_left_recursion_path.pl}

@@ -1,5 +1,4 @@
 materialize(answer, 1).
-table(reachable, 2).
 edge(a, b).
 edge(b, c).
 reachable(X, Z) :- reachable(X, Y), edge(Y, Z).

package/test/conformance/cases/{table/table_does_not_change_answers.pl → automatic-tabling/automatic_tabling_preserves_answers.pl}

@@ -1,6 +1,5 @@
-% `table/2` is a search-control declaration and does not change answers.
+% Automatic tabling is a search-control strategy and does not change answers.
 materialize(path, 2).
-table(path, 2).
 edge(a, b).
 edge(b, c).
 path(X, Y) :- edge(X, Y).

package/test/conformance/cases/{table/extra_table_bound_cycle.pl → automatic-tabling/extra_automatic_bound_cycle.pl}

@@ -1,5 +1,4 @@
 materialize(reach, 2).
-table(path, 2).
 edge(a, b).
 edge(b, a).
 path(X, Y) :- edge(X, Y).

package/test/conformance/cases/{table/extra_table_open_call_fallback.pl → automatic-tabling/extra_automatic_open_call_fallback.pl}

@@ -1,5 +1,4 @@
 materialize(answer, 2).
-table(edge, 2).
 edge(a, b).
 edge(b, c).
 answer(table_open_call_fallback, pair(X, Y)) :- edge(X, Y).

package/test/conformance/cases/rules/transitive_rule_three_edges.pl

@@ -1,5 +1,4 @@
 materialize(path, 2).
-table(path, 2).
 edge(a, b).
 edge(b, c).
 edge(c, d).

package/test/conformance/expected/{table/tabled_left_recursion_path.pl → automatic-tabling/automatic_left_recursion_path.pl}

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