eyeprolog 1.3.87 → 1.3.88

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.87",
+  "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]);
     },

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/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: () => {

package/the-art-of-eyeprolog.md

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