eyeling 1.11.0 → 1.11.2

package/HANDBOOK.md

@@ -769,7 +769,7 @@ Eyeling also accepts an older cwm-ish variant where the **subject is a 2-element
 * `NaN` is treated as **not equal to anything**, including itself, for `math:equalTo`.
 * Comparisons involving non-parsable values simply fail.
 
-Because these are pure tests, Eyeling treats them as **constraint builtins** and tends to push them to the end of forward-rule premises so they’re checked after other goals bind variables.
+These are pure tests. In forward rules, if a test builtin is encountered before its inputs are bound and it fails, Eyeling may **defer** it and try other goals first; once variables become bound, the test is retried.
 
 ---
 
@@ -1078,7 +1078,7 @@ Important constraint: the item to remove must be **ground** (fully known) before
 **Shape:**
 `(a b c) list:notMember x`
 
-Succeeds iff the object cannot be unified with any element of the subject list. This is treated as a constraint builtin.
+Succeeds iff the object cannot be unified with any element of the subject list. As a test, it typically works best once its inputs are bound; in forward rules Eyeling may defer it if it is reached before bindings are available.
 
 #### `list:append`
 
@@ -1310,7 +1310,7 @@ This is essentially a list-producing “findall”.
 
 For every solution of `WhereFormula`, `ThenFormula` must be provable under the bindings of that solution. If any witness fails, the builtin fails. No bindings are returned.
 
-This is treated as a constraint builtin.
+As a pure test (no returned bindings), this typically works best once its inputs are bound; in forward rules Eyeling may defer it if it is reached too early.
 
 ### Skolemization and URI casting
 
@@ -1350,7 +1350,7 @@ As a goal, this builtin simply checks that the terms are sufficiently bound/usab
 * When you run Eyeling with `--strings` / `-r`, the CLI collects all `log:outputString` triples from the *saturated* closure.
 * It sorts them deterministically by the subject “key” and concatenates the string values in that order.
 
-This is treated as a constraint builtin (it shouldn’t drive search; it should merely validate that strings exist once other reasoning has produced them).
+This is a pure test/side-effect marker (it shouldn’t drive search; it should merely validate that strings exist once other reasoning has produced them). In forward rules Eyeling may defer it if it is reached before the terms are usable.
 
 ---
 

package/eyeling-builtins.ttl

@@ -17,15 +17,13 @@
 #
 # Notes:
 # - ex:kind is intentionally coarse:
-#     ex:Test      = succeeds/fails, no new variable bindings (a "constraint")
+#     ex:Test      = succeeds/fails (typically no bindings)
 #     ex:Function  = computes an output and may bind variables
 #     ex:Relation  = unification-based, may bind variables
 #     ex:Generator = may yield multiple solutions
 #     ex:IO        = dereferences/parses external content (Node or browser)
 #     ex:Meta      = formula/type/meta-level operations
 #     ex:SideEffect= produces output; does not bind variables
-# - ex:isConstraint corresponds to isConstraintBuiltin(tr) in eyeling.js, with
-#   one suggested addition noted in the comments below.
 # ------------------------------------------------------------------------------
 
 ex:EyelingBuiltinCatalog a ex:Catalog ;
@@ -39,8 +37,6 @@ ex:IO a ex:Kind .
 ex:Meta a ex:Kind .
 ex:SideEffect a ex:Kind .
 
-ex:isConstraint a rdf:Property ;
-  rdfs:comment "True for builtins classified as constraint/test builtins by isConstraintBuiltin(tr) (premise reordering helper)." .
 ex:kind a rdf:Property .
 ex:aliasOf a rdf:Property .
 
@@ -60,22 +56,22 @@ crypto:sha512 a ex:Builtin ; ex:kind ex:Function ;
 
 # --- math: comparisons (constraint/test) -----------------------------
 
-math:equalTo a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:equalTo a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (=). No bindings; succeeds iff subject and object are numerically equal (supports XSD numeric literals, including special float/double lexicals)." .
 
-math:notEqualTo a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:notEqualTo a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (!=). No bindings; succeeds iff subject and object are numerically different." .
 
