eyeling 1.22.6 → 1.22.7

package/examples/output/act-gravity-mediator-witness.txt

@@ -0,0 +1,24 @@
+ACT gravity mediator witness
+
+Answer
+YES for the mediator-only witness run.
+NO for a purely classical mediator model under the same mediator-only conditions.
+
+Reason Why
+The positive run assumes locality and interoperability, excludes direct coupling between the two quantum systems, and records an entanglement witness after interaction through the mediator alone. Under those constructor-theoretic conditions, the mediator must be non-classical, so the run rules out a purely classical mediator model. The contrast run keeps the same locality, interoperability, and mediator-only structure but assigns the mediator a purely classical model. In that case the mediator-only entanglement witness is blocked, so the run cannot support the same non-classicality conclusion.
+
+Check
+C1  OK - locality is assumed in the positive run
+C2  OK - interoperability is assumed in the positive run
+C3  OK - direct coupling between the two quantum systems is excluded
+C4  OK - the positive run has a mediator-only interaction path
+C5  OK - an entanglement witness is observed in the positive run
+C6  OK - the positive run supports an information-transfer interface
+C7  OK - the positive run supports local readout
+C8  OK - the positive mediator is derived to be non-classical
+C9  OK - a purely classical mediator model is ruled out by the positive run
+C10 OK - the non-classicality conclusion applies to the gravitational mediator
+C11 OK - the contrast run is also mediator-only
+C12 OK - the contrast run cannot support a mediator-only entanglement witness
+C13 OK - the purely classical gravitational mediator cannot mediate entanglement under the witness conditions
+C14 OK - the contrast run cannot support the non-classicality conclusion

package/examples/output/act-isolation-breach.txt

@@ -0,0 +1,27 @@
+ACT isolation-breach token — broad constructor-theory coverage case
+
+Answer
+YES for the classical isolation-breach token.
+NO for universal cloning and unrestricted fan-out of the quantum provenance seal.
+
+Reason Why
+The isolation-breach token is treated as an abstract information variable carried by unlike classical media: a door beacon, a containment PLC, a nurse pager, and an incident board. Because those substrates are information media for the same variable, the token can be prepared, permuted, reversed, cloned locally, copied across media, measured into an output record, and composed into serial and parallel task networks. By contrast, the specimen seal is treated as a superinformation medium, so cloning all of its states is impossible and unrestricted parallel fan-out is blocked.
+
+Check
+C1  OK - the door beacon is an information medium
+C2  OK - the containment PLC is an information medium
+C3  OK - the nurse pager is an information medium
+C4  OK - the incident board is an information medium
+C5  OK - the door beacon distinguishes the breach bit
+C6  OK - the breach state can be prepared on the nurse pager
+C7  OK - permutation from safe to breach is possible on the door beacon
+C8  OK - the door beacon supports reversible permutation
+C9  OK - local cloning of the breach bit is possible on the containment PLC
+C10 OK - the breach bit can be copied from door beacon to containment PLC
+C11 OK - the breach bit can be copied from containment PLC to nurse pager
+C12 OK - the breach bit can be measured from nurse pager into the incident board
+C13 OK - a serial network from door beacon via containment PLC to incident board is possible
+C14 OK - a parallel network from containment PLC to nurse pager and incident board is possible
+C15 OK - cloning all states of the specimen seal is an impossible task
+C16 OK - the specimen seal cannot be universally cloned
+C17 OK - the specimen seal cannot support unrestricted parallel fan-out

package/examples/output/act-photosynthetic-exciton-transfer.txt

