eyeling 1.11.19 → 1.11.21

package/HANDBOOK.md

@@ -182,7 +182,7 @@ Eyeling interns IRIs and Literals by string value. Interning is a quiet performa
 
 In addition, interned **Iri**/**Literal** terms (and generated **Blank** terms) get a small, non-enumerable integer id `.__tid` that is stable for the lifetime of the process. This `__tid` is used as the engine’s “fast key”:
 
-- fact indexes (`__byPS` / `__byPO`) key by `__tid` instead of building `"I:..."` / `"L:..."` strings
+- fact indexes (`__byPred` / `__byPS` / `__byPO`) key by `__tid` values **and store fact *indices*** (predicate buckets are keyed by `predicate.__tid`, and PS/PO buckets are keyed by the subject/object `.__tid`; buckets contain integer indices into the `facts` array)
 - duplicate detection uses `"sid	pid	oid"` where each component is a `__tid`
 - unification/equality has an early-out when two terms share the same `__tid`
 
@@ -441,9 +441,9 @@ Facts live in an array `facts: Triple[]`.
 
 Eyeling attaches hidden (non-enumerable) index fields:
 
-* `facts.__byPred: Map<predicateIRI, Triple[]>`
-* `facts.__byPS: Map<predicateIRI, Map<termId, Triple[]>>` where `termId` is `term.__tid`
-* `facts.__byPO: Map<predicateIRI, Map<termId, Triple[]>>` where `termId` is `term.__tid`
+* `facts.__byPred: Map<predicateId, number[]>` where each entry is an index into `facts` (and `predicateId` is `predicate.__tid`)
+* `facts.__byPS: Map<predicateId, Map<termId, number[]>>` where each entry is an index into `facts` (and `termId` is `term.__tid`)
+* `facts.__byPO: Map<predicateId, Map<termId, number[]>>` where each entry is an index into `facts` (and `termId` is `term.__tid`)
 * `facts.__keySet: Set<string>` for a fast-path `"sid	pid	oid"` key (all three are `__tid` values)
 
 `termFastKey(term)` returns a `termId` (`term.__tid`) for **Iri**, **Literal**, and **Blank** terms, and `null` for structured terms (lists, quoted graphs) and variables.
@@ -519,9 +519,6 @@ for delta in deltas:
 
 **Implementation note (performance):** as of this version, Eyeling also avoids allocating short-lived substitution objects when matching goals against **facts** and when unifying a **backward-rule head** with the current goal. Instead of calling the pure `unifyTriple(..., subst)` (which clones the substitution on each variable bind), the prover performs an **in-place unification** directly into the mutable `substMut` store and records only the newly-bound variable names on the trail. This typically reduces GC pressure significantly on reachability / path-search workloads, where unification is executed extremely frequently.
 
-**Implementation note (performance): ground-goal memoization.** When the current goal triple is fully ground (contains no `Var`, no open-list term, and no quoted formula), satisfying it cannot introduce new bindings. Eyeling maintains a small per-proof memo cache for such ground goals, keyed by a canonical triple key. If the cache records that a ground goal is satisfiable (either by a direct fact match or only via backward rules), the prover skips re-proving it and continues with the remaining goals. This reduces repeated work in programs that issue the same membership-style checks many times (even without full tabling). The cache is bounded (default: 20k entries) and uses an LRU-style eviction; advanced callers can override the bound via `opts.groundMemoMax` passed to `proveGoals`.
-
-
 
 So built-ins behave like relations that can generate zero, one, or many possible bindings. A list generator might yield many deltas; a numeric test yields zero or one.
 

package/eyeling.js

@@ -1020,19 +1020,22 @@ function listAppendSplit(parts, resElems, subst) {
 
 function __rdfListObjectsForSP(facts, predIri, subj) {
   ensureFactIndexes(facts);
+  // Engine indexes predicate buckets by predicate term id.
+  const pk = internIri(predIri).__tid;
   const sk = termFastKey(subj);
   if (sk !== null) {
-    const ps = facts.__byPS.get(predIri);
+    const ps = facts.__byPS.get(pk);
     if (ps) {
       const bucket = ps.get(sk);
-      if (bucket && bucket.length) return bucket.map((tr) => tr.o);
+      if (bucket && bucket.length) return bucket.map((i) => facts[i].o);
     }
   }
 
   // Fallback scan (covers non-indexable terms)
-  const pb = facts.__byPred.get(predIri) || [];
+  const pb = facts.__byPred.get(pk) || [];
   const out = [];
-  for (const tr of pb) {
+  for (const i of pb) {
+    const tr = facts[i];
     if (termsEqual(tr.s, subj)) out.push(tr.o);
   }
   return out;
@@ -4953,12 +4956,13 @@ function alphaEqGraphTriples(xs, ys) {
 // ===========================================================================
 //
 // Facts:
-//   - __byPred: Map<predicateIRI, Triple[]>
-//   - __byPO:   Map<predicateIRI, Map<objectKey, Triple[]>>
-//   - __keySet: Set<"S\tP\tO"> for IRI/Literal-only triples (fast dup check)
+//   - __byPred: Map<predicateId, number[]>   (indices into facts array)
+//   - __byPS:   Map<predicateId, Map<subjectId, number[]>>
+//   - __byPO:   Map<predicateId, Map<objectId, number[]>>
+//   - __keySet: Set<"S\tP\tO"> for Iri/Literal/Blank-only triples (fast dup check)
 //
 // Backward rules:
-//   - __byHeadPred:   Map<headPredicateIRI, Rule[]>
+//   - __byHeadPred:   Map<headPredicateId, Rule[]>
 //   - __wildHeadPred: Rule[] (non-IRI head predicate)
 
 function termFastKey(t) {
@@ -4998,19 +5002,20 @@ function ensureFactIndexes(facts) {
     writable: true,
   });
 
-  for (const f of facts) indexFact(facts, f);
+  for (let i = 0; i < facts.length; i++) indexFact(facts, facts[i], i);
 }
 
-function indexFact(facts, tr) {
+function indexFact(facts, tr, idx) {
   if (tr.p instanceof Iri) {
-    const pk = tr.p.value;
+    // Use predicate term id as the primary key to avoid hashing long IRI strings.
+    const pk = tr.p.__tid;
 
     let pb = facts.__byPred.get(pk);
     if (!pb) {
       pb = [];
       facts.__byPred.set(pk, pb);
     }
-    pb.push(tr);
+    pb.push(idx);
 
     const sk = termFastKey(tr.s);
     if (sk !== null) {
@@ -5024,7 +5029,7 @@ function indexFact(facts, tr) {
         psb = [];
         ps.set(sk, psb);
       }
-      psb.push(tr);
+      psb.push(idx);
     }
 
     const ok = termFastKey(tr.o);
@@ -5039,7 +5044,7 @@ function indexFact(facts, tr) {
         pob = [];
         po.set(ok, pob);
       }
-      pob.push(tr);
+      pob.push(idx);
     }
   }
 
@@ -5051,19 +5056,19 @@ function candidateFacts(facts, goal) {
   ensureFactIndexes(facts);
 
   if (goal.p instanceof Iri) {
-    const pk = goal.p.value;
+    const pk = goal.p.__tid;
 
     const sk = termFastKey(goal.s);
     const ok = termFastKey(goal.o);
 
-    /** @type {Triple[] | null} */
+    /** @type {number[] | null} */
     let byPS = null;
     if (sk !== null) {
       const ps = facts.__byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
     }
 