-math:greaterThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:greaterThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (>). No bindings." .
 
-math:lessThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:lessThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (<). No bindings." .
 
-math:notLessThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:notLessThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (>=). No bindings." .
 
-math:notGreaterThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+math:notGreaterThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Numeric comparison (<=). No bindings." .
 
 # --- math: arithmetic / numeric functions ----------------------------
@@ -204,7 +200,7 @@ list:in a ex:Builtin ; ex:kind ex:Generator ;
 list:length a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Length of a list as an integer token. Strict when object is ground (no integer<->decimal equality)." .
 
-list:notMember a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+list:notMember a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: succeeds iff object does not unify with any element of the subject list. No new bindings." .
 
 list:reverse a ex:Builtin ; ex:kind ex:Function ;
@@ -224,7 +220,7 @@ list:firstRest a ex:Builtin ; ex:kind ex:Function ;
 log:equalTo a ex:Builtin ; ex:kind ex:Relation ;
   rdfs:comment "Unification: succeeds iff subject and object unify; may bind variables." .
 
-log:notEqualTo a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+log:notEqualTo a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: succeeds iff subject and object do NOT unify (implemented as: if unification succeeds, builtin fails). No new bindings returned." .
 
 log:conjunction a ex:Builtin ; ex:kind ex:Meta ;
@@ -263,13 +259,13 @@ log:impliedBy a ex:Builtin ; ex:kind ex:Relation ;
 log:includes a ex:Builtin ; ex:kind ex:Generator ;
   rdfs:comment "Proves the object formula in the (possibly scoped) facts/rules; returns the set of proof substitutions (may bind variables)." .
 
-log:notIncludes a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+log:notIncludes a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: succeeds iff proving the object formula yields no solutions. No new bindings." .
 
 log:collectAllIn a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Scoped collector: given (valueTemplate whereClause outList) and a scope formula, collects all solutions of whereClause and binds/unifies outList with the list of instantiated valueTemplate results." .
 
-log:forAllIn a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+log:forAllIn a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: for all solutions of whereClause, thenClause must have at least one solution in the same scope. No new bindings." .
 
 log:skolem a ex:Builtin ; ex:kind ex:Function ;
@@ -289,40 +285,40 @@ log:outputString a ex:Builtin ; ex:kind ex:SideEffect ;
 string:concatenation a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Concatenates a list of string-ish terms; binds/unifies object with the resulting string literal." .
 
-string:contains a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:contains a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: subject contains object (substring). No bindings." .
 
-string:containsIgnoringCase a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:containsIgnoringCase a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: case-insensitive contains. No bindings." .
 
-string:endsWith a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:endsWith a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: subject ends with object. No bindings." .
 
-string:startsWith a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:startsWith a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: subject starts with object. No bindings." .
 
-string:equalIgnoringCase a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:equalIgnoringCase a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: case-insensitive equality. No bindings." .
 
-string:notEqualIgnoringCase a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:notEqualIgnoringCase a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: case-insensitive inequality. No bindings." .
 
-string:greaterThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:greaterThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: Unicode codepoint order (>) on decoded strings. No bindings." .
 
-string:lessThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:lessThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: Unicode codepoint order (<) on decoded strings. No bindings." .
 
-string:notGreaterThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:notGreaterThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: Unicode codepoint order (<=). No bindings." .
 
-string:notLessThan a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:notLessThan a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: Unicode codepoint order (>=). No bindings." .
 
-string:matches a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:matches a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: regex match. Pattern is compiled with swap-style escaping helper. No bindings." .
 
-string:notMatches a ex:Builtin ; ex:kind ex:Test ; ex:isConstraint true ;
+string:notMatches a ex:Builtin ; ex:kind ex:Test;
   rdfs:comment "Constraint/test: negated regex match. No bindings." .
 
 string:replace a ex:Builtin ; ex:kind ex:Function ;

package/eyeling.js

