eyeprolog 1.3.86 → 1.3.88

package/package.json

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

package/src/ARCHITECTURE.md

@@ -36,7 +36,9 @@ Annotations are persistent across `Env.clone()` and therefore backtrack with the
 substitution. Language services may attach immutable constraint descriptors,
 but the unconstrained unification hot path only performs a null check; descriptor
 validation and reindexing run only in environments that actually contain
-annotations. `dif/2` is the first descriptor-based user of this mechanism.
+annotations. Descriptors can optionally define logical subsumption so the
+store retains only its strongest pending constraints. `dif/2` is the first
+descriptor-based user of this mechanism.
 
 `atts.js` layers Prolog-visible attributed variables over that same persistent
 environment. Per-module attributes follow the current variable representative.

package/src/iso.js

@@ -211,6 +211,19 @@ function difConstraint(left, right) {
         skipAttributeHooks: true,
       }) ? 'pending' : 'entailed';
     },
+    subsumes(other, env) {
+      if (other?.kind !== 'dif') return false;
+      // dif(A,B) implies dif(C,D) exactly when C=D entails A=B. Apply the
+      // most general finite-tree unifier for the other's forbidden equality;
+      // if this equality makes our terms identical, every instance forbidden
+      // by the other constraint is already forbidden by this one.
+      const probe = env.clone();
+      if (!unify(other.left, other.right, probe, {
+        skipVariableConstraints: true,
+        skipAttributeHooks: true,
+      })) return true;
+      return identical(left, right, probe);
+    },
     residualGoal() {
       return compound('dif', [left, right]);
     },
@@ -1756,15 +1769,6 @@ function writeOptionBoolean(value, env, option) {
   return value.name === 'true';
 }
 
-function writeOptionSpacing(value, env, option) {
-  value = deref(value, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== ATOM || !['minimal', 'standard'].includes(value.name)) {
-    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
-  }
-  return value.name;
-}
-
 function writeVariableNames(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
@@ -1806,7 +1810,7 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
     else if (option.name === 'double_quotes' && !solver?.isoStrict) {
       result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
     } else if (option.name === 'spacing' && !solver?.isoStrict) {
-      result.minimalOperatorSpacing = writeOptionSpacing(option.args[0], env, option) === 'minimal';
+      result.minimalOperatorSpacing = !writeOptionBoolean(option.args[0], env, option);
     } else {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }

package/src/term.js

@@ -465,9 +465,24 @@ export class Env {
         typeof constraint.status !== 'function') {
       throw new TypeError('variable constraint requires variables(env) and status(env)');
     }
-    const constraints = new Set(this._variableConstraints ?? []);
-    constraints.add(constraint);
-    this._variableConstraints = constraints;
+    this._setNormalizedVariableConstraints([...(this._variableConstraints ?? []), constraint]);
+  }
+  _setNormalizedVariableConstraints(constraints) {
+    // Descriptors may define logical subsumption. Keep the strongest pending
+    // constraints so equivalent, symmetric, or weaker residual goals do not
+    // accumulate, while unrelated descriptor kinds remain untouched.
+    const normalized = [];
+    candidateLoop:
+    for (const candidate of constraints) {
+      for (const existing of normalized) {
+        if (existing === candidate || existing.subsumes?.(candidate, this) === true) continue candidateLoop;
+      }
+      for (let index = normalized.length - 1; index >= 0; index--) {
+        if (candidate.subsumes?.(normalized[index], this) === true) normalized.splice(index, 1);
+      }
+      normalized.push(candidate);
+    }
+    this._variableConstraints = normalized.length === 0 ? null : new Set(normalized);
     this._reindexVariableConstraints();
   }
   variableConstraints(kind = null) {
@@ -487,8 +502,7 @@ export class Env {
       if (status === 'violated') return false;
       if (status !== 'entailed') pending.add(constraint);
     }
-    this._variableConstraints = pending.size === 0 ? null : pending;
-    this._reindexVariableConstraints();
+    this._setNormalizedVariableConstraints(pending);
     return true;
   }
   _reindexVariableConstraints() {

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -124,7 +124,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |
 | 5.5.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(minimal|standard)`. `minimal` emits only lexically required separators; `standard` adds conventional layout around operators. Strict core excludes these implementation-specific extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
+| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(true|false)`. `spacing(false)` emits only lexically required separators; `spacing(true)` adds conventional layout around operators. Strict core excludes these implementation-specific extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/run-iso-strict.mjs

@@ -285,13 +285,13 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
     const strictSpacingError = capture(() => run('', {
       isoStrict: true,
-      goal: 'write_term(1+1,[spacing(minimal)])',
+      goal: 'write_term(1+1,[spacing(false)])',
     }));
     equal(strictSpacingError.formal, 'domain_error(write_option)', 'strict spacing extension rejection');
 
     const normal = run('', { goal: 'write_term("ab",[double_quotes(true)])' });
     includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
-    includes(run('', { goal: 'write_term(1+1,[spacing(standard)])' }).stdout,
+    includes(run('', { goal: 'write_term(1+1,[spacing(true)])' }).stdout,
       '1 + 1', 'normal-profile spacing extension remains available');
   });
 

