eyeprolog 1.3.4 → 1.3.7

package/src/standard-library.js

@@ -129,6 +129,10 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 // modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
 export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext']);
 
+function* tabledNegationBuiltin({ solver, goal, env }) {
+  yield* solver.solveTabledNegation(goal.args[0], env);
+}
+
 function runtimeStatistics(solver) {
   return { ...solver.stats, ...memoryStatistics() };
 }
@@ -167,6 +171,7 @@ export function createEyePrologRegistry() {
   const registry = createDefaultRegistry();
   registry.add('statistics', 0, statisticsBuiltin, { deterministic: true });
   registry.add('statistics', 2, statisticsValueBuiltin);
+  registry.add('tnot', 1, tabledNegationBuiltin, { deterministic: true });
   eyePrologLibraryBuiltins.register(registry);
   clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;

package/src/term.js

@@ -82,7 +82,7 @@ export const compactVariableList = (length, variablePrefix) => {
   return size === 0n ? emptyList() : new CompactListTerm(size, variablePrefix);
 };
 export const isCompactList = (term) => term instanceof CompactListTerm;
-export const compactListLength = (term) => isCompactList(term) ? term._compactLength : null;
+export const compactListLength = (term) => typeof term?._compactLength === 'bigint' ? term._compactLength : null;
 
 export class Env {
   constructor(bindings) {

package/src/wfs.js

@@ -0,0 +1,338 @@
+// Finite Datalog well-founded semantics (WFS) evaluator.
+//
+// This module deliberately targets the function-free, range-restricted subset
+// marked by Program#markRecursivePredicates as group.wfsDatalog.  It uses the
+// alternating-fixpoint characterization of WFS: starting from an upper bound on
+// possible atoms, repeatedly compute the least model of the Gelfond-Lifschitz
+// reduct.  The final lower relation contains unconditional truths; the final
+// upper relation contains truths plus undefined (conditional) answers.
+//
+// Keeping this separate from ordinary \+/1 is intentional.  Only explicit
+// tnot/1 participates in WFS, matching the common tabled-negation convention.
+
+import { ATOM, COMPOUND, VAR } from './term.js';
+import { numberValueKey } from './number-value.js';
+
+function predicateKey(module, name, arity) {
+  return `${module ?? 'user'}:${name}/${arity}`;
+}
+
+function scalarKey(term) {
+  if (term.type === 'number') return `number\u0000${numberValueKey(term.name)}`;
+  return `${term.type}\u0000${term.name}`;
+}
+
+function sameScalar(left, right) {
+  return scalarKey(left) === scalarKey(right);
+}
+
+function tupleKey(tuple) {
+  return tuple.map(scalarKey).join('\u0001');
+}
+
+class Relation {
+  constructor(arity) {
+    this.arity = arity;
+    this.rows = [];
+    this.keys = new Set();
+    this.indexes = Array.from({ length: arity }, () => new Map());
+  }
+
+  add(tuple) {
+    const key = tupleKey(tuple);
+    if (this.keys.has(key)) return false;
+    const rowIndex = this.rows.length;
+    this.keys.add(key);
+    this.rows.push(tuple);
+    for (let i = 0; i < tuple.length; i++) {
+      const keyPart = scalarKey(tuple[i]);
+      let bucket = this.indexes[i].get(keyPart);
+      if (!bucket) {
+        bucket = [];
+        this.indexes[i].set(keyPart, bucket);
+      }
+      bucket.push(rowIndex);
+    }
+    return true;
+  }
+
+  has(tuple) {
+    return this.keys.has(tupleKey(tuple));
+  }
+
+  candidateIndexes(args, bindings) {
+    let selected = null;
+    for (let i = 0; i < args.length; i++) {
+      const value = resolvePatternTerm(args[i], bindings);
+      if (value == null) continue;
+      const bucket = this.indexes[i].get(scalarKey(value)) ?? EMPTY_ARRAY;
+      if (selected == null || bucket.length < selected.length) selected = bucket;
+      if (selected.length === 0) break;
+    }
+    return selected ?? null;
+  }
+}
+
+const EMPTY_ARRAY = Object.freeze([]);
+
+function emptyRelations(groups) {
+  const relations = new Map();
+  for (const group of groups) {
+    relations.set(predicateKey(group.module, group.name, group.arity), new Relation(group.arity));
+  }
+  return relations;
+}
+
+function copyBaseRelations(base, groups) {
+  const relations = emptyRelations(groups);
+  for (const [key, relation] of base) {
+    const target = relations.get(key);
+    if (!target) continue;
+    for (const row of relation.rows) target.add(row);
+  }
+  return relations;
+}
+
+function directLiteral(goal, module) {
+  if (goal?.type !== COMPOUND && goal?.type !== ATOM) return null;
+  return {
+    key: predicateKey(goal.module ?? module, goal.name, goal.arity),
+    name: goal.name,
+    arity: goal.arity,
+    module: goal.module ?? module,
+    args: goal.args ?? EMPTY_ARRAY,
+  };
+}
+
+function negativeLiteral(goal, module) {
+  if (goal?.type !== COMPOUND || goal.name !== 'tnot' || goal.arity !== 1) return null;
+  return directLiteral(goal.args[0], module);
+}
+
+function dependencyCone(program, rootGroup) {
+  const groups = [];
+  const seen = new Set();
+  const stack = [rootGroup];
+  while (stack.length > 0) {
+    const group = stack.pop();
+    const key = predicateKey(group.module, group.name, group.arity);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    groups.push(group);
+
+    for (const clause of group.clauses) {
+      for (const goal of clause.body) {
+        const neg = negativeLiteral(goal, group.module);
+        const literal = neg ?? directLiteral(goal, group.module);
+        if (!literal) continue;
+        const target = program.findGroup(literal.name, literal.arity, literal.module);
+        if (target) stack.push(target);
+      }
+    }
+  }
+  return groups;
+}
+
+function compileProgram(program, rootGroup) {
+  const groups = dependencyCone(program, rootGroup);
+  const base = emptyRelations(groups);
+  const rules = [];
+
+  for (const group of groups) {
+    const headKey = predicateKey(group.module, group.name, group.arity);
+    for (const clause of group.clauses) {
+      if (clause.body.length === 0) {
+        const tuple = clause.head.args ?? EMPTY_ARRAY;
+        // Program analysis already guarantees ground scalar facts in the WFS
+        // cone. Keep the guard so malformed dynamic input cannot corrupt a model.
+        if (tuple.every((term) => term.type !== VAR && (term.type === ATOM || term.type === 'number' || term.type === 'string'))) {
+          base.get(headKey)?.add(tuple);
+        }
+        continue;
+      }
+
+      const positives = [];
+      const negatives = [];
+      for (const goal of clause.body) {
+        const neg = negativeLiteral(goal, group.module);
+        if (neg) negatives.push(neg);
+        else {
+          const pos = directLiteral(goal, group.module);
+          if (pos) positives.push(pos);
+        }
+      }
+      rules.push({
+        head: {
+          key: headKey,
+          args: clause.head.args ?? EMPTY_ARRAY,
+        },
+        positives,
+        negatives,
+      });
+    }
+  }
+
+  return { groups, base, rules };
+}
+
+function resolvePatternTerm(term, bindings) {
+  if (term.type === VAR) return bindings.get(term.name) ?? null;
+  return term;
+}
+
+function matchTuple(args, tuple, bindings) {
+  let next = null;
+  for (let i = 0; i < args.length; i++) {
+    const pattern = args[i];
+    if (pattern.type === VAR) {
+      const current = (next ?? bindings).get(pattern.name);
+      if (current != null) {
+        if (!sameScalar(current, tuple[i])) return null;
+      } else {
+        if (next == null) next = new Map(bindings);
+        next.set(pattern.name, tuple[i]);
+      }
+      continue;
+    }
+    if (!sameScalar(pattern, tuple[i])) return null;
+  }
+  return next ?? bindings;
+}
+
+function estimateLiteral(literal, relation, bindings) {
+  const candidates = relation.candidateIndexes(literal.args, bindings);
+  return candidates == null ? relation.rows.length : candidates.length;
+}
+
+function forEachPositiveBinding(positives, relations, callback, bindings = new Map(), remaining = null) {
+  if (remaining == null) remaining = positives.map((_, index) => index);
+  if (remaining.length === 0) {
+    callback(bindings);
+    return;
+  }
+
+  let bestPos = 0;
+  let bestEstimate = Infinity;
+  for (let position = 0; position < remaining.length; position++) {
+    const literal = positives[remaining[position]];
+    const relation = relations.get(literal.key);
+    const estimate = relation ? estimateLiteral(literal, relation, bindings) : 0;
+    if (estimate < bestEstimate) {
+      bestEstimate = estimate;
+      bestPos = position;
+      if (estimate === 0) return;
+    }
+  }
+
+  const literalIndex = remaining[bestPos];
+  const literal = positives[literalIndex];
+  const relation = relations.get(literal.key);
+  if (!relation) return;
+  const candidates = relation.candidateIndexes(literal.args, bindings);
+  const nextRemaining = remaining.length === 1
+    ? EMPTY_ARRAY
+    : [...remaining.slice(0, bestPos), ...remaining.slice(bestPos + 1)];
+
+  if (candidates == null) {
+    for (let rowIndex = 0; rowIndex < relation.rows.length; rowIndex++) {
+      const next = matchTuple(literal.args, relation.rows[rowIndex], bindings);
+      if (next) forEachPositiveBinding(positives, relations, callback, next, nextRemaining);
+    }
+    return;
+  }
+  for (const rowIndex of candidates) {
+    const next = matchTuple(literal.args, relation.rows[rowIndex], bindings);
+    if (next) forEachPositiveBinding(positives, relations, callback, next, nextRemaining);
+  }
+}
+
+function instantiateTuple(args, bindings) {
+  const tuple = [];
+  for (const arg of args) {
+    const value = arg.type === VAR ? bindings.get(arg.name) : arg;
+    if (value == null || value.type === VAR) return null;
+    tuple.push(value);
+  }
+  return tuple;
+}
+
+function blockedByNegative(negatives, blockerRelations, bindings) {
+  if (!blockerRelations) return false;
+  for (const literal of negatives) {
+    const relation = blockerRelations.get(literal.key);
+    if (!relation) continue;
+    const tuple = instantiateTuple(literal.args, bindings);
+    if (tuple == null) return true; // range restriction should make this unreachable
+    if (relation.has(tuple)) return true;
+  }
+  return false;
+}
+
+function gamma(compiled, blockerRelations = null) {
+  const relations = copyBaseRelations(compiled.base, compiled.groups);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const rule of compiled.rules) {
+      const headRelation = relations.get(rule.head.key);
+      if (!headRelation) continue;
+      forEachPositiveBinding(rule.positives, relations, (bindings) => {
+        if (blockedByNegative(rule.negatives, blockerRelations, bindings)) return;
+        const tuple = instantiateTuple(rule.head.args, bindings);
+        if (tuple != null && headRelation.add(tuple)) changed = true;
+      });
+    }
+  }
+  return relations;
+}
+
+function relationSetsEqual(left, right) {
+  if (left.size !== right.size) return false;
+  for (const [key, leftRelation] of left) {
+    const rightRelation = right.get(key);
+    if (!rightRelation || leftRelation.keys.size !== rightRelation.keys.size) return false;
+    for (const tuple of leftRelation.keys) if (!rightRelation.keys.has(tuple)) return false;
+  }
+  return true;
+}
+
+export function evaluateWfs(program, rootGroup) {
+  const compiled = compileProgram(program, rootGroup);
+
+  // Positive closure with tnot erased is an upper bound on every atom that can
+  // participate in the WFS model, avoiding construction of the full Herbrand
+  // cross product for predicates of arity > 1.
+  let upper = gamma(compiled, null);
+  let lower = emptyRelations(compiled.groups);
+  let rounds = 0;
+
+  while (true) {
+    rounds++;
+    const nextLower = gamma(compiled, upper);
+    const nextUpper = gamma(compiled, nextLower);
+    if (relationSetsEqual(lower, nextLower) && relationSetsEqual(upper, nextUpper)) {
+      lower = nextLower;
+      upper = nextUpper;
+      break;
+    }
+    lower = nextLower;
+    upper = nextUpper;
+  }
+
+  return { lower, upper, rounds, groups: compiled.groups };
+}
+
+export function relationForGroup(model, group, kind = 'upper') {
+  const relations = kind === 'lower' ? model.lower : model.upper;
+  return relations.get(predicateKey(group.module, group.name, group.arity)) ?? null;
+}
+
+export function truthOfGroundGoal(model, goal) {
+  const key = predicateKey(goal.module ?? 'user', goal.name, goal.arity);
+  const tuple = goal.args ?? EMPTY_ARRAY;
+  const lower = model.lower.get(key);
+  if (lower?.has(tuple)) return 'true';
+  const upper = model.upper.get(key);
+  if (upper?.has(tuple)) return 'undefined';
+  return 'false';
+}

package/test/conformance/ISO-COMPLIANCE.md

@@ -56,7 +56,8 @@ not interpret the following as core-language features:
 - the implementation-specific `occurs_check` Prolog flag;
 - Part 2 module directives (`module/2`, `use_module/1-2`, `meta_predicate/1`);
 - Part 3 grammar-rule expansion and `phrase/2-3`;
-- automatic tabling, cycle guards, and recursive numeric execution shortcuts.
+- automatic tabling, cycle guards, and recursive numeric execution shortcuts;
+- EyeProlog well-founded negation via `tnot/1` and its WFS runtime statistics.
 
 The predefined Part 1 `1200 fx` `?-` operator and `1200 xfx` `-->` operator
 remain ordinary operator syntax in strict core mode. A conforming `op/3`

package/test/conformance/README.md

@@ -21,7 +21,10 @@ processor-requirement ledger for the Part 1 strict-core audit. This suite is
 still not an independent certification of every processor requirement, lexical
 edge, option combination, or prescribed error precedence. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
-contracts and extensions.
+contracts and extensions. EyeProlog-only execution features such as automatic
+tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core
+claim. Their focused semantic coverage lives primarily in regression tests;
+`tnot/1` is absent from the strict ISO registry.
 
 All conformance files live under topic directories such as `arithmetic/`, `lists/`, `syntax/`, or `variables/`; new top-level numbered files should not be added. The report uses those directories as coverage categories.
 

package/test/run-regression.mjs

@@ -3444,6 +3444,103 @@ check(A, B, C, D, E, F) :-
         assertEqual(result.stdout, '250000', 'distinct number syntax attempts');
       },
     },
