eyelang 4.0.5 → 4.0.7

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "4.0.5",
+  "version": "4.0.7",
   "description": "A small reasoning language with ISO Prolog-compatible surface syntax.",
   "type": "module",
   "main": "./index.js",
@@ -44,8 +44,7 @@
     "test:conformance": "node test/run-conformance.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
-    "preversion": "npm test && npm run conformance:report -- conformance-report.md",
-    "postversion": "git push origin HEAD --follow-tags",
-    "conformance:report": "node test/run-conformance-report.mjs"
+    "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
+    "postversion": "git push origin HEAD --follow-tags"
   }
 }

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

@@ -84,9 +84,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 +103,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();
   }
@@ -119,11 +120,11 @@ export class Program {
     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) deps[groupIndex].add(indexByGroup.get(dep));
+          }
         }
       }
     }
@@ -142,6 +143,13 @@ export class Program {
         }
       }
       group.recursive = recursive;
+      // 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}`);
     }
   }
 
@@ -295,6 +303,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/test/conformance/README.md

@@ -46,8 +46,8 @@ node test/run-conformance.mjs
 Summarize conformance coverage by category:
 
 ```sh
-npm run conformance:report
-npm run conformance:report -- conformance-report.md
+node test/run-conformance-report.mjs
+node test/run-conformance-report.mjs conformance-report.md
 ```
 
 Run matching conformance cases by passing a filename or directory fragment:

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-proofs/proofs/{table_recursive.pl → automatic_recursive.pl}

