eyeprolog 1.5.47 → 1.5.48

package/package.json

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

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/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