eyeprolog 1.6.19 → 1.6.21

package/examples/check/weighted-interval-scheduling.pl

@@ -3,8 +3,15 @@ condition('C2', well_founded, ok, 84).
 condition('C3', justification, ok, 84).
 condition('C4', coverage, ok, 158).
 condition('C5', re_decision, ok, 38).
-obligation(absent, theory_scoped, 4).
-obligation(builtin, theory_scoped, 5).
+obligation(absent, theory_scoped, \+ (interval(K, Startk, _finishk, _valuek), K > 8, Startk >= 11)).
+obligation(absent, theory_scoped, \+ (interval(K, Startk, _finishk, _valuek), K > 7, Startk >= 10)).
+obligation(absent, theory_scoped, \+ (interval(K, Startk, _finishk, _valuek), K > 6, Startk >= 9)).
+obligation(absent, theory_scoped, \+ (interval(K, Startk, _finishk, _valuek), K > 5, Startk >= 9)).
+obligation(builtin, theory_scoped, aggregate_min(Value, Value, (interval(Value, Startk, _finishk, _valuek), Value > 4, Startk >= 7), 8, 8)).
+obligation(builtin, theory_scoped, aggregate_min(Value, Value, (interval(Value, Startk, _finishk, _valuek), Value > 3, Startk >= 6), 7, 7)).
+obligation(builtin, theory_scoped, aggregate_min(Value, Value, (interval(Value, Startk, _finishk, _valuek), Value > 2, Startk >= 5), 6, 6)).
+obligation(builtin, theory_scoped, aggregate_min(Value, Value, (interval(Value, Startk, _finishk, _valuek), Value > 1, Startk >= 4), 4, 4)).
+obligation(builtin, theory_scoped, countall(interval(_i, _start, _finish, _value), 8)).
 steps(84).
 verified(37).
 recomputed(38).

package/examples/check/wolf-goat-cabbage.pl

@@ -3,7 +3,18 @@ condition('C2', well_founded, ok, 62).
 condition('C3', justification, ok, 62).
 condition('C4', coverage, ok, 94).
 condition('C5', re_decision, ok, 2).
