eyeprolog 1.5.46 → 1.5.48

package/ACKNOWLEDGEMENTS.md

@@ -6,8 +6,8 @@ Scale) research team, as part of the **Koreografeye** project.
 
 ## Standards
 
-Conformance work on this repository is checked against the following documents,
-which are consulted under a single-user licence and are not redistributed here:
+Conformance work on this repository targets the following standards.
+Licensed standards documents are not redistributed here:
 
 - ISO/IEC 13211-1:1995, *Information technology — Programming languages —
   Prolog — Part 1: General core*
@@ -15,7 +15,7 @@ which are consulted under a single-user licence and are not redistributed here:
 - ISO/IEC 13211-1:1995/Cor.2:2012
 - ISO/IEC 13211-1:1995/Cor.3:2017
 - ISO/IEC 13211-2:2000, *Part 2: Modules*, and its 2013 amendment
-- ISO/IEC TS 13211-3:2023, *Part 3: Definite clause grammar rules*
+- ISO/IEC TS 13211-3:2025, *Part 3: Definite clause grammar rules*
 
 ## External conformance corpora
 

package/conformance-report.md

@@ -47,27 +47,21 @@ spelling therefore changes this report even when no corpus file is added or remo
 | variables | 16 | 7 | 0 | 0 | 23 |
 | **Total** | **493** | **272** | **19** | **21** | **805** |
 
-## Known deviations
+## DCG conformance clarification
 
-These are conscious departures from a standards clause, not open defects.
+EyeProlog checks the input and remainder of `phrase/2-3` and reports
+`type_error(list, S)` when an argument is neither a list nor a partial list.
+These implementation-defined checks follow ISO/IEC TS 13211-3:2025,
+8.18.1.3 g and h; this behavior is not a known deviation.
 
