eyeprolog 1.5.24 → 1.5.25

package/examples/odrl-policy-reasoning.pl

@@ -345,11 +345,11 @@ profile_prohibition(Request) :-
   cycle_request(Request),
   tnot(profile_permission(Request)).
 
-% For a ground WFS claim, both Claim and tnot(Claim) conditionally succeed when
-% the truth value is undefined.  That lets this example expose all three states.
+% For a ground WFS claim, true and false are successful positive and negative
+% probes.  If neither probe succeeds, the WFS truth value is undefined.
 wfs_truth(Claim, true) :- call(Claim), \+ tnot(Claim).
 wfs_truth(Claim, false) :- tnot(Claim), \+ call(Claim).
-wfs_truth(Claim, undefined) :- call(Claim), tnot(Claim).
+wfs_truth(Claim, undefined) :- \+ call(Claim), \+ tnot(Claim).
 
 % --- Curated questions -----------------------------------------------------
 

package/index.d.ts

@@ -1,7 +1,7 @@
 export interface EyePrologStats {
   /** Alternating-fixed-point rounds used to build WFS models. */
   wfs_fixpoint_rounds: number;
-  /** Undefined WFS answers observed while producing query results. */
+  /** Undefined WFS atoms encountered while resolving query goals. */
   wfs_undefined_answers: number;
   [key: string]: number;
 }

package/package.json

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

package/src/solver.js

@@ -909,7 +909,10 @@ export class Solver {
         if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
       }
       if (!ok) continue;
-      if (!lower?.has(row)) this.stats.wfs_undefined_answers++;
+      if (!lower?.has(row)) {
+        this.stats.wfs_undefined_answers++;
+        continue;
+      }
       yield* this.solve(rest, next, depth + 1);
       if (this.solutionsSeen >= this.solutionLimit) return;
     }
@@ -927,7 +930,10 @@ export class Solver {
       const model = this.wfsModelFor(group);
       const truth = truthOfGroundGoal(model, invoked);
       if (truth === 'true') return;
-      if (truth === 'undefined') this.stats.wfs_undefined_answers++;
+      if (truth === 'undefined') {
+        this.stats.wfs_undefined_answers++;
+        return;
+      }
       yield env;
       return;
     }
@@ -1523,7 +1529,10 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
       if (!unify(goal.args[i], row[i], next)) { ok = false; break; }
     }
     if (!ok) continue;
-    if (!lower?.has(row)) solver.stats.wfs_undefined_answers++;
+    if (!lower?.has(row)) {
+      solver.stats.wfs_undefined_answers++;
+      continue;
+    }
     stack.push({ kind: 'goals', goals: rest, env: next, depth: depth + 1, active });
   }
 }

package/test/run-regression.mjs

@@ -7782,9 +7782,9 @@ win(X) :- move(X, Y), tnot(win(Y)).
         assertEqual(program.findGroup('win', 1).wfsDatalog, true, 'win/1 uses finite WFS evaluation');
         assertEqual(program.findGroup('win', 1).tabled, false, 'win/1 is not positive least-model tabled');
         const result = run(program, { goal: 'win(X)' });
-        assertEqual(result.stdout.trim().split('\n').length, 4, 'negative cycle yields four conditional WFS answers');
+        assertEqual(result.stdout, '', 'negative cycle does not expose undefined atoms as successful answers');
         assertEqual(result.stats.wfs_fixpoint_rounds, 2, 'alternating fixed point converges in two rounds');
-        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle answers are undefined rather than unconditional truths');
+        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle atoms are observed as undefined rather than unconditional truths');
 
         const nafProgram = Program.parse('p(X) :- \\+ q(X).\nq(X) :- p(X).\n');
         assertEqual(nafProgram.findGroup('p', 1).wfsDatalog, false, '\\+/1 remains ordinary negation as failure');
@@ -7804,7 +7804,23 @@ undefined_case :- tnot(win(c)).
 `;
         assertEqual(run(source, { goal: 'true_case' }).stdout, 'true_case.\n', 'win(a) is true because b is false');
         assertEqual(run(source, { goal: 'false_case' }).stdout, '', 'tnot(win(a)) fails for a true atom');
-        assertEqual(run(source, { goal: 'undefined_case' }).stdout, 'undefined_case.\n', 'tnot of an undefined WFS atom is a conditional success');
+        assertEqual(run(source, { goal: 'undefined_case' }).stdout, '', 'tnot of an undefined WFS atom is not a successful answer');
+      },
+    },
+    {
+      name: 'undefined WFS goals do not run continuations or print CLI answers',
+      run: () => {
+        const source = `
+:- use_module(library(tabling)).
+:- table(a/0).
+:- table(b/0).
+a :- tnot(b).
+b :- tnot(a).
+`;
+        const result = run(source, { goal: 'a, write(true), nl; halt' });
+        assertEqual(result.stdout, '', 'undefined first branch neither writes nor produces a ground answer');
+        assertEqual(result.haltCode, 0, 'fallback halt branch runs');
+        assertEqual(result.stats.wfs_undefined_answers, 1, 'undefined atom remains observable in statistics');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1144,8 +1144,9 @@ win(X) :- move(X, Y), tnot(win(Y)).
 ```
 
 Here neither `win(a)` nor `win(b)` is unconditionally established; both belong
-to the undefined part of the well-founded model. EyeProlog exposes undefined
-WFS answers as conditional successes, including inside finite collectors.
+to the undefined part of the well-founded model. EyeProlog retains that state
+internally but does not expose undefined atoms as successful query answers or
+run the remaining goals of a conjunction through them.
 Direct calls to `tnot/1` must be ground. In WFS rules, variables occurring in
 the head or a negated literal must be range-restricted by positive body
 literals. Ordinary `\+/1` is unchanged, and strict ISO mode does not provide
@@ -1664,8 +1665,8 @@ The reported counters include completed goal lists, calls to the goal solver
 and single-goal solver, unification attempts, maximum depth and goal-list size,
 deterministic built-in successes and failures, and table fixed-point rounds.
 WFS execution additionally reports `wfs_fixpoint_rounds` and
-`wfs_undefined_answers`. The latter counts undefined-answer observations made
-while producing query results; it is an execution statistic, not a declaration
+`wfs_undefined_answers`. The latter counts undefined atoms encountered while
+resolving query goals; it is an execution statistic, not a declaration
 that those atoms are true. All statistics describe work performed, not logical
 truth. Compare counters only across equivalent queries and the same
 implementation version.