@@ -0,0 +1,20 @@
+ACT photosynthetic exciton transfer
+
+Answer
+YES for the tuned antenna complex.
+NO for the detuned, strongly decohered contrast complex.
+
+Reason Why
+The tuned complex can sample exciton pathways coherently, use vibronically assisted transfer, and exploit short-lived quantum assistance along a downhill route to the reaction center. That makes efficient exciton transfer and reaction-center delivery possible in this case. The detuned contrast complex lacks the same alignment: coherent pathway sampling is blocked, vibronic assistance is unavailable, and the energy landscape is mismatched, so efficient reaction-center delivery is not possible in the same operating picture.
+
+Check
+C1  OK - the tuned complex can sample exciton pathways coherently
+C2  OK - the tuned complex can use vibronically assisted transfer
+C3  OK - short-lived quantum assistance is enough in the tuned downhill regime
+C4  OK - efficient exciton transfer is possible in the tuned complex
+C5  OK - the tuned complex can deliver excitation to the reaction center
+C6  OK - the detuned complex cannot sample pathways coherently
+C7  OK - the detuned complex cannot use vibronically assisted transfer
+C8  OK - the detuned complex cannot achieve directed reaction-center transfer
+C9  OK - the detuned complex cannot achieve efficient exciton transfer
+C10 OK - the detuned complex cannot deliver excitation efficiently to the reaction center

package/examples/output/act-sensor-memory-reset.txt

@@ -0,0 +1,20 @@
+ACT sensor memory reset
+
+Answer
+YES with the battery pack.
+NO with the ambient heat bath alone.
+
+Reason Why
+The alarm latch is a one-bit memory that must be reset to its standard clear state before the radiation sensor can be reused. In this case, the charged battery pack is treated as a work medium, so it can drive a controlled reset and prepare the latch in its reusable standard state. The ambient bath is treated as a heat medium, so by itself it cannot perform the same reliable directed reset. The example also shows an irreversibility pattern: useful work can be degraded into dissipated heat during reset, but the ambient heat bath alone cannot reconstruct the charged work resource.
+
+Check
+C1  OK - the battery pack can drive a controlled reset
+C2  OK - the alarm latch can be reliably reset from work
+C3  OK - the latch can be prepared in its standard reusable state
+C4  OK - the sensor can be made ready for reuse
+C5  OK - the work resource can degrade to heat during reset
+C6  OK - the ambient heat bath cannot drive a controlled reset
+C7  OK - the latch cannot be reliably reset from heat alone
+C8  OK - the latch cannot be prepared in its standard state from heat alone
+C9  OK - the sensor cannot be made ready for reuse from heat alone
+C10 OK - the ambient heat bath cannot reconstruct the charged work resource by itself

package/examples/output/act-tunnel-junction-wake-switch.txt

@@ -0,0 +1,21 @@
+ACT tunnel-junction wake switch
+
+Answer
+YES for the tunnel junction.
+NO for the conventional low-bias PN junction in the same wake-switch regime.
+
+Reason Why
+The tunnel junction is modeled as a heavily doped narrow PN junction with overlapping states, so quantum barrier transfer is possible. That makes sub-threshold current possible in the low-forward-bias regime, which in turn makes ultra-low-bias switching possible for the wake circuit. Because the device is also scanned through a peak-to-valley window, a negative differential response is possible as well. By contrast, the conventional junction lacks the structural conditions for the same transfer mode, so it cannot deliver the same low-bias switching task in this case.
+
+Check
+C1  OK - the tunnel junction can support quantum barrier transfer
+C2  OK - the tunnel junction is classified as tunneling-dominant
+C3  OK - the tunnel junction can deliver sub-threshold current
+C4  OK - the tunnel junction can show negative differential response
+C5  OK - the tunnel junction can perform ultra-low-bias switching
+C6  OK - the tunnel junction can serve the leak-alarm wake circuit
+C7  OK - the conventional junction cannot support the same quantum barrier transfer
+C8  OK - the conventional junction cannot deliver sub-threshold current in this regime
+C9  OK - the conventional junction cannot show the tunnel-style negative differential response
+C10 OK - the conventional junction cannot perform ultra-low-bias switching here
+C11 OK - the conventional junction cannot serve the leak-alarm wake circuit in this case

package/examples/output/act-yeast-self-reproduction.txt

