eyeprolog 1.3.32 → 1.3.34

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 168 | 218 | 0 | 0 | 386 |
+| iso | 169 | 217 | 0 | 0 | 386 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -24,4 +24,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 7 | 0 | 0 | 23 |
-| **Total** | **489** | **271** | **19** | **21** | **800** |
+| **Total** | **490** | **270** | **19** | **21** | **800** |

package/package.json

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

package/src/iso.js

@@ -1939,7 +1939,13 @@ function validateControlCallable(term, culprit, env) {
     if (current.type !== COMPOUND || ![',', ';', '->'].includes(current.name) || current.arity !== 2) continue;
     for (let index = current.arity - 1; index >= 0; index--) {
       const argument = deref(current.args[index], env);
-      if (argument.type === VAR) throw new PrologError('instantiation_error');
+      // A variable nested in a control construct is not an error at call/1
+      // entry: an earlier goal may instantiate it before execution reaches
+      // that position. If it is still unbound when selected, the solver then
+      // raises instantiation_error at that point, after any preceding effects.
+      // Non-variable non-callables are different: ISO call/1 validates those
+      // eagerly and reports the whole control term as the culprit.
+      if (argument.type === VAR) continue;
       if (argument.type !== ATOM && argument.type !== COMPOUND) {
         throw new PrologError('type_error(callable)', culprit);
       }
@@ -2360,7 +2366,6 @@ function evaluateOperation(term, args) {
     const value = fn(a);
     if (Number.isNaN(value) || (name === 'log' && a === 0)) throw new PrologError('evaluation_error(undefined)');
     if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
-    if (value === 0 && a !== 0 && name === 'exp') throw new PrologError('evaluation_error(underflow)');
     return { integer: false, value };
   }
   if (arity !== 2) throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
@@ -2420,12 +2425,6 @@ function evaluateOperation(term, args) {
   else throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
   if (Number.isNaN(value)) throw new PrologError('evaluation_error(undefined)');
   if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
-  const underflow = value === 0 && (
-    (name === '*' && x !== 0 && y !== 0) ||
-    (name === '/' && x !== 0) ||
-    ((name === '**' || name === '^') && x !== 0)
-  );
-  if (underflow) throw new PrologError('evaluation_error(underflow)');
   return { integer: false, value };
 }
 export function arithmeticValueTerm(value) {

package/src/quads.js

@@ -247,7 +247,10 @@ function executeQuery(program, query, input, maxSolutions, options) {
     error,
     tailOutput,
     inputPosition,
-    loops: solver.depthLimitExceeded || solver.inferenceLimitExceeded,
+    // Accept direct structural evidence from EyeProlog's recursion guard as
+    // well as bounded-search evidence. A detected active-variant cycle is
+    // stronger evidence than merely reaching a timeout/inference ceiling.
+    loops: solver.recursionCycleDetected || solver.depthLimitExceeded || solver.inferenceLimitExceeded,
   };
 }
 

package/src/solver.js

@@ -63,6 +63,10 @@ export class Solver {
     // limit accounting. time/1 snapshots this counter around the measured goal.
     this.inferenceObservation = options.inferenceObservation ?? { value: 0 };
     this.inferenceLimitExceeded = false;
+    // Set when the normal-profile recursion guard detects re-entry of an
+    // already active variant on the current search path. Quad `loops` checks
+    // use this structural evidence in addition to bounded resource probes.
+    this.recursionCycleDetected = false;
     this.maxMemoryBytes = options.maxMemoryBytes ?? softHeapLimit();
     this.memoryRecovery = options.memoryRecovery ?? {
       active: false,
@@ -261,6 +265,7 @@ export class Solver {
     if (!child || child === this || !child.stats) return;
     this.depthLimitExceeded ||= child.depthLimitExceeded;
     this.inferenceLimitExceeded ||= child.inferenceLimitExceeded;
+    this.recursionCycleDetected ||= child.recursionCycleDetected;
     for (const [key, value] of Object.entries(child.stats)) {
       if (key === 'max_depth' || key === 'max_goal_count') {
         this.stats[key] = Math.max(this.stats[key] ?? 0, value ?? 0);
@@ -845,7 +850,10 @@ export class Solver {
   }
 
   *solveUserGoalUncached(group, goal, rest, env, depth) {
-    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) return;
+    if (group.recursive && !group.cutRecursive && !group.linearNumeric && this.activeVariant(goal, env)) {
+      this.recursionCycleDetected = true;
+      return;
+    }
     // Program indexes provide candidate clauses, but every candidate is still
     // freshened and unified below. The index is a performance hint, not a
     // semantic shortcut.
@@ -1047,7 +1055,10 @@ function pushMemoAnswerFrames(stack, entry, goal, rest, env, depth, active, solv
 }
 
 function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth, active) {
-  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) return;
+  if (group.recursive && !group.cutRecursive && !group.linearNumeric && activeVariantIn(goal, env, active)) {
+    solver.recursionCycleDetected = true;
+    return;
+  }
   if (group.fastPi && pushFastPiFrames(stack, goal, rest, env, depth, active)) return;
   if (tryPushGroundScalarRuleFrame(stack, solver, group, goal, rest, env, depth, active)) return;
   if (tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth, active)) return;
@@ -1981,7 +1992,10 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     }
 
     const goal = runGoals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2035,7 +2049,10 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     }
 
     const goal = goals[state.index];
-    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) continue;
+    if (activeMightContain(goal, active) && activeVariantIn(goal, envWithLocal(env, state.names, state.values), active)) {
+      solver.recursionCycleDetected = true;
+      continue;
+    }
     solver.stats.solve_one_goal_calls++;
     const candidates = selectScalarFactCandidates(groups[state.index], goal, env, state.names, state.values);
     const nextStates = [];
@@ -2205,7 +2222,11 @@ function tryPushCompactBinaryChainFrames(stack, solver, group, goal, rest, env,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const seenSet = seen[secondType];
-    if (!seenSet || seenSet.has(secondName)) return true;
+    if (!seenSet) return true;
+    if (seenSet.has(secondName)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (cache[secondType].has(secondName)) {
       rememberCompactChainSuccess(cache, seen);
       stack.push({ kind: 'goals', goals: rest, env, depth: depth + 1, active });
@@ -2326,8 +2347,14 @@ function tryPushGroundChainFrames(stack, solver, group, goal, rest, env, depth,
     if (solver.solutionsSeen >= solver.solutionLimit) return true;
     solver.stats.max_depth = Math.max(solver.stats.max_depth, currentDepth);
     const key = groundChainKey(currentGoal);
-    if (seen.has(key)) return true;
-    if (activeVariantIn(currentGoal, currentEnv, active)) return true;
+    if (seen.has(key)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
+    if (activeVariantIn(currentGoal, currentEnv, active)) {
+      solver.recursionCycleDetected = true;
+      return true;
+    }
     if (solver.groundChainSuccess.has(key)) {
       rememberGroundChainSuccess(solver, seen);
       stack.push({ kind: 'goals', goals: rest, env: baseEnv, depth: depth + 1, active });

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

@@ -73,7 +73,7 @@ Status values are:
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |
 | 8.17.4 | Meaning/effects of `halt(Status)` | Integer `Status` is converted to the host process/runner halt code; it produces no Prolog solution. | **defined** — `haltBuiltin()`, `src/execute.js`, `src/cli.js`. |
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso.js`, `src/number-value.js`. |
-| 9.1.4.2 | Floating-point result function, including tiny non-zero arithmetic results | For arithmetic operation results that underflow to zero from non-zero operands, EyeProlog chooses the exceptional value `underflow`, exposed as `evaluation_error(underflow)`. Float token/`number_chars/2` input is a separate conversion path and finite input underflow rounds to `0.0`. | **defined** — `evaluateOperation()` and parser/number conversion; executable issue-56 regression below. |
+| 9.1.4.2 | Floating-point result function, including tiny non-zero arithmetic results | EyeProlog chooses `round(x)` rather than the exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller result to `0.0`, consistently with float-token and `number_chars/2` input. | **defined** — `evaluateOperation()` and parser/number conversion; executable issue-56 regression below. |
 | 9.1.4.3 | Approximate-addition function | ECMAScript binary64 addition is used; subtraction is implemented through the corresponding host operation and all finite results remain binary64 values. | **defined** — `evaluateOperation()` in `src/iso.js`. |
 | 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso.js` BigInt bitwise operators. |
 | 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso.js`. |
@@ -83,22 +83,18 @@ Status values are:
 | 9.4.5 | Bitwise complement | BigInt complement, i.e. `~N = -N-1`. | **defined** — `~a`. |
 | Cor.2 9.4.6 | `xor/2` with negative operands | BigInt infinite-two's-complement semantics. | **defined** — `a ^ b`. |
 
-### Why issue #56's two float results differ
-
-The arithmetic expression and the float token go through different specified
-layers. Clause 9.1.4 defines arithmetic operations in terms of the
-implementation-defined floating rounding/result functions, and EyeProlog's
-chosen `resultF` policy reports underflow for a non-zero arithmetic result that
-falls below the normal range and rounds to zero. By contrast, reading the token
-`0.1e-999` is an input conversion; the 1995 text does not precisely define the
-rounding of an inexact float token, a gap also called out in the later
-[WG17/STC item #40](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#40).
-EyeProlog's documented input policy is therefore to accept finite token
-underflow as `0.0` while arithmetic underflow remains an evaluation error.
-
-The regression suite contains an issue-56 case that checks both observations,
-and the existing `stc/float_underflow_input` conformance case covers the related
-input-conversion policy.
+### Issue #56: one underflow policy
+
+Clause 9.1.4.2 permits the processor to choose `round(x)` or the exceptional
+value `underflow` for a tiny non-zero arithmetic result. EyeProlog chooses
+`round(x)`. Because its floating-point profile is ECMAScript IEEE-754 binary64,
+representable subnormal values remain non-zero and smaller results round to
+`0.0`. Float-token and `number_chars/2` input use the same finite-double
+rounding policy, so the same mathematical magnitude is no longer accepted as
+`0.0` on input while rejected as an arithmetic result.
+
+The regression suite checks both arithmetic and token input, and the existing
+`stc/float_underflow_input` conformance case covers the related input conversion.
 
 ## Implementation-specific features required to be documented by 5.4
 

package/test/conformance/ISO-MATRIX.md

@@ -33,8 +33,8 @@ clause-by-clause in [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.m
 with *The Art of EyeProlog* remaining the implementation reference. In
 particular, the index records the unbounded integer model, `double_quotes=chars`,
 `//` rounding toward zero, the ECMAScript binary64 float policy (including the
-9.1.4.2 arithmetic-underflow choice), stream/character decisions, and the
-normal-profile extension boundary.
+9.1.4.2 choice to round tiny arithmetic results rather than raise underflow),
+stream/character decisions, and the normal-profile extension boundary.
 
 This is an executable conformance matrix, not a certification issued by an
 independent standards body. Release gating runs the ISO cases and the dedicated

package/test/conformance/STC-DRAFT-STATUS.md

@@ -37,7 +37,8 @@ record the behavior discussed in issue #54:
 - a positive finite numeric token beyond the representable range raises
   `representation_error(max_float)`;
 - the corresponding negative overflow raises `representation_error(min_float)`;
-- input underflow may round to `0.0`;
+- float input and arithmetic underflow use the same binary64 rounding policy;
+  values smaller than the representable range round to `0.0`;
 - overflow produced by arithmetic evaluation remains
   `evaluation_error(float_overflow)`.
 

package/test/conformance/cases/iso/arithmetic_underflow_rounds.pl

@@ -0,0 +1,7 @@
+%% goal: arithmetic_underflow_rounds
+
+arithmetic_underflow_rounds :-
+    A is 0.1*10** -999,
+    B is exp(-1000.0),
+    A =:= 0.0,
+    B =:= 0.0.

package/test/conformance/expected/iso/arithmetic_underflow_rounds.pl

@@ -0,0 +1 @@
+arithmetic_underflow_rounds.

package/test/run-regression.mjs

@@ -740,10 +740,10 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'arithmetic underflow choice differs from float-token input underflow (issue #56)',
+      name: 'arithmetic and float-token underflow both round to zero (issue #56)',
       run: () => {
-        const result = run('', { goal: 'catch((N is 0.1*10** -999), error(evaluation_error(underflow), _), N = underflow)' });
-        assertEqual(result.stdout, 'catch(underflow is 0.1 * 10 ** -999, error(evaluation_error(underflow), eyeprolog), underflow = underflow).\n', 'operation underflow');
+        assertEqual(run('', { goal: 'N is 0.1*10** -999' }).stdout, '0.0 is 0.1 * 10 ** -999.\n', 'operation underflow');
+        assertEqual(run('', { goal: 'N is exp(-1000.0)' }).stdout, '0.0 is exp(-1000.0).\n', 'function underflow');
         assertEqual(run('', { goal: 'N = 0.1e-999' }).stdout, '0.0 = 0.0.\n', 'float-token input underflow');
       },
     },
@@ -1317,6 +1317,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads preserves output before a delayed call/1 instantiation error (issue #57)',
+      run: () => {
+        const result = publicApi.runQuads(`16, "7.8.3.4#9"\n?- call((write(3), X)).\n   outputs("3"), instantiation_error.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'runQuads recognizes recursion-guard cycle evidence as loops (issue #58)',
+      run: () => {
+        const result = publicApi.runQuads(`inf :- inf, inf.\n\n23\n?- inf.\n   loops.\n`);
+        assertEqual(result.passed, 1, 'quad passed');
+        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+      },
+    },
     {
       name: '--quads runs embedded tests and reports failures through exit status',
       run: () => {
@@ -3431,7 +3447,7 @@ function documentationSyncCases() {
           '8.17.3', '8.17.4', '9.1.3.1', '9.1.4.1', '9.1.4.2', '9.1.4.3', '9.4',
           '9.4.1', '9.4.2', '9.4.3', '9.4.4', '9.4.5', 'Cor.2 9.4.6',
         ]) assertIncludes(text, `| ${clause} |`, `ISO 5.4 clause ${clause}`);
-        assertIncludes(text, 'Why issue #56', 'issue #56 explanation');
+        assertIncludes(text, 'Issue #56: one underflow policy', 'issue #56 explanation');
         assertIncludes(text, 'Implementation-specific features required to be documented by 5.4', '5.5 extension inventory');
       },
     },

package/the-art-of-eyeprolog.md

@@ -6831,9 +6831,12 @@ variable in the renamed exception term. `...` and `ad_infinitum` accept further
 indented descriptions after one query are independent checks: each re-runs the
 query, each is counted in the `quads:` summary, and a failing description does
 not suppress later descriptions for that query. `inputs/1` supplies and checks
-consumed characters; `outputs/1` checks emitted characters. `sto` marks
-an answer description that this finite-tree implementation skips. `loops` is
-checked with a deterministic solver-depth budget. The advanced stream
+consumed characters; `outputs/1` checks characters emitted while reaching
+the described answer or error, including output produced before a later
+exception. `sto` marks an answer description that this finite-tree
+implementation skips. `loops` accepts direct active-variant cycle evidence from
+EyeProlog's normal recursion guard, with bounded depth/inference exhaustion as a
+fallback for loops that have no such structural witness. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
 annotation, are not executed by the current runner.
 

package/test/conformance/errors/iso/arithmetic_underflow.pl

@@ -1,3 +0,0 @@
-%% goal: trigger
-
-trigger :- _ is exp(-1000.0).

package/test/conformance/expected-errors/iso/arithmetic_underflow.txt

@@ -1 +0,0 @@
-error(evaluation_error(underflow))