eyelang 1.7.15 → 1.7.17

package/README.md

@@ -49,6 +49,7 @@ console.log(result.stdout);
 - [Playground](https://eyereasoner.github.io/eyelang/playground)
 - [Guide](docs/guide.md)
 - [Language reference](docs/language-reference.md)
+- [A Compact Reasoning Workbench](docs/compact-reasoning-workbench.md)
 
 For local browser use, serve the checkout first so the playground can load ES modules and example files:
 

package/docs/compact-reasoning-workbench.md

@@ -0,0 +1,35 @@
+# A Compact Reasoning Workbench
+
+Eyelang began as a small thing: a few facts, a few rules, a way to ask a question and get an answer.
+
+At first it solved the familiar problems. Paths through graphs. Ancestors in families. Tiny proofs that fit on one screen. The early examples in `examples/` keep that beginning visible: they show the core idiom before anything becomes exotic. Facts describe a world, rules extend it, goals ask for visible consequences, and answers come back as ordinary terms.
+
+Then the examples started to widen.
+
+Mathematical programs turned recurrence, tabling, aggregation, and finite search into executable relations. Fibonacci numbers, Collatz traces, integer partitions, Catalan numbers, binomial identities, Stirling and Bell numbers, graph paths, and scheduling problems made performance visible without hiding the logic behind a host-language library.
+
+Knowledge-modeling examples pulled the same syntax in a different direction. Policies, GDPR-style compliance, access control, clinical screening, deontic rules, purpose mapping, alignment flows, and context audits were not mainly numerical problems. They were problems of explanation, qualification, exception, and traceability. In those cases Eyelang stayed close to the vocabulary of the domain.
+
+Science and engineering examples stretched the language again. Filters, beams, control systems, kinetics, gas laws, gradients, coding theory, and optimization showed that structured calculation could live inside a larger rule-based argument. The programs remained small enough to read, but substantial enough to test the engine.
+
+Then came examples that looked more like systems research than toy logic programs. Markov Logic Network-style scoring represented weighted possible worlds while keeping the probability model explicit. Type inference, abstract interpretation, pointer analysis, SAT solving, truth maintenance, and register allocation showed that programming-language and analysis problems could be written as compact theories rather than opaque procedures.
+
+At the far edge were the deliberately uncomfortable examples: partial evaluation, Knuth-Bendix completion, CDCL-style SAT solving, and bounded equality saturation. They did not pretend that Eyelang was a mutable union-find library, an industrial optimizer, or a replacement for every specialized solver. They were useful precisely because they marked the boundary. Some problems had to be bounded. Some had to be expressed carefully. Some revealed where a small logic engine ends and another tool should take over.
+
+That made `examples/` more than a gallery. It became executable documentation, regression evidence, and a map of the language's range. Each file was a compact theory with an expected output that could be run, inspected, and kept honest by the test suite.
+
+The surprise was not that every hard problem became easy. They did not.
+
+The surprise was that the same small core kept reaching.
+
+Across mathematics, knowledge modeling, science, program analysis, symbolic reasoning, optimization, explanation, and search, Eyelang stayed recognizable. The programs were not black boxes. They were little theories: readable, testable, and executable. When performance mattered, tabling and careful formulations often carried them farther than expected.
+
+By the end, Eyelang no longer looked like a toy language with a few clever demos.
+
+It looked like a compact reasoning workbench.
+
+Small enough to understand.
+
+Expressive enough to surprise.
+
+Fast enough to take seriously.

package/examples/deep-taxonomy-10.eye

@@ -1,11 +1,8 @@
 % =============================================================================================================================
-% Deep Taxonomy - depth 10 - expanded N3-style eyelang with checkpoint proof accelerators
+% Deep Taxonomy - depth 10 - expanded N3-style eyelang
 %
-% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
-% rules are redundant consequences of that chain and are placed first so eyelang
-% can prove terminal/report goals without overflowing the JavaScript call stack.
-% Report/check rules use once/1 so successful checks do not backtrack into a
-% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. Each step derives
+% the next taxonomy class together with two side labels.
 % =============================================================================================================================
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
@@ -27,12 +24,6 @@ a(ind, n0).
 is(test, true) :- once(a(ind, a2)).
 a(?x, a2) :- a(?x, n10).
 
-% Redundant checkpoint accelerators.
-
-a(?x, n10) :- a(?x, n0).
-a(?x, n4) :- a(?x, n0).
-a(?x, n9) :- a(?x, n0).
-
 % Adjacent N3-style taxonomy rules.
 
 a(?x, n1) :- a(?x, n0).
@@ -98,7 +89,7 @@ arc(check6, "C6 OK - the success flag is raised only after the terminal class a2
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n10 and then as a2.") :-
  once(is(test, true)).
 
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10 chain: each rule advances one taxonomy level and adds the matching side labels.") :-
  once(a(ind, a2)),
  once(is(test, true)).
 

package/examples/deep-taxonomy-100.eye

@@ -1,11 +1,8 @@
 % =============================================================================================================================
-% Deep Taxonomy - depth 100 - expanded N3-style eyelang with checkpoint proof accelerators
+% Deep Taxonomy - depth 100 - expanded N3-style eyelang
 %
-% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
-% rules are redundant consequences of that chain and are placed first so eyelang
-% can prove terminal/report goals without overflowing the JavaScript call stack.
-% Report/check rules use once/1 so successful checks do not backtrack into a
-% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. Each step derives
+% the next taxonomy class together with two side labels.
 % =============================================================================================================================
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
@@ -27,12 +24,6 @@ a(ind, n0).
 is(test, true) :- once(a(ind, a2)).
 a(?x, a2) :- a(?x, n100).
 
-% Redundant checkpoint accelerators.
-
-a(?x, n100) :- a(?x, n0).
-a(?x, n49) :- a(?x, n0).
-a(?x, n99) :- a(?x, n0).
-
 % Adjacent N3-style taxonomy rules.
 
 a(?x, n1) :- a(?x, n0).
@@ -368,7 +359,7 @@ arc(check6, "C6 OK - the success flag is raised only after the terminal class a2
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n100 and then as a2.") :-
  once(is(test, true)).
 
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100 chain: each rule advances one taxonomy level and adds the matching side labels.") :-
  once(a(ind, a2)),
  once(is(test, true)).
 

package/examples/deep-taxonomy-1000.eye

@@ -1,11 +1,8 @@
 % =============================================================================================================================
-% Deep Taxonomy - depth 1000 - expanded N3-style eyelang with checkpoint proof accelerators
+% Deep Taxonomy - depth 1000 - expanded N3-style eyelang
 %
-% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
-% rules are redundant consequences of that chain and are placed first so eyelang
-% can prove terminal/report goals without overflowing the JavaScript call stack.
-% Report/check rules use once/1 so successful checks do not backtrack into a
-% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. Each step derives
+% the next taxonomy class together with two side labels.
 % =============================================================================================================================
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
@@ -27,12 +24,6 @@ a(ind, n0).
 is(test, true) :- once(a(ind, a2)).
 a(?x, a2) :- a(?x, n1000).
 
-% Redundant checkpoint accelerators.
-
-a(?x, n1000) :- a(?x, n0).
-a(?x, n499) :- a(?x, n0).
-a(?x, n999) :- a(?x, n0).
-
 % Adjacent N3-style taxonomy rules.
 
 a(?x, n1) :- a(?x, n0).
@@ -3068,7 +3059,7 @@ arc(check6, "C6 OK - the success flag is raised only after the terminal class a2
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n1000 and then as a2.") :-
  once(is(test, true)).
 
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-1000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-1000 chain: each rule advances one taxonomy level and adds the matching side labels.") :-
  once(a(ind, a2)),
  once(is(test, true)).
 

package/examples/deep-taxonomy-10000.eye

@@ -1,11 +1,8 @@
 % =============================================================================================================================
-% Deep Taxonomy - depth 10000 - expanded N3-style eyelang with checkpoint proof accelerators
+% Deep Taxonomy - depth 10000 - expanded N3-style eyelang
 %
-% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
-% rules are redundant consequences of that chain and are placed first so eyelang
-% can prove terminal/report goals without overflowing the JavaScript call stack.
-% Report/check rules use once/1 so successful checks do not backtrack into a
-% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. Each step derives
+% the next taxonomy class together with two side labels.
 % =============================================================================================================================
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
@@ -27,21 +24,6 @@ a(ind, n0).
 is(test, true) :- once(a(ind, a2)).
 a(?x, a2) :- a(?x, n10000).
 
-% Redundant checkpoint accelerators.
-
-a(?x, n1000) :- a(?x, n0).
-a(?x, n2000) :- a(?x, n1000).
-a(?x, n3000) :- a(?x, n2000).
-a(?x, n4000) :- a(?x, n3000).
-a(?x, n5000) :- a(?x, n4000).
-a(?x, n6000) :- a(?x, n5000).
-a(?x, n7000) :- a(?x, n6000).
-a(?x, n8000) :- a(?x, n7000).
-a(?x, n9000) :- a(?x, n8000).
-a(?x, n10000) :- a(?x, n9000).
-a(?x, n4999) :- a(?x, n4000).
-a(?x, n9999) :- a(?x, n9000).
-
 % Adjacent N3-style taxonomy rules.
 
 a(?x, n1) :- a(?x, n0).
@@ -30077,7 +30059,7 @@ arc(check6, "C6 OK - the success flag is raised only after the terminal class a2
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n10000 and then as a2.") :-
  once(is(test, true)).
 
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10000 chain: each rule advances one taxonomy level and adds the matching side labels.") :-
  once(a(ind, a2)),
  once(is(test, true)).
 

package/examples/deep-taxonomy-100000.eye

@@ -1,11 +1,8 @@
 % =============================================================================================================================
-% Deep Taxonomy - depth 100000 - expanded N3-style eyelang with checkpoint proof accelerators
+% Deep Taxonomy - depth 100000 - expanded N3-style eyelang
 %
-% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
-% rules are redundant consequences of that chain and are placed first so eyelang
-% can prove terminal/report goals without overflowing the JavaScript call stack.
-% Report/check rules use once/1 so successful checks do not backtrack into a
-% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. Each step derives
+% the next taxonomy class together with two side labels.
 % =============================================================================================================================
 
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
@@ -27,111 +24,6 @@ a(ind, n0).
 is(test, true) :- once(a(ind, a2)).
 a(?x, a2) :- a(?x, n100000).
 
-% Redundant checkpoint accelerators.
-
-a(?x, n1000) :- a(?x, n0).
-a(?x, n2000) :- a(?x, n1000).
-a(?x, n3000) :- a(?x, n2000).
-a(?x, n4000) :- a(?x, n3000).
-a(?x, n5000) :- a(?x, n4000).
-a(?x, n6000) :- a(?x, n5000).
-a(?x, n7000) :- a(?x, n6000).
-a(?x, n8000) :- a(?x, n7000).
-a(?x, n9000) :- a(?x, n8000).
-a(?x, n10000) :- a(?x, n9000).
-a(?x, n11000) :- a(?x, n10000).
-a(?x, n12000) :- a(?x, n11000).
-a(?x, n13000) :- a(?x, n12000).
-a(?x, n14000) :- a(?x, n13000).
-a(?x, n15000) :- a(?x, n14000).
-a(?x, n16000) :- a(?x, n15000).
-a(?x, n17000) :- a(?x, n16000).
-a(?x, n18000) :- a(?x, n17000).
-a(?x, n19000) :- a(?x, n18000).
-a(?x, n20000) :- a(?x, n19000).
-a(?x, n21000) :- a(?x, n20000).
-a(?x, n22000) :- a(?x, n21000).
-a(?x, n23000) :- a(?x, n22000).
-a(?x, n24000) :- a(?x, n23000).
-a(?x, n25000) :- a(?x, n24000).
-a(?x, n26000) :- a(?x, n25000).
-a(?x, n27000) :- a(?x, n26000).
-a(?x, n28000) :- a(?x, n27000).
-a(?x, n29000) :- a(?x, n28000).
-a(?x, n30000) :- a(?x, n29000).
-a(?x, n31000) :- a(?x, n30000).
-a(?x, n32000) :- a(?x, n31000).
-a(?x, n33000) :- a(?x, n32000).
-a(?x, n34000) :- a(?x, n33000).
-a(?x, n35000) :- a(?x, n34000).
-a(?x, n36000) :- a(?x, n35000).
-a(?x, n37000) :- a(?x, n36000).
-a(?x, n38000) :- a(?x, n37000).
-a(?x, n39000) :- a(?x, n38000).
-a(?x, n40000) :- a(?x, n39000).
-a(?x, n41000) :- a(?x, n40000).
-a(?x, n42000) :- a(?x, n41000).
-a(?x, n43000) :- a(?x, n42000).
-a(?x, n44000) :- a(?x, n43000).
-a(?x, n45000) :- a(?x, n44000).
-a(?x, n46000) :- a(?x, n45000).
-a(?x, n47000) :- a(?x, n46000).
-a(?x, n48000) :- a(?x, n47000).
-a(?x, n49000) :- a(?x, n48000).
-a(?x, n50000) :- a(?x, n49000).
-a(?x, n51000) :- a(?x, n50000).
-a(?x, n52000) :- a(?x, n51000).
-a(?x, n53000) :- a(?x, n52000).
-a(?x, n54000) :- a(?x, n53000).
-a(?x, n55000) :- a(?x, n54000).
-a(?x, n56000) :- a(?x, n55000).
-a(?x, n57000) :- a(?x, n56000).
-a(?x, n58000) :- a(?x, n57000).
-a(?x, n59000) :- a(?x, n58000).
-a(?x, n60000) :- a(?x, n59000).
-a(?x, n61000) :- a(?x, n60000).
-a(?x, n62000) :- a(?x, n61000).
-a(?x, n63000) :- a(?x, n62000).
-a(?x, n64000) :- a(?x, n63000).
-a(?x, n65000) :- a(?x, n64000).
-a(?x, n66000) :- a(?x, n65000).
-a(?x, n67000) :- a(?x, n66000).
-a(?x, n68000) :- a(?x, n67000).
-a(?x, n69000) :- a(?x, n68000).
-a(?x, n70000) :- a(?x, n69000).
-a(?x, n71000) :- a(?x, n70000).
-a(?x, n72000) :- a(?x, n71000).
-a(?x, n73000) :- a(?x, n72000).
-a(?x, n74000) :- a(?x, n73000).
-a(?x, n75000) :- a(?x, n74000).
-a(?x, n76000) :- a(?x, n75000).
-a(?x, n77000) :- a(?x, n76000).
-a(?x, n78000) :- a(?x, n77000).
-a(?x, n79000) :- a(?x, n78000).
-a(?x, n80000) :- a(?x, n79000).
-a(?x, n81000) :- a(?x, n80000).
-a(?x, n82000) :- a(?x, n81000).
-a(?x, n83000) :- a(?x, n82000).
-a(?x, n84000) :- a(?x, n83000).
-a(?x, n85000) :- a(?x, n84000).
-a(?x, n86000) :- a(?x, n85000).
-a(?x, n87000) :- a(?x, n86000).
-a(?x, n88000) :- a(?x, n87000).
-a(?x, n89000) :- a(?x, n88000).
-a(?x, n90000) :- a(?x, n89000).
-a(?x, n91000) :- a(?x, n90000).
-a(?x, n92000) :- a(?x, n91000).
-a(?x, n93000) :- a(?x, n92000).
-a(?x, n94000) :- a(?x, n93000).
-a(?x, n95000) :- a(?x, n94000).
-a(?x, n96000) :- a(?x, n95000).
-a(?x, n97000) :- a(?x, n96000).
-a(?x, n98000) :- a(?x, n97000).
-a(?x, n99000) :- a(?x, n98000).
-a(?x, n100000) :- a(?x, n99000).
-a(?x, n49999) :- a(?x, n49000).
-a(?x, n99999) :- a(?x, n99000).
-
 % Adjacent N3-style taxonomy rules.
 
 a(?x, n1) :- a(?x, n0).
@@ -300167,7 +300059,7 @@ arc(check6, "C6 OK - the success flag is raised only after the terminal class a2
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n100000 and then as a2.") :-
  once(is(test, true)).
 
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100000 chain: each rule advances one taxonomy level and adds the matching side labels.") :-
  once(a(ind, a2)),
  once(is(test, true)).
 

package/examples/output/deep-taxonomy-10.eye

@@ -6,7 +6,7 @@ arc(check4, "C4 OK - the final taxonomy step from n9 to n10 was completed.").
 arc(check5, "C5 OK - once n10 is reached, the terminal class a2 is derived.").
 arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.").
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n10 and then as a2.").
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.").
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10 chain: each rule advances one taxonomy level and adds the matching side labels.").
 checkPassed(report, check1).
 checkPassed(report, check2).
 checkPassed(report, check3).

package/examples/output/deep-taxonomy-100.eye

@@ -6,7 +6,7 @@ arc(check4, "C4 OK - the final taxonomy step from n99 to n100 was completed.").
 arc(check5, "C5 OK - once n100 is reached, the terminal class a2 is derived.").
 arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.").
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n100 and then as a2.").
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.").
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100 chain: each rule advances one taxonomy level and adds the matching side labels.").
 checkPassed(report, check1).
 checkPassed(report, check2).
 checkPassed(report, check3).

package/examples/output/deep-taxonomy-1000.eye

@@ -6,7 +6,7 @@ arc(check4, "C4 OK - the final taxonomy step from n999 to n1000 was completed.")
 arc(check5, "C5 OK - once n1000 is reached, the terminal class a2 is derived.").
 arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.").
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n1000 and then as a2.").
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-1000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.").
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-1000 chain: each rule advances one taxonomy level and adds the matching side labels.").
 checkPassed(report, check1).
 checkPassed(report, check2).
 checkPassed(report, check3).

package/examples/output/deep-taxonomy-10000.eye

@@ -6,7 +6,7 @@ arc(check4, "C4 OK - the final taxonomy step from n9999 to n10000 was completed.
 arc(check5, "C5 OK - once n10000 is reached, the terminal class a2 is derived.").
 arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.").
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n10000 and then as a2.").
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.").
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10000 chain: each rule advances one taxonomy level and adds the matching side labels.").
 checkPassed(report, check1).
 checkPassed(report, check2).
 checkPassed(report, check3).

package/examples/output/deep-taxonomy-100000.eye

@@ -6,7 +6,7 @@ arc(check4, "C4 OK - the final taxonomy step from n99999 to n100000 was complete
 arc(check5, "C5 OK - once n100000 is reached, the terminal class a2 is derived.").
 arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.").
 answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n100000 and then as a2.").
-reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100000 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.").
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-100000 chain: each rule advances one taxonomy level and adds the matching side labels.").
 checkPassed(report, check1).
 checkPassed(report, check2).
 checkPassed(report, check3).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.7.15",
+  "version": "1.7.17",
   "description": "A small Prolog-like logic programming language for facts, rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/builtins/control.js

@@ -11,15 +11,19 @@ function* notBuiltin({ solver, goal, env }) {
   const limited = solver.cloneForInnerGoal(1);
   let found = false;
   for (const _ of limited.solve([goal.args[0]], env.clone(), 0)) { found = true; break; }
+  solver.absorbStatsFrom(limited);
   if (!found) yield env;
 }
 
 function* onceBuiltin({ solver, goal, env }) {
   const limited = solver.cloneForInnerGoal(1);
+  let first = null;
   for (const answerEnv of limited.solve([goal.args[0]], env.clone(), 0)) {
-    yield answerEnv;
+    first = answerEnv;
     break;
   }
+  solver.absorbStatsFrom(limited);
+  if (first) yield first;
 }
 
 function* forallBuiltin({ solver, goal, env }) {
@@ -28,7 +32,12 @@ function* forallBuiltin({ solver, goal, env }) {
     const checker = solver.cloneForInnerGoal(1);
     let ok = false;
     for (const _ of checker.solve([goal.args[1]], answerEnv.clone(), 0)) { ok = true; break; }
-    if (!ok) return;
+    solver.absorbStatsFrom(checker);
+    if (!ok) {
+      solver.absorbStatsFrom(generator);
+      return;
+    }
   }
+  solver.absorbStatsFrom(generator);
   yield env;
 }

package/src/cli.js

@@ -103,13 +103,12 @@ async function runDefault(engine, program, options) {
   const materializedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
   const facts = program.sourceFactLines(materializedKeys);
   const lines = new Set();
-  let lastStats = null;
   const registry = engine.getDefaultRegistry();
   const explanation = options.proof ? await loadExplanation() : null;
+  const solver = new engine.Solver(program, { registry });
 
   for (const goal of goals) {
-    const solver = new engine.Solver(program, { registry });
-
+    solver.solutionsSeen = 0;
     for (const env of solver.solve([goal], new engine.Env(), 0)) {
       if (!engine.termIsGround(goal, env)) continue;
 
@@ -122,10 +121,9 @@ async function runDefault(engine, program, options) {
       if (options.proof) writeExplanation(explanation, program, engine.copyResolved(goal, env), registry);
     }
 
-    lastStats = solver.stats;
   }
 
-  if (options.stats && lastStats) printStats(lastStats);
+  if (options.stats) printStats(solver.stats);
 }
 
 function writeExplanation(explanation, program, resolved, registry) {

package/src/solver.js

@@ -1,6 +1,6 @@
 // Depth-first eyelang solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
-import { COMPOUND, Env, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { COMPOUND, Env, copyResolved, flattenConjunction, freshTerm, termIsGround, termToString, unify, variantTerms } from './term.js';
 import { createDefaultRegistry } from './builtins/registry.js';
 import { selectClauseCandidates } from './program.js';
 
@@ -19,6 +19,7 @@ export class Solver {
     this.solutionsSeen = 0;
     this.active = [];
     this.memo = new Map();
+    this.groundChainSuccess = new Set();
     this.stats = {
       completed_goal_lists: 0,
       solve_goals_calls: 0,
@@ -34,9 +35,21 @@ export class Solver {
   cloneForInnerGoal(solutionLimit = this.solutionLimit) {
     const solver = new Solver(this.program, { registry: this.registry, maxDepth: this.maxDepth, solutionLimit });
     solver.memo = this.memo;
+    solver.groundChainSuccess = this.groundChainSuccess;
     return solver;
   }
 
+  absorbStatsFrom(child) {
+    if (!child || child === this || !child.stats) return;
+    for (const [key, value] of Object.entries(child.stats)) {
+      if (key === 'max_depth' || key === 'max_goal_count') {
+        this.stats[key] = Math.max(this.stats[key] ?? 0, value ?? 0);
+      } else {
+        this.stats[key] = (this.stats[key] ?? 0) + (value ?? 0);
+      }
+    }
+  }
+
   *solve(goals, env = new Env(), depth = 0) {
     if (!Array.isArray(goals)) goals = [goals];
 
@@ -267,6 +280,7 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
   if (activeVariantIn(goal, env, active)) return;
+  if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
   const candidates = selectClauseCandidates(group, goal, env);
   const frames = [];
   for (const pass of [candidates.primary, candidates.fallback]) {
@@ -294,6 +308,80 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
   for (let i = frames.length - 1; i >= 0; i--) stack.push(frames[i]);
 }
 
+
+function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active) {
+  // Compress deterministic ground single-goal chains such as deep taxonomy
+  // proofs: a(ind, n100000) -> a(ind, n99999) -> ... -> a(ind, n0).
+  // This is a search-control optimization only. It fires only while each step
+  // has exactly one matching clause and a single ground body goal; otherwise the
+  // normal clause path below remains authoritative.
+  if (!termIsGround(goal, env)) return false;
+
+  const baseEnv = env;
+  let currentGroup = group;
+  let currentGoal = copyResolved(goal, env);
+  let currentDepth = depth;
+  const currentEnv = new Env();
+  const seen = new Set();
+
+  while (true) {
+    // The compressed path is iterative and protected by `seen`, so it does not
+    // consume JavaScript recursion depth the way the ordinary solver path does.
+    // Keep recording the logical depth for diagnostics, but do not cut off long
+    // finite taxonomy chains with the recursive maxDepth guard.
+    if (solver.solutionsSeen >= solver.solutionLimit) return true;
+    solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
+    const key = `${currentGoal.name}/${currentGoal.arity}:${termToString(currentGoal, currentEnv, true)}`;
+    if (seen.has(key)) return true;
+    if (activeVariantIn(currentGoal, currentEnv, active)) return true;
+    if (solver.groundChainSuccess.has(key)) {
+      rememberGroundChainSuccess(solver, seen);
+      stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });
+      return true;
+    }
+    seen.add(key);
+
+    const candidates = selectClauseCandidates(currentGroup, currentGoal, currentEnv);
+    const matches = [];
+    for (const pass of [candidates.primary, candidates.fallback]) {
+      for (const clause of pass) {
+        if (headCannotMatch(currentGoal, clause.head, currentEnv)) continue;
+        const id = nextFreshId();
+        const freshHead = freshTerm(clause.head, id);
+        const freshBody = clause.body.map((term) => freshTerm(term, id));
+        const next = new Env();
+        solver.stats.unify_calls++;
+        if (!unify(currentGoal, freshHead, next)) continue;
+        matches.push({ body: freshBody, env: next });
+        if (matches.length > 1) return false;
+      }
+    }
+
+    if (matches.length !== 1) return false;
+    const match = matches[0];
+    if (match.body.length === 0) {
+      rememberGroundChainSuccess(solver, seen);
+      stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });
+      return true;
+    }
+    if (match.body.length !== 1) return false;
+    const nextGoal = match.body[0];
+    if (nextGoal.type !== COMPOUND || !termIsGround(nextGoal, match.env)) return false;
+    const resolvedNextGoal = copyResolved(nextGoal, match.env);
+    const nextGroup = solver.program.findGroup(resolvedNextGoal.name, resolvedNextGoal.arity);
+    if (!nextGroup) return false;
+
+    currentGoal = resolvedNextGoal;
+    currentGroup = nextGroup;
+    currentDepth++;
+  }
+}
+
+
+function rememberGroundChainSuccess(solver, seen) {
+  for (const key of seen) solver.groundChainSuccess.add(key);
+}
+
 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');