eyeprolog 1.3.65 → 1.3.66

package/README.md

@@ -130,6 +130,23 @@ local/global variable stack. `phrase/2` likewise supplies its fixed `[]`
 remainder directly to the grammar; `phrase/3` retains its delayed final output
 unification for steadfastness.
 
+### Delayed disequality with `dif/2`
+
+The normal EyeProlog runtime provides `dif/2` as a conforming extension;
+`--iso-strict` remains limited to ISO/IEC 13211-1 and does not expose it.
+Unlike `\=/2`, which only tests whether two terms are non-unifiable *now*,
+`dif/2` can succeed with a residual disequality constraint and reject a later
+binding that would make the terms identical. For example,
+`dif(X, Y), X = Y` fails, while `dif(X-Y, 1-2), X = Y, Y = 1` succeeds once
+the structural constraint becomes provably satisfied.
+
+The implementation uses backtracking-safe annotated variables in `Env`. A
+pending constraint is indexed by every currently unbound variable it mentions;
+variable aliasing and later bindings reindex the annotation, entailed constraints
+are removed, and violated constraints make unification fail. The interactive
+top level includes pending `dif/2` goals in residual answers. See
+[`examples/dif-constraints.pl`](examples/dif-constraints.pl).
+
 Recursion through negation is explicit. EyeProlog provides `tnot/1` for
 well-founded negation over finite, range-restricted, function-free Datalog
 components. Ordinary `\+/1` remains negation-as-failure and is not silently
@@ -258,7 +275,7 @@ be continued without rebuilding a full clause-resolution frame for every
 suffix.  Open and remainder-producing uses still retain the ordinary DCG
 solutions and backtracking behavior.
 
-EyeProlog also adds 128 public library predicate indicators to its 129-entry ISO
+EyeProlog also adds 129 public library predicate indicators to its 129-entry ISO
 profile. **88 are implemented entirely as ordinary Prolog clauses** in focused
 modules under `src/lib/`; the remaining control predicates and finite-domain
 `library(clpz)` kernel use backtrackable host support.

package/examples/dif-constraints.pl

@@ -0,0 +1,19 @@
+% Delayed disequality constraints with dif/2.
+%
+% Unlike \=/2, dif/2 records a constraint when its arguments are still
+% unifiable and rechecks that constraint after later bindings.
+
+%% goal: allowed_pair(X, Y)
+%% goal: specialization(X, Y)
+
+allowed_pair(X, Y) :-
+    dif(X, Y),
+    X = left,
+    Y = right.
+
+% The structural constraint remains pending after X=Y. Binding both to 1
+% then proves X-Y and 1-2 different, so the constraint is discharged.
+specialization(X, Y) :-
+    dif(X-Y, 1-2),
+    X = Y,
+    Y = 1.

package/examples/output/dif-constraints.pl

@@ -0,0 +1,2 @@
+allowed_pair(left, right).
+specialization(1, 1).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.65",
+  "version": "1.3.66",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -495,6 +495,7 @@
           "derived-backward-rule",
           "derived-rule",
           "diamond-property",
+          "dif-constraints",
           "dijkstra",
           "dijkstra-findall-sort",
           "dijkstra-risk-path",

package/src/ARCHITECTURE.md

@@ -31,6 +31,13 @@ kernel component into the ISO registry or a frontend.  In particular,
 report processor errors without importing `iso.js` and creating an
 `iso.js <-> dcg.js` cycle.
 
+`term.js` also owns the generic annotated-variable storage carried by `Env`.
+Annotations are persistent across `Env.clone()` and therefore backtrack with the
+substitution. Language services may attach immutable constraint descriptors,
+but the unconstrained unification hot path only performs a null check; descriptor
+validation and reindexing run only in environments that actually contain
+annotations. `dif/2` is the first user of this mechanism.
+
 The JavaScript runtime stays flat directly under `src/`; the existing `src/lib/`
 contains Prolog library sources rather than JavaScript runtime modules. The architecture
 test rejects JavaScript import cycles under `src/`. Cleanup lifecycle hooks are

package/src/iso.js