@@ -727,7 +727,7 @@ const {
 
 const { lex, N3SyntaxError, decodeN3StringEscapes } = require('./lexer');
 const { Parser } = require('./parser');
-const { liftBlankRuleVars, reorderPremiseForConstraints, isConstraintBuiltin } = require('./rules');
+const { liftBlankRuleVars } = require('./rules');
 
 const { termToN3, tripleToN3 } = require('./printing');
 
@@ -905,8 +905,7 @@ function __makeRuleFromTerms(left, right, isForward) {
   }
 
   const headBlankLabels = collectBlankLabelsInTriples(rawConclusion);
-  const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
-  const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+  const [premise, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
   return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
 }
 
@@ -2707,8 +2706,12 @@ function evalUnaryMathRel(g, subst, forwardFn, inverseFn /* may be null */) {
     return [];
   }
 
-  // Fully unbound: treat as satisfiable (avoid infinite enumeration)
-  if (sIsUnbound && oIsUnbound) return [{ ...subst }];
+  // Fully unbound: do *not* treat as immediately satisfiable.
+  // In goal proving, succeeding with no bindings can let a conjunction
+  // "pass" before other goals bind one side, preventing later evaluation
+  // in the now-solvable direction. Instead, we fail here so the engine's
+  // builtin deferral can retry the goal once variables are bound.
+  if (sIsUnbound && oIsUnbound) return [];
 
   return [];
 }
@@ -5394,6 +5397,26 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     return termHasVarOrBlank(tr.s) || termHasVarOrBlank(tr.p) || termHasVarOrBlank(tr.o);
   }
 
+  // Some functional math relations (sin/cos/...) can be used as a pure
+  // satisfiability check. When *both* sides are unbound we avoid infinite
+  // enumeration by producing no bindings, but we still want the conjunction
+  // to succeed once it has been fully deferred to the end.
+  function isSatisfiableWhenFullyUnbound(pIriVal) {
+    return (
+      pIriVal === MATH_NS + 'sin' ||
+      pIriVal === MATH_NS + 'cos' ||
+      pIriVal === MATH_NS + 'tan' ||
+      pIriVal === MATH_NS + 'asin' ||
+      pIriVal === MATH_NS + 'acos' ||
+      pIriVal === MATH_NS + 'atan' ||
+      pIriVal === MATH_NS + 'sinh' ||
+      pIriVal === MATH_NS + 'cosh' ||
+      pIriVal === MATH_NS + 'tanh' ||
+      pIriVal === MATH_NS + 'degrees' ||
+      pIriVal === MATH_NS + 'negation'
+    );
+  }
+
   const initialGoals = Array.isArray(goals) ? goals.slice() : [];
   const initialSubst = subst ? { ...subst } : {};
   const initialVisited = visited ? visited.slice() : [];
@@ -5443,7 +5466,7 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
       const remaining = max - results.length;
       if (remaining <= 0) return results;
       const builtinMax = Number.isFinite(remaining) && !restGoals.length ? remaining : undefined;
-      const deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen, builtinMax);
+      let deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen, builtinMax);
 
       // If the builtin currently yields no solutions but still contains
       // unbound variables, try other goals first (defer). This fixes
@@ -5467,6 +5490,25 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
         continue;
       }
 
