eyelang 4.0.6 → 4.0.8

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,59 @@ 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: '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: () => {
         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 +824,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 +847,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`);
         }
       },
@@ -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');
       },
     },
     {

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).