package/test/run-regression.mjs

@@ -210,6 +210,55 @@ function regressionCases() {
           'freeze/2 residual projection terminates alongside dif/2 (issue #73)');
       },
     },
+    {
+      name: 'dif/2 removes symmetric and logically weaker residual constraints (issue #79)',
+      run: () => {
+        const residuals = runCli([], {
+          input:
+            'dif(X,Y),dif(Y,X).\n' +
+            'dif(X,Y),dif(X-Y,Z-Z).\n' +
+            'dif(X-Y,Z-Z),dif(X,Y).\n' +
+            'dif(X,a),dif(X,b).\n' +
+            'dif(X,a),dif(Y,a),X=Y.\n' +
+            'halt.\n',
+        });
+        assertEqual(residuals.status, 0, 'dif/2 normalization display status');
+        assertEqual(residuals.stdout,
+          '?-    dif(X, Y).\n' +
+          '?-    dif(X, Y).\n' +
+          '?-    dif(X, Y).\n' +
+          '?-    dif(X, a), dif(X, b).\n' +
+          '?-    X = Y, dif(Y, a).\n' +
+          '?- ',
+          'dif/2 residuals are minimal independent of insertion order');
+        assertEqual(residuals.stderr, '', 'dif/2 normalization display stderr');
+
+        const pendingDifCount = (text) => {
+          const solver = new Solver(Program.parse(''), { registry: getEyePrologRegistry() });
+          const solutions = solver.solve([parseGoalText(text)], new Env(), 0);
+          const answer = solutions.next();
+          assertEqual(answer.done, false, `${text} succeeds`);
+          const count = answer.value.variableConstraints('dif').length;
+          solutions.return();
+          return count;
+        };
+        assertEqual(pendingDifCount('dif(X,Y),dif(Y,X)'), 1,
+          'symmetric disequalities share one descriptor');
+        assertEqual(pendingDifCount('dif(X-Y,Z-Z),dif(X,Y)'), 1,
+          'stronger later disequality replaces the weaker descriptor');
+        assertEqual(pendingDifCount('dif(X,a),dif(X,b)'), 2,
+          'independent disequalities are both retained');
+        assertEqual(pendingDifCount('dif(X,a),dif(Y,a),X=Y'), 1,
+          'later aliasing coalesces newly equivalent disequalities');
+        for (const prefix of [
+          'dif(X,Y),dif(X-Y,Z-Z)',
+          'dif(X-Y,Z-Z),dif(X,Y)',
+        ]) {
+          assertEqual(run('', { goal: `${prefix},X=Y` }).stats.completed_goal_lists, 0,
+            `${prefix} retains the stronger disequality semantics`);
+        }
+      },
+    },
     {
       name: 'library(atts) provides Scryer-style attributed-variable hooks',
       run: () => {
@@ -4078,8 +4127,8 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
       run: () => {
         const source = [
           'emit :-',
-          '  write_term(1+1, [spacing(minimal)]), put_char(\'|\'),',
-          '  write_term(1+1, [spacing(standard)]).',
+          '  write_term(1+1, [spacing(false)]), put_char(\'|\'),',
+          '  write_term(1+1, [spacing(true)]).',
           '',
         ].join('\n');
         assertEqual(run(source, { goal: 'emit' }).stdout, '1+1|1 + 1emit.\n',
@@ -4104,7 +4153,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         }
         assertEqual(variableError?.formal, 'instantiation_error', 'variable spacing value');
 
-        for (const value of ['true', 'false', '1', '0']) {
+        for (const value of ['minimal', 'standard', '1', '0']) {
           let domainError = null;
           try {
             run('', { goal: `write_term(1+1,[spacing(${value})])` });

package/the-art-of-eyeprolog.md

@@ -5439,11 +5439,11 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `double_quotes(true|false)`: `true` lets eligible character/code lists use the
 current `double_quotes` representation, while strict ISO mode rejects this
 implementation-specific write option. Normal mode also accepts the
-implementation-specific `spacing(minimal|standard)` option: `minimal` emits
-only separators required to avoid lexical ambiguity, while `standard` adds
+implementation-specific boolean `spacing(true|false)` option: `false` emits
+only separators required to avoid lexical ambiguity, while `true` adds
 conventional layout around operators. For example,
-`write_term(1+1,[spacing(minimal)])` emits `1+1` and
-`write_term(1+1,[spacing(standard)])` emits `1 + 1`. The REPL always follows
+`write_term(1+1,[spacing(false)])` emits `1+1` and
+`write_term(1+1,[spacing(true)])` emits `1 + 1`. The REPL always follows
 the minimal-separator rule, so `X=1*1` is displayed as `X = 1*1`, while a
 separator is retained in `X = a+ -b` because the adjacent graphic tokens would
 otherwise merge. Strict ISO mode rejects both extension options.
@@ -6139,7 +6139,7 @@ the beginning. A peek does not mark the stream as past-end.
 | `write(+Term)`, `write(+Stream,+Term)` | Writes readable operator notation without quoting atoms merely because quoting would be required for reparsing. Number variables are enabled. |
 | `writeq(+Term)`, `writeq(+Stream,+Term)` | Like `write`, but quotes atoms when required for unambiguous input syntax. |
 | `write_canonical(+Term)`, `write_canonical(+Stream,+Term)` | Writes quoted canonical functor notation while ignoring operators and without interpreting *$VAR/1*. |
-| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(minimal or standard)*. |
+| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(true or false)*. |
 
 Term input uses the program's current operator table and the same ISO quoted-character
 syntax as source text, including backslash-terminated octal and hexadecimal
@@ -6284,6 +6284,12 @@ otherwise it delays the goal until `Term` becomes nonvariable. Suspensions are
 kept in the logical environment, so bindings and backtracking remain isolated
 between solution branches.
 
+`dif(?Left,?Right)` posts a delayed finite-tree disequality when its arguments
+can still unify. Its residual store is normalized by logical implication:
+symmetric or equivalent constraints share one residual, and a stronger
+constraint removes weaker ones regardless of insertion order. Independent
+disequalities remain separate.
+
 <!-- eyeprolog-library-catalog:start -->
 
 | Module | Exported predicate indicators | Primary role |
@@ -7796,7 +7802,7 @@ Notable implementation boundaries are:
 - `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
   `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
   including option validation and traversal rules; normal mode also offers
-  `double_quotes(true|false)` and `spacing(minimal|standard)` as explicitly
+  `double_quotes(true|false)` and `spacing(true|false)` as explicitly
   implementation-specific extensions, which strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.