eyeprolog 1.6.6 → 1.6.8

package/examples/proof/clpb-boolean-circuit.pl

@@ -10,6 +10,7 @@ clause(1,
 clause(2,
        xor_row(row(var('X'), var('Y'), var('Z'))),
        (xor_circuit(var('X'), var('Y'), var('Z')), labeling([var('X'), var('Y'), var('Z')]))).
+clause(3, xor_circuit_verified(var('T')), taut(x # y =:= x * ~ y + ~ x * y, var('T'))).
 
 step(xor_row(row(0, 0, 0)),
      rule(2),
@@ -39,3 +40,5 @@ step(xor_row(row(1, 0, 1)),
 step(xor_circuit(1, 0, 1), rule(1), ['X' = 1, 'Y' = 0, 'Z' = 1], [sat(1 =:= 1 * ~ 0 + ~ 1 * 0)]).
 step(sat(1 =:= 1 * ~ 0 + ~ 1 * 0), builtin, [], []).
 step(labeling([1, 0, 1]), builtin, [], []).
+step(xor_circuit_verified(1), rule(3), ['T' = 1], [taut(x # y =:= x * ~ y + ~ x * y, 1)]).
+step(taut(x # y =:= x * ~ y + ~ x * y, 1), builtin, [], []).

package/examples/proof/clpb-cardinality.pl

@@ -1,3 +1,43 @@
 review_quorum(selection(alice(0), bob(0), carol(1), dan(1))).
 review_quorum(selection(alice(0), bob(1), carol(1), dan(0))).
 review_quorum_count(2).
+
+clause(1,
+       review_constraints(var('Alice'), var('Bob'), var('Carol'), var('Dan')),
+       sat(card([2], [var('Alice'), var('Bob'), var('Carol'), var('Dan')]) * (var('Alice') =< var('Carol')) * (var('Bob') # var('Dan')))).
+clause(2,
+       review_quorum(selection(alice(var('Alice')), bob(var('Bob')), carol(var('Carol')), dan(var('Dan')))),
+       (review_constraints(var('Alice'), var('Bob'), var('Carol'), var('Dan')),
+        labeling([var('Alice'), var('Bob'), var('Carol'), var('Dan')]))).
+clause(3,
+       review_quorum_count(var('Count')),
+       sat_count(card([2], [var('Alice'), var('Bob'), var('Carol'), var('Dan')]) * (var('Alice') =< var('Carol')) * (var('Bob') # var('Dan')), var('Count'))).
+
+step(review_quorum(selection(alice(0), bob(0), carol(1), dan(1))),
+     rule(2),
+     ['Alice' = 0, 'Bob' = 0, 'Carol' = 1, 'Dan' = 1],
+     [review_constraints(0, 0, 1, 1), labeling([0, 0, 1, 1])]).
+step(review_constraints(0, 0, 1, 1),
+     rule(1),
+     ['Alice' = 0, 'Bob' = 0, 'Carol' = 1, 'Dan' = 1],
+     [sat(card([2], [0, 0, 1, 1]) * (0 =< 1) * (0 # 1))]).
+step(sat(card([2], [0, 0, 1, 1]) * (0 =< 1) * (0 # 1)), builtin, [], []).
+step(labeling([0, 0, 1, 1]), builtin, [], []).
+step(review_quorum(selection(alice(0), bob(1), carol(1), dan(0))),
+     rule(2),
+     ['Alice' = 0, 'Bob' = 1, 'Carol' = 1, 'Dan' = 0],
+     [review_constraints(0, 1, 1, 0), labeling([0, 1, 1, 0])]).
+step(review_constraints(0, 1, 1, 0),
+     rule(1),
+     ['Alice' = 0, 'Bob' = 1, 'Carol' = 1, 'Dan' = 0],
+     [sat(card([2], [0, 1, 1, 0]) * (0 =< 1) * (1 # 0))]).
+step(sat(card([2], [0, 1, 1, 0]) * (0 =< 1) * (1 # 0)), builtin, [], []).
+step(labeling([0, 1, 1, 0]), builtin, [], []).
+step(review_quorum_count(2),
+     rule(3),
+     ['Count' = 2],
+     [sat_count(card([2], [Alice, Bob, Carol, Dan]) * (Alice =< Carol) * (Bob # Dan), 2)]).
+step(sat_count(card([2], [Alice, Bob, Carol, Dan]) * (Alice =< Carol) * (Bob # Dan), 2),
+     builtin,
+     [],
+     []).

package/examples/proof/clpb-feature-model.pl

@@ -11,6 +11,9 @@ clause(2,
        feature_plan(features(cloud(var('Cloud')), edge(var('Edge')), audit(var('Audit')), encryption(var('Encryption')))),
        (feature_constraints(var('Cloud'), var('Edge'), var('Audit'), var('Encryption')),
         labeling([var('Cloud'), var('Edge'), var('Audit'), var('Encryption')]))).
+clause(3,
+       feature_plan_count(var('Count')),
+       sat_count((anonymous(1) # var('Edge')) * (var('Audit') =< anonymous(2)) * (var('Edge') =< var('Audit')), var('Count'))).
 
 step(feature_plan(features(cloud(0), edge(1), audit(1), encryption(1))),
      rule(2),
@@ -52,3 +55,8 @@ step(feature_constraints(1, 0, 1, 1),
      [sat((1 # 0) * (1 =< 1) * (0 =< 1))]).
 step(sat((1 # 0) * (1 =< 1) * (0 =< 1)), builtin, [], []).
 step(labeling([1, 0, 1, 1]), builtin, [], []).
+step(feature_plan_count(4),
+     rule(3),
+     ['Count' = 4],
+     [sat_count((_Cloud # Edge) * (Audit =< _Encryption) * (Edge =< Audit), 4)]).
+step(sat_count((_Cloud # Edge) * (Audit =< _Encryption) * (Edge =< Audit), 4), builtin, [], []).

package/package.json

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

package/src/cli.js

@@ -35,7 +35,7 @@ export async function main(argv) {
     files: [],
     proof: false,
     proofDetail: 'abstract',
-    verifyProof: null,
+    checkProof: null,
     quads: false,
     quiet: false,
     stats: false,
@@ -64,10 +64,10 @@ export async function main(argv) {
       if (detail !== 'abstract' && detail !== 'expanded') throw new Error('--proof-detail requires abstract or expanded');
       options.proof = true;
       options.proofDetail = detail;
-    } else if (!endOptions && arg === '--verify-proof') {
+    } else if (!endOptions && arg === '--check-proof') {
       const file = argv[++i];
-      if (file == null) throw new Error('--verify-proof requires a file');
-      options.verifyProof = file;
+      if (file == null) throw new Error('--check-proof requires a file');
+      options.checkProof = file;
     } else if (!endOptions && (arg === '--quads' || arg === '-q')) {
       options.quads = true;
     } else if (!endOptions && arg === '--quiet') {
@@ -117,18 +117,18 @@ export async function main(argv) {
   if (options.isoStrict && options.quads) {
     throw new Error('--iso-strict cannot be combined with --quads');
   }
-  if (options.verifyProof != null && options.quads) {
-    throw new Error('--verify-proof cannot be combined with --quads');
+  if (options.checkProof != null && options.quads) {
+    throw new Error('--check-proof cannot be combined with --quads');
   }
-  if (options.verifyProof != null && options.proof) {
-    throw new Error('--verify-proof cannot be combined with --proof or --proof-detail');
+  if (options.checkProof != null && options.proof) {
+    throw new Error('--check-proof cannot be combined with --proof or --proof-detail');
   }
-  if (options.verifyProof != null && options.goals.length > 0) {
-    throw new Error('--verify-proof cannot be combined with --goal');
+  if (options.checkProof != null && options.goals.length > 0) {
+    throw new Error('--check-proof cannot be combined with --goal');
   }
 
   if (options.isoStrict && options.files.length === 0 && options.goals.length === 0 &&
-      options.verifyProof == null && !options.proof && !options.quiet && !options.stats && !options.warnings) {
+      options.checkProof == null && !options.proof && !options.quiet && !options.stats && !options.warnings) {
     const engine = await loadEngine();
     const { runRepl } = await import('./repl.js');
     const exitCode = await runRepl(engine, {
@@ -172,7 +172,7 @@ export async function main(argv) {
     sourceParts.push({ text: '', filename: '<empty>' });
   }
 
-  if (options.goals.length === 0 && !options.quads && options.verifyProof == null) {
+  if (options.goals.length === 0 && !options.quads && options.checkProof == null) {
     for (const source of sourceParts) options.goals.push(...goalsFromSource(source.text));
   }
 
@@ -188,7 +188,7 @@ export async function main(argv) {
 
   const engine = await loadEngine();
   let program = engine.Program.parseSources(sourceParts, {
-    sourceMetadata: options.proof || options.verifyProof != null || options.isoStrict,
+    sourceMetadata: options.proof || options.checkProof != null || options.isoStrict,
     isoStrict: options.isoStrict,
     autoload: options.autoload,
     autoloadGoals: options.goals,
@@ -198,7 +198,7 @@ export async function main(argv) {
   // A bare `?- Goal.` asks its question the same way a `%% ?-` comment
   // does, but only the parser can find it, so it is picked up here rather
   // than from the source text.
-  if (options.goals.length === 0 && !options.quads && options.verifyProof == null && program.queries.length > 0) {
+  if (options.goals.length === 0 && !options.quads && options.checkProof == null && program.queries.length > 0) {
     options.goals.push(...program.queries.map((query) => query.goal));
     program = engine.autoloadProgramGoals(program, options.goals, { autoload: options.autoload });
   }
@@ -214,16 +214,16 @@ export async function main(argv) {
     return;
   }
 
-  if (options.verifyProof != null) {
+  if (options.checkProof != null) {
     const { checkProofDocument, verdict } = await import('./check-proof.js');
-    const proofText = await fs.readFile(options.verifyProof, 'utf8');
+    const proofText = await fs.readFile(options.checkProof, 'utf8');
     const report = checkProofDocument(program, proofText);
-    if (report.steps === 0) throw new Error(`no step/4 proof step found in ${options.verifyProof}`);
+    if (report.steps === 0) throw new Error(`no step/4 proof step found in ${options.checkProof}`);
     if (!report.valid) {
       for (const failure of report.failures.slice(0, 5)) {
         process.stderr.write(`  [${failure.condition}] ${failure.conclusion} -- ${failure.detail}\n`);
       }
-      throw new Error(`${options.verifyProof} is not a valid proof for this program: ${report.failures.length} failure(s)`);
+      throw new Error(`${options.checkProof} is not a valid proof for this program: ${report.failures.length} failure(s)`);
     }
     process.stdout.write(`${verdict(report)}.\n`);
     return;
@@ -317,10 +317,23 @@ async function runDefault(engine, program, options) {
     });
     if (options.proof && !options.quiet) {
       const explanation = await loadExplanation();
-      const roots = claimed
-        .map((fact) => explanation.proofNodeFor(program, fact, { registry, proofDetail: options?.proofDetail ?? 'abstract' }))
-        .filter(Boolean);
+      const detail = options?.proofDetail ?? 'abstract';
+      const roots = [];
+      const unexplained = [];
+      for (const fact of claimed) {
+        const node = explanation.proofNodeFor(program, fact, { registry, proofDetail: detail, solver });
+        if (node) roots.push(node);
+        else unexplained.push(fact);
+      }
       const { clauses, steps } = explanation.flattenProof(roots, program);
+      // An answer the explanation replay cannot reproduce is recorded as
+      // `unproven` rather than left without a step: a document containing
+      // one is not a valid proof, and saying so is the point.
+      const concluded = new Set(steps.map((step) => engine.termToString(step.conclusion, new engine.Env(), true)));
+      for (const fact of unexplained) {
+        if (concluded.has(engine.termToString(fact, new engine.Env(), true))) continue;
+        steps.push({ conclusion: fact, by: engine.atom('unproven'), bindings: [], uses: [] });
+      }
       process.stdout.write(engine.proofBlocks(program, clauses, steps));
     }
     if (haltCode != null) process.exitCode = haltCode;
@@ -347,7 +360,7 @@ Options:
   -h, --help            Show this help text and exit.
   -p, --proof           Enable proof explanations.
   --proof-detail mode   Use abstract or expanded proof detail (implies --proof).
-  --verify-proof file   Check a saved proof document against the input program.
+  --check-proof file   Check a saved proof document against the input program.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
                         Note: -q is quads, not quiet; --quiet has no short form.
   --quiet               Suppress answer terms while preserving Prolog output.

package/src/explain.js

@@ -41,6 +41,19 @@ export function explainProof(program, goal, options = {}) {
   return whyProof(program, goal, options);
 }
 
+// The solver a replay evaluates through.
+//
+// A constraint library keeps state on the solver instance that running a
+// program's directives again does not rebuild -- CLP(B) answers its goals
+// only through the solver that posted the constraints. So when the engine is
+// explaining its own run, it explains through that solver; a caller with none
+// gets a fresh one, which is enough for everything that is pure resolution.
+let liveSolver = null;
+
+function hostSolver(program, registry) {
+  return liveSolver && liveSolver.program === program ? liveSolver : new Solver(program, { registry });
+}
+
 function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, detail) {
   if (depth > maxDepth) return;
 
@@ -90,7 +103,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
   // ordinary clauses, but explanations collapse its private helper expansion
   // behind an explicit library(Name, Arity) boundary.
   if (detail !== 'expanded' && group.module !== 'user' && program.modules.get(group.module)?.filename?.startsWith('src/lib/')) {
-    const solver = new Solver(program, { registry });
+    const solver = hostSolver(program, registry);
     for (const next of solver.solve([goal], env.clone(), 0)) {
       const proofEnv = next.clone ? next.clone() : next;
       yield {
@@ -199,7 +212,7 @@ function builtinDefinition(program, goal, env, registry) {
   const def = registry.get(goal.name, goal.arity);
   if (!def) return { handled: false, def: null, solver: null };
 
-  const solver = new Solver(program, { registry });
+  const solver = hostSolver(program, registry);
   if (!builtinIsUsedForGoal(def, solver, goal, env)) return { handled: false, def: null, solver: null };
   return { handled: true, def, solver };
 }
@@ -812,10 +825,18 @@ export function flattenProof(roots, program) {
 
 // The root of an answer's proof tree, for `flattenProof`.
 export function proofNodeFor(program, goal, options = {}) {
+  liveSolver = options.solver ?? null;
   const maxDepth = options.maxDepth ?? 256;
   const registry = options.registry ?? getEyePrologRegistry();
   const env = options.env ?? new Env();
   const detail = normalizeProofDetail(options.proofDetail ?? 'abstract');
-  for (const proof of proveGoalAll(program, goal, env, 0, maxDepth, registry, [], detail)) return proof.node;
+  try {
+    for (const proof of proveGoalAll(program, goal, env, 0, maxDepth, registry, [], detail)) return proof.node;
+  } catch {
+    // A replay that raises has not explained anything, and an answer the
+    // engine found should not be lost because explaining it failed. The
+    // caller records the answer as `unproven`, which says exactly that.
+    return null;
+  }
   return null;
 }

package/src/index.js

@@ -40,6 +40,7 @@ import { getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { executeForwardRules, executeGoals, hasForwardRules, normalizeGoals } from './execute.js';
 import { proofBlocks } from './result-format.js';
+import { Env, atom, termToString } from './term.js';
 
 // The public API is an entry point above the solver/registry layers, so it can
 // install pruning-aware iterator disposal without introducing an import cycle.
@@ -89,7 +90,7 @@ export function run(source, options = {}) {
         options.ioOptions?.errorWrite?.(line);
       },
     }));
-    if (includeWhy) output.push(proofBlocksFor(program, derived, runOptions.registry, options.proofDetail));
+    if (includeWhy) output.push(proofBlocksFor(program, derived, runOptions.registry, options.proofDetail, solver));
   } else {
     // A bare `?- Goal.` asks its question the same way a `%% ?-` comment
     // does; only the parser can find it, so it is picked up here.
@@ -102,7 +103,7 @@ export function run(source, options = {}) {
         claimed.push(resolved);
       },
     }));
-    if (includeWhy) output.push(proofBlocksFor(program, claimed, runOptions.registry, options.proofDetail));
+    if (includeWhy) output.push(proofBlocksFor(program, claimed, runOptions.registry, options.proofDetail, solver));
   }
   return { stdout: output.join(''), stats: solver.stats, haltCode };
 }
@@ -110,9 +111,25 @@ export function run(source, options = {}) {
 // The `clause/3` and `step/4` blocks explaining the facts a run claimed.
 // One walk across every claim, so a conclusion several of them rest on is
 // explained once.
-function proofBlocksFor(program, claimed, registry, proofDetail = 'abstract') {
-  const roots = claimed.map((fact) => proofNodeFor(program, fact, { registry, proofDetail })).filter(Boolean);
+//
+// An answer the solver found but the explanation replay cannot reproduce --
+// a CLP(B) answer decided by propagation rather than by resolution -- is
+// recorded as `unproven` rather than quietly left without a step. A document
+// containing one is not a valid proof, and saying so is the point.
+function proofBlocksFor(program, claimed, registry, proofDetail = 'abstract', solver = null) {
+  const roots = [];
+  const unexplained = [];
+  for (const fact of claimed) {
+    const node = proofNodeFor(program, fact, { registry, proofDetail, solver });
+    if (node) roots.push(node);
+    else unexplained.push(fact);
+  }
   const { clauses, steps } = flattenProof(roots, program);
+  const concluded = new Set(steps.map((step) => termToString(step.conclusion, new Env(), true)));
+  for (const fact of unexplained) {
+    if (concluded.has(termToString(fact, new Env(), true))) continue;
+    steps.push({ conclusion: fact, by: atom('unproven'), bindings: [], uses: [] });
+  }
   return proofBlocks(program, clauses, steps);
 }
 

package/test/regression/cases-regression.mjs

@@ -4338,7 +4338,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
       },
     },
     {
-      name: '--verify-proof re-performs a saved proof and rejects tampering',
+      name: '--check-proof re-performs a saved proof and rejects tampering',
       run: () => {
         const programFile = path.join(temp.dir, `proof-program-${++temp.counter}.pl`);
         const proofFile = path.join(temp.dir, `proof-certificate-${++temp.counter}.pl`);
@@ -4346,15 +4346,15 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         const generated = runCli(['--proof', programFile]);
         assertEqual(generated.status, 0, 'proof generation status');
         fs.writeFileSync(proofFile, generated.stdout);
-        const verified = runCli(['--verify-proof', proofFile, programFile]);
+        const verified = runCli(['--check-proof', proofFile, programFile]);
         assertEqual(verified.status, 0, 'verification status');
         assertEqual(verified.stdout, 'checked: 2 steps.\n', 'verification stdout');
-        const strictVerified = runCli(['--iso-strict', '--verify-proof', proofFile, programFile]);
+        const strictVerified = runCli(['--iso-strict', '--check-proof', proofFile, programFile]);
         assertEqual(strictVerified.status, 0, 'strict verification status');
         assertEqual(strictVerified.stdout, 'checked: 2 steps.\n', 'strict verification stdout');
         const tamperedFile = path.join(temp.dir, `proof-certificate-bad-${++temp.counter}.pl`);
         fs.writeFileSync(tamperedFile, generated.stdout.replace('step(p(a),', 'step(p(b),'));
-        const rejected = runCli(['--verify-proof', tamperedFile, programFile]);
+        const rejected = runCli(['--check-proof', tamperedFile, programFile]);
         assertEqual(rejected.status, 1, 'tampered verification status');
         assertIncludes(rejected.stderr, 'is not a valid proof for this program', 'tampered verification stderr');
       },

package/test/run-proof-checking.mjs

@@ -19,22 +19,37 @@ const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const examplesDir = path.join(root, 'examples');
 
 /// Proofs that do not check, and what each one exposes. An entry here is a
-/// gap in proof *generation*, not in the checker: these answers come from
-/// CLP(B) propagation, which the explanation replay cannot reproduce by
-/// resolution, so the writer records them as `unproven` and says so rather
-/// than leaving them out.
-const KNOWN_GAPS = new Map([
-  ['clpb-boolean-circuit.pl', 'a CLP(B) answer decided by propagation, not by resolution'],
-  ['clpb-cardinality.pl', 'a CLP(B) answer decided by propagation, not by resolution'],
-  ['clpb-feature-model.pl', 'a CLP(B) answer decided by propagation, not by resolution'],
-]);
+/// gap in proof *generation*, not in the checker: the explanation replay
+/// cannot reproduce the answer, so the writer records it as `unproven` and
+/// says so rather than leaving it out.
+///
+/// Explaining through the solver that produced the answer closed the three
+/// CLP(B) gaps that used to be here, so the list is empty: every packaged
+/// proof checks, and this test fails if one stops doing so.
+///
+/// The CLP(Z) examples are not in this corpus, and not because they fail:
+/// `clpz`'s goal expansion names the variables it introduces from a counter
+/// that advances across a run, so a `clause/3` record of an expanded body
+/// differs between runs and cannot be compared against a golden. Checked
+/// directly rather than through a golden, `clpz-factorial`, `clpz-n-queens`,
+/// `clpz-global-constraints` and `clpz-sudoku-9x9` all check.
+const KNOWN_GAPS = new Map([]);
+
+const totals = { steps: 0, verified: 0, trusted: 0 };
 
 export function runProofChecking(reporter = new TestReporter()) {
   reporter.section('Proof checking');
+  totals.steps = 0;
+  totals.verified = 0;
+  totals.trusted = 0;
   for (const name of [...proofExamples].sort()) {
     reporter.test(name, () => checkPackagedProof(name));
   }
   reporter.sectionTotal('proof checking');
+  // What the corpus establishes, in the terms the specification uses: a
+  // verified step was re-performed, a trusted one was recorded because
+  // re-deciding it would mean running the program.
+  reporter.section(`${totals.steps} steps, ${totals.verified} verified, ${totals.trusted} trusted`);
 }
 
 function checkPackagedProof(name) {
@@ -42,6 +57,9 @@ function checkPackagedProof(name) {
   const proof = fs.readFileSync(path.join(examplesDir, 'proof', name), 'utf8');
   const program = Program.parseSources([{ text: source, filename: name }], { sourceMetadata: true });
   const report = checkProofDocument(program, proof);
+  totals.steps += report.steps;
+  totals.verified += report.verified;
+  totals.trusted += report.trusted.length;
   const gap = KNOWN_GAPS.get(name);
   if (gap) {
     assertEqual(report.valid, false, `${name} now checks; remove it from KNOWN_GAPS (${gap})`);

package/the-art-of-eyeprolog.md

@@ -1494,7 +1494,7 @@ output is valid EyeProlog input and can be kept and checked later:
 
 ```sh
 eyeprolog --proof examples/socrates.pl > socrates.why.pl
-eyeprolog --verify-proof socrates.why.pl examples/socrates.pl
+eyeprolog --check-proof socrates.why.pl examples/socrates.pl
 ```
 
 The second command re-performs every inference the document records against
@@ -9589,7 +9589,7 @@ explicit.
 | `-h`, `--help` | Show usage |
 | `-p`, `--proof` | Print `why/2` explanations |
 | `--proof-detail abstract|expanded` | Select library abstraction for proof output; implies `--proof` |
-| `--verify-proof File` | Verify saved `why/2` proof certificates against the input program without proof search |
+| `--check-proof File` | Verify saved `why/2` proof certificates against the input program without proof search |
 | `-q`, `--quads` | Run embedded quad tests and fail if any do not hold |
 | `--quiet` | Suppress resolved answer terms while preserving Prolog output and diagnostics |
 | `--iso-strict` | Restrict parsing and execution to ISO/IEC 13211-1:1995 + Corrigenda 1–3; reject EyeProlog language extensions (including `table` and `:+`) and disable bundled-library autoloading |
@@ -9636,7 +9636,7 @@ Work in a fixed sequence:
 1. predict the ground answers before running the program;
 2. run without observation flags and compare stdout with that prediction;
 3. add `--proof` when the support for an answer is the question; save the
-   output and use `--verify-proof` when the derivation itself must cross a
+   output and use `--check-proof` when the derivation itself must cross a
    process or review boundary;
 4. add `--warnings` when portability or negative dependencies are the
    question; use `--portable` when non-profile dependencies must fail CI;
@@ -9648,7 +9648,7 @@ For example:
 eyeprolog --goal 'ancestor(X, Y)' examples/ancestor.pl
 eyeprolog --proof --goal 'type(X, Y)' examples/socrates.pl
 eyeprolog --proof examples/socrates.pl > socrates.why.pl
-eyeprolog --verify-proof socrates.why.pl examples/socrates.pl
+eyeprolog --check-proof socrates.why.pl examples/socrates.pl
 eyeprolog --warnings --goal 'answer(X)' test/conformance/warnings/negation/unstratified_mutual.pl
 eyeprolog --portable --goal 'sudoku9(S)' examples/clpz-sudoku-9x9.pl
 eyeprolog --stats --goal 'path(a, X)' examples/path-discovery.pl > answers.pl 2> run.stats