eyeling 1.5.35 → 1.5.37

package/eyeling.js

@@ -67,6 +67,52 @@ const jsonPointerCache = new Map();
 // Controls whether human-readable proof comments are printed.
 let proofCommentsEnabled = true;
 
+// ----------------------------------------------------------------------------
+// Deterministic time support
+// ----------------------------------------------------------------------------
+// If set, overrides time:localTime across the whole run (and across runs if you
+// pass the same value). Store as xsd:dateTime *lexical* string (no quotes).
+let fixedNowLex = null;
+
+// If not fixed, we still memoize one value per run to avoid re-firing rules.
+let runNowLex = null;
+
+function normalizeDateTimeLex(s) {
+  // Accept: 2025-... , "2025-..." , "2025-..."^^xsd:dateTime , "..."^^<...>
+  if (s == null) return null;
+  let t = String(s).trim();
+  const caret = t.indexOf("^^");
+  if (caret >= 0) t = t.slice(0, caret).trim();
+  if (t.startsWith('"') && t.endsWith('"') && t.length >= 2) t = t.slice(1, -1);
+  return t.trim();
+}
+
+function utcIsoDateTimeStringFromEpochSeconds(sec) {
+  const ms = sec * 1000;
+  const d = new Date(ms);
+  function pad(n, w = 2) { return String(n).padStart(w, "0"); }
+  const year = d.getUTCFullYear();
+  const month = d.getUTCMonth() + 1;
+  const day = d.getUTCDate();
+  const hour = d.getUTCHours();
+  const min = d.getUTCMinutes();
+  const s2 = d.getUTCSeconds();
+  const ms2 = d.getUTCMilliseconds();
+  const msPart = ms2 ? "." + String(ms2).padStart(3, "0") : "";
+  return (
+    pad(year, 4) + "-" + pad(month) + "-" + pad(day) + "T" +
+    pad(hour) + ":" + pad(min) + ":" + pad(s2) + msPart +
+    "+00:00"
+  );
+}
+
+function getNowLex() {
+  if (fixedNowLex) return fixedNowLex;
+  if (runNowLex) return runNowLex;
+  runNowLex = localIsoDateTimeString(new Date());
+  return runNowLex;
+}
+
 // Deterministic pseudo-UUID from a string key (for log:skolem).
 // Not cryptographically strong, but stable and platform-independent.
 function deterministicSkolemIdFromKey(key) {
@@ -106,6 +152,8 @@ function deterministicSkolemIdFromKey(key) {
   );
 }
 
+let runLocalTimeCache = null;
+
 // ============================================================================
 // AST (Abstract Syntax Tree)
 // ============================================================================
@@ -511,6 +559,7 @@ class PrefixEnv {
     m["string"] = STRING_NS;
     m["list"] = LIST_NS;
     m["time"] = TIME_NS;
+    m["genid"] = SKOLEM_NS;
     m[""] = "";
     return new PrefixEnv(m);
   }
@@ -1225,7 +1274,7 @@ function termsEqual(a, b) {
     return true;
   }
   if (a instanceof FormulaTerm) {
-    return triplesListEqual(a.triples, b.triples);
+    return alphaEqFormulaTriples(a.triples, b.triples);
   }
   return false;
 }
@@ -1244,6 +1293,96 @@ function triplesListEqual(xs, ys) {
   return true;
 }
 
