eyeprolog 1.6.6 → 1.6.7

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

@@ -39,3 +39,4 @@ 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), unproven, [], []).

package/examples/proof/clpb-cardinality.pl

@@ -1,3 +1,7 @@
 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).
+
+step(review_quorum(selection(alice(0), bob(0), carol(1), dan(1))), unproven, [], []).
+step(review_quorum(selection(alice(0), bob(1), carol(1), dan(0))), unproven, [], []).
+step(review_quorum_count(2), unproven, [], []).

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

@@ -52,3 +52,4 @@ 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), unproven, [], []).

package/package.json

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

package/src/cli.js

@@ -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 });
+        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;

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.
@@ -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.
+//
+// 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') {
-  const roots = claimed.map((fact) => proofNodeFor(program, fact, { registry, proofDetail })).filter(Boolean);
+  const roots = [];
+  const unexplained = [];
+  for (const fact of claimed) {
+    const node = proofNodeFor(program, fact, { registry, proofDetail });
+    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/run-proof-checking.mjs

@@ -29,12 +29,21 @@ const KNOWN_GAPS = new Map([
   ['clpb-feature-model.pl', 'a CLP(B) answer decided by propagation, not by resolution'],
 ]);
 
+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 +51,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})`);