eyeprolog 1.3.3 → 1.3.7

package/src/standard-library.js

@@ -109,10 +109,10 @@ export const eyePrologInteropAutoload = Object.freeze({
   'foldl/6': 'lists',
   'sum_list/2': 'lists',
   'list_to_set/2': 'lists',
-  // call_nth/2 is available in both Trealla and Scryer (the latter via
-  // library(iso_ext)).  EyeProlog keeps its adapter in library(prologue), so
-  // autoloading hides that implementation-specific location from source.
-  'call_nth/2': 'prologue',
+  // call_nth/2 is available in both Trealla and Scryer.  EyeProlog exposes
+  // it from library(iso_ext), matching the explicit Scryer import while still
+  // allowing Trealla-style unqualified source to use the same autoload entry.
+  'call_nth/2': 'iso_ext',
   // Trealla and Scryer expose between/3 without an EyeProlog-style
   // library(prologue) dependency.  EyeProlog keeps its implementation in the
   // Prologue module but autoloads it so portable source need not name that
@@ -125,9 +125,13 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 );
 
 // Libraries whose *name* is part of the current interop profile.  A program
-// may freely use_module(library(lists)); predicates in that module which are
-// outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists']);
+// may freely use_module/1 with these common module names; predicates in those
+// 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-conformance.mjs

@@ -18,6 +18,7 @@ function withStandardModules(text) {
   return `:- use_module(library(aggregate)).
 :- use_module(library(comparison)).
 :- use_module(library(dates)).
+:- use_module(library(iso_ext)).
 :- use_module(library(lists)).
 :- use_module(library(primes)).
 :- use_module(library(prologue), [between/3]).