+      // If we've rotated through the whole conjunction without being able to
+      // make progress, and this is a functional math relation with *both* sides
+      // unbound, treat it as satisfiable once (no bindings) rather than failing
+      // the whole conjunction.
+      const __fullyUnboundSO =
+        (goal0.s instanceof Var || goal0.s instanceof Blank) &&
+        (goal0.o instanceof Var || goal0.o instanceof Blank) &&
+        parseNum(goal0.s) === null &&
+        parseNum(goal0.o) === null;
+      if (
+        state.canDeferBuiltins &&
+        !deltas.length &&
+        isSatisfiableWhenFullyUnbound(__pv0) &&
+        __fullyUnboundSO &&
+        (!restGoals.length || dc >= state.goals.length)
+      ) {
+        deltas = [{}];
+      }
+
       const nextStates = [];
       for (const delta of deltas) {
         const composed = composeSubst(state.subst, delta);
@@ -5833,8 +5875,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
 
               if (left !== null && right !== null) {
                 if (isFwRuleTriple) {
-                  const [premise0, conclusion] = liftBlankRuleVars(left, right);
-                  const premise = reorderPremiseForConstraints(premise0);
+                  const [premise, conclusion] = liftBlankRuleVars(left, right);
                   const headBlankLabels = collectBlankLabelsInTriples(conclusion);
                   const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
 
@@ -6864,7 +6905,7 @@ const {
 } = require('./prelude');
 
 const { N3SyntaxError } = require('./lexer');
-const { liftBlankRuleVars, reorderPremiseForConstraints } = require('./rules');
+const { liftBlankRuleVars } = require('./rules');
 
 class Parser {
   constructor(tokens) {
@@ -7484,8 +7525,9 @@ class Parser {
 
     const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
 
-    // Reorder constraints for *forward* rules.
-    const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+    // Keep premise order as written; the engine may defer some builtins in
+    // forward rules when they cannot yet run due to unbound variables.
+    const premise = premise0;
 
     return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
   }
@@ -8062,11 +8104,6 @@ module.exports = { termToN3, tripleToN3 };
 'use strict';
 
 const {
-  MATH_NS,
-  LIST_NS,
-  LOG_NS,
-  STRING_NS,
-  Iri,
   Var,
   Blank,
   ListTerm,
@@ -8122,81 +8159,10 @@ function liftBlankRuleVars(premise, conclusion) {
   return [newPremise, conclusion];
 }
 
-function isConstraintBuiltin(tr) {
-  if (!(tr.p instanceof Iri)) return false;
-  const v = tr.p.value;
-
-  // math: numeric comparisons (no new bindings, just tests)
-  if (
-    v === MATH_NS + 'equalTo' ||
-    v === MATH_NS + 'greaterThan' ||
-    v === MATH_NS + 'lessThan' ||
-    v === MATH_NS + 'notEqualTo' ||
-    v === MATH_NS + 'notGreaterThan' ||
-    v === MATH_NS + 'notLessThan'
-  ) {
-    return true;
-  }
-
-  // list: membership test with no bindings
-  if (v === LIST_NS + 'notMember') {
-    return true;
-  }
-
-  // log: tests that are purely constraints (no new bindings)
-  if (
-    v === LOG_NS + 'forAllIn' ||
-    v === LOG_NS + 'notEqualTo' ||
-    v === LOG_NS + 'notIncludes' ||
-    v === LOG_NS + 'outputString'
-  ) {
-    return true;
-  }
-
-  // string: relational / membership style tests (no bindings)
-  if (
-    v === STRING_NS + 'contains' ||
-    v === STRING_NS + 'containsIgnoringCase' ||
-    v === STRING_NS + 'endsWith' ||
-    v === STRING_NS + 'equalIgnoringCase' ||
-    v === STRING_NS + 'greaterThan' ||
-    v === STRING_NS + 'lessThan' ||
-    v === STRING_NS + 'matches' ||
-    v === STRING_NS + 'notEqualIgnoringCase' ||
-    v === STRING_NS + 'notGreaterThan' ||
-    v === STRING_NS + 'notLessThan' ||
-    v === STRING_NS + 'notMatches' ||
-    v === STRING_NS + 'startsWith'
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
-// Move constraint builtins to the end of the rule premise.
-// This is a simple "delaying" strategy similar in spirit to Prolog's when/2:
-// - normal goals first (can bind variables),
-// - pure test / constraint builtins last (checked once bindings are in place).
-function reorderPremiseForConstraints(premise) {
-  if (!premise || premise.length === 0) return premise;
-
-  const normal = [];
-  const delayed = [];
-
-  for (const tr of premise) {
-    if (isConstraintBuiltin(tr)) delayed.push(tr);
-    else normal.push(tr);
-  }
-  return normal.concat(delayed);
-}
-
 // ===========================================================================
 
 module.exports = {
   liftBlankRuleVars,
-  isConstraintBuiltin,
-  reorderPremiseForConstraints,
 };
 
   };

package/lib/engine.js

@@ -42,7 +42,7 @@ const {
 
 const { lex, N3SyntaxError, decodeN3StringEscapes } = require('./lexer');
 const { Parser } = require('./parser');
-const { liftBlankRuleVars, reorderPremiseForConstraints, isConstraintBuiltin } = require('./rules');
+const { liftBlankRuleVars } = require('./rules');
 
 const { termToN3, tripleToN3 } = require('./printing');
 
@@ -220,8 +220,7 @@ function __makeRuleFromTerms(left, right, isForward) {
   }
 
   const headBlankLabels = collectBlankLabelsInTriples(rawConclusion);
-  const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
-  const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+  const [premise, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
   return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
 }
 
@@ -2022,8 +2021,12 @@ function evalUnaryMathRel(g, subst, forwardFn, inverseFn /* may be null */) {
     return [];
   }
 
-  // Fully unbound: treat as satisfiable (avoid infinite enumeration)
-  if (sIsUnbound && oIsUnbound) return [{ ...subst }];
+  // Fully unbound: do *not* treat as immediately satisfiable.
+  // In goal proving, succeeding with no bindings can let a conjunction
+  // "pass" before other goals bind one side, preventing later evaluation
+  // in the now-solvable direction. Instead, we fail here so the engine's
+  // builtin deferral can retry the goal once variables are bound.
+  if (sIsUnbound && oIsUnbound) return [];
 
   return [];
 }
@@ -4709,6 +4712,26 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     return termHasVarOrBlank(tr.s) || termHasVarOrBlank(tr.p) || termHasVarOrBlank(tr.o);
   }
 
+  // Some functional math relations (sin/cos/...) can be used as a pure
+  // satisfiability check. When *both* sides are unbound we avoid infinite
+  // enumeration by producing no bindings, but we still want the conjunction
+  // to succeed once it has been fully deferred to the end.
+  function isSatisfiableWhenFullyUnbound(pIriVal) {
+    return (
+      pIriVal === MATH_NS + 'sin' ||
+      pIriVal === MATH_NS + 'cos' ||
+      pIriVal === MATH_NS + 'tan' ||
+      pIriVal === MATH_NS + 'asin' ||
+      pIriVal === MATH_NS + 'acos' ||
+      pIriVal === MATH_NS + 'atan' ||
+      pIriVal === MATH_NS + 'sinh' ||
+      pIriVal === MATH_NS + 'cosh' ||
+      pIriVal === MATH_NS + 'tanh' ||
+      pIriVal === MATH_NS + 'degrees' ||
+      pIriVal === MATH_NS + 'negation'
+    );
+  }
+
   const initialGoals = Array.isArray(goals) ? goals.slice() : [];
   const initialSubst = subst ? { ...subst } : {};
   const initialVisited = visited ? visited.slice() : [];
@@ -4758,7 +4781,7 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
       const remaining = max - results.length;
       if (remaining <= 0) return results;
       const builtinMax = Number.isFinite(remaining) && !restGoals.length ? remaining : undefined;
-      const deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen, builtinMax);
+      let deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen, builtinMax);
 
       // If the builtin currently yields no solutions but still contains
       // unbound variables, try other goals first (defer). This fixes
@@ -4782,6 +4805,25 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
         continue;
       }
 
+      // If we've rotated through the whole conjunction without being able to
+      // make progress, and this is a functional math relation with *both* sides
+      // unbound, treat it as satisfiable once (no bindings) rather than failing
+      // the whole conjunction.
+      const __fullyUnboundSO =
+        (goal0.s instanceof Var || goal0.s instanceof Blank) &&
+        (goal0.o instanceof Var || goal0.o instanceof Blank) &&
+        parseNum(goal0.s) === null &&
+        parseNum(goal0.o) === null;
+      if (
+        state.canDeferBuiltins &&
+        !deltas.length &&
+        isSatisfiableWhenFullyUnbound(__pv0) &&
+        __fullyUnboundSO &&
+        (!restGoals.length || dc >= state.goals.length)
+      ) {
+        deltas = [{}];
+      }
+
       const nextStates = [];
       for (const delta of deltas) {
         const composed = composeSubst(state.subst, delta);
@@ -5148,8 +5190,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
 
               if (left !== null && right !== null) {
                 if (isFwRuleTriple) {
-                  const [premise0, conclusion] = liftBlankRuleVars(left, right);
-                  const premise = reorderPremiseForConstraints(premise0);
+                  const [premise, conclusion] = liftBlankRuleVars(left, right);
                   const headBlankLabels = collectBlankLabelsInTriples(conclusion);
                   const newRule = new Rule(premise, conclusion, true, false, headBlankLabels);
 

package/lib/parser.js

@@ -40,7 +40,7 @@ const {
 } = require('./prelude');
 
 const { N3SyntaxError } = require('./lexer');
-const { liftBlankRuleVars, reorderPremiseForConstraints } = require('./rules');
+const { liftBlankRuleVars } = require('./rules');
 
 class Parser {
   constructor(tokens) {
@@ -660,8 +660,9 @@ class Parser {
 
     const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
 
-    // Reorder constraints for *forward* rules.
-    const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+    // Keep premise order as written; the engine may defer some builtins in
+    // forward rules when they cannot yet run due to unbound variables.
+    const premise = premise0;
 
     return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
   }

package/lib/rules.js

@@ -8,11 +8,6 @@
 'use strict';
 
 const {
-  MATH_NS,
-  LIST_NS,
-  LOG_NS,
-  STRING_NS,
-  Iri,
   Var,
   Blank,
   ListTerm,
@@ -68,79 +63,8 @@ function liftBlankRuleVars(premise, conclusion) {
   return [newPremise, conclusion];
 }
 
-function isConstraintBuiltin(tr) {
-  if (!(tr.p instanceof Iri)) return false;
-  const v = tr.p.value;
-
-  // math: numeric comparisons (no new bindings, just tests)
-  if (
-    v === MATH_NS + 'equalTo' ||
-    v === MATH_NS + 'greaterThan' ||
-    v === MATH_NS + 'lessThan' ||
-    v === MATH_NS + 'notEqualTo' ||
-    v === MATH_NS + 'notGreaterThan' ||
-    v === MATH_NS + 'notLessThan'
-  ) {
-    return true;
-  }
-
-  // list: membership test with no bindings
-  if (v === LIST_NS + 'notMember') {
-    return true;
-  }
-
-  // log: tests that are purely constraints (no new bindings)
-  if (
-    v === LOG_NS + 'forAllIn' ||
-    v === LOG_NS + 'notEqualTo' ||
-    v === LOG_NS + 'notIncludes' ||
-    v === LOG_NS + 'outputString'
-  ) {
-    return true;
-  }
-
-  // string: relational / membership style tests (no bindings)
-  if (
-    v === STRING_NS + 'contains' ||
-    v === STRING_NS + 'containsIgnoringCase' ||
-    v === STRING_NS + 'endsWith' ||
-    v === STRING_NS + 'equalIgnoringCase' ||
-    v === STRING_NS + 'greaterThan' ||
-    v === STRING_NS + 'lessThan' ||
-    v === STRING_NS + 'matches' ||
-    v === STRING_NS + 'notEqualIgnoringCase' ||
-    v === STRING_NS + 'notGreaterThan' ||
-    v === STRING_NS + 'notLessThan' ||
-    v === STRING_NS + 'notMatches' ||
-    v === STRING_NS + 'startsWith'
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
-// Move constraint builtins to the end of the rule premise.
-// This is a simple "delaying" strategy similar in spirit to Prolog's when/2:
-// - normal goals first (can bind variables),
-// - pure test / constraint builtins last (checked once bindings are in place).
-function reorderPremiseForConstraints(premise) {
-  if (!premise || premise.length === 0) return premise;
-
-  const normal = [];
-  const delayed = [];
-
-  for (const tr of premise) {
-    if (isConstraintBuiltin(tr)) delayed.push(tr);
-    else normal.push(tr);
-  }
-  return normal.concat(delayed);
-}
-
 // ===========================================================================
 
 module.exports = {
   liftBlankRuleVars,
-  isConstraintBuiltin,
-  reorderPremiseForConstraints,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [