eyeprolog 1.5.76 → 1.5.78

package/README.md

@@ -84,7 +84,7 @@ The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-gr
 The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing), [explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration), [operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response), [software supply-chain vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response), and a [scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
 
 ## Benchmarks
-EyeProlog has 19 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark -- --save .benchmarks/baseline.json`; use `node test/run-benchmark-tests.mjs` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `node test/lips-benchmark.mjs`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `node test/lips-benchmark.mjs` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+EyeProlog has 21 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, the dynamic database, and bignum arithmetic. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark -- --save .benchmarks/baseline.json`; use `node test/run-benchmark-tests.mjs` for harness checks. For a classic LIPS number, run `node test/lips-benchmark.mjs`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog over the checked [`examples/bench.pl`](examples/bench.pl) naive-reverse workload (the classic Quintus 1984 `nrev/2` benchmark on a 30-element list), subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 For the project policy on post-ISO-standard and WG17 compatibility features such as digit separators, see [ISO/WG17 compatibility extensions](test/conformance/ISO-WG17-EXTENSIONS.md).
 ## Development
 ```sh

package/package.json

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

package/src/iso.js

@@ -1162,6 +1162,12 @@ function streamHandleId(value, env) {
   // and rejecting an equally valid stream reference as malformed.
   if (value.type !== COMPOUND || value.name !== '$stream' || value.arity !== 1) return null;
   const id = deref(value.args[0], env);
+  // The shape is right, but the argument that would identify the stream is
+  // still unbound: whether this term is a valid stream reference cannot be
+  // decided yet, so that is an instantiation error, not a domain error (see
+  // issue #109's stc#72 follow-up) — unlike a wrong functor/arity above,
+  // which can never become valid no matter how any variable gets bound.
+  if (id.type === VAR) throw new PrologError('instantiation_error');
   return id.type === NUMBER && isDecimalInteger(id.name) ? Number(id.name) : null;
 }
 

package/test/bench/benchmarks.json

@@ -8,16 +8,6 @@
     ],
     "expectedSha256": "a0aa24fcbc87c394a4da789ac861b8e18cabad5e0d73b25ddc02df5dd4376c1b"
   },
-  {
-    "name": "classic-nrev",
-    "group": "recursion/lips",
-    "file": "examples/bench.pl",
-    "goals": [
-      "bench_result(X0)"
-    ],
-    "expectedSha256": "8045dc0730e4996a7b01fb2348311fb175ed53f4c49d14f82e01a3d470602255",
-    "logicalInferences": 496
-  },
   {
     "name": "clpz-sudoku",
     "group": "clpz",
@@ -172,5 +162,32 @@
       "bulk_write_result(X0, X1)"
     ],
     "expectedSha256": "8471da130a4a3a92dd31ee6cf285b1e129886177d7be367d51650a48b8920324"
+  },
+  {
+    "name": "quine-mccluskey",
+    "group": "dynamic-database",
+    "file": "examples/quine-mccluskey.pl",
+    "goals": [
+      "answer(X0)"
+    ],
+    "expectedSha256": "9ebf4a55f6f15a78ad614da02b418650d77cae39eb0d49cbf9eb614865bec501"
+  },
+  {
+    "name": "fibonacci",
+    "group": "tabling",
+    "file": "examples/fibonacci.pl",
+    "goals": [
+      "fibonacci(X0, X1)"
+    ],
+    "expectedSha256": "3adc819083c11d6bf4195e2718904d1712c21553d8fcad970c11a4a4e79e2a3f"
+  },
+  {
+    "name": "iso-atomic-conversion",
+    "group": "term-io",
+    "file": "examples/iso-atomic-conversion.pl",
+    "goals": [
+      "report(X0, X1)"
+    ],
+    "expectedSha256": "68c82dac7dd666cae5af51786f4fbc75423aac12309cedda1e342aba08ea4253"
   }
 ]

package/test/benchmark.mjs

@@ -69,9 +69,6 @@ for (const item of manifest) {
   if (!/^[0-9a-f]{64}$/.test(item.expectedSha256)) {
     throw new Error(`invalid expectedSha256 for benchmark ${item.name}`);
   }
-  if (item.logicalInferences != null && (!Number.isInteger(item.logicalInferences) || item.logicalInferences <= 0)) {
-    throw new Error(`invalid logicalInferences for benchmark ${item.name}`);
-  }
 }
 
 const selected = manifest.filter((item) => {
@@ -118,16 +115,6 @@ function formatMs(value) {
   return `${value.toFixed(1)} ms`;
 }
 
-function lipsFor(logicalInferences, medianMs) {
-  if (!Number.isFinite(logicalInferences) || !Number.isFinite(medianMs) || medianMs <= 0) return null;
-  return logicalInferences * 1000 / medianMs;
-}
-
-function formatLips(value) {
-  if (value == null) return '—';
-  return Math.round(value).toLocaleString('en-US');
-}
-
 function changePercent(medianMs, baselineMs) {
   if (baselineMs == null || baselineMs === 0) return null;
   return ((medianMs - baselineMs) / baselineMs) * 100;
@@ -141,6 +128,28 @@ function changeText(item) {
   return `${change < 0 ? '↓' : '↑'} ${value}`;
 }
 
+// A regression (slower) reads red, an improvement (faster) reads green, and a
+// change too small to trust (< 5%) reads dim rather than either color, so the
+// palette itself does not editorialize about noise-level swings.
+function changeColor(item) {
+  if (item.changePercent == null) return null;
+  if (Math.abs(item.changePercent) < 5) return 'dim';
+  return item.changePercent < 0 ? 'green' : 'red';
+}
+
+const supportsColor = !options.json && process.stdout.isTTY &&
+  process.env.NO_COLOR == null && process.env.TERM !== 'dumb';
+const ANSI = { bold: '1', dim: '2', green: '32', red: '31' };
+function paint(name, text) {
+  return name && supportsColor ? `\x1b[${ANSI[name]}m${text}\x1b[0m` : text;
+}
+function visibleLength(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+function padVisible(text, width) {
+  return text + ' '.repeat(Math.max(0, width - visibleLength(text)));
+}
+
 function summarizeResults(results) {
   const comparable = results.filter((item) =>
     Number.isFinite(item.medianMs) &&
@@ -226,8 +235,6 @@ for (const item of selected) {
     answerLines: worker.answerLines,
     outputBytes: worker.outputBytes,
     sha256: worker.digest,
-    logicalInferences: item.logicalInferences ?? null,
-    lips: lipsFor(item.logicalInferences, medianMs),
     baselineMs: baselineItem?.medianMs ?? null,
     changePercent: changePercent(medianMs, baselineItem?.medianMs ?? null),
   });
@@ -265,42 +272,36 @@ if (options.json) {
     results,
   }, null, 2)}\n`);
 } else {
-  const headers = ['Benchmark', 'Median/op', 'LIPS', 'Range/op', 'Batch', 'Baseline', 'Change', 'Answers'];
+  const headers = ['Benchmark', 'Median/op', 'Range/op', 'Batch', 'Baseline', 'Change', 'Answers'];
   const rows = results.map((item) => [
     item.name,
     formatMs(item.medianMs),
-    formatLips(item.lips),
     `${formatMs(item.minMs)}–${formatMs(item.maxMs)}`,
     String(item.batchSize),
     formatMs(item.baselineMs),
-    changeText(item),
+    paint(changeColor(item), changeText(item)),
     String(item.answerLines),
   ]);
-  const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
-  const printRow = (row) => process.stdout.write(`${row.map((cell, index) => cell.padEnd(widths[index])).join('  ')}\n`);
-  printRow(headers);
-  printRow(widths.map((width) => '-'.repeat(width)));
+  const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => visibleLength(row[index]))));
+  const printRow = (row, style) => process.stdout.write(
+    `${row.map((cell, index) => paint(style, padVisible(cell, widths[index]))).join('  ')}\n`,
+  );
+  printRow(headers, 'bold');
+  printRow(widths.map((width) => '-'.repeat(width)), 'dim');
   for (const row of rows) printRow(row);
 
   if (summary.comparable > 0) {
     process.stdout.write(
       `\nSuite score: ${summary.ratio.toFixed(3)}x baseline ` +
-      `(${changeText({ changePercent: summary.changePercent })}); ` +
-      `equal-weight geometric mean across ${summary.comparable}/${summary.total} comparable benchmarks.\n`,
-    );
-    process.stdout.write(
-      `Time-weighted total: ${formatMs(summary.currentTotalMs)} vs ${formatMs(summary.baselineTotalMs)} ` +
-      `(${changeText({ changePercent: summary.totalChangePercent })}).\n`,
+      `(${paint(changeColor({ changePercent: summary.changePercent }), changeText({ changePercent: summary.changePercent }))}), ` +
+      `${summary.comparable}/${summary.total} comparable. ` +
+      `Time-weighted: ${formatMs(summary.currentTotalMs)} vs ${formatMs(summary.baselineTotalMs)} ` +
+      `(${paint(changeColor({ changePercent: summary.totalChangePercent }), changeText({ changePercent: summary.totalChangePercent }))}).\n`,
     );
   }
 
