eyelang 1.7.16 → 1.7.17

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.16",
+  "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');