+// Alpha-equivalence for quoted formulas, up to *variable* and blank-node renaming.
+// Treats a formula as an unordered set of triples (order-insensitive match).
+function alphaEqVarName(x, y, vmap) {
+  if (vmap.hasOwnProperty(x)) return vmap[x] === y;
+  vmap[x] = y;
+  return true;
+}
+
+function alphaEqTermInFormula(a, b, vmap, bmap) {
+  // Blank nodes: renamable
+  if (a instanceof Blank && b instanceof Blank) {
+    const x = a.label;
+    const y = b.label;
+    if (bmap.hasOwnProperty(x)) return bmap[x] === y;
+    bmap[x] = y;
+    return true;
+  }
+
+  // Variables: renamable (ONLY inside quoted formulas)
+  if (a instanceof Var && b instanceof Var) {
+    return alphaEqVarName(a.name, b.name, vmap);
+  }
+
+  if (a instanceof Iri && b instanceof Iri) return a.value === b.value;
+  if (a instanceof Literal && b instanceof Literal) return a.value === b.value;
+
+  if (a instanceof ListTerm && b instanceof ListTerm) {
+    if (a.elems.length !== b.elems.length) return false;
+    for (let i = 0; i < a.elems.length; i++) {
+      if (!alphaEqTermInFormula(a.elems[i], b.elems[i], vmap, bmap)) return false;
+    }
+    return true;
+  }
+
+  if (a instanceof OpenListTerm && b instanceof OpenListTerm) {
+    if (a.prefix.length !== b.prefix.length) return false;
+    for (let i = 0; i < a.prefix.length; i++) {
+      if (!alphaEqTermInFormula(a.prefix[i], b.prefix[i], vmap, bmap)) return false;
+    }
+    // tailVar is a var-name string, so treat it as renamable too
+    return alphaEqVarName(a.tailVar, b.tailVar, vmap);
+  }
+
+  // Nested formulas: compare with fresh maps (separate scope)
+  if (a instanceof FormulaTerm && b instanceof FormulaTerm) {
+    return alphaEqFormulaTriples(a.triples, b.triples);
+  }
+
+  return false;
+}
+
+function alphaEqTripleInFormula(a, b, vmap, bmap) {
+  return (
+    alphaEqTermInFormula(a.s, b.s, vmap, bmap) &&
+    alphaEqTermInFormula(a.p, b.p, vmap, bmap) &&
+    alphaEqTermInFormula(a.o, b.o, vmap, bmap)
+  );
+}
+
+function alphaEqFormulaTriples(xs, ys) {
+  if (xs.length !== ys.length) return false;
+  // Fast path: exact same sequence.
+  if (triplesListEqual(xs, ys)) return true;
+
+  // Order-insensitive backtracking match, threading var/blank mappings.
+  const used = new Array(ys.length).fill(false);
+
+  function step(i, vmap, bmap) {
+    if (i >= xs.length) return true;
+    const x = xs[i];
+    for (let j = 0; j < ys.length; j++) {
+      if (used[j]) continue;
+      const y = ys[j];
+      // Cheap pruning when both predicates are IRIs.
+      if (x.p instanceof Iri && y.p instanceof Iri && x.p.value !== y.p.value) continue;
+
+      const v2 = { ...vmap };
+      const b2 = { ...bmap };
+      if (!alphaEqTripleInFormula(x, y, v2, b2)) continue;
+
+      used[j] = true;
+      if (step(i + 1, v2, b2)) return true;
+      used[j] = false;
+    }
+    return false;
+  }
+
+  return step(0, {}, {});
+}
+
 function alphaEqTerm(a, b, bmap) {
   if (a instanceof Blank && b instanceof Blank) {
     const x = a.label;
@@ -1274,8 +1413,8 @@ function alphaEqTerm(a, b, bmap) {
     return true;
   }
   if (a instanceof FormulaTerm && b instanceof FormulaTerm) {
-    // formulas are treated as opaque here: exact equality
-    return triplesListEqual(a.triples, b.triples);
+    // formulas are alpha-equivalent up to var/blank renaming
+    return alphaEqFormulaTriples(a.triples, b.triples);
   }
   return false;
 }
@@ -1541,12 +1680,29 @@ function containsVarTerm(t, v) {
   return false;
 }
 
+function isGroundTermInFormula(t) {
+  // EYE-style: variables inside formula terms are treated as local placeholders,
+  // so they don't make the *surrounding triple* non-ground.
+  if (t instanceof OpenListTerm) return false;
+  if (t instanceof ListTerm) return t.elems.every(e => isGroundTermInFormula(e));
+  if (t instanceof FormulaTerm) return t.triples.every(tr => isGroundTripleInFormula(tr));
+  // Iri/Literal/Blank/Var are all OK inside formulas
+  return true;
+}
+
+function isGroundTripleInFormula(tr) {
+  return (
+    isGroundTermInFormula(tr.s) &&
+    isGroundTermInFormula(tr.p) &&
+    isGroundTermInFormula(tr.o)
+  );
+}
+
 function isGroundTerm(t) {
   if (t instanceof Var) return false;
   if (t instanceof ListTerm) return t.elems.every(e => isGroundTerm(e));
   if (t instanceof OpenListTerm) return false;
-  if (t instanceof FormulaTerm)
-    return t.triples.every(tr => isGroundTriple(tr));
+  if (t instanceof FormulaTerm) return t.triples.every(tr => isGroundTripleInFormula(tr));
   return true;
 }
 
@@ -1755,8 +1911,11 @@ function unifyTerm(a, b, subst) {
     return s2;
   }
 
-  // Formulas: unify their internal triple sets (order-insensitive)
+  // Formulas:
+  // 1) If they are alpha-equivalent, succeed without leaking internal bindings.
+  // 2) Otherwise fall back to full unification (may bind vars).
   if (a instanceof FormulaTerm && b instanceof FormulaTerm) {
+    if (alphaEqFormulaTriples(a.triples, b.triples)) return { ...subst };
     return unifyFormulaTriples(a.triples, b.triples, subst);
   }
   return null;
@@ -2869,7 +3028,8 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // time:localTime
   // "" time:localTime ?D.  binds ?D to “now” as xsd:dateTime.
   if (g.p instanceof Iri && g.p.value === TIME_NS + "localTime") {
-    const now = localIsoDateTimeString(new Date());
+    const now = getNowLex();
+
     if (g.o instanceof Var) {
       const s2 = { ...subst };
       s2[g.o.name] = new Literal(`"${now}"^^<${XSD_NS}dateTime>`);
@@ -3692,6 +3852,12 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 function isBuiltinPred(p) {
   if (!(p instanceof Iri)) return false;
   const v = p.value;
+
+  // Treat RDF Collections as list-term builtins too.
+  if (v === RDF_NS + "first" || v === RDF_NS + "rest") {
+    return true;
+  }
+
   return (
     v.startsWith(CRYPTO_NS) ||
     v.startsWith(MATH_NS)   ||
@@ -4148,6 +4314,16 @@ function termToN3(t, pref) {
   }
  if (t instanceof Literal) {
    const [lex, dt] = literalParts(t.value);
+
+   // Pretty-print xsd:boolean as bare true/false
+   if (dt === XSD_NS + "boolean") {
+     const v = stripQuotes(lex);
+     if (v === "true" || v === "false") return v;
+     // optional: normalize 1/0 too
+     if (v === "1") return "true";
+     if (v === "0") return "false";
+   }
+
    if (!dt) return t.value; // keep numbers, booleans, lang-tagged strings, etc.
    const qdt = pref.shrinkIri(dt);
    if (qdt !== null) return `${lex}^^${qdt}`;   // e.g. ^^rdf:JSON

package/package.json

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

package/test/api.test.js

@@ -672,6 +672,36 @@ ${U('a')} <-${U('p')} ${U('b')}.`,
       new RegExp(`_:b2\\s+<${EX}q>\\s+<${EX}joe>\\s*\\.`),
     ],
   },
+
+  { name: '48 rdf:first: works on list terms (alias of list:first)',
+    opt: { proofComments: false }, input: ` { ( ${U('a')} ${U('b')} ${U('c')} ) rdf:first ?x. } => { ${U('s')} ${U('first')} ?x. }.
+`,
+    expect: [new RegExp(`${EX}s>\\s+<${EX}first>\\s+<${EX}a>\\s*\\.`)],
+  },
+
+  { name: '49 rdf:rest: works on list terms (alias of list:rest)',
+    opt: { proofComments: false }, input: ` { ( ${U('a')} ${U('b')} ${U('c')} ) rdf:rest ?r. ?r rdf:first ?y. } => { ${U('s')} ${U('second')} ?y. }.
+`,
+    expect: [new RegExp(`${EX}s>\\s+<${EX}second>\\s+<${EX}b>\\s*\\.`)],
+  },
+
+  { name: '50 rdf collection materialization: rdf:first/rdf:rest triples become list terms',
+    opt: { proofComments: false }, input: ` ${U('s')} ${U('p')} _:l1.
+_:l1 rdf:first ${U('a')}.
+_:l1 rdf:rest _:l2.
+_:l2 rdf:first ${U('b')}.
+_:l2 rdf:rest rdf:nil.
+
+{ ${U('s')} ${U('p')} ?lst. ?lst rdf:first ?x. } => { ${U('s')} ${U('q')} ?x. }.
+{ ${U('s')} ${U('p')} ?lst. ?lst rdf:rest ?r. ?r rdf:first ?y. } => { ${U('s')} ${U('q2')} ?y. }.
+{ ${U('s')} ${U('p')} ?lst. ?lst list:rest ?r. ?r list:first ?y. } => { ${U('s')} ${U('q3')} ?y. }.
+`,
+    expect: [
+      new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}a>\\s*\\.`),
+      new RegExp(`${EX}s>\\s+<${EX}q2>\\s+<${EX}b>\\s*\\.`),
+      new RegExp(`${EX}s>\\s+<${EX}q3>\\s+<${EX}b>\\s*\\.`),
+    ],
+  },
 ];
 
 let passed = 0;

package/examples/drone-corridor-planner-v2.n3

@@ -1,237 +0,0 @@
-# ========================================================================================
-# Drone Corridor Planner v2 (example N3 program)
-#
-# What this file is
-# - A tiny “planner” written in Notation3 (N3): it searches for a sequence of
-#   actions that moves a drone from a start state to a goal state.
-# - Intended to run in an N3 reasoner that supports forward rules (`=>`),
-#   backward rules (`<=`), and a few built-ins (e.g., `math:*`, `list:*`).
-#
-# How to run (one simple option)
-# - With the JavaScript `eyeling` CLI:
-#     npx eyeling examples/drone-corridor-planner-v2.n3
-#   The output will be newly derived facts, including one or more `gps:plan`
-#   results (see “Output” below).
-#
-# Big idea (in plain terms)
-# - We describe a “world” as a small set of facts: location, battery level,
-#   and whether the drone has a permit.
-# - We describe each possible action (fly, train, charge, buy/get permit) as a
-#   state transition:  FROM-state  ->  TO-state  plus some numeric “weights”.
-# - The rules then *compose* these transitions into multi-step plans while
-#   aggregating the weights (e.g., add durations, multiply beliefs).
-#
-# Reading the action descriptions
-# - Each action is encoded as a `gps:description` with this shape:
-#     ( FROM  true  TO  :actionName  duration  cost  belief  comfort )
-#   where:
-#   - FROM / TO are little graphs in `{ ... }` describing the state.
-#   - `true` is a placeholder “precondition” (kept for symmetry with richer
-#     variants where extra conditions may appear).
-#   - duration/cost/belief/comfort are example numbers used for scoring/pruning.
-#
-# Bounded search (why it doesn’t loop forever)
-# - The planner is *fuel-bounded*: it carries a list of “fuel tokens” and
-#   consumes one token per step. When fuel runs out, expansion stops.
-# - This is important because the map can contain cycles (e.g., going back to a
-#   previous city). Fuel-bounding keeps the search safe and finite.
-#
-# How scores are combined across a multi-step plan
-# - Duration and cost are summed.
-# - Belief and comfort are multiplied (so long plans tend to reduce them).
-# - The list of actions is built by appending each step’s action name.
-#
-# Output (what you should expect to see)
-# - The “Query” section asks for plans that take the drone from the initial
-#   state to the goal (Oostende), then prunes bad plans using thresholds like:
-#     belief > ...  and  cost < ...
-# - Each surviving plan is reported as a derived fact like:
-#     :d1 gps:plan ( ...actions... duration cost belief comfort battery permit fuelLeft ).
-#
-# Customizing this example
-# - Add/edit `gps:description` lines to introduce new routes/actions.
-# - Change the initial state (`:d1 :location ...`, `:battery ...`, `:permit ...`).
-# - Adjust `:fuel7` (more/less steps) and the pruning thresholds in the Query.
-#
-# Notes
-# - This is a *toy* corridor-planning model meant to illustrate rule-based
-#   planning patterns. The numeric values and “units” are illustrative.
-# ========================================================================================
-
-@prefix math: <http://www.w3.org/2000/10/swap/math#>.
-@prefix list: <http://www.w3.org/2000/10/swap/list#>.
-@prefix gps:  <https://eyereasoner.github.io/eye/reasoning/gps/gps-schema#>.
-@prefix :     <https://eyereasoner.github.io/eye/reasoning#>.
-
-# ----------------
-# current state
-# ----------------
-:d1 :location :Gent.
-:d1 :battery  :full.
-:d1 :permit   :none.
-
-# bounded search horizon (7 steps max)
-:fuel7 :value (:t :t :t :t :t :t :t).
-
-# -----------------------------------------------------------------
-# "map" / action descriptions (as backward rules)
-# State = { ?S :location ... . ?S :battery ... . ?S :permit ... . }
-# -----------------------------------------------------------------
-# two ways to reach Brugge (tradeoff: cost/comfort)
-{:map-DRONE gps:description (
-  {?S :location :Gent.   ?S :battery :full. ?S :permit ?P.} true
-  {?S :location :Brugge. ?S :battery :mid.  ?S :permit ?P.}
-  :fly_gent_brugge
-  1500.0 0.006 0.99 0.99
-)} <= true.
-
-{:map-DRONE gps:description (
-  {?S :location :Gent.   ?S :battery ?B.    ?S :permit ?P.} true
-  {?S :location :Brugge. ?S :battery ?B.    ?S :permit ?P.}
-  :train_gent_brugge
-  1700.0 0.012 0.999 0.995
-)} <= true.
-
-# via Kortrijk (permit + charging opportunities)
-{:map-DRONE gps:description (
-  {?S :location :Gent.     ?S :battery :full. ?S :permit ?P.} true
-  {?S :location :Kortrijk. ?S :battery :mid.  ?S :permit ?P.}
-  :fly_gent_kortrijk
-  1600.0 0.007 0.99 0.99
-)} <= true.
-
-{:map-DRONE gps:description (
-  {?S :location :Kortrijk. ?S :battery :mid.  ?S :permit ?P.} true
-  {?S :location :Brugge.   ?S :battery :low.  ?S :permit ?P.}
-  :fly_kortrijk_brugge
-  1600.0 0.007 0.99 0.99
-)} <= true.
-
-# cycle edge (safe due to fuel bound; typically pruned by belief threshold)
-{:map-DRONE gps:description (
-  {?S :location :Brugge.   ?S :battery :mid.  ?S :permit ?P.} true
-  {?S :location :Kortrijk. ?S :battery :low.  ?S :permit ?P.}
-  :fly_brugge_kortrijk
-  1600.0 0.007 0.985 0.98
-)} <= true.
-
-# get permit in Kortrijk (best belief)
-{:map-DRONE gps:description (
-  {?S :location :Kortrijk. ?S :battery ?B. ?S :permit :none.} true
-  {?S :location :Kortrijk. ?S :battery ?B. ?S :permit :yes.}
-  :get_zone_permit_kortrijk
-  300.0 0.001 0.999 1.0
-)} <= true.
-
-# get permit in Brugge (faster, but lower belief)
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery ?B. ?S :permit :none.} true
-  {?S :location :Brugge. ?S :battery ?B. ?S :permit :yes.}
-  :buy_permit_brugge
-  450.0 0.002 0.98 1.0
-)} <= true.
-
-# charging options
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery :low. ?S :permit ?P.} true
-  {?S :location :Brugge. ?S :battery :full. ?S :permit ?P.}
-  :quick_charge_brugge
-  600.0 0.004 0.999 0.97
-)} <= true.
-
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery :mid. ?S :permit ?P.} true
-  {?S :location :Brugge. ?S :battery :full. ?S :permit ?P.}
-  :topup_brugge
-  400.0 0.003 0.999 0.98
-)} <= true.
-
-{:map-DRONE gps:description (
-  {?S :location :Kortrijk. ?S :battery :mid. ?S :permit ?P.} true
-  {?S :location :Kortrijk. ?S :battery :full. ?S :permit ?P.}
-  :emergency_charge_kortrijk
-  500.0 0.003 0.999 0.95
-)} <= true.
-
-# to Oostende: three alternatives
-# A) restricted corridor: fastest+comfortable, but requires permit=yes and full battery
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery :full. ?S :permit :yes.} true
-  {?S :location :Oostende. ?S :battery :mid. ?S :permit :yes.}
-  :cross_corridor_brugge_oostende
-  900.0 0.004 0.98 1.0
-)} <= true.
-
-# B) public coastline: no permit required, slower
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery :mid. ?S :permit ?P.} true
-  {?S :location :Oostende. ?S :battery :low. ?S :permit ?P.}
-  :public_coastline_brugge_oostende
-  1300.0 0.006 0.97 0.96
-)} <= true.
-
-{:map-DRONE gps:description (
-  {?S :location :Brugge. ?S :battery :full. ?S :permit ?P.} true
-  {?S :location :Oostende. ?S :battery :mid. ?S :permit ?P.}
-  :public_coastline_brugge_oostende
-  1200.0 0.006 0.975 0.96
-)} <= true.
-
-# C) Kortrijk shortcut: requires permit and full battery; quicker but lower comfort
-{:map-DRONE gps:description (
-  {?S :location :Kortrijk. ?S :battery :full. ?S :permit :yes.} true
-  {?S :location :Oostende. ?S :battery :mid. ?S :permit :yes.}
-  :direct_corridor_kortrijk_oostende
-  1100.0 0.009 0.955 0.92
-)} <= true.
-
-# -------------------------------------------------
-# planner: compute all bounded paths
-# -------------------------------------------------
-# Base: one description is a path (consume 1 fuel token)
-{
-  (?From ?To (?Act) ?Dur ?Cost ?Bel ?Comf ?FuelIn ?FuelOut) :path true.
-}
-<=
-{
-  :map-DRONE gps:description (?From true ?To ?Act ?Dur ?Cost ?Bel ?Comf).
-  ?FuelIn list:rest ?FuelOut.
-}.
-
-# Recursive: chain one step + rest path, aggregate weights, consume 1 fuel token
-{
-  (?From ?To ?Actions ?Dur ?Cost ?Bel ?Comf ?FuelIn ?FuelOut) :path true.
-}
-<=
-{
-  :map-DRONE gps:description (?From true ?Mid ?Act ?Dur1 ?Cost1 ?Bel1 ?Comf1).
-
-  ?FuelIn list:rest ?FuelMid.
-  (?Mid ?To ?RestActs ?Dur2 ?Cost2 ?Bel2 ?Comf2 ?FuelMid ?FuelOut) :path true.
-
-  ((?Act) ?RestActs) list:append ?Actions.
-
-  (?Dur1  ?Dur2)  math:sum     ?Dur.
-  (?Cost1 ?Cost2) math:sum     ?Cost.
-  (?Bel1  ?Bel2)  math:product ?Bel.
-  (?Comf1 ?Comf2) math:product ?Comf.
-}.
-
-# -------------------------------------------------
-# Query: plans for d1 to Oostende with pruning thresholds
-# -------------------------------------------------
-{
-  :fuel7 :value ?Fuel.
-
-  ({:d1 :location :Gent. :d1 :battery :full. :d1 :permit :none.}
-   {:d1 :location :Oostende. :d1 :battery ?B. :d1 :permit ?P.}
-   ?Acts ?Dur ?Cost ?Bel ?Comf ?Fuel ?FuelLeft) :path true.
-
-  ?Bel  math:greaterThan 0.94.
-  ?Cost math:lessThan    0.03.
-}
-=>
-{
-  :d1 gps:plan (?Acts ?Dur ?Cost ?Bel ?Comf ?B ?P ?FuelLeft).
-}.
-