-  process.stdout.write(`\n${results.length} benchmarks; ${options.runs} measured batch${options.runs === 1 ? '' : 'es'} each after ${options.warmup} warm-up batch${options.warmup === 1 ? '' : 'es'}, calibrated after one priming execution toward ${options.targetMs} ms per batch.\n`);
-  if (baselineWarning) process.stdout.write(`${baselineWarning}\n`);
-  if (baselinePath == null && !baselineWarning) process.stdout.write('No timing baseline found; run npm run benchmark -- --save .benchmarks/baseline.json to create .benchmarks/baseline.json.\n');
-  if (options.save != null) process.stdout.write(`Saved timing baseline: ${path.relative(root, options.save)}\n`);
-  process.stdout.write('Change compares the current median/op directly with the saved baseline median/op; the measured range is shown separately.\n');
-  process.stdout.write('The classic-nrev LIPS column is a quick wall-clock estimate. Use node test/lips-benchmark.mjs for the Quintus-style dummy-subtracted CPU measurement.\n');
-  if (summary.comparable > 0) {
-    process.stdout.write('Suite score is the geometric mean of current/baseline ratios, so every benchmark has equal relative weight; Time-weighted total compares summed medians and is dominated by longer workloads.\n');
-  }
+  process.stdout.write(`\n${results.length} benchmarks, ${options.runs}× after ${options.warmup}× warm-up, ~${options.targetMs} ms/batch.\n`);
+  if (baselineWarning) process.stdout.write(paint('dim', `${baselineWarning}\n`));
+  else if (baselinePath == null) process.stdout.write(paint('dim', 'No baseline: npm run benchmark -- --save .benchmarks/baseline.json\n'));
+  if (options.save != null) process.stdout.write(`Saved baseline: ${path.relative(root, options.save)}\n`);
 }