-obligation(absent, theory_scoped, 12).
+obligation(absent, theory_scoped, \+ member("ewew", ["wwww"])).
+obligation(absent, theory_scoped, \+ member("wwew", ["ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("eeew", ["wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("weww", ["eeew", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("eewe", ["weww", "eeew", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("wewe", ["eewe", "weww", "eeew", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("eeee", ["wewe", "eewe", "weww", "eeew", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("ewee", ["wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("wwwe", ["ewee", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("eewe", ["wwwe", "ewee", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("wewe", ["eewe", "wwwe", "ewee", "wwew", "ewew", "wwww"])).
+obligation(absent, theory_scoped, \+ member("eeee", ["wewe", "eewe", "wwwe", "ewee", "wwew", "ewew", "wwww"])).
 steps(62).
 verified(48).
 recomputed(2).

package/examples/check/workplace-compliance.pl

@@ -3,7 +3,8 @@ condition('C2', well_founded, ok, 15).
 condition('C3', justification, ok, 15).
 condition('C4', coverage, ok, 15).
 condition('C5', re_decision, ok, 0).
-obligation(absent, theory_scoped, 2).
+obligation(absent, theory_scoped, \+ does(alice, work_related_task)).
+obligation(absent, theory_scoped, \+ does(dave, log_off_at_end_of_shift)).
 steps(15).
 verified(13).
 recomputed(0).

package/examples/evidence-demand-authority.pl

@@ -0,0 +1,103 @@
+% An authority demands evidence, then withdraws the demand as one it was never
+% permitted to make. Three questions survive the withdrawal, and none of them
+% is answered by "never mind": was the status ever at risk, may the missed
+% deadline count against the holder, and what becomes of evidence that was
+% handed over while the demand still looked binding?
+%
+% The case is modelled so that each of those is a separate query with its own
+% derivation, because they have different answers. Withdrawing a demand settles
+% the first. It does not by itself settle the other two.
+%
+% The reasoning rests on one distinction the engine takes seriously elsewhere:
+% not proving something is not the same as disproving it. The holder never
+% showed they still met the conditions. That is not a finding that they did
+% not, and a ground for termination needs the finding, not the silence.
+
+:- dynamic(breached/2).
+
+%% ?- demand_validity(X0, X1).
+
+%% ?- termination_ground(X0, X1).
+
+%% ?- admissible(X0, X1).
+
+%% ?- holder_status(X0, X1).
+
+
+% What the authority may ask for at all. A power is granted for a purpose; a
+% demand outside it is not a weaker demand, it is not a demand.
+may_demand(authority, evidence_of(criminal_record)).
+may_demand(authority, evidence_of(identity)).
+
+% What was actually demanded, and under what deadline.
+demanded(authority, holder, evidence_of(continued_conditions), deadline(30)).
+withdrawn(authority, evidence_of(continued_conditions), reason(not_permitted_to_ask)).
+
+% What happened. The holder let the deadline pass, and separately had already
+% sent one document while the demand still appeared to bind.
+elapsed(deadline(30)).
+produced(holder, document(tenancy_record), under(evidence_of(continued_conditions))).
+
+% The conditions of the status itself, and what is actually known about them.
+condition_of_status(lawful_residence).
+condition_of_status(no_relevant_conviction).
+
+% Breaches are recorded here. The relation is declared and empty: no breach is
+% known. Declaring it says that much -- asking whether a breach is recorded is
+% a question with an answer, and the answer is no. Leaving it undeclared would
+% instead make the question an error, which is a different thing from silence.
+
+
+% A demand is valid only if it falls within a granted power.
+demand_validity(Subject, valid) :-
+  demanded(authority, _, Subject, _),
+  may_demand(authority, Subject).
+
+demand_validity(Subject, invalid(outside_granted_power)) :-
+  demanded(authority, _, Subject, _),
+  \+ may_demand(authority, Subject).
+
+
+% A missed deadline is a ground for termination only when the demand it
+% attached to was one the authority could make. Against an invalid demand the
+% silence carries nothing, whether or not the demand was later withdrawn --
+% the withdrawal records the defect, it does not create it.
+termination_ground(missed_deadline(Subject), available) :-
+  demanded(authority, holder, Subject, Deadline),
+  elapsed(Deadline),
+  demand_validity(Subject, valid).
+
+termination_ground(missed_deadline(Subject), unavailable(demand_was_invalid)) :-
+  demanded(authority, holder, Subject, Deadline),
+  elapsed(Deadline),
+  demand_validity(Subject, invalid(_)).
+
+% A breach of an actual condition would be a ground. None is recorded, and the
+% absence of a record is not a breach, so this rule derives nothing here. It is
+% written out so the proof shows which ground was looked for and not found.
+termination_ground(breach(Condition), available) :-
+  condition_of_status(Condition),
+  breached(holder, Condition).
+
+
+% Evidence handed over under a demand that could not be made does not become
+% usable because it was handed over. The defect is in the asking, so it reaches
+% everything the asking produced.
+admissible(document(D), no(obtained_under_invalid_demand)) :-
+  produced(holder, document(D), under(Subject)),
+  demand_validity(Subject, invalid(_)).
+
+admissible(document(D), yes) :-
+  produced(holder, document(D), under(Subject)),
+  demand_validity(Subject, valid).
+
+
+% The status stands unless some ground for ending it is available.
+holder_status(status, retained) :-
+  \+ available_ground.
+
+holder_status(status, terminated) :-
+  available_ground.
+
+available_ground :-
+  termination_ground(_, available).

package/examples/output/evidence-demand-authority.pl

@@ -0,0 +1,4 @@
+demand_validity(evidence_of(continued_conditions), invalid(outside_granted_power)).
+termination_ground(missed_deadline(evidence_of(continued_conditions)), unavailable(demand_was_invalid)).
+admissible(document(tenancy_record), no(obtained_under_invalid_demand)).
+holder_status(status, retained).

package/examples/proof/evidence-demand-authority.pl

@@ -0,0 +1,53 @@
+demand_validity(evidence_of(continued_conditions), invalid(outside_granted_power)).
+termination_ground(missed_deadline(evidence_of(continued_conditions)), unavailable(demand_was_invalid)).
+admissible(document(tenancy_record), no(obtained_under_invalid_demand)).
+holder_status(status, retained).
+
+clause(4, demanded(authority, holder, evidence_of(continued_conditions), deadline(30)), true).
+clause(6, elapsed(deadline(30)), true).
+clause(7,
+       produced(holder, document(tenancy_record), under(evidence_of(continued_conditions))),
+       true).
+clause(11,
+       demand_validity(var('Subject'), invalid(outside_granted_power)),
+       (demanded(authority, anonymous(1), var('Subject'), anonymous(2)),
+        \+ may_demand(authority, var('Subject')))).
+clause(13,
+       termination_ground(missed_deadline(var('Subject')), unavailable(demand_was_invalid)),
+       (demanded(authority, holder, var('Subject'), var('Deadline')),
+        elapsed(var('Deadline')),
+        demand_validity(var('Subject'), invalid(anonymous(1))))).
+clause(15,
+       admissible(document(var('D')), no(obtained_under_invalid_demand)),
+       (produced(holder, document(var('D')), under(var('Subject'))),
+        demand_validity(var('Subject'), invalid(anonymous(1))))).
+clause(17, holder_status(status, retained), \+ available_ground).
+
+step(demand_validity(evidence_of(continued_conditions), invalid(outside_granted_power)),
+     rule(11),
+     ['Subject' = evidence_of(continued_conditions)],
+     [demanded(authority, holder, evidence_of(continued_conditions), deadline(30)),
+      \+ may_demand(authority, evidence_of(continued_conditions))]).
+step(demanded(authority, holder, evidence_of(continued_conditions), deadline(30)),
+     fact(4),
+     [],
+     []).
+step(\+ may_demand(authority, evidence_of(continued_conditions)), absent, [], []).
+step(termination_ground(missed_deadline(evidence_of(continued_conditions)), unavailable(demand_was_invalid)),
+     rule(13),
+     ['Subject' = evidence_of(continued_conditions), 'Deadline' = deadline(30)],
+     [demanded(authority, holder, evidence_of(continued_conditions), deadline(30)),
+      elapsed(deadline(30)),
+      demand_validity(evidence_of(continued_conditions), invalid(outside_granted_power))]).
+step(elapsed(deadline(30)), fact(6), [], []).
+step(admissible(document(tenancy_record), no(obtained_under_invalid_demand)),
+     rule(15),
+     ['D' = tenancy_record, 'Subject' = evidence_of(continued_conditions)],
+     [produced(holder, document(tenancy_record), under(evidence_of(continued_conditions))),
+      demand_validity(evidence_of(continued_conditions), invalid(outside_granted_power))]).
+step(produced(holder, document(tenancy_record), under(evidence_of(continued_conditions))),
+     fact(7),
+     [],
+     []).
+step(holder_status(status, retained), rule(17), [], [\+ available_ground]).
+step(\+ available_ground, absent, [], []).

package/package.json

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

package/playground.html

@@ -522,6 +522,7 @@
           "equivalence-classes-overlap-implies-same-class",
           "eulerian-path",
           "ev-range-worlds",
+          "evidence-demand-authority",
           "existential-rule",
           "exoplanet-validation-worlds",
           "explainable-ev-depot-configuration",

package/src/check-proof.js

@@ -39,6 +39,7 @@
 import { ATOM, COMPOUND, Env, compareTerms, copyResolved, freshTerm, properListItems, termToString, unify } from './term.js';
 import { parseProgramText } from './parser.js';
 import { clauseNumbering } from './explain.js';
+import { formatTermForWrite } from './write.js';
 import { Program, autoloadProgramGoals } from './program.js';
 import { Solver } from './solver.js';
 
@@ -345,7 +346,7 @@ export function checkProofDocument(program, text) {
     if (REDECIDED.has(justification.kind)) {
       const reason = notRedecidableReason(step.conclusion);
       if (reason) {
-        trusted.push({ kind: justification.kind, conclusion: key(step.conclusion), reason });
+        trusted.push({ kind: justification.kind, conclusion: key(step.conclusion), term: step.conclusion, reason });
         continue;
       }
       const outcome = redecide(step.conclusion);
@@ -376,12 +377,12 @@ export function checkProofDocument(program, text) {
           continue;
         }
         // Nothing was learned about this step, so it is still an obligation.
-        trusted.push({ kind: justification.kind, conclusion: key(step.conclusion), reason: 'theory_scoped' });
+        trusted.push({ kind: justification.kind, conclusion: key(step.conclusion), term: step.conclusion, reason: 'theory_scoped' });
       }
       continue;
     }
     if (TRUSTED.has(justification.kind)) {
-      trusted.push({ kind: justification.kind, conclusion: key(step.conclusion) });
+      trusted.push({ kind: justification.kind, conclusion: key(step.conclusion), term: step.conclusion });
       continue;
     }
 
@@ -429,6 +430,8 @@ export function checkProofDocument(program, text) {
   ];
 
   return {
+    writeOptions: { doubleQuotes: program?.doubleQuotes ?? 'chars', doubleBar: true, quoted: true,
+      operators: [...(program?.operators?.values() ?? [])] },
     valid: failures.length === 0,
     steps: steps.length,
     verified,
@@ -454,7 +457,9 @@ export function checkProofDocument(program, text) {
 //   steps/1 verified/1 recomputed/1 trusted/1 claims/1
 //   verdict(checked | checked_with_obligations | failed(N))
 export function checkReportTerms(report) {
-  const options = { quoted: true };
+  // Write terms the way the proof under check writes them, so `\\+ G` is not
+  // spelled `'\\\\+'(G)` here and the two documents stay comparable by eye.
+  const options = report.writeOptions ?? { quoted: true };
   const out = [];
   const say = (line) => out.push(line);
 
@@ -465,20 +470,20 @@ export function checkReportTerms(report) {
 
   for (const failure of report.failures ?? []) {
     const conclusion = failure.term != null
-      ? termToString(failure.term, new Env(), true, options)
+      ? formatTermForWrite(failure.term, new Env(), options)
       : quotedAtom(failure.conclusion);
     say(`failure('${failure.condition}', ${conclusion}, ${quotedAtom(failure.detail)}).`);
   }
 
-  const groups = new Map();
+  // One fact per obligation, naming the conclusion itself. A count would say
+  // how much the check rests on without saying what, and what it rests on is
+  // the part a reader -- or a later program -- has to weigh. The total is in
+  // trusted/1 below.
   for (const item of report.trusted ?? []) {
-    const reason = item.reason ?? 'theory_scoped';
-    const groupKey = `${item.kind}\u0000${reason}`;
-    groups.set(groupKey, (groups.get(groupKey) ?? 0) + 1);
-  }
-  for (const [groupKey, count] of groups) {
-    const [kind, reason] = groupKey.split('\u0000');
-    say(`obligation(${kind}, ${reason}, ${count}).`);
+    const conclusion = item.term != null
+      ? formatTermForWrite(item.term, new Env(), options)
+      : quotedAtom(item.conclusion);
+    say(`obligation(${item.kind}, ${item.reason ?? 'theory_scoped'}, ${conclusion}).`);
   }
 
   say(`steps(${report.steps}).`);

package/src/cli.js

@@ -422,7 +422,9 @@ Options:
                         that calls a library. (implies --proof)
   --check-proof file    Check a saved proof document against the input program
                         and write the result as Prolog facts: condition/4 per
-                        condition, failure/3, obligation/3, and verdict/1.
+                        condition, failure/3 for what did not hold, one
+                        obligation/3 naming each conclusion the check rests on,
+                        and verdict/1.
                         Use - to read the proof from stdin, for example
                         eyeprolog --proof p.pl | eyeprolog --check-proof - p.pl
   -q, --quads           Run embedded quad tests and fail if any do not hold.