@@ -0,0 +1,23 @@
+ACT yeast self-reproduction
+
+Answer
+YES for the viable starter culture.
+NO for accurate self-reproduction in the non-digital contrast lineage.
+
+Reason Why
+The starter genome is treated as a replicator storing digital hereditary information, while the cell machinery is treated as the vehicle that enables metabolism and copying support. Under no-design laws, digital information makes accurate genome copying possible. Because the replicator is accurate and paired with a vehicle, the whole starter cell qualifies as a self-reproducer. With a variation source and a selection environment, natural selection also becomes possible. By contrast, the non-digital lineage cannot support accurate genome copying under the same no-design-laws assumption, so it cannot sustain the same accurate self-reproduction or natural-selection story.
+
+Check
+C1  OK - no-design laws are assumed
+C2  OK - digital information is physically instantiated for the viable lineage
+C3  OK - a viable replicator is present
+C4  OK - a viable vehicle is present
+C5  OK - accurate genome copying is possible for the viable lineage
+C6  OK - the viable lineage has a replicator-plus-vehicle architecture
+C7  OK - the starter cell qualifies as a self-reproducer
+C8  OK - heritable variation is possible for the viable lineage
+C9  OK - the viable starter culture can support a natural-selection lineage
+C10 OK - the fitter viable variant is selected in the fermenter
+C11 OK - the non-digital contrast genome cannot be copied accurately under no-design laws
+C12 OK - the non-digital contrast cell cannot achieve accurate self-reproduction
+C13 OK - the non-digital contrast cell cannot support the same natural-selection lineage

package/examples/output/complex-matrix-stability.txt

@@ -0,0 +1,14 @@
+Complex Matrix Stability — ARC-style
+
+Answer
+We compare three diagonal 2x2 complex matrices for discrete-time stability: A_unstable = [[(1,1),(0,0)],[(0,0),(2,0)]], A_stable = [[(1,0),(0,0)],[(0,0),(-1,0)]], and A_damped = [[(0,0),(0,0)],[(0,0),(0,0)]]. Their spectral radii are ρ(A_unstable) = 2, ρ(A_stable) = 1, and ρ(A_damped) = 0. So A_unstable is unstable, A_stable is marginally stable, and A_damped is damped.
+
+Reason Why
+For a discrete-time linear system x_{k+1} = A x_k, the eigenvalues of A govern the behaviour of the modes. Because these matrices are diagonal, the eigenvalues are just the diagonal entries. The spectral radius is the maximum modulus of the eigenvalues: if it is greater than 1 a mode grows, if it equals 1 the modes remain bounded without decaying, and if it is less than 1 all modes decay to zero. Here the diagonal entries give radii 2, 1, and 0 respectively, which explains the three classifications.
+
+Check
+C1 OK - A_unstable has eigenvalues (1,1) and (2,0) with spectral radius 2, so it is unstable.
+C2 OK - A_stable has eigenvalues (1,0) and (-1,0) with spectral radius 1, so it is marginally stable.
+C3 OK - A_damped has eigenvalues (0,0) and (0,0) with spectral radius 0, so every mode decays to zero.
+C4 OK - for z = (1,2) and w = (0,1), the squared modulus of z*w equals the product of the squared moduli.
+C5 OK - the spectral-radius-squared of 2*A_unstable is four times that of A_unstable.

package/examples/output/fundamental-theorem-arithmetic.txt

@@ -0,0 +1,15 @@
+Fundamental Theorem of Arithmetic — ARC-style
+
+Answer
+For n = 202692987, the prime factors are 3 * 3 * 7 * 829 * 3881, the prime-power form is 3^2 * 7 * 829 * 3881, and the product of these factors is 202692987 with 4 distinct primes.
+
+Reason Why
+Existence in this run comes from repeated smallest-divisor decomposition: 202692987 factors as 3 * 3 * 7 * 829 * 3881. Each distinct factor is prime. For uniqueness up to order, the reverse traversal gives 3881 * 829 * 7 * 3 * 3, and both traversals sort to the same multiset of primes. So this concrete case exhibits the Fundamental Theorem of Arithmetic for 202692987: a prime factorization exists and is unique up to order. The extreme prime factors are 3 and 3881.
+
+Check
+C1 OK - repeated smallest-divisor decomposition produced the expected smallest-first factor list (3 3 7 829 3881).
+C2 OK - the product of the computed factors reconstructs n = 202692987.
+C3 OK - every distinct factor in the decomposition is prime by trial division.
+C4 OK - the prime-power form matches 3^2 * 7 * 829 * 3881.
+C5 OK - smallest-first and largest-first traversals have the same multiset of primes, so the factorization agrees up to order.
+C6 OK - the smallest and largest prime factors are 3 and 3881.

