eyeprolog 1.3.3 → 1.3.7

package/test/run-regression.mjs

@@ -20,6 +20,7 @@ import {
   createDefaultRegistry,
   getStrictIsoRegistry,
   getEyePrologRegistry,
+  standardLibrarySources,
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
@@ -67,6 +68,7 @@ function withStandardModules(source) {
   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]).
@@ -2214,6 +2216,22 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'library(lists) and library(iso_ext) co-import without collisions',
+      run: () => {
+        const input = [
+          ':- use_module(library(lists)).',
+          ':- use_module(library(iso_ext)).',
+          '%% goal: answer(N)',
+          'answer(N) :- call_nth(member(_, [a,b,c]), N), N = 2.',
+          '',
+        ].join('\n');
+        const result = runCli(['--portable', '--no-autoload', '-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'answer(2).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'strict ISO mode disables interop autoloading',
       run: () => {
@@ -3426,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: () => {
@@ -3608,20 +3723,22 @@ 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');
-        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists', 'common explicit library module profile');
+        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
-        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'prologue', 'call_nth/2 canonical internal autoload');
+        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
         assertEqual(eyePrologNativeLibraryIndicators.length, 40, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');
@@ -3671,6 +3788,28 @@ check(A, B, C, D, E, F) :-
         assertEqual(program.findGroup('random', 3)?.module, 'random', 'random/3 is imported from library(random)');
       },
     },
+    {
+      name: 'aligned bundled libraries have no overlapping full-module exports',
+      run: () => {
+        const owners = new Map();
+        for (const [moduleName, entry] of standardLibrarySources) {
+          // library(prologue) is the documented legacy compatibility umbrella;
+          // aligned libraries must remain pairwise collision-free so full
+          // use_module/1 imports can be combined safely.
+          if (moduleName === 'prologue') continue;
+          const parsed = Program.parse(entry.source);
+          const definition = parsed.modules.get(moduleName);
+          if (!definition) throw new Error(`missing module declaration for ${moduleName}`);
+          for (const indicator of definition.exports.keys()) {
+            const previous = owners.get(indicator);
+            if (previous != null) throw new Error(`duplicate export ${indicator}: ${previous}, ${moduleName}`);
+            owners.set(indicator, moduleName);
+          }
+        }
+        assertEqual(owners.get('countall/2'), 'iso_ext', 'countall/2 has one aligned owner');
+        assertEqual(owners.get('call_nth/2'), 'iso_ext', 'call_nth/2 has one aligned owner');
+      },
+    },
     {
       name: 'portable library executes against the ISO-only registry',
       run: () => {
@@ -4226,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: () => {

package/the-art-of-eyeprolog.md

@@ -1121,13 +1121,36 @@ particular user is unblocked.
   <figcaption>Absence becomes informative only inside a declared complete boundary: Clara is allowed because the event registry is complete and she is not on its blocked list.</figcaption>
 </figure>
 
-Negative dependencies should be stratified: compute a lower relation, then
-negate it from a higher layer. Use `--warnings` to report negative recursion:
+For ordinary `\+/1`, negative dependencies should normally be stratified:
+compute a lower relation, then negate it from a higher layer. Use `--warnings`
+to report negative recursion:
 
 ```sh
 eyeprolog --warnings program.pl
 ```
 
+Some finite rule systems intentionally contain recursion through negation. In
+normal mode, EyeProlog provides explicit `tnot/1` for that case. When the
+reachable component is finite, function-free, and range-restricted Datalog,
+cycles through `tnot/1` are evaluated with the well-founded semantics (WFS)
+rather than ordinary negation-as-failure. WFS has three truth states: true,
+false, and undefined. A negative cycle may therefore produce a conditional
+answer instead of forcing an arbitrary true/false choice.
+
+```eyeprolog
+move(a, b).
+move(b, a).
+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.
+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
+`tnot/1`.
+
 Universal checking needs no extension predicate: define the counterexample and
 negate it.
 
@@ -1155,6 +1178,7 @@ Finite aggregation asks about a solution set:
 ```eyeprolog
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 findall(Template, Goal, List).
 countall(Goal, Count).
@@ -1573,9 +1597,20 @@ analysis, and other recursive relations with overlapping subproblems.
 
 Ordinary goals use indexed depth-first resolution. Positive recursive groups
 are tabled automatically. Bound recursive calls reuse answers and cyclic calls
-iterate toward a fixed point. Fully open or structurally unbounded calls may
-retain ordinary resolution. Recursive components with negative dependencies
-are not positive fixed points.
+iterate toward a fixed point. For sufficiently large finite, function-free
+Datalog dependency cones, EyeProlog may share one most-general relation table
+across call variants. This turns an open closure such as `tc(X, Y)` into one
+finite relation computation rather than many overlapping bound subcomputations;
+bound consumers can then use indexes over the stored answers. The exact
+admission policy is an engine optimization, not part of the language contract.
+Fully open or structurally unbounded recursive programs may retain ordinary
+resolution.
+
+Recursive components with negative dependencies are not positive least-fixed-
+point problems. When such a component uses explicit `tnot/1` and satisfies the
+finite, range-restricted, function-free Datalog restrictions, EyeProlog instead
+computes the alternating fixed point of the well-founded semantics. Existing
+`\+/1` code remains ordinary negation-as-failure.
 
 ### Deeper implementation: how clause indexing stays semantic
 
@@ -1611,8 +1646,12 @@ eyeprolog --stats examples/observability-log-correlation.pl
 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.
-They describe work performed, not logical truth. Compare counters only across
-equivalent queries and the same implementation version.
+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
+that those atoms are true. All statistics describe work performed, not logical
+truth. Compare counters only across equivalent queries and the same
+implementation version.
 
 Common sources of nontermination are recursive calls made before constraints,
 ever-growing terms, infinite open mathematical queries, negative cycles, and
@@ -1946,6 +1985,8 @@ Part III moved from obtaining answers to trusting them:
 - a query selects a question; a proof records one successful justification;
 - an explicit integrity query identifies input that a host may reject;
 - automatic tabling computes fixed points for eligible positive recursion;
+- explicit `tnot/1` gives eligible finite Datalog components well-founded,
+  three-valued negation without changing ordinary `\+/1`;
 - indexing and ready filters improve control without changing intended meaning;
 - knowledge engineering separates sources, concepts, decisions, and reasons;
 - explicit host boundaries divide input validation from logical derivation;
@@ -1964,7 +2005,10 @@ turned fixed-point ideas into a goal-directed technique that shares recursive
 calls and accumulates answers. EyeProlog's automatic positive tabling is smaller
 than the general systems in that literature, but inherits their central
 insight: remembering a recursive question can change termination without
-changing what the relation says.
+changing what the relation says. For finite Datalog with recursion through
+explicit `tnot/1`, EyeProlog also uses the alternating-fixed-point account of
+the well-founded semantics so a negative cycle may remain undefined instead of
+being collapsed into ordinary negation-as-failure.
 
 In parallel, deductive databases asked where facts come from and how derived
 claims retain provenance. EyeProlog adopts the expectation that conclusions
@@ -3555,6 +3599,25 @@ component grows monotonically with newly discovered answers until no rule adds
 another. The implementation is performing a local, demand-driven fixed-point
 calculation.
 
+There is an important lifetime distinction between a table that is needed to
+finish one fixed point and a cache of tables retained for possible later reuse.
+For recursive grammars invoked through `phrase/2-3`, EyeProlog uses a separate
+invocation-keyed table scope rather than the caller's general table map. Static
+analysis also recognizes the normalized DCG form of strict list-tail recursion
+(for example `... --> [_], ...`). On a new input, such a grammar runs directly
+without automatic tabling because every recursive call consumes the input and
+there is no fixed-point cycle to close. This prevents a stream of distinct
+sequences from constructing a useless suffix-table family for every input.
+
+The optimization is deliberately asymmetric. If the same `phrase/2-3`
+invocation repeats, normal tabling is allowed again so the compact completed
+table from that invocation can serve subsequent repetitions. That is useful for
+workloads that probe one grammar/input many thousands of times. Only one
+invocation signature is retained in the phrase scope, completed entries are
+still subject to a bound, and active fixed points are never evicted. Thus the
+policy limits cross-call retention without turning each distinct input into an
+O(cache-size) eviction pass or changing the declarative answers.
+
 **Exercises.**
 
 1. Run the triple program with one, two, and three arguments bound. Compare the
@@ -6019,8 +6082,8 @@ between solution branches.
 | `library(clpz)` | `#>/2`, `#</2`, `#>=/2`, `#=</2`, `#=/2`, `#\=/2`, `#\/1`, `#<==>/2`, `#==>/2`, `#<==/2`, `#\//2`, `#\/2`, `#/\/2`, `in/2`, `ins/2`, `all_different/1`, `all_distinct/1`, `nvalue/2`, `sum/3`, `scalar_product/4`, `tuples_in/2`, `labeling/2`, `label/1`, `indomain/1`, `lex_chain/1`, `serialized/2`, `global_cardinality/2`, `global_cardinality/3`, `circuit/1`, `chain/2`, `element/3`, `zcompare/3`, `fd_var/1`, `fd_inf/2`, `fd_sup/2`, `fd_size/2`, `fd_dom/2` |
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |
-| `library(iso_ext)` | `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
-| `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `countall/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
+| `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
+| `library(lists)` | `member/2`, `memberchk/2`, `select/3`, `append/2`, `append/3`, `last/2`, `same_length/2`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `reverse/2`, `length/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `foldl/4`, `foldl/5`, `foldl/6`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
 | `library(primes)` | `smallest_divisor_from/3` |
 | `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `freeze/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` |
 | `library(random)` | `random/3` |
@@ -6046,14 +6109,21 @@ This generator mode is important for portable stress and enumeration programs.
 EyeProlog-only helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4`
 remain available for compatibility but are outside this profile.
 
+`library(iso_ext)` is also recognized as a common interop module name.
+EyeProlog exports `call_nth/2` there, matching Scryer's explicit import
+organization while still permitting unqualified autoloaded source. The aligned
+`library(lists)` and `library(iso_ext)` export sets are intentionally disjoint,
+so a source file may import both without an accidental predicate collision.
+`library(prologue)` is retained as an EyeProlog compatibility umbrella and may
+overlap these modules; use selective imports when legacy code combines it with
+the aligned libraries.
+
 Normal EyeProlog execution can autoload an otherwise undefined unqualified call
 only when the interop table assigns it one canonical provider. Thus `member/2`
-autoloads from `library(lists)`. `between/3` and `call_nth/2` are also in the
-interop profile; EyeProlog can satisfy them from its internal
-`library(prologue)` implementation without forcing portable source to mention
-that EyeProlog-specific library name. Autoloading is disabled by
-`--no-autoload`, by the JavaScript option `autoload: false`, and always by
-`--iso-strict`.
+autoloads from `library(lists)`, `call_nth/2` from `library(iso_ext)`, and
+`between/3` from the internal `library(prologue)` implementation. Autoloading is
+disabled by `--no-autoload`, by the JavaScript option `autoload: false`, and
+always by `--iso-strict`.
 
 `-w` / `--warnings` reports explicit non-profile library dependencies and calls
 to non-profile predicates from common libraries. `--portable` turns those
@@ -6075,11 +6145,14 @@ cumulative and two-dimensional scheduling constraints, and unbounded-domain
 propagation that are not yet exported here.
 
 `library(iso_ext)` collects extensions commonly found in mature Prolog
-systems. `forall/2` checks an action for every solution of a condition;
-`cfor/3` enumerates an inclusive evaluated integer range; `succ/2` relates
-adjacent nonnegative integers; `findall/4` collects into a difference list;
-and `variant/2` recognizes terms equal up to variable renaming. Its portable
-`countall/2` counts solutions without exposing a template.
+systems. `call_nth/2` exposes the ordinal number of each solution and supports
+the explicit import used by Scryer-style source; `forall/2` checks an action for
+every solution of a condition; `cfor/3` enumerates an inclusive evaluated
+integer range; `succ/2` relates adjacent nonnegative integers; `findall/4`
+collects into a difference list; and `variant/2` recognizes terms equal up to
+variable renaming. Its portable `countall/2` counts solutions without exposing
+a template. `countall/2` is not exported by `library(lists)`, avoiding a
+full-module import collision between the two libraries.
 
 `uuid(+Seed0,-UUID,-Seed)` creates a version 4 UUID atom using `random/3`.
 Passing the returned seed to the next call produces the next UUID; restarting
@@ -6272,6 +6345,7 @@ There is no `not/1` alias; use ISO `\+/1`. `forall/2` is available from
 ```eyeprolog
 :- use_module(library(aggregate)).
 :- use_module(library(lists)).
+:- use_module(library(iso_ext)).
 
 cost(a, 8).
 cost(b, 3).

package/why-eyeprolog.md

@@ -31,6 +31,8 @@ keeps a narrow architecture:
 
 - one parser and term model;
 - one solver with automatic tabling for eligible positive recursion;
+- explicit `tnot/1` with well-founded semantics for finite, range-restricted,
+  function-free Datalog components;
 - the ISO built-in registry;
 - lean portable ISO Part 2 library modules;
 - ISO Part 3 definite clause grammars and `phrase/2-3`;
@@ -43,6 +45,21 @@ relations such as list processing remain ordinary Prolog clauses imported with
 standard sorting, arithmetic, meta-calls, streams, and database operations use
 their ISO definitions directly.
 
+
+## Why keep well-founded negation explicit?
+
+Ordinary Prolog `\+/1` is negation-as-failure and remains useful when a closed,
+usually stratified relation has already been computed. Non-stratified rule
+systems need a different semantic choice. EyeProlog therefore does not silently
+change `\+/1`; normal mode provides `tnot/1` for finite Datalog components that
+need the three-valued well-founded semantics. This keeps the extension visible
+in source code and lets strict ISO mode remove it cleanly.
+
+The same boundary guides performance work. EyeProlog may evaluate large finite
+positive Datalog closures with a shared relation-wide table, but the admission
+heuristics are implementation details. Programs should rely on the documented
+semantics and finiteness conditions, not on a particular internal threshold.
+
 ## Why proofs?
 
 An answer says that a goal succeeded. A proof records one successful route