eyeling 1.26.0 → 1.26.1

package/lib/cli.js

@@ -211,8 +211,8 @@ function main() {
           baseIri: __sourceLabelToBaseIri(sourceLabel),
           label: sourceLabel,
           collectUsedPrefixes: streamMode,
-          collectSourceLocations: engine.getProofCommentsEnabled(),
           keepSourceArtifacts: false,
+          sourceLocations: engine.getProofCommentsEnabled(),
           rdf: rdfMode,
         }),
       );
@@ -368,7 +368,7 @@ function main() {
   }
 
   if (engine.getProofCommentsEnabled()) {
-    process.stdout.write(engine.renderProofDocument(outDerived, derived, triples, prefixes, brules));
+    process.stdout.write(engine.renderProofDocument(outDerived, derived.concat(outDerived || []), triples, prefixes, brules));
     return;
   }
 

package/lib/engine.js

@@ -25,6 +25,7 @@ const {
   Triple,
   Rule,
   DerivedFact,
+  varsInRule,
   internIri,
   collectBlankLabelsInTriples,
   copyQuotedGraphMetadata,
@@ -42,7 +43,7 @@ const EMPTY_LIST_TERM = new ListTerm([]);
 const { lex, N3SyntaxError } = require('./lexer');
 const { Parser } = require('./parser');
 const { liftBlankRuleVars } = require('./rules');
-const { parseN3SourceList } = require('./multisource');
+const { parseN3Text, parseN3SourceList } = require('./multisource');
 
 const {
   makeBuiltins,
@@ -2435,217 +2436,6 @@ function unifyTriple(pat, fact, subst) {
   return s3;
 }
 
-
-function __copyProofSourceMetadata(from, to) {
-  if (!from || !to) return to;
-  for (const key of ['__sourceOffset', '__source']) {
-    if (hasOwn.call(from, key)) {
-      Object.defineProperty(to, key, {
-        value: from[key],
-        enumerable: false,
-        writable: false,
-        configurable: true,
-      });
-    }
-  }
-  return to;
-}
-
-function __standardizeRuleForProof(rule, gen) {
-  const proofVarNames = Object.create(null);
-
-  function renameTerm(t, vmapName, vmapVar, genArr) {
-    if (t instanceof Var) {
-      if (!hasOwn.call(vmapVar, t.name)) {
-        const name = `${t.name}__proof_${genArr[0]}`;
-        genArr[0] += 1;
-        vmapName[t.name] = name;
-        vmapVar[t.name] = new Var(name);
-        proofVarNames[name] = t.name;
-      }
-      return vmapVar[t.name];
-    }
-    if (t instanceof ListTerm) {
-      let changed = false;
-      const elems2 = t.elems.map((e) => {
-        const e2 = renameTerm(e, vmapName, vmapVar, genArr);
-        if (e2 !== e) changed = true;
-        return e2;
-      });
-      return changed ? new ListTerm(elems2) : t;
-    }
-    if (t instanceof OpenListTerm) {
-      let changed = false;
-      const newXs = t.prefix.map((e) => {
-        const e2 = renameTerm(e, vmapName, vmapVar, genArr);
-        if (e2 !== e) changed = true;
-        return e2;
-      });
-      if (!hasOwn.call(vmapName, t.tailVar)) {
-        const name = `${t.tailVar}__proof_${genArr[0]}`;
-        genArr[0] += 1;
-        vmapName[t.tailVar] = name;
-        vmapVar[t.tailVar] = new Var(name);
-        proofVarNames[name] = t.tailVar;
-      }
-      const newTail = vmapName[t.tailVar];
-      if (newTail !== t.tailVar) changed = true;
-      return changed ? new OpenListTerm(newXs, newTail) : t;
-    }
-    if (t instanceof GraphTerm) {
-      let changed = false;
-      const triples2 = t.triples.map((tr) => {
-        const s2 = renameTerm(tr.s, vmapName, vmapVar, genArr);
-        const p2 = renameTerm(tr.p, vmapName, vmapVar, genArr);
-        const o2 = renameTerm(tr.o, vmapName, vmapVar, genArr);
-        if (s2 !== tr.s || p2 !== tr.p || o2 !== tr.o) changed = true;
-        return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
-      });
-      return changed ? copyQuotedGraphMetadata(t, new GraphTerm(triples2)) : t;
-    }
-    return t;
-  }
-
-  const vmapName = Object.create(null);
-  const vmapVar = Object.create(null);
-  const premise = rule.premise.map((tr) => {
-    const s2 = renameTerm(tr.s, vmapName, vmapVar, gen);
-    const p2 = renameTerm(tr.p, vmapName, vmapVar, gen);
-    const o2 = renameTerm(tr.o, vmapName, vmapVar, gen);
-    return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
-  });
-  const conclusion = rule.conclusion.map((tr) => {
-    const s2 = renameTerm(tr.s, vmapName, vmapVar, gen);
-    const p2 = renameTerm(tr.p, vmapName, vmapVar, gen);
-    const o2 = renameTerm(tr.o, vmapName, vmapVar, gen);
-    return s2 === tr.s && p2 === tr.p && o2 === tr.o ? tr : new Triple(s2, p2, o2);
-  });
-  const out = new Rule(premise, conclusion, rule.isForward, rule.isFuse, rule.headBlankLabels);
-  Object.defineProperty(out, '__proofVarSourceNames', {
-    value: proofVarNames,
-    enumerable: false,
-    writable: false,
-    configurable: true,
-  });
-  return __copyProofSourceMetadata(rule, out);
-}
-
-function __mergeProofSubst(base, delta) {
-  const out = __cloneSubst(base);
-  for (const k in delta || {}) {
-    if (!hasOwn.call(delta, k)) continue;
-    const v = applySubstTerm(delta[k], out);
-    if (hasOwn.call(out, k)) {
-      if (!termsEqual(applySubstTerm(out[k], out), v)) return null;
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-function __sourceSortKey(obj) {
-  const src = obj && obj.__source;
-  const label = src && typeof src.label === 'string' ? src.label : '';
-  const line = src && Number.isInteger(src.line) ? src.line : 0;
-  return `${label}\t${line}`;
-}
-
-function __candidateFactsForProof(facts, goal) {
-  if (!Array.isArray(facts)) return [];
-  ensureFactIndexes(facts);
-  const candidates = candidateFacts(facts, goal);
-  if (!candidates) return facts;
-  const out = [];
-  for (let i = 0; i < candidates.exactLen; i++) out.push(facts[candidates.exact[i]]);
-  for (let i = 0; i < candidates.wildLen; i++) out.push(facts[candidates.wild[i]]);
-  return out;
-}
-
-function findBackwardProofForGoal(goal, facts, backRules, opts = {}) {
-  const maxDepth = Number.isInteger(opts.maxDepth) && opts.maxDepth > 0 ? opts.maxDepth : 64;
-  const varGen = [0];
-
-  function proofKey(tr) {
-    return `${skolemKeyFromTerm(tr.s)}\t${skolemKeyFromTerm(tr.p)}\t${skolemKeyFromTerm(tr.o)}`;
-  }
-
-  function proveGoal(goal0, subst, depth, visited) {
-    if (depth > maxDepth) return [];
-    const g = applySubstTriple(goal0, subst);
-    const key = proofKey(g);
-    if (visited.has(key)) return [];
-
-    if (isBuiltinPred(g.p)) {
-      const builtinGoalForEval = g.p instanceof Iri && g.p.value === LOG_NS + 'rawType' ? goal0 : g;
-      const builtinSubstForEval = g.p instanceof Iri && g.p.value === LOG_NS + 'rawType' ? subst : __emptySubst();
-      const deltas = evalBuiltin(builtinGoalForEval, builtinSubstForEval, facts, backRules, depth, varGen, 1) || [];
-      const out = [];
-      for (const delta of deltas) {
-        const subst2 = __mergeProofSubst(subst, delta);
-        if (subst2 === null) continue;
-        const fact = applySubstTriple(g, subst2);
-        out.push({ subst: subst2, proof: { kind: 'builtin', fact, builtin: fact.p } });
-        break;
-      }
-      return out;
-    }
-
-    const factResults = [];
-    for (const f of __candidateFactsForProof(facts, g)) {
-      const subst2 = unifyTriple(g, f, subst);
-      if (subst2 === null) continue;
-      factResults.push({ subst: subst2, proof: { kind: 'fact', fact: applySubstTriple(f, subst2), source: f.__source } });
-      break;
-    }
-    if (factResults.length) return factResults;
-
-    if (!(g.p instanceof Iri)) return [];
-    ensureBackRuleIndexes(backRules);
-    const rules = (backRules.__byHeadPred.get(g.p.__tid) || []).concat(backRules.__wildHeadPred || []);
-    rules.sort((a, b) => (__sourceSortKey(a) < __sourceSortKey(b) ? -1 : __sourceSortKey(a) > __sourceSortKey(b) ? 1 : 0));
-
-    const visited2 = new Set(visited);
-    visited2.add(key);
-
-    for (const r of rules) {
-      if (!r || !Array.isArray(r.conclusion) || r.conclusion.length !== 1) continue;
-      const rStd = __standardizeRuleForProof(r, varGen);
-      const head = rStd.conclusion[0];
-      if (head.p instanceof Iri && head.p.__tid !== g.p.__tid) continue;
-      const subst1 = unifyTriple(head, g, subst);
-      if (subst1 === null) continue;
-      const bodyProof = proveGoalList(rStd.premise || [], subst1, depth + 1, visited2);
-      if (!bodyProof) continue;
-      const fact = applySubstTriple(g, bodyProof.subst);
-      const premises = (rStd.premise || []).map((prem) => applySubstTriple(prem, bodyProof.subst));
-      const df = new DerivedFact(fact, rStd, premises, bodyProof.subst);
-      return [{ subst: bodyProof.subst, proof: { kind: 'rule', df, children: bodyProof.proofs } }];
-    }
-
-    return [];
-  }
-
-  function proveGoalList(goals, subst, depth, visited) {
-    let states = [{ subst, proofs: [] }];
-    for (const goal1 of goals || []) {
-      const next = [];
-      for (const state of states) {
-        const proofs = proveGoal(goal1, state.subst, depth, visited);
-        for (const pr of proofs) next.push({ subst: pr.subst, proofs: state.proofs.concat([pr.proof]) });
-      }
-      if (!next.length) return null;
-      // Keep proof reconstruction deterministic and cheap: one proof is enough
-      // for an explanation of the already-derived enclosing fact.
-      states = [next[0]];
-    }
-    return states[0] || { subst, proofs: [] };
-  }
-
-  const found = proveGoal(goal, __emptySubst(), 0, new Set());
-  return found.length ? found[0].proof : null;
-}
-
 // Strategy: when the substitution is "large" or search depth is high,
 // keep only bindings that are still relevant to:
 //   - variables appearing in the remaining goals
@@ -3367,6 +3157,120 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
   return results;
 }
 
+
+// Reconstruct one backward proof for N3 proof output. This is intentionally
+// called only by renderProofDocument(), so normal reasoning does not pay for it.
+function __proofTripleKey(tr) {
+  if (!tr) return '';
+  return `${skolemKeyFromTerm(tr.s)}\t${skolemKeyFromTerm(tr.p)}\t${skolemKeyFromTerm(tr.o)}`;
+}
+
+function __copyProofSource(from, to) {
+  if (from && to && Object.prototype.hasOwnProperty.call(from, '__source')) {
+    Object.defineProperty(to, '__source', {
+      value: from.__source,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+  }
+  return to;
+}
+
+function __annotateProofVarSourceNames(rule) {
+  if (!rule) return rule;
+  const sourceNames = Object.create(null);
+  for (const name of varsInRule(rule)) {
+    const m = /^(.*)__\d+$/.exec(name);
+    sourceNames[name] = m ? m[1] : name;
+  }
+  Object.defineProperty(rule, '__proofVarSourceNames', {
+    value: sourceNames,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return rule;
+}
+
+function findBackwardProofForGoal(goal, facts, backRules, opts = {}) {
+  const maxDepth = Number.isInteger(opts.maxDepth) && opts.maxDepth >= 0 ? opts.maxDepth : 64;
+  const varGen = Array.isArray(opts.varGen) ? opts.varGen : [1];
+  const visited = opts.visited instanceof Set ? opts.visited : new Set();
+  const factList = Array.isArray(facts) ? facts : [];
+  const ruleList = Array.isArray(backRules) ? backRules : [];
+
+  function matchingBaseFact(g) {
+    const candidates = g && g.p instanceof Iri ? candidateFacts(factList, g) : null;
+    const total = candidates ? candidates.totalLen : factList.length;
+    for (let i = 0; i < total; i++) {
+      let f;
+      if (candidates) {
+        if (i < candidates.exactLen) f = factList[candidates.exact[i]];
+        else f = factList[candidates.wild[i - candidates.exactLen]];
+      } else {
+        f = factList[i];
+      }
+      if (unifyTriple(g, f, __emptySubst()) !== null) return f;
+    }
+    return null;
+  }
+
+  function builtinProof(g) {
+    if (!(g && isBuiltinPred(g.p))) return null;
+    return { kind: 'builtin', fact: g, builtin: g.p };
+  }
+
+  function solve(g, depth) {
+    if (!g || depth > maxDepth) return null;
+
+    const base = matchingBaseFact(g);
+    if (base) return { kind: 'fact', fact: base, source: base.__source };
+
+    const builtin = builtinProof(g);
+    if (builtin) return builtin;
+
+    if (!(g.p instanceof Iri)) return null;
+    const gKey = __proofTripleKey(g);
+    if (visited.has(gKey)) return null;
+    visited.add(gKey);
+
+    try {
+      ensureBackRuleIndexes(ruleList);
+      const candRules = (ruleList.__byHeadPred.get(g.p.__tid) || []).concat(ruleList.__wildHeadPred);
+      for (const r of candRules) {
+        if (!r || !Array.isArray(r.conclusion) || r.conclusion.length !== 1) continue;
+        const rawHead = r.conclusion[0];
+        if (rawHead.p instanceof Iri && rawHead.p.__tid !== g.p.__tid) continue;
+
+        const rStd = __annotateProofVarSourceNames(__copyProofSource(r, standardizeRule(r, varGen)));
+        const head = rStd.conclusion[0];
+        const s0 = unifyTriple(head, g, __emptySubst());
+        if (s0 === null) continue;
+
+        const solutions = proveGoals(rStd.premise, s0, factList, ruleList, depth + 1, [], varGen, 1, {
+          keepVars: varsInRule(rStd),
+          deferBuiltins: true,
+        });
+        if (!solutions.length) continue;
+
+        const subst = solutions[0];
+        const fact = applySubstTriple(head, subst);
+        const premises = rStd.premise.map((prem) => applySubstTriple(prem, subst));
+        const df = new DerivedFact(fact, rStd, premises, __cloneSubst(subst));
+        const children = premises.map((prem) => builtinProof(prem) || solve(prem, depth + 1));
+        return { kind: 'rule', df, children };
+      }
+    } finally {
+      visited.delete(gKey);
+    }
+
+    return null;
+  }
+
+  return solve(goal, 0);
+}
+
 // ===========================================================================
 // Forward chaining to fixpoint
 // ===========================================================================
@@ -4052,7 +3956,7 @@ function reasonStream(input, opts = {}) {
 
   const useRdfCompatibility = !!rdf;
 
-  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility });
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility, sourceLocations: proof });
   const parsedInput = parsedSourceList || normalizeParsedReasonerInputSync(input);
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
@@ -4088,11 +3992,22 @@ function reasonStream(input, opts = {}) {
     if (baseIri) prefixes.setBase(baseIri);
   } else {
     const n3Text = normalizeReasonerInputSync(input);
-    const toks = lex(n3Text, { rdf: useRdfCompatibility });
-    const parser = new Parser(toks);
-    if (baseIri) parser.prefixes.setBase(baseIri);
+    if (proof) {
+      const parsed = parseN3Text(n3Text, {
+        label: 'input.n3',
+        baseIri: baseIri || '',
+        keepSourceArtifacts: false,
+        sourceLocations: true,
+        rdf: useRdfCompatibility,
+      });
+      ({ prefixes, triples, frules, brules, logQueryRules } = parsed);
+    } else {
+      const toks = lex(n3Text, { rdf: useRdfCompatibility });
+      const parser = new Parser(toks);
+      if (baseIri) parser.prefixes.setBase(baseIri);
 
-    [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+      [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+    }
   }
   // Make the parsed prefixes available to log:trace output
   trace.setTracePrefixes(prefixes);
@@ -4163,7 +4078,7 @@ function reasonStream(input, opts = {}) {
   const closureN3 = proof
     ? renderProofDocument(
         Array.isArray(logQueryRules) && logQueryRules.length ? queryDerived : derived,
-        derived,
+        derived.concat(queryDerived || []),
         triples,
         prefixes,
         brules,
@@ -4216,7 +4131,7 @@ function reasonRdfJs(input, opts = {}) {
 
   Promise.resolve().then(async () => {
     try {
-      const normalizedInput = parseN3SourceList(input, restOpts) || (await normalizeReasonerInputAsync(input));
+      const normalizedInput = parseN3SourceList(input, { ...restOpts, sourceLocations: !!(restOpts.proof || restOpts.proofComments) }) || (await normalizeReasonerInputAsync(input));
       reasonStream(normalizedInput, {
         ...restOpts,
         rdfjs: false,