eyeprolog 1.6.15 → 1.6.16

package/package.json

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

package/src/check-proof.js

@@ -351,8 +351,10 @@ export function checkProofDocument(program, text) {
       failures.push({ condition: 'C4', conclusion: key(claim), detail: 'claimed, but no step concludes it' });
     }
   }
+  let uses = 0;
   for (const step of steps) {
     for (const use of step.uses) {
+      uses++;
       if (byConclusion.has(key(use)) || given.has(key(use))) continue;
       failures.push({ condition: 'C4', conclusion: key(step.conclusion), detail: `uses ${key(use)}, which nothing concludes and the program does not give` });
     }
@@ -360,7 +362,57 @@ export function checkProofDocument(program, text) {
 
   checkWellFounded(byConclusion, failures);
 
-  return { valid: failures.length === 0, steps: steps.length, verified, redecided, trusted, failures, claims: claims.length };
+  const failed = (condition) => failures.filter((failure) => failure.condition === condition).length;
+  // What each condition covered, so a reader can see the shape of the check
+  // rather than only its verdict. A condition that examined nothing says so:
+  // "0 steps" is information, not a pass.
+  const conditions = [
+    { id: 'C1', name: 'Resolution', covered: verified, failed: failed('C1'),
+      summary: `${verified} step(s) re-performed against the source clause they cite` },
+    { id: 'C2', name: 'Well-founded', covered: steps.length, failed: failed('C2'),
+      summary: `${steps.length} step(s) checked for a conclusion resting on its own derivation` },
+    { id: 'C3', name: 'Justification', covered: steps.length, failed: failed('C3'),
+      summary: `${steps.length} step(s) carrying exactly one known justification` },
+    { id: 'C4', name: 'Coverage', covered: claims.length + uses, failed: failed('C4'),
+      summary: `${claims.length} claim(s) and ${uses} use(s) resolved to a step or to a statement the program gives` },
+    { id: 'C5', name: 'Re-decision', covered: redecided, failed: failed('C5'),
+      summary: `${redecided} step(s) recomputed against a program holding no clause of the theory` },
+  ];
+
+  return {
+    valid: failures.length === 0,
+    steps: steps.length,
+    verified,
+    redecided,
+    uses,
+    trusted,
+    failures,
+    claims: claims.length,
+    conditions,
+  };
+}
+
+// The condition-by-condition account, as lines. The obligations are listed
+// under C5 because that is the condition they escaped: a step recorded as
+// `builtin` that recomputation could not decide, or one whose justification
+// puts it outside recomputation altogether.
+export function conditionReport(report) {
+  const lines = [];
+  for (const condition of report.conditions ?? []) {
+    const mark = condition.failed > 0 ? `${condition.failed} failure(s)` : 'ok';
+    lines.push(`  ${condition.id} ${condition.name.padEnd(13)} ${mark.padEnd(14)} ${condition.summary}`);
+  }
+  const obligations = report.trusted ?? [];
+  if (obligations.length > 0) {
+    const byReason = new Map();
+    for (const item of obligations) {
+      const reason = item.reason ?? item.kind;
+      byReason.set(reason, (byReason.get(reason) ?? 0) + 1);
+    }
+    const parts = [...byReason].map(([reason, count]) => `${count} ${reason}`).join(', ');
+    lines.push(`  -- ${obligations.length} obligation(s) the check rests on rather than establishes: ${parts}`);
+  }
+  return lines;
 }
 
 // The program's clauses, numbered from 1 in load order -- the numbering

package/src/cli.js

@@ -252,16 +252,20 @@ export async function main(argv) {
   }
 
   if (options.checkProof != null) {
-    const { checkProofDocument, verdict } = await import('./check-proof.js');
+    const { checkProofDocument, conditionReport, verdict } = await import('./check-proof.js');
     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.checkProof}`);
     if (!report.valid) {
+      // The conditions go to stderr alongside the failures, so a failing run
+      // still says which of the five objected and which held.
+      for (const line of conditionReport(report)) process.stderr.write(`${line}\n`);
       for (const failure of report.failures.slice(0, 5)) {
         process.stderr.write(`  [${failure.condition}] ${failure.conclusion} -- ${failure.detail}\n`);
       }
       throw new Error(`${options.checkProof} is not a valid proof for this program: ${report.failures.length} failure(s)`);
     }
+    if (!options.quiet) for (const line of conditionReport(report)) process.stdout.write(`${line}\n`);
     process.stdout.write(`${verdict(report)}.\n`);
     return;
   }
@@ -396,7 +400,10 @@ Input:
 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).
+  --proof-detail mode   abstract stops at a bundled library predicate and records
+                        it as one builtin step; expanded explains through it,
+                        as ordinary source steps. Only differs for a program
+                        that calls a library. (implies --proof)
   --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.

package/test/regression/cases-regression.mjs

@@ -4348,15 +4348,28 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         fs.writeFileSync(proofFile, generated.stdout);
         const verified = runCli(['--check-proof', proofFile, programFile]);
         assertEqual(verified.status, 0, 'verification status');
-        assertEqual(verified.stdout, 'checked: 2 steps.\n', 'verification stdout');
+        // The run accounts for all five conditions and then gives its verdict,
+        // so a reader sees which conditions the result rests on rather than
+        // only that it passed.
+        for (const condition of ['C1 Resolution', 'C2 Well-founded', 'C3 Justification', 'C4 Coverage', 'C5 Re-decision']) {
+          assertIncludes(verified.stdout, condition, `verification reports ${condition}`);
+        }
+        assertEqual(verified.stdout.trimEnd().split('\n').pop(), 'checked: 2 steps.', 'verification verdict');
+        assertEqual(verified.stdout.includes('obligation'), false, 'nothing was left trusted');
+        const quiet = runCli(['--quiet', '--check-proof', proofFile, programFile]);
+        assertEqual(quiet.stdout, 'checked: 2 steps.\n', 'quiet verification stdout is the verdict alone');
         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');
+        assertEqual(strictVerified.stdout.trimEnd().split('\n').pop(), 'checked: 2 steps.', 'strict verification verdict');
         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(['--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');
+        // A failing run still accounts for every condition, so the report says
+        // which one objected rather than only that something did.
+        assertIncludes(rejected.stderr, 'C1 Resolution', 'tampered run still reports the conditions');
+        assertIncludes(rejected.stderr, 'failure(s)', 'tampered run marks the objecting condition');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1538,10 +1538,14 @@ Checking re-performs each step against the clause it cites: the clause must
 exist, its variables bound as the step recorded them must yield exactly this
 conclusion from exactly these uses, every claim must have a step, every use
 must resolve to a step or to a statement the program gives, and no conclusion
-may rest on itself. `builtin`, `absent`, `collected` and `asserted` steps are
-trusted rather than checked — deciding them again would mean running the
-program, which is what a checker must not do — and the report says how many
-there were rather than folding them into an undifferentiated success. An
+may rest on itself. A `builtin` step derives from no clause, so reading the
+document cannot decide it; it is computed again instead, against a program
+holding the bundled libraries and no clause of the theory under proof, and
+must agree. `absent`, `collected` and `asserted` steps stay trusted: the first
+two range over the theory that recomputation deliberately excludes, and a
+clause asserted at run time is in no source file to check against. The report
+counts what was verified, what was recomputed, and what remains an obligation
+rather than folding them into an undifferentiated success. An
 answer the solver found but the explanation cannot reproduce is recorded as
 `unproven`, which makes the document fail its check, because that is the
 truth about it.