package/examples/output/get-uuid.n3

@@ -1,2 +1,2 @@
-<urn:uuid:ad88d7b6-5b37-4eeb-a044-7bca1ffc366c> <a> <b> .
-<urn:uuid:37d41865-0910-9953-46c7-01359fbab6fa> <a> <b> .
+<urn:uuid:e6a48091-90e6-72fc-d944-9891bcca2363> <file:///home/jdroo/github.com/eyereasoner/eyeling/examples/a> <file:///home/jdroo/github.com/eyereasoner/eyeling/examples/b> .
+<urn:uuid:8228641a-8d20-b064-4ae2-12e31442492a> <file:///home/jdroo/github.com/eyereasoner/eyeling/examples/a> <file:///home/jdroo/github.com/eyereasoner/eyeling/examples/b> .

package/examples/output/harborsmr.txt

@@ -0,0 +1,20 @@
+HarborSMR — bounded flexible-export insight for port electrolysis
+
+Answer
+PERMIT
+The port hydrogen hub may use the SMR insight to run PEM electrolyzer train 2 at 16 MW from 14:00 to 18:00.
+
+Reason Why
+The operator shares only a narrow, expiring insight that a temporary 18 MW flexible-export window is available. The request is for electrolysis dispatch only, the requested 16 MW fits inside the permitted window, safety margins are above threshold, no outage blocks the window, and the policy forbids redistribution for market resale. Raw reactor telemetry stays local.
+
+Check
+C1  OK - reserve margin exceeds the dispatch threshold
+C2  OK - cooling margin exceeds the dispatch threshold
+C3  OK - no planned outage blocks the window
+C4  OK - requested MW fits within the export window
+C5  OK - serialized insight omits sensitive telemetry terms
+C6  OK - aggregate excludes core temperature, rod position, neutron flux, and operator IDs
+C7  OK - policy allows use for electrolysis dispatch before expiry
+C8  OK - policy prohibits redistribution for market resale
+C9  OK - scope is explicit: device, event, start, and expiry
+C10 OK - dispatch plan matches the requested load and power

package/examples/output/meta-rule-audit.n3

@@ -0,0 +1,44 @@
+@prefix : <http://example.org/> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+{
+    ?X a ?C .
+    ?C rdfs:subClassOf ?D .
+} :ruleStatus :Bidirectional .
+{
+    ?X a ?C .
+    ?C rdfs:subClassOf ?D .
+} :ruleHead {
+    ?X a ?D .
+} .
+{
+    ?P :parentOf ?Q .
+} :ruleStatus :ForwardOnly .
+{
+    ?P :parentOf ?Q .
+} :ruleHead {
+    ?Q :childOf ?P .
+} .
+{
+    ?Org :employs ?P .
+} :ruleStatus :BackwardOnly .
+{
+    ?Org :employs ?P .
+} :ruleHead {
+    ?P :worksFor ?Org .
+} .
+{
+    :alice a :Student .
+    :Student rdfs:subClassOf :Person .
+} :activeAs :ForwardBody .
+{
+    :alice :parentOf :bob .
+} :activeAs :ForwardBody .
+{
+    :alice a :Student .
+    :Student rdfs:subClassOf :Person .
+} :activeAs :BackwardBody .
+{
+    :acme :employs :carol .
+} :activeAs :BackwardBody .

package/examples/output/theory-diff.n3

@@ -0,0 +1,22 @@
+@prefix : <http://example.org/> .
+
+{
+    ?P :parentOf ?Q .
+} :missingForwardRule {
+    ?Q :childOf ?P .
+} .
+{
+    ?Org :employs ?P .
+} :missingBackwardRule {
+    ?P :worksFor ?Org .
+} .
+{
+    ?Org :employs ?P .
+} :extraForwardRule {
+    ?P :worksFor ?Org .
+} .
+{
+    ?P :mentors ?Q .
+} :extraForwardRule {
+    ?Q :menteeOf ?P .
+} .

package/examples/theory-diff.n3