package/test/regression/cases-regression.mjs

@@ -46,6 +46,21 @@ export function regressionCases() {
         assertIncludes(result.stdout, 'A1 = ', 'query succeeds and reports the shared stream number');
       },
     },
+    {
+      name: 'close/1 raises instantiation_error, not domain_error(stream_or_alias), for a $stream/1 term whose argument is unbound (issue #109 follow-up)',
+      run: () => {
+        const result = runCli([], { input:
+          "S='$stream'(X),close(S).\nhalt.\n",
+        });
+        assertEqual(result.status, 0, result.stderr);
+        // The argument that would identify the stream is still unbound, so
+        // whether this term is a valid stream reference cannot be decided
+        // yet — that calls for instantiation_error, not a domain_error
+        // claiming the term itself is already known to be invalid.
+        assertIncludes(result.stdout, 'error(instantiation_error,', 'unbound $stream/1 argument reports instantiation_error');
+        assertNotIncludes(result.stdout, 'domain_error(stream_or_alias', 'no domain_error(stream_or_alias, ...) once the argument is still unbound');
+      },
+    },
     {
       name: 'top level never mints a generated variable name that collides with a query variable\'s own name (issue #108)',
       run: () => {

package/test/run-benchmark-tests.mjs

@@ -42,10 +42,8 @@ function runWorker(item) {
   ]);
 }
 
-ok(Array.isArray(manifest) && manifest.length === 19, 'benchmark manifest should contain exactly 19 representative workloads');
+ok(Array.isArray(manifest) && manifest.length === 21, 'benchmark manifest should contain exactly 21 representative workloads');
 ok(new Set(manifest.map((item) => item.name)).size === manifest.length, 'benchmark names should be unique');
-const classicNrev = manifest.find((item) => item.name === 'classic-nrev');
-ok(classicNrev?.logicalInferences === 496, 'classic nrev should retain the traditional 496-call LIPS accounting');
 
 for (const item of manifest) {
   ok(/^[0-9a-f]{64}$/.test(item.expectedSha256), `${item.name} should have a committed semantic checksum`);
@@ -72,18 +70,6 @@ ok(adaptive.results[0].batchSize > 1, 'adaptive benchmark smoke test should batc
 ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-expression').expectedSha256,
   'adaptive batching should preserve the semantic checksum');
 
-const nrev = await spawnJson([
-  path.join(root, 'test', 'benchmark.mjs'),
-  '--filter', 'classic-nrev',
-  '--runs', '1',
-  '--warmup', '0',
-  '--target-ms', '0',
-  '--json',
-]);
-ok(nrev.results.length === 1, 'classic nrev benchmark should be selectable');
-ok(nrev.results[0].logicalInferences === 496, 'classic nrev JSON should expose its logical-inference count');
-ok(Number.isFinite(nrev.results[0].lips) && nrev.results[0].lips > 0, 'classic nrev JSON should report positive LIPS');
-
 const classicLips = await spawnJson([
   path.join(root, 'test', 'lips-benchmark.mjs'),
   '--count', '20',

package/the-art-of-eyeprolog.md

@@ -10358,7 +10358,7 @@ npm run benchmark -- --save .benchmarks/baseline.json
 node test/lips-benchmark.mjs
 ```
 
-The benchmark suite contains 19 representative workloads and stores their
+The benchmark suite contains 21 representative workloads and stores their
 semantic output digests in the repository, while wall-clock baselines remain
 machine-local under `.benchmarks/` because absolute timings are machine-specific.
 Each benchmark runs in its own fresh Node worker. Inside that worker, one untimed