@@ -3,12 +3,12 @@ why(
   path(a, b),
   proof(
     goal(path(a, b)),
-    by(rule("<stdin>", clause(5))),
+    by(rule("<stdin>", clause(4))),
     bindings([binding("X", a), binding("Y", b)]),
     uses([
       proof(
         goal(edge(a, b)),
-        by(fact("<stdin>", clause(3)))
+        by(fact("<stdin>", clause(2)))
       )
     ])
   )
@@ -19,12 +19,12 @@ why(
   path(b, c),
   proof(
     goal(path(b, c)),
-    by(rule("<stdin>", clause(5))),
+    by(rule("<stdin>", clause(4))),
     bindings([binding("X", b), binding("Y", c)]),
     uses([
       proof(
         goal(edge(b, c)),
-        by(fact("<stdin>", clause(4)))
+        by(fact("<stdin>", clause(3)))
       )
     ])
   )
@@ -35,21 +35,21 @@ why(
   path(a, c),
   proof(
     goal(path(a, c)),
-    by(rule("<stdin>", clause(6))),
+    by(rule("<stdin>", clause(5))),
     bindings([binding("X", a), binding("Z", c), binding("Y", b)]),
     uses([
       proof(
         goal(edge(a, b)),
-        by(fact("<stdin>", clause(3)))
+        by(fact("<stdin>", clause(2)))
       ),
       proof(
         goal(path(b, c)),
-        by(rule("<stdin>", clause(5))),
+        by(rule("<stdin>", clause(4))),
         bindings([binding("X", b), binding("Y", c)]),
         uses([
           proof(
             goal(edge(b, c)),
-            by(fact("<stdin>", clause(4)))
+            by(fact("<stdin>", clause(3)))
           )
         ])
       )

package/test/conformance/expected-proofs/proofs/{extra_table_path_bound.pl → extra_automatic_path_bound.pl}

@@ -3,17 +3,17 @@ why(
   answer(table_path_bound, b),
   proof(
     goal(answer(table_path_bound, b)),
-    by(rule("<stdin>", clause(7))),
+    by(rule("<stdin>", clause(6))),
     bindings([binding("X", b)]),
     uses([
       proof(
         goal(path(a, b)),
-        by(rule("<stdin>", clause(5))),
+        by(rule("<stdin>", clause(4))),
         bindings([binding("X", a), binding("Y", b)]),
         uses([
           proof(
             goal(edge(a, b)),
-            by(fact("<stdin>", clause(3)))
+            by(fact("<stdin>", clause(2)))
           )
         ])
       )
@@ -26,26 +26,26 @@ why(
   answer(table_path_bound, c),
   proof(
     goal(answer(table_path_bound, c)),
-    by(rule("<stdin>", clause(7))),
+    by(rule("<stdin>", clause(6))),
     bindings([binding("X", c)]),
     uses([
       proof(
         goal(path(a, c)),
-        by(rule("<stdin>", clause(6))),
+        by(rule("<stdin>", clause(5))),
         bindings([binding("X", a), binding("Z", c), binding("Y", b)]),
         uses([
           proof(
             goal(edge(a, b)),
-            by(fact("<stdin>", clause(3)))
+            by(fact("<stdin>", clause(2)))
           ),
           proof(
             goal(path(b, c)),
-            by(rule("<stdin>", clause(5))),
+            by(rule("<stdin>", clause(4))),
             bindings([binding("X", b), binding("Y", c)]),
             uses([
               proof(
                 goal(edge(b, c)),
-                by(fact("<stdin>", clause(4)))
+                by(fact("<stdin>", clause(3)))
               )
             ])
           )

package/test/conformance/proofs/proofs/{table_recursive.pl → automatic_recursive.pl}

@@ -1,6 +1,5 @@
-% Reference 12: tabled recursive proofs still explain the successful derivation path.
+% Reference 12: automatically tabled recursive proofs still explain the successful derivation path.
 materialize(path, 2).
-table(path, 2).
 edge(a, b).
 edge(b, c).
 path(X, Y) :- edge(X, Y).

package/test/conformance/proofs/proofs/{extra_table_path_bound.pl → extra_automatic_path_bound.pl}

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

package/test/conformance/warnings/negation/{extra_stratified_negation_with_table_quiet.pl → extra_stratified_negation_with_recursion_quiet.pl}

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

package/test/run-regression.mjs

@@ -749,21 +749,21 @@ function whiteBoxCases() {
       },
     },
     {
-      name: 'table declaration marks predicate group tabled',
+      name: 'recursive predicate groups are tabled automatically',
       run: () => {
-        const program = Program.parse('table(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\n');
+        const program = Program.parse('edge(a, b).\npath(X, Y) :- edge(X, Y).\npath(X, Z) :- path(X, Y), edge(Y, Z).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
-        assertEqual(group.tabled, true, 'path/2 tabled through table/2');
+        assertEqual(group.tabled, true, 'path/2 tabled automatically');
       },
     },
     {
-      name: 'memoize fact does not table predicates',
+      name: 'ordinary declaration-like facts do not table predicates',
       run: () => {
         const program = Program.parse('memoize(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
-        assertEqual(group.tabled, false, 'memoize/2 is not a table declaration');
+        assertEqual(group.tabled, false, 'memoize/2 has no search-control meaning');
       },
     },
     {
@@ -786,17 +786,17 @@ function whiteBoxCases() {
       },
     },
     {
-      name: 'challenging examples keep dynamic-programming predicates tabled',
+      name: 'challenging examples infer dynamic-programming predicates automatically',
       run: () => {
         const checks = [
           ['binomial-vandermonde.pl', 'choose_step', 5, true],
-          ['catalan-convolution.pl', 'catalan', 2, false],
+          ['catalan-convolution.pl', 'catalan', 2, true],
           ['chart-parser.pl', 'span', 4, true],
           ['continued-fraction-sqrt2.pl', 'conv', 3, true],
-          ['critical-path-schedule.pl', 'earliest_start', 2, false],
-          ['critical-path-schedule.pl', 'finish_time', 2, false],
+          ['critical-path-schedule.pl', 'earliest_start', 2, true],
+          ['critical-path-schedule.pl', 'finish_time', 2, true],
           ['integer-partitions.pl', 'partitions', 3, true],
-          ['matrix-chain-order.pl', 'cost', 3, false],
+          ['matrix-chain-order.pl', 'cost', 3, true],
           ['modular-exponentiation.pl', 'pow_mod', 4, true],
           ['pell-equation.pl', 'pell', 3, true],
           ['stirling-bell-numbers.pl', 'stirling2', 3, false],
@@ -809,7 +809,7 @@ function whiteBoxCases() {
           const program = Program.parseSources([{ text, filename }]);
           const group = program.findGroup(name, arity);
           assertEqual(Boolean(group), true, `${filename} ${name}/${arity} group exists`);
-          assertEqual(group.tabled, true, `${filename} ${name}/${arity} tabled`);
+          assertEqual(group.tabled, recursive, `${filename} ${name}/${arity} automatic table decision`);
           assertEqual(group.recursive, recursive, `${filename} ${name}/${arity} recursive`);
         }
       },

package/test/conformance/cases/declarations/table_is_also_fact.pl

@@ -1,4 +0,0 @@
-% Declarations remain ordinary facts unless materialized output excludes them.
-materialize(answer, 2).
-table(path, 2).
-answer(Name, Arity) :- table(Name, Arity).

package/test/conformance/expected/declarations/table_is_also_fact.pl

@@ -1 +0,0 @@
-answer(path, 2).