@@ -0,0 +1,125 @@
+# =======================================================
+# Theory diff for quoted rule sets
+#
+# Compares two quoted theories and reports:
+# - forward rules missing from the candidate
+# - backward rules missing from the candidate
+# - extra forward rules in the candidate
+# - extra backward rules in the candidate
+#
+# It exercises:
+# - multiple quoted formulas as first-class values
+# - log:includes on quoted => and <=
+# - log:notIncludes for structural diffing
+# - matching quoted rule bodies and heads across formulas
+# =======================================================
+
+@prefix : <http://example.org/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+<> :base {
+    {
+        ?X a ?C .
+        ?C rdfs:subClassOf ?D .
+    }
+    =>
+    {
+        ?X a ?D .
+    }.
+
+    {
+        ?P :parentOf ?Q .
+    }
+    =>
+    {
+        ?Q :childOf ?P .
+    }.
+
+    {
+        ?P :worksFor ?Org .
+    }
+    <=
+    {
+        ?Org :employs ?P .
+    }.
+}.
+
+<> :candidate {
+    {
+        ?X a ?C .
+        ?C rdfs:subClassOf ?D .
+    }
+    =>
+    {
+        ?X a ?D .
+    }.
+
+    {
+        ?Org :employs ?P .
+    }
+    =>
+    {
+        ?P :worksFor ?Org .
+    }.
+
+    {
+        ?P :mentors ?Q .
+    }
+    =>
+    {
+        ?Q :menteeOf ?P .
+    }.
+}.
+
+# --------------------
+# Missing in candidate
+# --------------------
+
+{
+    ?W :base ?Base.
+    ?W :candidate ?Cand.
+    ?Base log:includes { ?B log:implies ?H }.
+    ?Cand log:notIncludes { ?B log:implies ?H }.
+}
+=>
+{
+    ?B :missingForwardRule ?H .
+}.
+
+{
+    ?W :base ?Base.
+    ?W :candidate ?Cand.
+    ?Base log:includes { ?H log:impliedBy ?B }.
+    ?Cand log:notIncludes { ?H log:impliedBy ?B }.
+}
+=>
+{
+    ?B :missingBackwardRule ?H .
+}.
+
+# ------------------
+# Extra in candidate
+# ------------------
+
+{
+    ?W :base ?Base.
+    ?W :candidate ?Cand.
+    ?Cand log:includes { ?B log:implies ?H }.
+    ?Base log:notIncludes { ?B log:implies ?H }.
+}
+=>
+{
+    ?B :extraForwardRule ?H .
+}.
+
+{
+    ?W :base ?Base.
+    ?W :candidate ?Cand.
+    ?Cand log:includes { ?H log:impliedBy ?B }.
+    ?Base log:notIncludes { ?H log:impliedBy ?B }.
+}
+=>
+{
+    ?B :extraBackwardRule ?H .
+}.

package/eyeling.js

