eyeprolog 1.3.87 → 1.3.89

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.87",
+  "version": "1.3.89",
   "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-all.mjs

@@ -21,7 +21,7 @@ await runStandalone(async (reporter) => {
   runOpenRuleBenchChecks(reporter);
   runArchitecture(reporter);
   runCleanup(reporter);
-  runRegression(reporter);
+  await runRegression(reporter);
   await runPlayground(reporter);
   await runExamples(reporter);
   runBookExamples(reporter);

package/test/run-examples.mjs

@@ -87,13 +87,7 @@ export async function runExamples(reporter = new TestReporter()) {
     .sort();
 
   reporter.section('Examples');
-  const deepTaxonomyIndex = files.indexOf('deep-taxonomy-100000.pl');
-  if (deepTaxonomyIndex >= 0) {
-    await runExampleTasks(files.slice(0, deepTaxonomyIndex + 1), (name, result) => reporter.testResult(name, result), 2);
-    await runExampleTasks(files.slice(deepTaxonomyIndex + 1), (name, result) => reporter.testResult(name, result), 3);
-  } else {
-    await runExampleTasks(files, (name, result) => reporter.testResult(name, result), 3);
-  }
+  await runExampleTasks(files, (name, result) => reporter.testResult(name, result), 3);
   reporter.sectionTotal('examples');
 
   reporter.section('Proof examples');

package/test/run-regression.mjs

@@ -7,6 +7,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { Worker, parentPort, workerData } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import publicDefaultApi from '../index.js';
 import * as publicApi from '../src/index.js';
@@ -84,13 +85,15 @@ function sourceAtom(value) {
   return `'${String(value).replaceAll('\\', '\\\\').replaceAll("'", "''")}'`;
 }
 
-export function runRegression(reporter = new TestReporter(), requestedSection = null) {
-  const sections = [
+const regressionSections = [
     { key: 'regression', name: 'Regression', cases: regressionCases },
     { key: 'docs', name: 'Documentation sync', cases: documentationSyncCases },
     { key: 'api', name: 'API', cases: apiCases },
     { key: 'white-box', name: 'White-box', cases: whiteBoxCases },
-  ];
+];
+
+export async function runRegression(reporter = new TestReporter(), requestedSection = null) {
+  const sections = regressionSections;
   const selected = requestedSection == null
     ? sections
     : sections.filter((section) => section.key === requestedSection);
@@ -98,16 +101,167 @@ export function runRegression(reporter = new TestReporter(), requestedSection =
     throw new Error(`unknown regression section: ${requestedSection}; expected ${sections.map(({ key }) => key).join(', ')}`);
   }
 
+  const prepared = selected.map((section) => ({ ...section, tests: section.cases() }));
+  const testCount = prepared.reduce((sum, section) => sum + section.tests.length, 0);
+  const parallelism = os.availableParallelism?.() ?? os.cpus().length;
+  // Several cases start bounded-heap child processes, so leave CPU and memory
+  // headroom instead of matching the host's full logical-core count.
+  const workerCount = Math.min(testCount, Math.max(1, Math.min(4, parallelism - 1)));
+  if (workerCount === 1) {
+    withRegressionTemp(() => {
+      for (const section of prepared) runSection(reporter, section.name, section.tests);
+    });
+    return;
+  }
+
+  const results = new Map();
+  let reportSection = 0;
+  let reportTest = 0;
+  reporter.section(prepared[0].name);
+  const reportReady = () => {
+    while (reportSection < prepared.length) {
+      const section = prepared[reportSection];
+      const result = results.get(testKey(section.key, reportTest));
+      if (result == null) return;
+      reporter.testResult(section.tests[reportTest].name, result);
+      reportTest++;
+      if (reportTest !== section.tests.length) continue;
+      reporter.sectionTotal(sectionLabel(section.name), sectionElapsedMs(section, results));
+      reportSection++;
+      reportTest = 0;
+      if (reportSection < prepared.length) reporter.section(prepared[reportSection].name);
+    }
+  };
+  await runRegressionWorkers(prepared, workerCount, results, reportReady);
+}
+
+function withRegressionTemp(runTests) {
   tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-regression.'));
   tmpCounter = 0;
   try {
-    for (const section of selected) runSection(reporter, section.name, section.cases());
+    return runTests();
   } finally {
     fs.rmSync(tmp, { recursive: true, force: true });
     tmp = null;
   }
 }
 
+async function runRegressionWorkers(sections, workerCount, results, onResult) {
+  const tasks = sections.flatMap((section) => section.tests.map((_, index) => ({
+    sectionKey: section.key,
+    index,
+  })));
+  let nextTask = 0;
+  let completed = 0;
+  let settled = false;
+
+  return new Promise((resolve, reject) => {
+    const workers = Array.from({ length: workerCount }, () => new Worker(new URL(import.meta.url), {
+      workerData: { regressionWorker: true },
+    }));
+
+    const closeWorkers = () => {
+      for (const worker of workers) worker.postMessage({ close: true });
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      Promise.all(workers.map((worker) => worker.terminate())).finally(() => reject(error));
+    };
+    const assign = (worker) => {
+      if (settled) return;
+      const task = tasks[nextTask++];
+      if (task != null) worker.postMessage(task);
+    };
+
+    for (const worker of workers) {
+      worker.on('message', (message) => {
+        if (settled) return;
+        if (message.ready) {
+          assign(worker);
+          return;
+        }
+        results.set(testKey(message.sectionKey, message.index), {
+          ms: message.ms,
+          error: deserializeWorkerError(message.error),
+          startedAt: message.startedAt,
+          finishedAt: message.finishedAt,
+        });
+        try {
+          onResult();
+        } catch (error) {
+          fail(error);
+          return;
+        }
+        completed++;
+        if (completed === tasks.length) {
+          settled = true;
+          const exits = Promise.all(workers.map((candidate) => new Promise((done, failed) => {
+            candidate.once('exit', done);
+            candidate.once('error', failed);
+          })));
+          closeWorkers();
+          exits.then(() => resolve(results), reject);
+        } else {
+          assign(worker);
+        }
+      });
+      worker.on('error', fail);
+      worker.on('exit', (code) => {
+        if (!settled) fail(new Error(`regression worker exited unexpectedly with status ${code}`));
+      });
+    }
+  });
+}
+
+function testKey(sectionKey, index) {
+  return `${sectionKey}:${index}`;
+}
+
+function sectionElapsedMs(section, results) {
+  const timings = section.tests.map((_, index) => results.get(testKey(section.key, index)));
+  return Math.max(...timings.map(({ finishedAt }) => finishedAt)) -
+    Math.min(...timings.map(({ startedAt }) => startedAt));
+}
+
+function deserializeWorkerError(error) {
+  if (error == null) return null;
+  return Object.assign(new Error(error.message), { stack: error.stack });
+}
+
+function startRegressionWorker() {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-regression-worker.'));
+  tmpCounter = 0;
+  const casesBySection = new Map(regressionSections.map((section) => [section.key, section.cases()]));
+  parentPort.on('message', ({ sectionKey, index, close }) => {
+    if (close) {
+      fs.rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+      parentPort.close();
+      return;
+    }
+    const testCase = casesBySection.get(sectionKey)?.[index];
+    const startedAt = Date.now();
+    const started = performance.now();
+    let error = null;
+    try {
+      if (testCase == null) throw new Error(`unknown regression test ${sectionKey}:${index}`);
+      testCase.run();
+    } catch (caught) {
+      error = { message: caught?.message ?? String(caught), stack: caught?.stack ?? String(caught) };
+    }
+    parentPort.postMessage({
+      sectionKey,
+      index,
+      ms: Math.round(performance.now() - started),
+      startedAt,
+      finishedAt: Date.now(),
+      error,
+    });
+  });
+  parentPort.postMessage({ ready: true });
+}
+
 function regressionCases() {
   return [
     {
@@ -210,6 +364,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: () => {
@@ -7136,6 +7339,8 @@ function format(value) {
   return typeof value === 'string' ? JSON.stringify(value) : String(value);
 }
 
-if (isMainModule(import.meta.url)) {
+if (workerData?.regressionWorker) {
+  startRegressionWorker();
+} else if (isMainModule(import.meta.url)) {
   await runStandalone((reporter) => runRegression(reporter, process.argv[2] ?? null));
 }

package/test/test-style.mjs

@@ -41,12 +41,12 @@ export class TestReporter {
     this.sectionCount++;
   }
 
-  sectionTotal(label = null) {
+  sectionTotal(label = null, elapsedMs = null) {
     if (this.currentSection == null) return;
 
     const ok = this.ok - this.currentSection.okAtStart;
     const total = this.total - this.currentSection.totalAtStart;
-    const ms = nowMs() - this.currentSection.startedAt;
+    const ms = elapsedMs ?? nowMs() - this.currentSection.startedAt;
     const suite = label ?? defaultSectionLabel(this.currentSection.name);
     this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }

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 |