-    /** @type {Triple[] | null} */
+    /** @type {number[] | null} */
     let byPO = null;
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
@@ -5077,7 +5082,7 @@ function candidateFacts(facts, goal) {
     return facts.__byPred.get(pk) || [];
   }
 
-  return facts;
+  return null;
 }
 
 function hasFactIndexed(facts, tr) {
@@ -5087,7 +5092,7 @@ function hasFactIndexed(facts, tr) {
   if (key !== null) return facts.__keySet.has(key);
 
   if (tr.p instanceof Iri) {
-    const pk = tr.p.value;
+    const pk = tr.p.__tid;
 
     const ok = termFastKey(tr.o);
     if (ok !== null) {
@@ -5098,12 +5103,12 @@ function hasFactIndexed(facts, tr) {
         // different existentials unless explicitly connected. Do NOT treat
         // triples as duplicates modulo blank renaming, or you'll incorrectly
         // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-        return pob.some((t) => triplesEqual(t, tr));
+        return pob.some((i) => triplesEqual(facts[i], tr));
       }
     }
 
     const pb = facts.__byPred.get(pk) || [];
-    return pb.some((t) => triplesEqual(t, tr));
+    return pb.some((i) => triplesEqual(facts[i], tr));
   }
 
   // Non-IRI predicate: fall back to strict triple equality.
@@ -5112,8 +5117,9 @@ function hasFactIndexed(facts, tr) {
 
 function pushFactIndexed(facts, tr) {
   ensureFactIndexes(facts);
+  const idx = facts.length;
   facts.push(tr);
-  indexFact(facts, tr);
+  indexFact(facts, tr, idx);
 }
 
 function ensureBackRuleIndexes(backRules) {
@@ -5137,7 +5143,7 @@ function indexBackRule(backRules, r) {
   if (!r || !r.conclusion || r.conclusion.length !== 1) return;
   const head = r.conclusion[0];
   if (head && head.p instanceof Iri) {
-    const k = head.p.value;
+    const k = head.p.__tid;
     let bucket = backRules.__byHeadPred.get(k);
     if (!bucket) {
       bucket = [];
@@ -5691,61 +5697,6 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     trail.length = mark;
   }
 
-
-  // ---------------------------------------------------------------------------
-  // Ground-goal memoization (small cache)
-  // ---------------------------------------------------------------------------
-  //
-  // For fully ground (variable-free) triple subgoals, the proof search can be
-  // repeated many times across different branches of the DFS. Because a ground
-  // goal never produces bindings, it is safe to memoize whether it is satisfiable.
-  //
-  // Cache values:
-  //   0 = unsatisfiable
-  //   1 = satisfiable (direct fact match exists)
-  //   2 = satisfiable (only via backward rules)
-  //   3 = in progress (cycle breaker)
-  const __GROUND_MEMO_MAX =
-    opts && typeof opts.groundMemoMax === 'number' && opts.groundMemoMax > 0 ? opts.groundMemoMax : 20000;
-  const __groundGoalMemo = new Map();
-  const __MEMO_FALSE = 0;
-  const __MEMO_TRUE_FACT = 1;
-  const __MEMO_TRUE_RULE = 2;
-  const __MEMO_INPROGRESS = 3;
-
-  function __memoSet(key, val) {
-    if (__groundGoalMemo.has(key)) __groundGoalMemo.delete(key);
-    __groundGoalMemo.set(key, val);
-    if (__groundGoalMemo.size > __GROUND_MEMO_MAX) {
-      const firstKey = __groundGoalMemo.keys().next().value;
-      __groundGoalMemo.delete(firstKey);
-    }
-  }
-
-  function __isMemoGroundTerm(t) {
-    if (t instanceof Var) return false;
-    if (t instanceof OpenListTerm) return false;
-    if (t instanceof GraphTerm) return false;
-    if (t instanceof ListTerm) return t.elems.every(__isMemoGroundTerm);
-    // Iri, Literal, Blank (and other atomics) are considered ground here.
-    return true;
-  }
-
-  function __memoKeyTerm(t) {
-    if (t instanceof Iri || t instanceof Literal || t instanceof Blank) return t.__tid || null;
-    if (t instanceof ListTerm) return 'L(' + t.elems.map(__memoKeyTerm).join(',') + ')';
-    return null;
-  }
-
-  function __memoKeyTriple(tr) {
-    if (!__isMemoGroundTerm(tr.s) || !__isMemoGroundTerm(tr.p) || !__isMemoGroundTerm(tr.o)) return null;
-    const ks = __memoKeyTerm(tr.s);
-    const kp = __memoKeyTerm(tr.p);
-    const ko = __memoKeyTerm(tr.o);
-    if (ks === null || kp === null || ko === null) return null;
-    return ks + '	' + kp + '	' + ko;
-  }
-
   // In-place unification into the mutable substitution + trail.
   // This avoids allocating short-lived "delta" substitution objects on the hot path
   // (facts and backward-rule head matching).
@@ -5875,163 +5826,6 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     return true;
   }
 
-
-  // Boolean (existence) prover used by ground-goal memoization.
-  // Returns true as soon as one proof for the goal list is found.
-  function __existsGoals(goalsNow, curDepth, visitedNow) {
-    if (!goalsNow.length) return true;
-
-    const rawGoal = goalsNow[0];
-    const restGoals = goalsNow.length > 1 ? goalsNow.slice(1) : [];
-    const goal0 = applySubstTriple(rawGoal, substMut);
-
-    // Builtins
-    const __pv0 = goal0.p instanceof Iri ? goal0.p.value : null;
-    const __rdfFirstOrRest = __pv0 === RDF_NS + 'first' || __pv0 === RDF_NS + 'rest';
-    const __treatBuiltin =
-      isBuiltinPred(goal0.p) &&
-      !(__rdfFirstOrRest && !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm));
-
-    if (__treatBuiltin) {
-      const deltas = evalBuiltin(goal0, {}, facts, backRules, curDepth, varGen, 1);
-      for (const delta of deltas) {
-        const mark = trail.length;
-        if (!applyDeltaToSubst(delta)) {
-          undoTo(mark);
-          continue;
-        }
-        const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-        undoTo(mark);
-        if (ok) return true;
-      }
-      return false;
-    }
-
-    // Loop check for backward reasoning
-    if (listHasTriple(visitedNow, goal0)) return false;
-    const visitedForRules = visitedNow.concat([goal0]);
-
-    // Ground-goal memo check (only safe when the goal is fully ground)
-    const memoKey = __memoKeyTriple(goal0);
-    if (memoKey) {
-      const mv = __groundGoalMemo.get(memoKey);
-      if (mv === __MEMO_FALSE) return false;
-      if (mv === __MEMO_TRUE_FACT) return __existsGoals(restGoals, curDepth + 1, visitedNow);
-      if (mv === __MEMO_TRUE_RULE) return __existsGoals(restGoals, curDepth + 1, visitedForRules);
-      if (mv === __MEMO_INPROGRESS) return false;
-
-      __memoSet(memoKey, __MEMO_INPROGRESS);
-      const kind = __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules);
-      __memoSet(memoKey, kind);
-
-      if (kind === __MEMO_FALSE) return false;
-      if (kind === __MEMO_TRUE_FACT) return __existsGoals(restGoals, curDepth + 1, visitedNow);
-      return __existsGoals(restGoals, curDepth + 1, visitedForRules);
-    }
-
-    // Backward rules (indexed by head predicate) — explored first
-    if (goal0.p instanceof Iri) {
-      ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
-
-      for (const r of candRules) {
-        if (r.conclusion.length !== 1) continue;
-        const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
-
-        const rStd = standardizeRule(r, varGen);
-        const head = rStd.conclusion[0];
-
-        const mark = trail.length;
-        if (!unifyTripleTrail(head, goal0)) {
-          undoTo(mark);
-          continue;
-        }
-
-        const newGoals = rStd.premise.concat(restGoals);
-        const ok = __existsGoals(newGoals, curDepth + 1, visitedForRules);
-        undoTo(mark);
-        if (ok) return true;
-      }
-    }
-
-    // Facts
-    if (goal0.p instanceof Iri) {
-      const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
-        const mark = trail.length;
-        if (!unifyTripleTrail(goal0, f)) {
-          undoTo(mark);
-          continue;
-        }
-        const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-        undoTo(mark);
-        if (ok) return true;
-      }
-      return false;
-    }
-
-    for (const f of facts) {
-      const mark = trail.length;
-      if (!unifyTripleTrail(goal0, f)) {
-        undoTo(mark);
-        continue;
-      }
-      const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-      undoTo(mark);
-      if (ok) return true;
-    }
-    return false;
-  }
-
-  function __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules) {
-    // Try direct facts first (cheap): if any fact matches, we can treat this as "fact satisfiable"
-    // for visited semantics.
-    if (goal0.p instanceof Iri) {
-      const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
-        const mark = trail.length;
-        const ok = unifyTripleTrail(goal0, f);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_FACT;
-      }
-    } else {
-      for (const f of facts) {
-        const mark = trail.length;
-        const ok = unifyTripleTrail(goal0, f);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_FACT;
-      }
-    }
-
-    // Otherwise, look for a proof via backward rules.
-    if (goal0.p instanceof Iri) {
-      ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
-
-      for (const r of candRules) {
-        if (r.conclusion.length !== 1) continue;
-        const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
-
-        const rStd = standardizeRule(r, varGen);
-        const head = rStd.conclusion[0];
-
-        const mark = trail.length;
-        if (!unifyTripleTrail(head, goal0)) {
-          undoTo(mark);
-          continue;
-        }
-
-        const ok = __existsGoals(rStd.premise, curDepth + 1, visitedForRules);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_RULE;
-      }
-    }
-
-    return __MEMO_FALSE;
-  }
-
   function dfs(goalsNow, curDepth, visitedNow, canDeferBuiltins, deferCount) {
     if (results.length >= max) return;
     if (!goalsNow.length) {
@@ -6108,50 +5902,15 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     if (listHasTriple(visitedNow, goal0)) return;
     const visitedForRules = visitedNow.concat([goal0]);
 
-    // Ground-goal memoization: if a goal is fully ground, it cannot introduce new bindings,
-    // so we can cache whether it is satisfiable and skip re-proving it across branches.
-    const __memoKey0 = __memoKeyTriple(goal0);
-    if (__memoKey0) {
-      const mv = __groundGoalMemo.get(__memoKey0);
-      if (mv === __MEMO_FALSE) return;
-
-      if (mv === __MEMO_TRUE_FACT || mv === __MEMO_TRUE_RULE) {
-        const __nextVisited = mv === __MEMO_TRUE_FACT ? visitedNow : visitedForRules;
-        if (!restGoals.length) {
-          results.push(gcCompactForGoals(substMut, [], answerVars));
-        } else {
-          dfs(restGoals, curDepth + 1, __nextVisited, canDeferBuiltins, 0);
-        }
-        return;
-      }
-
-      // Cycle breaker for recursive ground goals.
-      if (mv === __MEMO_INPROGRESS) return;
-
-      __memoSet(__memoKey0, __MEMO_INPROGRESS);
-      const kind = __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules);
-      __memoSet(__memoKey0, kind);
-
-      if (kind === __MEMO_FALSE) return;
-
-      const __nextVisited = kind === __MEMO_TRUE_FACT ? visitedNow : visitedForRules;
-      if (!restGoals.length) {
-        results.push(gcCompactForGoals(substMut, [], answerVars));
-      } else {
-        dfs(restGoals, curDepth + 1, __nextVisited, canDeferBuiltins, 0);
-      }
-      return;
-    }
-
     // 3) Backward rules (indexed by head predicate) — explored first
     if (goal0.p instanceof Iri) {
       ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
+      const candRules = (backRules.__byHeadPred.get(goal0.p.__tid) || []).concat(backRules.__wildHeadPred);
 
       for (const r of candRules) {
         if (r.conclusion.length !== 1) continue;
         const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
+        if (rawHead.p instanceof Iri && rawHead.p.__tid !== goal0.p.__tid) continue;
 
         const rStd = standardizeRule(r, varGen);
         const head = rStd.conclusion[0];
@@ -6177,7 +5936,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     // 4) Try to satisfy the goal from known facts
     if (goal0.p instanceof Iri) {
       const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
+      for (const idx of candidates) {
+        const f = facts[idx];
         const mark = trail.length;
         if (!unifyTripleTrail(goal0, f)) {
           undoTo(mark);

package/lib/builtins.js

@@ -1008,19 +1008,22 @@ function listAppendSplit(parts, resElems, subst) {
 
 function __rdfListObjectsForSP(facts, predIri, subj) {
   ensureFactIndexes(facts);
+  // Engine indexes predicate buckets by predicate term id.
+  const pk = internIri(predIri).__tid;
   const sk = termFastKey(subj);
   if (sk !== null) {
-    const ps = facts.__byPS.get(predIri);
+    const ps = facts.__byPS.get(pk);
     if (ps) {
       const bucket = ps.get(sk);
-      if (bucket && bucket.length) return bucket.map((tr) => tr.o);
+      if (bucket && bucket.length) return bucket.map((i) => facts[i].o);
     }
   }
 
   // Fallback scan (covers non-indexable terms)
-  const pb = facts.__byPred.get(predIri) || [];
+  const pb = facts.__byPred.get(pk) || [];
   const out = [];
-  for (const tr of pb) {
+  for (const i of pb) {
+    const tr = facts[i];
     if (termsEqual(tr.s, subj)) out.push(tr.o);
   }
   return out;

package/lib/engine.js

@@ -579,12 +579,13 @@ function alphaEqGraphTriples(xs, ys) {
 // ===========================================================================
 //
 // Facts:
-//   - __byPred: Map<predicateIRI, Triple[]>
-//   - __byPO:   Map<predicateIRI, Map<objectKey, Triple[]>>
-//   - __keySet: Set<"S\tP\tO"> for IRI/Literal-only triples (fast dup check)
+//   - __byPred: Map<predicateId, number[]>   (indices into facts array)
+//   - __byPS:   Map<predicateId, Map<subjectId, number[]>>
+//   - __byPO:   Map<predicateId, Map<objectId, number[]>>
+//   - __keySet: Set<"S\tP\tO"> for Iri/Literal/Blank-only triples (fast dup check)
 //
 // Backward rules:
-//   - __byHeadPred:   Map<headPredicateIRI, Rule[]>
+//   - __byHeadPred:   Map<headPredicateId, Rule[]>
 //   - __wildHeadPred: Rule[] (non-IRI head predicate)
 
 function termFastKey(t) {
@@ -624,19 +625,20 @@ function ensureFactIndexes(facts) {
     writable: true,
   });
 
-  for (const f of facts) indexFact(facts, f);
+  for (let i = 0; i < facts.length; i++) indexFact(facts, facts[i], i);
 }
 
-function indexFact(facts, tr) {
+function indexFact(facts, tr, idx) {
   if (tr.p instanceof Iri) {
-    const pk = tr.p.value;
+    // Use predicate term id as the primary key to avoid hashing long IRI strings.
+    const pk = tr.p.__tid;
 
     let pb = facts.__byPred.get(pk);
     if (!pb) {
       pb = [];
       facts.__byPred.set(pk, pb);
     }
-    pb.push(tr);
+    pb.push(idx);
 
     const sk = termFastKey(tr.s);
     if (sk !== null) {
@@ -650,7 +652,7 @@ function indexFact(facts, tr) {
         psb = [];
         ps.set(sk, psb);
       }
-      psb.push(tr);
+      psb.push(idx);
     }
 
     const ok = termFastKey(tr.o);
@@ -665,7 +667,7 @@ function indexFact(facts, tr) {
         pob = [];
         po.set(ok, pob);
       }
-      pob.push(tr);
+      pob.push(idx);
     }
   }
 
@@ -677,19 +679,19 @@ function candidateFacts(facts, goal) {
   ensureFactIndexes(facts);
 
   if (goal.p instanceof Iri) {
-    const pk = goal.p.value;
+    const pk = goal.p.__tid;
 
     const sk = termFastKey(goal.s);
     const ok = termFastKey(goal.o);
 
-    /** @type {Triple[] | null} */
+    /** @type {number[] | null} */
     let byPS = null;
     if (sk !== null) {
       const ps = facts.__byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
     }
 
-    /** @type {Triple[] | null} */
+    /** @type {number[] | null} */
     let byPO = null;
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
@@ -703,7 +705,7 @@ function candidateFacts(facts, goal) {
     return facts.__byPred.get(pk) || [];
   }
 
-  return facts;
+  return null;
 }
 
 function hasFactIndexed(facts, tr) {
@@ -713,7 +715,7 @@ function hasFactIndexed(facts, tr) {
   if (key !== null) return facts.__keySet.has(key);
 
   if (tr.p instanceof Iri) {
-    const pk = tr.p.value;
+    const pk = tr.p.__tid;
 
     const ok = termFastKey(tr.o);
     if (ok !== null) {
@@ -724,12 +726,12 @@ function hasFactIndexed(facts, tr) {
         // different existentials unless explicitly connected. Do NOT treat
         // triples as duplicates modulo blank renaming, or you'll incorrectly
         // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-        return pob.some((t) => triplesEqual(t, tr));
+        return pob.some((i) => triplesEqual(facts[i], tr));
       }
     }
 
     const pb = facts.__byPred.get(pk) || [];
-    return pb.some((t) => triplesEqual(t, tr));
+    return pb.some((i) => triplesEqual(facts[i], tr));
   }
 
   // Non-IRI predicate: fall back to strict triple equality.
@@ -738,8 +740,9 @@ function hasFactIndexed(facts, tr) {
 
 function pushFactIndexed(facts, tr) {
   ensureFactIndexes(facts);
+  const idx = facts.length;
   facts.push(tr);
-  indexFact(facts, tr);
+  indexFact(facts, tr, idx);
 }
 
 function ensureBackRuleIndexes(backRules) {
@@ -763,7 +766,7 @@ function indexBackRule(backRules, r) {
   if (!r || !r.conclusion || r.conclusion.length !== 1) return;
   const head = r.conclusion[0];
   if (head && head.p instanceof Iri) {
-    const k = head.p.value;
+    const k = head.p.__tid;
     let bucket = backRules.__byHeadPred.get(k);
     if (!bucket) {
       bucket = [];
@@ -1317,60 +1320,6 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     trail.length = mark;
   }
 
-  // ---------------------------------------------------------------------------
-  // Ground-goal memoization (small cache)
-  // ---------------------------------------------------------------------------
-  //
-  // For fully ground (variable-free) triple subgoals, the proof search can be
-  // repeated many times across different branches of the DFS. Because a ground
-  // goal never produces bindings, it is safe to memoize whether it is satisfiable.
-  //
-  // Cache values:
-  //   0 = unsatisfiable
-  //   1 = satisfiable (direct fact match exists)
-  //   2 = satisfiable (only via backward rules)
-  //   3 = in progress (cycle breaker)
-  const __GROUND_MEMO_MAX =
-    opts && typeof opts.groundMemoMax === 'number' && opts.groundMemoMax > 0 ? opts.groundMemoMax : 20000;
-  const __groundGoalMemo = new Map();
-  const __MEMO_FALSE = 0;
-  const __MEMO_TRUE_FACT = 1;
-  const __MEMO_TRUE_RULE = 2;
-  const __MEMO_INPROGRESS = 3;
-
-  function __memoSet(key, val) {
-    if (__groundGoalMemo.has(key)) __groundGoalMemo.delete(key);
-    __groundGoalMemo.set(key, val);
-    if (__groundGoalMemo.size > __GROUND_MEMO_MAX) {
-      const firstKey = __groundGoalMemo.keys().next().value;
-      __groundGoalMemo.delete(firstKey);
-    }
-  }
-
-  function __isMemoGroundTerm(t) {
-    if (t instanceof Var) return false;
-    if (t instanceof OpenListTerm) return false;
-    if (t instanceof GraphTerm) return false;
-    if (t instanceof ListTerm) return t.elems.every(__isMemoGroundTerm);
-    // Iri, Literal, Blank (and other atomics) are considered ground here.
-    return true;
-  }
-
-  function __memoKeyTerm(t) {
-    if (t instanceof Iri || t instanceof Literal || t instanceof Blank) return t.__tid || null;
-    if (t instanceof ListTerm) return 'L(' + t.elems.map(__memoKeyTerm).join(',') + ')';
-    return null;
-  }
-
-  function __memoKeyTriple(tr) {
-    if (!__isMemoGroundTerm(tr.s) || !__isMemoGroundTerm(tr.p) || !__isMemoGroundTerm(tr.o)) return null;
-    const ks = __memoKeyTerm(tr.s);
-    const kp = __memoKeyTerm(tr.p);
-    const ko = __memoKeyTerm(tr.o);
-    if (ks === null || kp === null || ko === null) return null;
-    return ks + '	' + kp + '	' + ko;
-  }
-
   // In-place unification into the mutable substitution + trail.
   // This avoids allocating short-lived "delta" substitution objects on the hot path
   // (facts and backward-rule head matching).
@@ -1500,162 +1449,6 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     return true;
   }
 
-  // Boolean (existence) prover used by ground-goal memoization.
-  // Returns true as soon as one proof for the goal list is found.
-  function __existsGoals(goalsNow, curDepth, visitedNow) {
-    if (!goalsNow.length) return true;
-
-    const rawGoal = goalsNow[0];
-    const restGoals = goalsNow.length > 1 ? goalsNow.slice(1) : [];
-    const goal0 = applySubstTriple(rawGoal, substMut);
-
-    // Builtins
-    const __pv0 = goal0.p instanceof Iri ? goal0.p.value : null;
-    const __rdfFirstOrRest = __pv0 === RDF_NS + 'first' || __pv0 === RDF_NS + 'rest';
-    const __treatBuiltin =
-      isBuiltinPred(goal0.p) &&
-      !(__rdfFirstOrRest && !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm));
-
-    if (__treatBuiltin) {
-      const deltas = evalBuiltin(goal0, {}, facts, backRules, curDepth, varGen, 1);
-      for (const delta of deltas) {
-        const mark = trail.length;
-        if (!applyDeltaToSubst(delta)) {
-          undoTo(mark);
-          continue;
-        }
-        const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-        undoTo(mark);
-        if (ok) return true;
-      }
-      return false;
-    }
-
-    // Loop check for backward reasoning
-    if (listHasTriple(visitedNow, goal0)) return false;
-    const visitedForRules = visitedNow.concat([goal0]);
-
-    // Ground-goal memo check (only safe when the goal is fully ground)
-    const memoKey = __memoKeyTriple(goal0);
-    if (memoKey) {
-      const mv = __groundGoalMemo.get(memoKey);
-      if (mv === __MEMO_FALSE) return false;
-      if (mv === __MEMO_TRUE_FACT) return __existsGoals(restGoals, curDepth + 1, visitedNow);
-      if (mv === __MEMO_TRUE_RULE) return __existsGoals(restGoals, curDepth + 1, visitedForRules);
-      if (mv === __MEMO_INPROGRESS) return false;
-
-      __memoSet(memoKey, __MEMO_INPROGRESS);
-      const kind = __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules);
-      __memoSet(memoKey, kind);
-
-      if (kind === __MEMO_FALSE) return false;
-      if (kind === __MEMO_TRUE_FACT) return __existsGoals(restGoals, curDepth + 1, visitedNow);
-      return __existsGoals(restGoals, curDepth + 1, visitedForRules);
-    }
-
-    // Backward rules (indexed by head predicate) — explored first
-    if (goal0.p instanceof Iri) {
-      ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
-
-      for (const r of candRules) {
-        if (r.conclusion.length !== 1) continue;
-        const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
-
-        const rStd = standardizeRule(r, varGen);
-        const head = rStd.conclusion[0];
-
-        const mark = trail.length;
-        if (!unifyTripleTrail(head, goal0)) {
-          undoTo(mark);
-          continue;
-        }
-
-        const newGoals = rStd.premise.concat(restGoals);
-        const ok = __existsGoals(newGoals, curDepth + 1, visitedForRules);
-        undoTo(mark);
-        if (ok) return true;
-      }
-    }
-
-    // Facts
-    if (goal0.p instanceof Iri) {
-      const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
-        const mark = trail.length;
-        if (!unifyTripleTrail(goal0, f)) {
-          undoTo(mark);
-          continue;
-        }
-        const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-        undoTo(mark);
-        if (ok) return true;
-      }
-      return false;
-    }
-
-    for (const f of facts) {
-      const mark = trail.length;
-      if (!unifyTripleTrail(goal0, f)) {
-        undoTo(mark);
-        continue;
-      }
-      const ok = __existsGoals(restGoals, curDepth + 1, visitedNow);
-      undoTo(mark);
-      if (ok) return true;
-    }
-    return false;
-  }
-
-  function __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules) {
-    // Try direct facts first (cheap): if any fact matches, we can treat this as "fact satisfiable"
-    // for visited semantics.
-    if (goal0.p instanceof Iri) {
-      const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
-        const mark = trail.length;
-        const ok = unifyTripleTrail(goal0, f);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_FACT;
-      }
-    } else {
-      for (const f of facts) {
-        const mark = trail.length;
-        const ok = unifyTripleTrail(goal0, f);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_FACT;
-      }
-    }
-
-    // Otherwise, look for a proof via backward rules.
-    if (goal0.p instanceof Iri) {
-      ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
-
-      for (const r of candRules) {
-        if (r.conclusion.length !== 1) continue;
-        const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
-
-        const rStd = standardizeRule(r, varGen);
-        const head = rStd.conclusion[0];
-
-        const mark = trail.length;
-        if (!unifyTripleTrail(head, goal0)) {
-          undoTo(mark);
-          continue;
-        }
-
-        const ok = __existsGoals(rStd.premise, curDepth + 1, visitedForRules);
-        undoTo(mark);
-        if (ok) return __MEMO_TRUE_RULE;
-      }
-    }
-
-    return __MEMO_FALSE;
-  }
-
   function dfs(goalsNow, curDepth, visitedNow, canDeferBuiltins, deferCount) {
     if (results.length >= max) return;
     if (!goalsNow.length) {
@@ -1732,50 +1525,15 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     if (listHasTriple(visitedNow, goal0)) return;
     const visitedForRules = visitedNow.concat([goal0]);
 
-    // Ground-goal memoization: if a goal is fully ground, it cannot introduce new bindings,
-    // so we can cache whether it is satisfiable and skip re-proving it across branches.
-    const __memoKey0 = __memoKeyTriple(goal0);
-    if (__memoKey0) {
-      const mv = __groundGoalMemo.get(__memoKey0);
-      if (mv === __MEMO_FALSE) return;
-
-      if (mv === __MEMO_TRUE_FACT || mv === __MEMO_TRUE_RULE) {
-        const __nextVisited = mv === __MEMO_TRUE_FACT ? visitedNow : visitedForRules;
-        if (!restGoals.length) {
-          results.push(gcCompactForGoals(substMut, [], answerVars));
-        } else {
-          dfs(restGoals, curDepth + 1, __nextVisited, canDeferBuiltins, 0);
-        }
-        return;
-      }
-
-      // Cycle breaker for recursive ground goals.
-      if (mv === __MEMO_INPROGRESS) return;
-
-      __memoSet(__memoKey0, __MEMO_INPROGRESS);
-      const kind = __groundGoalSatisfiableKind(goal0, curDepth, visitedNow, visitedForRules);
-      __memoSet(__memoKey0, kind);
-
-      if (kind === __MEMO_FALSE) return;
-
-      const __nextVisited = kind === __MEMO_TRUE_FACT ? visitedNow : visitedForRules;
-      if (!restGoals.length) {
-        results.push(gcCompactForGoals(substMut, [], answerVars));
-      } else {
-        dfs(restGoals, curDepth + 1, __nextVisited, canDeferBuiltins, 0);
-      }
-      return;
-    }
-
     // 3) Backward rules (indexed by head predicate) — explored first
     if (goal0.p instanceof Iri) {
       ensureBackRuleIndexes(backRules);
-      const candRules = (backRules.__byHeadPred.get(goal0.p.value) || []).concat(backRules.__wildHeadPred);
+      const candRules = (backRules.__byHeadPred.get(goal0.p.__tid) || []).concat(backRules.__wildHeadPred);
 
       for (const r of candRules) {
         if (r.conclusion.length !== 1) continue;
         const rawHead = r.conclusion[0];
-        if (rawHead.p instanceof Iri && rawHead.p.value !== goal0.p.value) continue;
+        if (rawHead.p instanceof Iri && rawHead.p.__tid !== goal0.p.__tid) continue;
 
         const rStd = standardizeRule(r, varGen);
         const head = rStd.conclusion[0];
@@ -1801,7 +1559,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     // 4) Try to satisfy the goal from known facts
     if (goal0.p instanceof Iri) {
       const candidates = candidateFacts(facts, goal0);
-      for (const f of candidates) {
+      for (const idx of candidates) {
+        const f = facts[idx];
         const mark = trail.length;
         if (!unifyTripleTrail(goal0, f)) {
           undoTo(mark);

package/package.json

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