@@ -2354,6 +2354,23 @@ function __logNaturalPriorityFromTerm(t) {
 // ===========================================================================
 // Backward proof & builtins mutual recursion — declarations first
 
+function __varCameFromBoundSubstitution(goalTerm, subst) {
+  if (!(goalTerm instanceof Var)) return false;
+  if (!subst || !Object.prototype.hasOwnProperty.call(subst, goalTerm.name)) return false;
+
+  let cur = subst[goalTerm.name];
+  const seen = new Set([goalTerm.name]);
+
+  while (cur instanceof Var) {
+    if (seen.has(cur.name)) return true;
+    seen.add(cur.name);
+    if (!Object.prototype.hasOwnProperty.call(subst, cur.name)) return true;
+    cur = subst[cur.name];
+  }
+
+  return false;
+}
+
 function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   const g = applySubstTriple(goal, subst);
   const pv = iriValue(g.p);
@@ -3820,7 +3837,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   // Schema: $s+ log:rawType $o-
   // Returns one of log:Formula, log:Literal, rdf:List, or log:Other.
   if (pv === LOG_NS + 'rawType') {
-    if (g.s instanceof Var) return [];
+    if (g.s instanceof Var && !__varCameFromBoundSubstitution(goal.s, subst)) return [];
 
     let ty;
     if (g.s instanceof GraphTerm) ty = internIri(LOG_NS + 'Formula');
@@ -4870,7 +4887,11 @@ module.exports = {
 
 'use strict';
 
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
 const engine = require('./engine');
+const deref = require('./deref');
 const { PrefixEnv } = require('./prelude');
 
 function offsetToLineCol(text, offset) {
@@ -4913,6 +4934,29 @@ function readTextFromStdinSync() {
   return fs.readFileSync(0, { encoding: 'utf8' });
 }
 
+function __isNetworkOrFileIri(s) {
+  return typeof s === 'string' && /^(https?:|file:\/\/)/i.test(s);
+}
+
+function __sourceLabelToBaseIri(sourceLabel) {
+  if (!sourceLabel || sourceLabel === '<stdin>') return '';
+  if (__isNetworkOrFileIri(sourceLabel)) return deref.stripFragment(sourceLabel);
+  return pathToFileURL(path.resolve(sourceLabel)).toString();
+}
+
+function __readInputSourceSync(sourceLabel) {
+  if (sourceLabel === '<stdin>') return readTextFromStdinSync();
+
+  if (__isNetworkOrFileIri(sourceLabel)) {
+    const txt = deref.derefTextSync(sourceLabel);
+    if (typeof txt !== 'string') throw new Error(`Failed to dereference ${sourceLabel}`);
+    return txt;
+  }
+
+  const fs = require('node:fs');
+  return fs.readFileSync(sourceLabel, { encoding: 'utf8' });
+}
+
 function main() {
   // Drop "node" and script name; keep only user-provided args
   // Expand combined short options: -pt == -p -t
@@ -5026,13 +5070,11 @@ function main() {
   }
 
   const sourceLabel = useImplicitStdin || positional[0] === '-' ? '<stdin>' : positional[0];
+  const baseIri = __sourceLabelToBaseIri(sourceLabel);
+
   let text;
   try {
-    if (sourceLabel === '<stdin>') text = readTextFromStdinSync();
-    else {
-      const fs = require('node:fs');
-      text = fs.readFileSync(sourceLabel, { encoding: 'utf8' });
-    }
+    text = __readInputSourceSync(sourceLabel);
   } catch (e) {
     if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
     else console.error(`Error reading file ${JSON.stringify(sourceLabel)}: ${e.message}`);
@@ -5044,6 +5086,7 @@ function main() {
   try {
     toks = engine.lex(text);
     const parser = new engine.Parser(toks);
+    if (baseIri) parser.prefixes.setBase(baseIri);
     [prefixes, triples, frules, brules, qrules] = parser.parseDocument();
     // Make the parsed prefixes available to log:trace output (CLI path)
     engine.setTracePrefixes(prefixes);
@@ -5951,21 +5994,80 @@ function __isStrictGroundTriple(tr) {
 // -----------------------------------------------------------------------------
 // Used to maintain O(1) membership sets for dynamically promoted rules, and to
 // memoize per-firing head-blank skolemization.
+//
+// Important: variables and blank nodes *inside quoted formulas* are local to the
+// formula. Canonicalize those labels by first occurrence so alpha-equivalent
+// formulas (for example the repeated results of log:semantics after
+// standardize-apart) get the same identity key. Keep top-level blank labels
+// untouched so distinct existential witnesses in the global fact set do not
+// collapse together.
+function __keyFromTermForRuleIdentity(term) {
+  const ctx = { quotedVar: new Map(), quotedBlank: new Map() };
+
+  function canonQuotedVar(name) {
+    let out = ctx.quotedVar.get(name);
+    if (!out) {
+      out = `v${ctx.quotedVar.size}`;
+      ctx.quotedVar.set(name, out);
+    }
+    return out;
+  }
+
+  function canonQuotedBlank(label) {
+    let out = ctx.quotedBlank.get(label);
+    if (!out) {
+      out = `b${ctx.quotedBlank.size}`;
+      ctx.quotedBlank.set(label, out);
+    }
+    return out;
+  }
+
+  function enc(u, inQuotedFormula) {
+    if (u instanceof Iri) return ['I', u.value];
+    if (u instanceof Literal) return ['L', u.value];
+    if (u instanceof Blank) return inQuotedFormula ? ['BQ', canonQuotedBlank(u.label)] : ['B', u.label];
+    if (u instanceof Var) return inQuotedFormula ? ['VQ', canonQuotedVar(u.name)] : ['V', u.name];
+    if (u instanceof ListTerm) return ['List', u.elems.map((e) => enc(e, inQuotedFormula))];
+    if (u instanceof OpenListTerm) {
+      return [
+        'OpenList',
+        u.prefix.map((e) => enc(e, inQuotedFormula)),
+        inQuotedFormula ? ['TailVQ', canonQuotedVar(u.tailVar)] : ['TailV', u.tailVar],
+      ];
+    }
+    if (u instanceof GraphTerm)
+      return ['Graph', u.triples.map((tr) => [enc(tr.s, true), enc(tr.p, true), enc(tr.o, true)])];
+    return ['Other', String(u)];
+  }
+
+  return JSON.stringify(enc(term, false));
+}
+
 function __ruleKey(isForward, isFuse, premise, conclusion, dynamicConclusionTerm /* optional */) {
   let out = (isForward ? 'F' : 'B') + (isFuse ? '!' : '') + '|P|';
   for (let i = 0; i < premise.length; i++) {
     const tr = premise[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   out += '|C|';
   for (let i = 0; i < conclusion.length; i++) {
     const tr = conclusion[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   if (dynamicConclusionTerm) {
-    out += '|T|' + skolemKeyFromTerm(dynamicConclusionTerm);
+    out += '|T|' + __keyFromTermForRuleIdentity(dynamicConclusionTerm);
   }
   return out;
 }
@@ -5976,7 +6078,12 @@ function __firingKey(ruleIndex, instantiatedPremises) {
   for (let i = 0; i < instantiatedPremises.length; i++) {
     const tr = instantiatedPremises[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   return out;
 }
@@ -8216,7 +8323,17 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
       if (remaining <= 0) continue;
       const builtinMax = Number.isFinite(remaining) && !restGoals.length ? remaining : undefined;
 
-      let deltas = evalBuiltin(goal0, {}, facts, backRules, frame.curDepth, varGen, builtinMax);
+      const builtinGoalForEval = goalPredicateIri === LOG_NS + 'rawType' ? rawGoal : goal0;
+      const builtinSubstForEval = goalPredicateIri === LOG_NS + 'rawType' ? substMut : {};
+      let deltas = evalBuiltin(
+        builtinGoalForEval,
+        builtinSubstForEval,
+        facts,
+        backRules,
+        frame.curDepth,
+        varGen,
+        builtinMax,
+      );
 
       const dc = typeof frame.deferCount === 'number' ? frame.deferCount : 0;
       const builtinDeltasAreVacuous = deltas.length > 0 && deltas.every((d) => Object.keys(d).length === 0);

package/lib/builtins.js

@@ -1875,6 +1875,23 @@ function __logNaturalPriorityFromTerm(t) {
 // ===========================================================================
 // Backward proof & builtins mutual recursion — declarations first
 
+function __varCameFromBoundSubstitution(goalTerm, subst) {
+  if (!(goalTerm instanceof Var)) return false;
+  if (!subst || !Object.prototype.hasOwnProperty.call(subst, goalTerm.name)) return false;
+
+  let cur = subst[goalTerm.name];
+  const seen = new Set([goalTerm.name]);
+
+  while (cur instanceof Var) {
+    if (seen.has(cur.name)) return true;
+    seen.add(cur.name);
+    if (!Object.prototype.hasOwnProperty.call(subst, cur.name)) return true;
+    cur = subst[cur.name];
+  }
+
+  return false;
+}
+
 function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   const g = applySubstTriple(goal, subst);
   const pv = iriValue(g.p);
@@ -3341,7 +3358,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   // Schema: $s+ log:rawType $o-
   // Returns one of log:Formula, log:Literal, rdf:List, or log:Other.
   if (pv === LOG_NS + 'rawType') {
-    if (g.s instanceof Var) return [];
+    if (g.s instanceof Var && !__varCameFromBoundSubstitution(goal.s, subst)) return [];
 
     let ty;
     if (g.s instanceof GraphTerm) ty = internIri(LOG_NS + 'Formula');