-### phrase/2-3 terminal-sequence type errors
+The Part 3 implementation target is
+[ISO/IEC TS 13211-3:2025](https://www.iso.org/standard/83635.html).
+The public [error subclause](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/draft-8.18.1.3)
+also specifies `list` for these checks.
 
-ISO/IEC TS 13211-3:2023, 8.18.1.4 c and d specify that a processor which
-checks the terminal-sequence arguments of `phrase/2-3` shall report
-`type_error(terminal_sequence, S)`. Error clause c is required for
-`phrase/2` and implementation defined for `phrase/3`.
-
-EyeProlog checks both arguments but reports `type_error(list, S)`.
-Ulrich Neumerkel's `phrase_quad.pl` corpus, which the release gate fetches
-live from TU Wien, accepts only `false` or `type_error(list, S)` for quads
-41 and 42, so the published TS and that corpus cannot both be satisfied.
-The corpus predates the TS. Changing the error term is a one-line edit in
-`phraseSolutions` (`src/iso.js`); it additionally requires relaxing quads
-41-42 of the Neumerkel gate.
-
-Note that TS 13211-3, 7.14.7.2 gives `phrase({true}, nonlist, S)` as an
-example which succeeds with `S = nonlist`, which is consistent with the TS
-permitting `phrase/3` to omit the check entirely. EyeProlog prefers the
-stricter diagnostic that the TS also explicitly allows.
+The [phrase comparison](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/phrase)
+links the machine-readable `phrase_quad.pl` corpus. `npm test` fetches and
+runs that corpus live through the Neumerkel gate; the offline regression
+suite runs all 58 vendored quads. Neither expectations nor error matching
+are relaxed for quads 41-44.
 

package/package.json

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

package/src/iso.js

@@ -3022,12 +3022,10 @@ function* phraseSolutions({ solver, goal, env }, state) {
   const input = goal.args[1];
   const requestedOutput = goal.arity === 2 ? emptyTerminalSequence() : goal.args[2];
   validateDcgEmbeddedGoals(grammarBody, input, requestedOutput);
-  // ISO/IEC TS 13211-3:2023, 8.18.1.4 c and d require
-  // type_error(terminal_sequence, S) here.  EyeProlog still reports
-  // type_error(list, S): Ulrich Neumerkel's phrase_quad corpus, which the
-  // release gate fetches live, accepts only `false` or type_error(list, S)
-  // for quads 41-42, so the two cannot currently both be satisfied.  See
-  // conformance-report.md, "Known deviations".
+  // ISO/IEC TS 13211-3:2025, 8.18.1.3 g and h permit these checks
+  // and specify type_error(list, S) for invalid terminal-sequence arguments.
+  // Keep both diagnostics and the unmodified upstream phrase quad gate.
+  // See conformance-report.md and issue #94.
   if (!isListOrPartialList(input, env)) {
     throw new PrologError('type_error(list)', deref(input, env));
   }

package/src/quads.js

@@ -68,7 +68,18 @@ function checkQuadDescription(program, quad, description, options, context) {
 }
 
 function checkDescription(program, quad, description, options, context) {
-  const alternatives = splitOperator(description, '|');
+  const parts = splitOperator(description, '|');
+  const alternatives = [];
+  const unordered = new Set();
+  for (const part of parts) {
+    if (part.type === ATOM && part.name === 'other_answer_sequence') {
+      const previous = alternatives.at(-1);
+      if (previous == null || unordered.has(previous)) {
+        return { ok: false, kind: 'malformed', expected: part };
+      }
+      unordered.add(previous);
+    } else alternatives.push(part);
+  }
   // Probe an explicitly accepted nontermination outcome before alternatives
   // that would run the same query without a bound.
   const ordered = [...alternatives].sort((left, right) =>
@@ -80,7 +91,7 @@ function checkDescription(program, quad, description, options, context) {
   let unsupported = null;
   let undecided = null;
   for (const alternative of ordered) {
-    const checked = checkAlternative(program, quad, alternative, options, context);
+    const checked = checkAlternative(program, quad, alternative, options, context, unordered.has(alternative));
     if (checked.ok) return checked;
     if (checked.kind === 'unsupported') unsupported ??= checked;
     if (checked.kind === 'undecided') undecided ??= checked;
@@ -88,7 +99,7 @@ function checkDescription(program, quad, description, options, context) {
   return unsupported ?? undecided ?? { ok: false, kind: 'failed', expected: description };
 }
 
-function checkAlternative(program, quad, alternative, options, context) {
+function checkAlternative(program, quad, alternative, options, context, unordered = false) {
   const leaves = splitOperator(alternative, ';').map(describeLeaf);
   const requiresSto = leaves.some((leaf) => leaf.sto);
   const unsupported = leaves.find((leaf) => leaf.unsupported != null)?.unsupported;
@@ -96,6 +107,13 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: false, kind: 'unsupported', expected: unsupported };
   }
 
+  // A permutation describes a complete sequence, not an arbitrary prefix or
+  // a negative assertion. Do not silently weaken those annotations.
+  if (unordered && leaves.some((leaf) => leaf.more || leaf.unexpected || leaf.sto ||
+      leaf.waits || leaf.input != null || leaf.peek != null)) {
+    return { ok: false, kind: 'unsupported', expected: alternative };
+  }
+
   const ioLeaves = leaves.filter((leaf) => leaf.input != null || leaf.peek != null);
   if (ioLeaves.length > 1 || (ioLeaves.length > 0 && leaves.length !== 1)) {
     return { ok: false, kind: 'malformed', expected: alternative };
@@ -143,6 +161,8 @@ function checkAlternative(program, quad, alternative, options, context) {
     return { ok: leaf.unexpected ? !matches : matches };
   }
 
+  if (unordered) return checkAnswerPermutation(program, quad.query, leaves, actual, alternative);
+
   let position = 0;
   for (const leaf of leaves) {
     if (leaf.more && !leaf.hasExpectation) return { ok: true };
@@ -186,6 +206,37 @@ function checkAlternative(program, quad, alternative, options, context) {
   return { ok: ended };
 }
 
+// Match a multiset, preserving duplicate counts. A greedy match is insufficient:
+// wildcard and approximate descriptions may overlap more specific descriptions.
+// Augmenting paths find a one-to-one assignment without enumerating permutations.
+function checkAnswerPermutation(program, query, leaves, actual, alternative) {
+  const terminalAt = leaves.findIndex((leaf) => leaf.false || leaf.loops || leaf.error != null);
+  if (terminalAt >= 0 && terminalAt !== leaves.length - 1) return { ok: false };
+  const answers = terminalAt < 0 ? leaves : leaves.slice(0, -1);
+  if (actual.solutions.length > answers.length) return { ok: false };
+  if (actual.undecided) return undecidedResult(actual, alternative);
+  if (actual.solutions.length !== answers.length) return { ok: false };
+  if (terminalAt >= 0) {
+    if (!matchLeaf(program, query, leaves[terminalAt], actual, answers.length)) return { ok: false };
+  } else if (!actual.complete || actual.error != null || actual.loopObserved) return { ok: false };
+
+  const edges = answers.map((leaf) => actual.solutions.flatMap((_, position) =>
+    matchLeaf(program, query, leaf, actual, position) ? [position] : []));
+  const owners = Array(answers.length).fill(-1);
+  const assign = (index, seen) => {
+    for (const position of edges[index]) {
+      if (seen.has(position)) continue;
+      seen.add(position);
+      if (owners[position] < 0 || assign(owners[position], seen)) {
+        owners[position] = index;
+        return true;
+      }
+    }
+    return false;
+  };
+  return { ok: answers.every((_, index) => assign(index, new Set())) };
+}
+
 function malformedAlternative(query, alternative) {
   const queryNames = new Set(namedVariables(query).map((variable) => variable.name));
   for (const leaf of splitOperator(alternative, ';').map(describeLeaf)) {

package/test/conformance/cases/iso/part3_grammar_body_constructs.pl

@@ -1,35 +1,34 @@
-% ISO/IEC TS 13211-3:2023, 7.14 - the semantics of each grammar body element,
-% expressed as the phrase/3 identities the TS states for them.
+% ISO/IEC TS 13211-3:2025 grammar-body semantics regressions.
 digit(D) --> [D], { member(D, [a,b]) }.
 
-% 7.14.1  phrase([], S0, S) is true iff S0 = S.
+% phrase([], S0, S) is true iff S0 = S.
 answer(empty_sequence, S) :- phrase([], [a,b], S).
 
-% 7.14.3  phrase((A,B), S0, S) iff phrase(A, S0, S1), phrase(B, S1, S).
+% phrase((A,B), S0, S) iff phrase(A, S0, S1), phrase(B, S1, S).
 answer(concatenation, S) :- phrase(([a], [b]), [a,b,c], S).
 
-% 7.14.4  phrase((A;B), S0, S) iff ( phrase(A,S0,S) ; phrase(B,S0,S) ).
+% phrase((A;B), S0, S) iff ( phrase(A,S0,S) ; phrase(B,S0,S) ).
 answer(alternative, S) :- phrase(([a] ; [b]), [b,c], S).
 
-% 7.14.5.3  the if-then-else examples given verbatim in the TS.
+% if-then-else regression examples.
 answer(ite_13, yes) :- phrase((("1" | "2") -> "3" ; "4"), "13").
 answer(ite_23, yes) :- phrase((("1" | "2") -> "3" ; "4"), "23").
 answer(ite_4, yes) :- phrase((("1" | "2") -> "3" ; "4"), "4").
 answer(ite_single, no) :- \+ phrase((("1" | "2") -> "3" ; "4"), [_]).
 
-% 7.14.7  phrase({G}, S0, S) is true iff ( G, S0 = S ).
+% phrase({G}, S0, S) is true iff ( G, S0 = S ).
 answer(grammar_body_goal, S) :- phrase({true}, [a], S).
 
-% 7.14.9  phrase(phrase(NT), S0, S) iff phrase(NT, S0, S).
+% phrase(phrase(NT), S0, S) iff phrase(NT, S0, S).
 answer(phrase_nonterminal, S) :- phrase(phrase([a]), [a,b], S).
 
-% 7.14.10  phrase(!, S0, S) is true iff S0 = S.
+% phrase(!, S0, S) is true iff S0 = S.
 answer(cut_identity, S) :- phrase(!, [a,b], S).
 
-% 7.14.11  phrase(\+ GRBody, S0, S) iff ( \+ phrase(GRBody, S0, _), S0 = S ).
+% phrase(\+ GRBody, S0, S) iff ( \+ phrase(GRBody, S0, _), S0 = S ).
 answer(negation_identity, S) :- phrase(\+ [a], [b,c], S).
 answer(negation_blocks, no) :- \+ phrase(\+ [a], [a], _).
 
-% 7.14.2  ('.')//2 separates a terminal from the rest of the sequence.
+% ('.')//2 separates a terminal from the rest of the sequence.
 answer(terminal_split, D) :- phrase(digit(D), [b]).
 %% goal: answer(X0, X1)

package/test/conformance/cases/iso/part3_phrase_examples.pl

@@ -1,5 +1,4 @@
-% ISO/IEC TS 13211-3:2023, 8.18.1.5 - the worked phrase/2 and phrase/3
-% examples, using the grammar given verbatim in that subclause.
+% ISO/IEC TS 13211-3:2025 phrase/2 and phrase/3 regression examples.
 determiner --> [the].
 determiner --> [a].
 

package/test/run-conformance-report.mjs

@@ -119,7 +119,7 @@ export function formatConformanceReport(report = buildConformanceReport()) {
   }
   lines.push(`| **Total** | **${report.total.positive}** | **${report.total.errors}** | **${report.total.warnings}** | **${report.total.proofs}** | **${report.total.total}** |`);
 
-  lines.push(...knownDeviationSection());
+  lines.push(...dcgConformanceSection());
 
   if (report.corpusIssues.length > 0) {
     lines.push('', '## Corpus issues', '');
@@ -133,35 +133,27 @@ export function formatConformanceReport(report = buildConformanceReport()) {
   return `${lines.join('\n')}\n`;
 }
 
-// Deviations that are known, deliberate, and traceable to a specific clause.
-// Keeping them in the generated report means they survive regeneration instead
-// of living only in a commit message.
-function knownDeviationSection() {
+// Keep the standards clarification in the generated report.
+function dcgConformanceSection() {
   return [
     '',
-    '## Known deviations',
+    '## DCG conformance clarification',
     '',
-    'These are conscious departures from a standards clause, not open defects.',
+    'EyeProlog checks the input and remainder of `phrase/2-3` and reports',
+    '`type_error(list, S)` when an argument is neither a list nor a partial list.',
+    'These implementation-defined checks follow ISO/IEC TS 13211-3:2025,',
+    '8.18.1.3 g and h; this behavior is not a known deviation.',
     '',
-    '### phrase/2-3 terminal-sequence type errors',
+    'The Part 3 implementation target is',
+    '[ISO/IEC TS 13211-3:2025](https://www.iso.org/standard/83635.html).',
+    'The public [error subclause](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/draft-8.18.1.3)',
+    'also specifies `list` for these checks.',
     '',
-    'ISO/IEC TS 13211-3:2023, 8.18.1.4 c and d specify that a processor which',
-    'checks the terminal-sequence arguments of `phrase/2-3` shall report',
-    '`type_error(terminal_sequence, S)`. Error clause c is required for',
-    '`phrase/2` and implementation defined for `phrase/3`.',
-    '',
-    'EyeProlog checks both arguments but reports `type_error(list, S)`.',
-    'Ulrich Neumerkel\'s `phrase_quad.pl` corpus, which the release gate fetches',
-    'live from TU Wien, accepts only `false` or `type_error(list, S)` for quads',
-    '41 and 42, so the published TS and that corpus cannot both be satisfied.',
-    'The corpus predates the TS. Changing the error term is a one-line edit in',
-    '`phraseSolutions` (`src/iso.js`); it additionally requires relaxing quads',
-    '41-42 of the Neumerkel gate.',
-    '',
-    'Note that TS 13211-3, 7.14.7.2 gives `phrase({true}, nonlist, S)` as an',
-    'example which succeeds with `S = nonlist`, which is consistent with the TS',
-    'permitting `phrase/3` to omit the check entirely. EyeProlog prefers the',
-    'stricter diagnostic that the TS also explicitly allows.',
+    'The [phrase comparison](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/phrase)',
+    'links the machine-readable `phrase_quad.pl` corpus. `npm test` fetches and',
+    'runs that corpus live through the Neumerkel gate; the offline regression',
+    'suite runs all 58 vendored quads. Neither expectations nor error matching',
+    'are relaxed for quads 41-44.',
     '',
   ];
 }

package/test/run-regression.mjs

@@ -995,6 +995,45 @@ why(
         assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads matches other_answer_sequence permutations exactly (issue #95)',
+      run: () => {
+        const cases = [
+          ['setof groups', 'setof(1, (Y=2 ; Y=1), L)', 'Y=2,L=[1];Y=1,L=[1]', true],
+          ['reverse', '(X=1;X=2;X=3)', 'X=3;X=2;X=1', true],
+          ['duplicates', '(X=1;X=1;X=2)', 'X=2;X=1;X=1', true],
+          ['wrong multiplicity', '(X=1;X=1;X=2)', 'X=2;X=2;X=1', false],
+          ['missing', '(X=1;X=2)', 'X=3;X=2;X=1', false],
+          ['extra', '(X=1;X=2;X=3)', 'X=2;X=1', false],
+          ['wrong value', '(X=1;X=2)', 'X=3;X=1', false],
+          ['overlapping patterns', '(X=f(a);X=f(b))', "X=f('...');X=f(a)", true],
+          ['variable sharing', '(X=Y;true)', 'true;X=Y', true],
+          ['wrong sharing', '(X=Y;true)', 'X=Y;X=Y', false],
+          ['per-answer output', '(X=1,write(a);X=2,write(b))', 'X=2,outputs("b");X=1,outputs("a")', true],
+          ['wrong output', '(X=1,write(a);X=2,write(b))', 'X=2,outputs("a");X=1,outputs("b")', false],
+          ['unlisted exception', '(X=1;throw(ball))', 'X=1', false],
+          ['terminal exception', '(X=1;X=2;throw(ball))', 'X=2;X=1;throw(ball)', true],
+          ['terminal failure', '(X=1;X=2)', 'X=2;X=1;false', true],
+          ['empty sequence', 'fail', 'false', true],
+          ['ordinary order retained', '(X=1;X=2)', 'X=2;X=1', false, false],
+        ];
+        for (const [name, query, answers, passes, unordered = true] of cases) {
+          const result = publicApi.runQuads(`?- ${query}.\n   ${answers}${unordered ? ' | other_answer_sequence' : ''}.\n`);
+          assertEqual(result.passed, passes ? 1 : 0, name);
+          assertEqual(result.undecided, 0, `${name} decided`);
+        }
+        for (const answers of ['other_answer_sequence', 'other_answer_sequence | X=1',
+          'X=1 | other_answer_sequence | other_answer_sequence']) {
+          const result = publicApi.runQuads(`?- X=1.\n   ${answers}.\n`);
+          assertEqual(result.results[0].kind, 'malformed', 'orphan or repeated marker');
+        }
+        const bounded = publicApi.runQuads(
+          'p(0). p(X) :- p(Y), X is Y+1.\n?- p(X).\n   X=1;X=0 | other_answer_sequence.\n',
+          { quadMaxInferences: 1 },
+        );
+        assertEqual(bounded.undecided, 1, 'bounded execution is not proof of a permutation');
+      },
+    },
     {
       name: 'runQuads supports realistic decimal-precision float descriptions with ~~ (issue #90)',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -9663,8 +9663,16 @@ error, including output produced before a later exception. Its argument may be
 an exact character list/string or a DCG body: terminal sequences,
 conjunction/disjunction, `...`/`ad_infinitum` sequence wildcards, and
 user-defined DCG nonterminals are matched against the captured characters.
-The `waits` and unordered `other_answer_sequence` annotations are not executed
-by the current runner.
+Appending `| other_answer_sequence` accepts any permutation of the preceding
+complete answer sequence. Substitutions, residual constraints, per-answer output,
+and duplicate counts must still match; missing or extra answers are failures.
+A final failure or exception stays at the end. Overlapping wildcard or approximate
+answer descriptions are matched one-to-one rather than greedily. Search-budget
+exhaustion remains undecided. Prefix (`...`), negative (`unexpected`), STO, and
+input/wait annotations are not supported in a permuted sequence.
+
+For `setof(1, (Y=2 ; Y=1), L)`, the description
+`Y=2, L=[1] ; Y=1, L=[1] | other_answer_sequence` accepts either group order.
 
 #### STO, loops, and undecided quad results