eyeprolog 1.6.39 → 1.6.41

package/examples/check/dependency-depth-10000.pl

@@ -0,0 +1,14 @@
+condition('C1', resolution, ok, 2).
+condition('C2', well_founded, ok, 3).
+condition('C3', justification, ok, 3).
+condition('C4', coverage, ok, 3).
+condition('C5', re_decision, ok, 1).
+condition('C6', boundary_consistency, ok, 0).
+condition('C7', relevance, ok, 4).
+steps(3).
+verified(2).
+recomputed(1).
+composed(0).
+trusted(0).
+claims(1).
+verdict(checked).

package/examples/check/dependency-preparation-5000.pl

@@ -0,0 +1,14 @@
+condition('C1', resolution, ok, 2).
+condition('C2', well_founded, ok, 2).
+condition('C3', justification, ok, 2).
+condition('C4', coverage, ok, 2).
+condition('C5', re_decision, ok, 0).
+condition('C6', boundary_consistency, ok, 0).
+condition('C7', relevance, ok, 3).
+steps(2).
+verified(2).
+recomputed(0).
+composed(0).
+trusted(0).
+claims(1).
+verdict(checked).

package/examples/deck/README.md

@@ -81,6 +81,8 @@ check of that proof. Each deck links to the source and opens the example in the
 - [Delayed disequality with dif/2](https://eyereasoner.github.io/eyeprolog/examples/deck/dif-constraints) — How do you say "these must differ" before you know what they are?
 - [Delfour: a privacy-preserving shopping insight](https://eyereasoner.github.io/eyeprolog/examples/deck/delfour) — Can a store scanner give diabetes-aware advice without ever learning about the diabetes?
 - [Deontic logic](https://eyereasoner.github.io/eyeprolog/examples/deck/deontic-logic) — Which duties were broken, which were repaired, and does someone need to review it?
+- [Dependency depth: 10,000 predicates](https://eyereasoner.github.io/eyeprolog/examples/deck/dependency-depth-10000) — Can dependency analysis follow a deep chain without exhausting the JavaScript stack?
+- [Dependency preparation: 5,000 predicates](https://eyereasoner.github.io/eyeprolog/examples/deck/dependency-preparation-5000) — How quickly can the engine prepare thousands of distinct predicates?
 - [Dijkstra with findall and sort](https://eyereasoner.github.io/eyeprolog/examples/deck/dijkstra-findall-sort) — What is the cheapest route, found the way Dijkstra would?
 - [Dining philosophers](https://eyereasoner.github.io/eyeprolog/examples/deck/dining-philosophers) — Who eats when, and with which forks?
 - [DONALD + GERALD = ROBERT](https://eyereasoner.github.io/eyeprolog/examples/deck/donald-gerald-robert) — Which digit does each letter stand for?

package/examples/deck/dependency-depth-10000.md

@@ -0,0 +1,107 @@
+# Dependency depth: 10,000 predicates
+
+## Can dependency analysis follow a deep chain without exhausting the JavaScript stack?
+
+A dependency graph can be deep even when its clauses are simple. This
+example has 10,000 distinct predicates and 9,999 edges in one chain.
+Dependency analysis uses an explicit traversal stack, so the graph's depth
+does not consume one JavaScript call frame per predicate.
+
+[Run it in the playground](https://eyereasoner.github.io/eyeprolog/playground#example=dependency-depth-10000) ·
+[Source](../dependency-depth-10000.pl) ·
+[Answer](../output/dependency-depth-10000.pl) ·
+[Proof](../proof/dependency-depth-10000.pl) ·
+[Check](../check/dependency-depth-10000.pl)
+
+---
+
+# The question
+
+Can the engine prepare and analyze the whole chain, including propagation
+of a cut from its final predicate back to every caller?
+The declared query asks `chain9998(ready)` to keep the resulting proof small.
+
+---
+
+# The rules
+
+```prolog
+chain0(X) :- chain1(X).
+chain1(X) :- chain2(X).
+% ... one clause per predicate ...
+chain9998(X) :- chain9999(X).
+chain9999(ready) :- !.
+```
+
+There are no cycles. Each predicate can reach the terminal cut, including
+`chain0/1`, which is 9,999 edges away. The graph is also stratified: there is
+no negative cycle.
+
+---
+
+# The answer
+
+Run from the repository root:
+
+```sh
+node bin/eyeprolog.js examples/dependency-depth-10000.pl
+```
+
+```text
+chain9998(ready).
+```
+
+---
+
+# The reason
+
+```text
+step(chain9998(ready), rule(9999), ['X' = ready], [chain9999(ready)]).
+step(chain9999(ready), rule(10000), [], "!").
+step(!, builtin, [], []).
+```
+
+Two rule applications and the cut establish the answer. This short proof
+keeps the example inexpensive to prove and check during `npm test`.
+
+---
+
+# The check
+
+```sh
+node bin/eyeprolog.js --check-proof examples/proof/dependency-depth-10000.pl examples/dependency-depth-10000.pl
+```
+
+The packaged report records `steps(3)`, `verified(2)`, `recomputed(1)`,
+`trusted(0)`, and `verdict(checked)`. It checks the query's derivation.
+The white-box regression checks the complete dependency graph separately.
+
+---
+
+# Analyze the full graph
+
+Run this from the repository root with the ordinary Node stack setting:
+
+```sh
+node --input-type=module <<'JS'
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { Program } from './src/index.js';
+const source = fs.readFileSync('examples/dependency-depth-10000.pl', 'utf8');
+const program = Program.parse(source);
+assert.equal(program.groups.size, 10000);
+assert.equal(program.isStratifiedNegation(), true);
+assert.equal(program.negationDependencies.length, 9999);
+for (let i = 0; i < 10000; i++) {
+  const group = program.findGroup(`chain${i}`, 1);
+  assert.equal(group.recursive, false);
+  assert.equal(group.cutReachable, true);
+}
+console.log('10,000 predicates analyzed; terminal cut reaches every caller.');
+JS
+```
+
+This exercises preparation and negation analysis across the full depth.
+The result establishes graph-analysis depth, rather than a bound on the
+depth of arbitrary Prolog execution. For preparation timing, see
+[the 5,000-predicate example](dependency-preparation-5000.md).

package/examples/deck/dependency-preparation-5000.md

@@ -0,0 +1,106 @@
+# Dependency preparation: 5,000 predicates
+
+## How quickly can the engine prepare thousands of distinct predicates?
+
+Generated programs can contain thousands of predicate names. Before answering
+any query, EyeProlog prepares their dependency graph and execution plans.
+This example gives that work a reproducible input: 5,000 predicates connected
+by 4,999 dependency edges.
+
+[Run it in the playground](https://eyereasoner.github.io/eyeprolog/playground#example=dependency-preparation-5000) ·
+[Source](../dependency-preparation-5000.pl) ·
+[Answer](../output/dependency-preparation-5000.pl) ·
+[Proof](../proof/dependency-preparation-5000.pl) ·
+[Check](../check/dependency-preparation-5000.pl)
+
+---
+
+# The question
+
+How much preparation does a long chain of distinct predicates require?
+The declared query asks only `chain4998(ready)`. Loading the source prepares
+the entire graph; answering this query needs only its final edge.
+
+---
+
+# The rules
+
+```prolog
+chain0(X) :- chain1(X).
+chain1(X) :- chain2(X).
+% ... one clause per predicate ...
+chain4998(X) :- chain4999(X).
+chain4999(ready).
+```
+
+Each name introduces a separate graph vertex. The engine identifies the
+components once and propagates planning properties over the graph. None of
+these predicates is recursive, and none reaches a cut.
+
+---
+
+# The answer
+
+Run from the repository root:
+
+```sh
+node bin/eyeprolog.js examples/dependency-preparation-5000.pl
+```
+
+```text
+chain4998(ready).
+```
+
+---
+
+# The reason
+
+```text
+step(chain4998(ready), rule(4999), ['X' = ready], [chain4999(ready)]).
+step(chain4999(ready), fact(5000), [], []).
+```
+
+The proof has two steps. Keeping the query short lets this example exercise
+preparation without adding a 5,000-step proof to every test run.
+
+---
+
+# The check
+
+```sh
+node bin/eyeprolog.js --check-proof examples/proof/dependency-preparation-5000.pl examples/dependency-preparation-5000.pl
+```
+
+The packaged report records `steps(2)`, `verified(2)`, `trusted(0)`, and
+`verdict(checked)`. It checks the answer's two inferences. The white-box
+regression separately checks all 5,000 predicate plans and all 4,999 graph
+edges, including negation stratification.
+
+---
+
+# Time preparation
+
+Run this from the repository root. Source reading and module startup happen
+outside the timed region. Three warm-ups precede nine measured parses;
+the printed value is their median. Use the same Node version and machine
+when comparing releases. Timing is an observation, not a test threshold.
+
+```sh
+node --input-type=module <<'JS'
+import fs from 'node:fs';
+import { Program } from './src/index.js';
+const source = fs.readFileSync('examples/dependency-preparation-5000.pl', 'utf8');
+for (let i = 0; i < 3; i++) Program.parse(source);
+const samples = [];
+for (let i = 0; i < 9; i++) {
+  const start = performance.now();
+  const program = Program.parse(source);
+  samples.push(performance.now() - start);
+  if (program.groups.size !== 5000) throw new Error('wrong predicate count');
+}
+samples.sort((a, b) => a - b);
+console.log(`Median preparation: ${samples[4].toFixed(1)} ms`);
+JS
+```
+
+Continue with [the 10,000-predicate depth example](dependency-depth-10000.md).