@@ -167,6 +167,7 @@ export const eyePrologLibraryBuiltins = {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
+    registry.add('dif', 2, difBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('time', 1, timeBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__time', 1, timeBuiltin, { eyePrologLibrary: true });
   },
@@ -189,6 +190,43 @@ function* nonUnification({ goal, env }) {
   if (!unify(goal.args[0], goal.args[1], env.clone())) yield env;
 }
 
+function difConstraint(left, right) {
+  return Object.freeze({
+    kind: 'dif',
+    left,
+    right,
+    variables(env) {
+      return new Set([...termVariableNames(left, env), ...termVariableNames(right, env)]);
+    },
+    status(env) {
+      if (identical(left, right, env)) return 'violated';
+      const probe = env.clone();
+      return unify(left, right, probe, { skipVariableConstraints: true }) ? 'pending' : 'entailed';
+    },
+    residualGoal() {
+      return compound('dif', [left, right]);
+    },
+  });
+}
+
+function* difBuiltin({ goal, env }) {
+  const left = goal.args[0];
+  const right = goal.args[1];
+  if (identical(left, right, env)) return;
+
+  // In EyeProlog's finite-tree model, terms that cannot unify are already
+  // provably different and need no residual constraint. Otherwise attach a
+  // disequality constraint to every currently unbound variable it mentions.
+  const probe = env.clone();
+  if (!unify(left, right, probe, { skipVariableConstraints: true })) {
+    yield env;
+    return;
+  }
+  const next = env.clone();
+  next.addVariableConstraint(difConstraint(left, right));
+  yield next;
+}
+
 function termVariableNames(term, env, names = new Set(), seen = new Set()) {
   term = deref(term, env);
   if (term.type === VAR) {
@@ -1646,7 +1684,7 @@ function writeOptionBoolean(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
   if (value.type !== ATOM || !['true', 'false'].includes(value.name)) {
-    throw new PrologError('domain_error(write_option)', option);
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
   return value.name === 'true';
 }
@@ -1657,19 +1695,20 @@ function writeVariableNames(value, env, option) {
   const items = properListItems(value, env);
   if (items == null) {
     if (isPartialList(value, env)) throw new PrologError('instantiation_error');
-    throw new PrologError('domain_error(write_option)', option);
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
   const names = new Map();
   for (const item of items) {
     const pair = deref(item, env);
+    if (pair.type === VAR) throw new PrologError('instantiation_error');
     if (pair.type !== COMPOUND || pair.name !== '=' || pair.arity !== 2) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     const name = deref(pair.args[0], env);
     const target = deref(pair.args[1], env);
     if (name.type === VAR) throw new PrologError('instantiation_error');
     if (name.type !== ATOM) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     // Corrigendum 3 permits any term on the right. Only variables can name a
     // variable being written; retain the leftmost applicable entry.
@@ -1682,7 +1721,7 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
   const result = defaultTermWriteOptions(mode);
   for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     if (option.name === 'quoted') result.quoted = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'ignore_ops') result.ignoreOps = writeOptionBoolean(option.args[0], env, option);
@@ -1691,7 +1730,7 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
     else if (option.name === 'double_quotes' && !solver?.isoStrict) {
       result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
     } else {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
   }
   return result;

package/src/repl.js

@@ -740,6 +740,19 @@ function formatAnswer(engine, state, variables, env) {
       doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     })}`);
   }
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    const residual = constraint.residualGoal?.(env);
+    if (residual == null) continue;
+    collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+    bindings.push(engine.formatTermForWrite(residual, env, {
+      quoted: true,
+      operators,
+      variableNames: names,
+      operatorAtomsAsArgs: true,
+      dottedGraphicAtoms: true,
+      doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    }));
+  }
   return bindings.length === 0 ? 'true' : bindings.join(', ');
 }
 

package/src/solver.js

@@ -1971,7 +1971,7 @@ function fastCountBranch(branch, env) {
 
 function fastCountPureGoal(solver, goal, env) {
   if (solver.isoStrict || solver.solutionLimit !== Infinity || solver.maxInferences !== Infinity ||
-      env._clpz != null || (env._delays != null && env._delays.size !== 0)) return null;
+      env._clpz != null || env._variableConstraints != null || (env._delays != null && env._delays.size !== 0)) return null;
   const budget = { remaining: 8192 };
   const branches = expandPureCountGoal(solver, goal, goal.module ?? 'user', new Set(), budget);
   if (branches == null) return null;
@@ -2015,6 +2015,7 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     if (state.index === runLength) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
       frames.push({ kind: 'goals', goals: rest, env: next, depth: state.depth, active });
       if (frames.length > frameLimit) {
         // Do not repeat the old bug of abandoning the optimization and then
@@ -2079,6 +2080,7 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     if (state.index === goals.length) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
       yield next;
       continue;
     }
@@ -2183,6 +2185,7 @@ function matchScalarFact(goal, head, env) {
 
   const next = env.clone();
   for (let i = 0; i < names.length; i++) next.bind(names[i], values[i]);
+  if (next._variableConstraints != null && !next.validateVariableConstraints()) return null;
   return next;
 }
 

package/src/standard-library.js

@@ -48,7 +48,7 @@ function libraryUrl(filename) {
 }
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([
-  'call_nth/2', 'freeze/2', 'countall/2', 'time/1',
+  'call_nth/2', 'freeze/2', 'dif/2', 'countall/2', 'time/1',
   '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
   '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',

package/src/term.js

@@ -97,6 +97,11 @@ export class Env {
       cache: null,
     };
     this._delays = null;
+    // Backtracking-safe attributed-variable constraints. Constraints are
+    // immutable descriptors shared by cloned environments; the Set/Map index
+    // is copied only when a branch adds, removes, or reindexes a constraint.
+    this._variableConstraints = null;
+    this._variableAnnotations = null;
     this._clpz = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
@@ -110,6 +115,8 @@ export class Env {
     const clone = Object.create(Env.prototype);
     clone._state = this._state;
     clone._delays = this._delays;
+    clone._variableConstraints = this._variableConstraints;
+    clone._variableAnnotations = this._variableAnnotations;
     clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
@@ -236,6 +243,54 @@ export class Env {
     if (ready.length > 0) this._delays = remaining;
     return ready;
   }
+  addVariableConstraint(constraint) {
+    if (constraint == null || typeof constraint.variables !== 'function' ||
+        typeof constraint.status !== 'function') {
+      throw new TypeError('variable constraint requires variables(env) and status(env)');
+    }
+    const constraints = new Set(this._variableConstraints ?? []);
+    constraints.add(constraint);
+    this._variableConstraints = constraints;
+    this._reindexVariableConstraints();
+  }
+  variableConstraints(kind = null) {
+    const constraints = [...(this._variableConstraints ?? [])];
+    return kind == null ? constraints : constraints.filter((constraint) => constraint.kind === kind);
+  }
+  variableAnnotations(name) {
+    const root = deref(variable(name), this);
+    if (root.type !== VAR) return [];
+    return [...(this._variableAnnotations?.get(root.name) ?? [])];
+  }
+  validateVariableConstraints() {
+    if (this._variableConstraints == null || this._variableConstraints.size === 0) return true;
+    const pending = new Set();
+    for (const constraint of this._variableConstraints) {
+      const status = constraint.status(this);
+      if (status === 'violated') return false;
+      if (status !== 'entailed') pending.add(constraint);
+    }
+    this._variableConstraints = pending.size === 0 ? null : pending;
+    this._reindexVariableConstraints();
+    return true;
+  }
+  _reindexVariableConstraints() {
+    if (this._variableConstraints == null || this._variableConstraints.size === 0) {
+      this._variableAnnotations = null;
+      return;
+    }
+    const annotations = new Map();
+    for (const constraint of this._variableConstraints) {
+      for (const name of constraint.variables(this)) {
+        const root = deref(variable(name), this);
+        if (root.type !== VAR) continue;
+        const set = annotations.get(root.name) ?? new Set();
+        set.add(constraint);
+        annotations.set(root.name, set);
+      }
+    }
+    this._variableAnnotations = annotations.size === 0 ? null : annotations;
+  }
 }
 
 export function deref(term, env) {
@@ -373,6 +428,7 @@ export function unify(left, right, env, options = {}) {
 
     return false;
   }
+  if (options.skipVariableConstraints !== true && env?._variableConstraints != null && !env.validateVariableConstraints()) return false;
   return true;
 }
 

package/test/run-regression.mjs

@@ -110,6 +110,41 @@ export function runRegression(reporter = new TestReporter(), requestedSection =
 
 function regressionCases() {
   return [
+    {
+      name: 'dif/2 keeps a delayed disequality across later unification (issue #68)',
+      run: () => {
+        assertEqual(run('', { goal: 'dif(1,Y),Y=1' }).stats.completed_goal_lists, 0,
+          'binding a constrained variable to the forbidden value fails');
+        assertEqual(run('', { goal: 'dif(1,Y),Y=2' }).stats.completed_goal_lists, 1,
+          'binding a constrained variable to a different value succeeds');
+        assertEqual(run('', { goal: 'dif(X,Y),X=Y' }).stats.completed_goal_lists, 0,
+          'aliasing two constrained variables fails');
+        assertEqual(run('', { goal: 'dif(X-Y,1-2),X=Y,Y=1' }).stats.completed_goal_lists, 1,
+          'a specialization that makes the terms non-unifiable discharges the constraint');
+        assertEqual(run('', { goal: 'dif(X-Y,1-2),X=Y,X=2' }).stats.completed_goal_lists, 1,
+          'a second specialization discharges the same structural constraint');
+        assertEqual(run('p(a).', { goal: 'dif(X,a),p(X)' }).stats.completed_goal_lists, 0,
+          'scalar-fact fast matching still validates annotated variables');
+        assertEqual(run('p(b).', { goal: 'dif(X,a),p(X)' }).stats.completed_goal_lists, 1,
+          'scalar-fact fast matching can discharge an annotated disequality');
+      },
+    },
+    {
+      name: 'write_term variable_names/1 errors preserve the instantiated option culprit (issue #69)',
+      run: () => {
+        const scalar = run('', {
+          isoStrict: true,
+          goal: "catch((VN=1,write_term(T,[variable_names(VN)])),error(E,_),writeq(E))",
+        });
+        assertEqual(scalar.stdout, 'domain_error(write_option,variable_names(1))', 'scalar culprit');
+
+        const list = run('', {
+          isoStrict: true,
+          goal: "catch((VN=[[]],write_term(T,[variable_names(VN)])),error(E,_),writeq(E))",
+        });
+        assertEqual(list.stdout, 'domain_error(write_option,variable_names([[]]))', 'list culprit');
+      },
+    },
     {
       name: 'large source scanning avoids quadratic full-stop lookback',
       run: () => {
@@ -4694,7 +4729,7 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 160, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and private library adapters');
+        assertEqual(library.defs.size, 161, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and private library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -4705,11 +4740,13 @@ answer(ok) :-
         assertEqual(Boolean(library.get('tnot', 1)), true, 'tnot/1 is an EyeProlog WFS extension');
         assertEqual(registry.get('time', 1), null, 'time/1 is absent from the ISO registry');
         assertEqual(Boolean(library.get('time', 1)), true, 'time/1 is an EyeProlog timing extension');
+        assertEqual(registry.get('dif', 2), null, 'dif/2 is absent from the strict ISO core registry');
+        assertEqual(Boolean(library.get('dif', 2)), true, 'dif/2 is an EyeProlog attributed-variable constraint extension');
         assertEqual(registry.get('call_cleanup', 2), null, 'call_cleanup/2 is absent from the ISO registry');
         assertEqual(Boolean(library.get('call_cleanup', 2)), true, 'call_cleanup/2 is an EyeProlog cleanup control');
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 41, 'public native EyeProlog builtin count');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 42, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 87, 'portable Prolog library count');
         assertEqual(eyePrologInteropLibraryIndicators.length, 29, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext,lambda', 'common explicit library module profile');
@@ -4719,9 +4756,9 @@ answer(ok) :-
         assertEqual(eyePrologInteropAutoload['time/1'], 'iso_ext', 'time/1 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['.../2'], 'iso_ext', '.../2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 41, 'native host library count');
-        assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');
-        assertEqual(eyePrologLibraryIndicators.length, 128, 'complete EyeProlog library surface');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 42, 'native host library count');
+        assertEqual(eyePrologNativeLibraryIndicators.slice(0, 3).join(','), 'call_nth/2,freeze/2,dif/2', 'control and constraint predicates requiring host support');
+        assertEqual(eyePrologLibraryIndicators.length, 129, 'complete EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');

package/the-art-of-eyeprolog.md

@@ -6211,13 +6211,13 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **128 library predicate indicators** in addition to the 129
+EyeProlog exposes **129 library predicate indicators** in addition to the 129
 indicators in its isolated ISO profile. **88 are defined entirely as ordinary
 Prolog clauses** in focused modules under `src/lib/`. The remaining public
 relations use small private host adapters where control, constraints, or host
 observability cannot be expressed by ordinary clauses alone; `time/1` is one
 such relation. The resulting normal EyeProlog language surface is therefore
-**257 public predicate indicators**. Most library relations remain module source
+**258 public predicate indicators**. Most library relations remain module source
 clauses over private adapters. `time/1` is additionally registered directly in
 the normal EyeProlog runtime so Trealla-style timing works at the interactive
 top level without an import; it is absent from the strict ISO registry.
@@ -6257,6 +6257,7 @@ between solution branches.
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |
 | `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2`, `time/1`, `.../2` |
+| Normal runtime extension | `dif/2` |
 | `library(lambda)` | `^/3`, `^/4`, `^/5`, `^/6`, `^/7`, `^/8`, `^/9`, `^/10`, `\/1`, `\/2`, `\/3`, `\/4`, `\/5`, `\/6`, `\/7`, `\/8`, `+\/2`, `+\/3`, `+\/4`, `+\/5`, `+\/6`, `+\/7`, `+\/8`, `+\/9` |
 | `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
 | `library(primes)` | `smallest_divisor_from/3` |
@@ -7130,7 +7131,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **211 self-contained runnable programs**. Every
+top-level directory contains **212 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic tables below link every top-level program and open the program