+    {
+      name: 'recursive phrase tables stay bounded across distinct inputs (issues #28/#48)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = `
+          :- use_module(library(prologue)).
+          ... --> [].
+          ... --> [_], ... .
+
+          vchars("0123456789.").
+
+          ti(Nth:E:Chs, Pot, Start) :-
+            length(Chs, _),
+            call_nth(chs(Chs), Nth), Nth >= Start,
+            Nth mod 10^Pot =:= 0,
+            E = cnt.
+
+          chs(Chs) :-
+            vchars(VChs),
+            maplistch(Chs, VChs),
+            catch(number_chars(_, Chs), error(syntax_error(_), _), false),
+            \\+ phrase((..., ("//"|"++")), Chs).
+
+          maplistch([], _).
+          maplistch([Ch|Chs], VChs) :-
+            member(Ch, VChs),
+            maplistch(Chs, VChs).
+        `;
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)}, { autoloadGoals: ['ti(R,3,0)'] });
+          const listTailGroup = program.findGroup('...', 2, 'user');
+          if (listTailGroup?.listTailRecursive !== true) {
+            throw new Error('recursive DCG tail-consumption was not recognized');
+          }
+          const solver = new Solver(program, { registry: getEyePrologRegistry(), maxMemoryBytes: Infinity });
+          const goal = parseGoalText('ti(R,3,0)', {
+            doubleQuotes: 'chars',
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 20) break;
+          }
+          if (count !== 20) throw new Error('unexpected checkpoint count: ' + count);
+          const scope = solver.innerTableScopes.get('phrase');
+          if (scope == null) throw new Error('missing phrase table scope');
+          if (scope.memo.size !== 0) throw new Error('distinct tail-DCG inputs should not retain phrase tables: ' + scope.memo.size);
+          process.stdout.write(count + ':' + scope.memo.size);
+        `;
+        const result = spawnSync(process.execPath, [
+          // This corresponds to 20,000 accepted number candidates. Before the
+          // phrase-local cache, every distinct recursive DCG tail stayed rooted
+          // in the caller memo and this workload exhausted a 32 MiB old space.
+          '--max-old-space-size=32',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded phrase-table child status; stderr=${result.stderr}`);
+        const [countText, cacheText] = result.stdout.trim().split(':');
+        assertEqual(countText, '20', 'recursive phrase checkpoints');
+        assertEqual(cacheText, '0', 'distinct tail-DCG phrase cache');
+      },
+    },
+    {
+      name: 'repeated identical phrase invocation reuses a compact table (issue #48)',
+      run: () => {
+        const program = Program.parse(`
+          :- use_module(library(prologue)).
+          ... --> [].
+          ... --> [_], ... .
+        `, { autoloadGoals: ['phrase((...,("ba"|"gh")),"abcdef")'] });
+        const solver = new Solver(program, { registry: getEyePrologRegistry(), maxMemoryBytes: Infinity });
+        const goal = parseGoalText('phrase((...,("ba"|"gh")),"abcdef")', {
+          doubleQuotes: 'chars',
+          operatorDefinitions: [...program.operators.values()],
+        });
+        const runFailure = () => {
+          let answers = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) answers++;
+          assertEqual(answers, 0, 'failing phrase answer count');
+        };
+        runFailure();
+        assertEqual(solver.stats.table_fixpoint_rounds, 0, 'first distinct tail-DCG invocation stays untabled');
+        runFailure();
+        const roundsAfterSecond = solver.stats.table_fixpoint_rounds;
+        if (roundsAfterSecond <= 0) throw new Error('repeated phrase invocation did not build reusable table');
+        const scope = solver.innerTableScopes.get('phrase');
+        if (scope == null || scope.memo.size <= 0 || scope.memo.size > 1024) {
+          throw new Error('unexpected repeated phrase table size: ' + (scope?.memo.size ?? 'missing'));
+        }
+        runFailure();
+        assertEqual(solver.stats.table_fixpoint_rounds, roundsAfterSecond, 'third identical phrase call reuses completed table');
+      },
+    },
     {
       name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {
@@ -3626,13 +3723,15 @@ check(A, B, C, D, E, F) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 155, 'EyeProlog registry contains ISO definitions, observability extensions, and private library adapters');
+        assertEqual(library.defs.size, 156, 'EyeProlog registry contains ISO definitions, observability extensions, WFS tnot/1, and private library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
         assertEqual(registry.get('statistics', 2), null, 'statistics/2 is absent from the ISO registry');
         assertEqual(Boolean(library.get('statistics', 0)), true, 'statistics/0 is an EyeProlog observability extension');
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
+        assertEqual(registry.get('tnot', 1), null, 'tnot/1 is absent from the ISO registry');
+        assertEqual(Boolean(library.get('tnot', 1)), true, 'tnot/1 is an EyeProlog WFS extension');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 62, 'portable Prolog library count');
         assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
@@ -4266,6 +4365,94 @@ function whiteBoxCases() {
         assertEqual(program.findGroup('q', 1).tabled, false, 'q/1 not positively tabled');
       },
     },
+    {
+      name: 'large finite Datalog uses an indexed least model only for broad calls',
+      run: () => {
+        const edges = Array.from({ length: 130 }, (_, i) => `edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${edges}\npath(X,Y) :- edge(X,Y).\npath(X,Y) :- edge(X,Z), path(Z,Y).\n`;
+        const program = Program.parse(source);
+        const group = program.findGroup('path', 2);
+        assertEqual(group.datalogLeastModel, true, 'large range-restricted Datalog is eligible');
+
+        const broad = run(program, { goal: 'path(X,Y)' });
+        assertEqual(broad.stdout.trim().split('\n').length, 8515, 'semi-naive closure has every chain pair');
+        assertEqual(broad.stats.datalog_evaluations, 1, 'broad query builds one least model');
+
+        const ground = run(program, { goal: 'path(n0,n130)' });
+        assertEqual(ground.stdout, 'path(n0, n130).\n', 'ground chain still succeeds');
+        assertEqual(ground.stats.datalog_evaluations, 0, 'ground query keeps the ordinary indexed chain path');
+      },
+    },
+    {
+      name: 'findall length counting preserves multiplicity and observable bags',
+      run: () => {
+        const source = `
+p(a).
+p(b).
+q(X) :- p(X).
+q(X) :- p(X).
+bench(N) :- findall(X, q(X), Bag), length(Bag, N).
+collect(Bag,N) :- findall(X, q(X), Bag), length(Bag, N).
+`;
+        assertEqual(run(source, { goal: 'bench(N)' }).stdout, 'bench(4).\n', 'dead bag counts all four proof solutions');
+        assertEqual(run(source, { goal: 'collect(Bag,N)' }).stdout, 'collect("abab", 4).\n', 'bag exposed through the rule head is materialized');
+      },
+    },
+    {
+      name: 'ground negation probes a complete positive Datalog model',
+      run: () => {
+        const edges = Array.from({ length: 130 }, (_, i) => `edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${edges}
+path(X,Y) :- edge(X,Y).
+path(X,Y) :- edge(X,Z), path(Z,Y).
+blocked(X,Y) :- path(X,Y).
+candidate(n0,n130).
+candidate(n130,n0).
+keep(X,Y) :- candidate(X,Y), \\+ blocked(X,Y).
+`;
+        const result = run(source, { goal: 'keep(X,Y)' });
+        assertEqual(result.stdout, 'keep(n130, n0).\n', 'negation sees the complete transitive closure');
+        assertEqual(result.stats.datalog_evaluations, 1, 'ground truth probe reuses one complete least model');
+      },
+    },
+    {
+      name: 'tnot enables finite Datalog well-founded semantics without changing ISO negation',
+      run: () => {
+        const program = Program.parse(`
+move(1, 2).
+move(2, 3).
+move(3, 4).
+move(4, 1).
+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.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');
+
+        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');
+      },
+    },
+    {
+      name: 'finite WFS distinguishes true false and undefined for ground tnot calls',
+      run: () => {
+        const source = `
+move(a, b).
+move(c, d).
+move(d, c).
+win(X) :- move(X, Y), tnot(win(Y)).
+true_case :- win(a).
+false_case :- tnot(win(a)).
+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');
+      },
+    },
     {
       name: 'cyclic tabling reaches a complete fixed point',
       run: () => {