eyeling 1.26.0 → 1.26.2

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 { parseN3SourceList, parseN3Text } = 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
 // ===========================================================================
@@ -4048,12 +3952,22 @@ function reasonStream(input, opts = {}) {
     skipUnsupportedRdfJs = false,
     builtinModules = null,
     rdf = false,
+    sourceLabel = '<input>',
   } = opts;
 
   const useRdfCompatibility = !!rdf;
 
-  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility });
-  const parsedInput = parsedSourceList || normalizeParsedReasonerInputSync(input);
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility, sourceLocations: proof });
+  const parsedTextInput = (!parsedSourceList && proof && typeof input === 'string')
+    ? parseN3Text(input, {
+        baseIri: baseIri || '',
+        label: sourceLabel || '<input>',
+        keepSourceArtifacts: false,
+        sourceLocations: true,
+        rdf: useRdfCompatibility,
+      })
+    : null;
+  const parsedInput = parsedSourceList || parsedTextInput || normalizeParsedReasonerInputSync(input);
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
   const __oldEnforceHttps = deref.getEnforceHttpsEnabled();
@@ -4163,7 +4077,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 +4130,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,

package/lib/explain.js

@@ -135,7 +135,6 @@ ${lineIndent(body, '    ')}
 }`;
   }
 
-
   function clonePrefixEnvWithProofVocabulary(prefixes) {
     const map = { ...(prefixes && prefixes.map ? prefixes.map : {}) };
     if (!map.pe) map.pe = PE_NS;
@@ -153,6 +152,11 @@ ${lineIndent(body, '    ')}
     return source.label.replace(/\\/g, '/').split('/').pop() || source.label;
   }
 
+  function sourceKeyForProof(source) {
+    if (!source) return '<unknown>';
+    return `${sourceLabelForProof(source)}:${Number.isInteger(source.line) ? source.line : ''}`;
+  }
+
   function byBlankNode(kind, source) {
     const src = source || {};
     const props = [`pe:${kind} ${n3String(sourceLabelForProof(src))}`];
@@ -160,121 +164,129 @@ ${lineIndent(body, '    ')}
     return `[ ${props.join('; ')} ]`;
   }
 
-  function renderBindingList(df, prefixes) {
-    if (!df || !df.rule || !df.subst) return '';
+  function renderBindingItems(df, prefixes) {
+    if (!df || !df.rule || !df.subst) return [];
     const ruleVars = varsInRule(df.rule);
     const visibleNames = Object.keys(df.subst)
       .filter((name) => ruleVars.has(name))
       .sort();
-    if (!visibleNames.length) return '';
+    if (!visibleNames.length) return [];
     const sourceNames = (df.rule && df.rule.__proofVarSourceNames) || null;
-    return visibleNames
-      .map((name) => {
-        const value = applySubstTerm(new Var(name), df.subst);
-        const displayName = sourceNames && sourceNames[name] ? sourceNames[name] : name;
-        return `[ pe:var ${n3String(displayName)}; pe:value ${termToN3(value, prefixes)} ]`;
-      })
-      .join(', ');
+    return visibleNames.map((name) => {
+      const value = applySubstTerm(new Var(name), df.subst);
+      const displayName = sourceNames && sourceNames[name] ? sourceNames[name] : name;
+      return `[ pe:var ${n3String(displayName)}; pe:value ${termToN3(value, prefixes)} ]`;
+    });
   }
 
-  function proofSourceKey(source) {
-    if (!source) return '';
-    const label = typeof source.label === 'string' ? source.label : '';
-    const line = Number.isInteger(source.line) ? source.line : 0;
-    return `${label}\t${line}`;
+  function withLastLineSuffix(text, suffix) {
+    const lines = String(text).split(/\r?\n/);
+    lines[lines.length - 1] += suffix;
+    return lines.join('\n');
   }
 
-  function proofEntryKey(kind, fact, source, extra) {
-    return `${kind}\t${proofTripleKey(fact)}\t${proofSourceKey(source)}\t${extra || ''}`;
+  function renderPredicateObjects(predicate, objects, isLast) {
+    const values = (objects || []).filter((value) => value);
+    if (!values.length) return [];
+    const end = isLast ? '.' : ';';
+    if (values.length === 1 && !values[0].includes('\n')) {
+      return [`    ${predicate} ${values[0]}${end}`];
+    }
+    const out = [`    ${predicate}`];
+    for (let i = 0; i < values.length; i++) {
+      const suffix = i === values.length - 1 ? end : ',';
+      out.push(lineIndent(withLastLineSuffix(values[i], suffix), '      '));
+    }
+    return out;
   }
 
-  function ruleEntryKey(df) {
-    const rule = df && df.rule;
-    const premises = (df && df.premises ? df.premises : []).map((prem) => proofTripleKey(prem)).join('\t');
-    return proofEntryKey('rule', df && df.fact, rule && rule.__source, premises);
+  function proofEntryKey(entry) {
+    if (!entry) return '';
+    if (entry.kind === 'rule') {
+      const df = entry.df;
+      const source = df && df.rule && df.rule.__source;
+      const premiseKey = (df && df.premises ? df.premises : []).map(proofTripleKey).join('|');
+      return `rule:${proofTripleKey(df && df.fact)}:${sourceKeyForProof(source)}:${premiseKey}`;
+    }
+    if (entry.kind === 'builtin') return `builtin:${proofTripleKey(entry.fact)}`;
+    return `fact:${proofTripleKey(entry.fact)}:${sourceKeyForProof(entry.source)}`;
   }
 
   function collectProofEntries(rootDf, derivedByKey, baseFactByKey, resolveBackwardProof) {
     const entries = [];
     const seen = new Set();
 
-    function entryKeyForProof(proof, fallbackTriple) {
-      if (!proof) return proofEntryKey('fact', fallbackTriple, null);
-      if (proof.kind === 'rule') return ruleEntryKey(proof.df);
-      if (proof.kind === 'builtin') return proofEntryKey('builtin', proof.fact || fallbackTriple, null);
-      return proofEntryKey('fact', proof.fact || fallbackTriple, proof.source);
+    function remember(entry) {
+      const key = proofEntryKey(entry);
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      entries.push(entry);
+      return true;
+    }
+
+    function derivedCandidatesForKey(key) {
+      const found = derivedByKey.get(key);
+      if (!found) return [];
+      return Array.isArray(found) ? found : [found];
     }
 
-    function visitProofNode(proof, fallbackTriple) {
+    function visitProofNode(proof, fallbackTriple, parentDf) {
       if (!proof) {
-        visitFactTriple(fallbackTriple);
+        visitFactTriple(fallbackTriple, parentDf);
         return;
       }
-      const key = entryKeyForProof(proof, fallbackTriple);
-      if (!key || seen.has(key)) return;
       if (proof.kind === 'rule' && proof.df) {
         visitDerivedFact(proof.df, proof.children || null);
         return;
       }
-      seen.add(key);
       if (proof.kind === 'builtin') {
-        entries.push({
-          kind: 'builtin',
-          fact: proof.fact || fallbackTriple,
-          builtin: proof.builtin || (proof.fact && proof.fact.p),
-        });
-      } else {
-        entries.push({ kind: 'fact', fact: proof.fact || fallbackTriple, source: proof.source });
+        remember({ kind: 'builtin', fact: proof.fact || fallbackTriple, builtin: proof.builtin || (proof.fact && proof.fact.p) });
+        return;
       }
+      remember({ kind: 'fact', fact: proof.fact || fallbackTriple, source: proof.source });
     }
 
-    function visitFactTriple(tr) {
-      const tripleKey = proofTripleKey(tr);
-      if (!tripleKey) return;
-      const df = derivedByKey.get(tripleKey);
-      if (df) {
-        visitDerivedFact(df);
+    function visitFactTriple(tr, parentDf) {
+      const key = proofTripleKey(tr);
+      const base = baseFactByKey.get(key) || null;
+      if (base) {
+        remember({ kind: 'fact', fact: base, source: base.__source });
         return;
       }
-      const base = baseFactByKey.get(tripleKey) || null;
-      if (base) {
-        const key = proofEntryKey('fact', base, base.__source);
-        if (seen.has(key)) return;
-        seen.add(key);
-        entries.push({ kind: 'fact', fact: base, source: base.__source });
+
+      const candidates = derivedCandidatesForKey(key);
+      const df = candidates.find((candidate) => candidate !== parentDf) || null;
+      if (df) {
+        visitDerivedFact(df);
         return;
       }
+
       if (tr && isBuiltinPred(tr.p)) {
-        const key = proofEntryKey('builtin', tr, null);
-        if (seen.has(key)) return;
-        seen.add(key);
-        entries.push({ kind: 'builtin', fact: tr, builtin: tr.p });
+        remember({ kind: 'builtin', fact: tr, builtin: tr.p });
         return;
       }
+
       if (resolveBackwardProof) {
         const proof = resolveBackwardProof(tr);
         if (proof) {
-          visitProofNode(proof, tr);
+          visitProofNode(proof, tr, parentDf);
           return;
         }
       }
-      const key = proofEntryKey('fact', tr, null);
-      if (seen.has(key)) return;
-      seen.add(key);
-      entries.push({ kind: 'fact', fact: tr, source: null });
+
+      remember({ kind: 'fact', fact: tr, source: null });
     }
 
     function visitDerivedFact(df, children) {
-      const key = ruleEntryKey(df);
-      if (!key || seen.has(key)) return;
-      seen.add(key);
-      entries.push({ kind: 'rule', df });
+      if (!df || !df.fact) return;
+      const entry = { kind: 'rule', df };
+      if (!remember(entry)) return;
 
       if (Array.isArray(children) && children.length) {
-        for (const child of children) visitProofNode(child);
+        for (const child of children) visitProofNode(child, null, df);
         return;
       }
-      for (const prem of df.premises || []) visitFactTriple(prem);
+      for (const prem of df.premises || []) visitFactTriple(prem, df);
     }
 
     visitDerivedFact(rootDf);
@@ -304,16 +316,18 @@ ${lineIndent(body, '    ')}
     }
 
     const df = entry.df;
-    const props = [`pe:by ${byBlankNode('rule', df.rule && df.rule.__source)}`];
-    const bindings = renderBindingList(df, prefixes);
-    if (bindings) props.push(`pe:binding ${bindings}`);
-    if (df.premises && df.premises.length) {
-      props.push(`pe:uses ${df.premises.map((prem) => graphForTriple(prem, prefixes)).join(', ')}`);
-    }
+    const bindingItems = renderBindingItems(df, prefixes);
+    const useItems = (df.premises || []).map((prem) => graphForTriple(prem, prefixes));
+    const propertyGroups = [
+      { predicate: 'pe:by', objects: [byBlankNode('rule', df.rule && df.rule.__source)] },
+      { predicate: 'pe:binding', objects: bindingItems },
+      { predicate: 'pe:uses', objects: useItems },
+    ].filter((group) => group.objects.length);
 
     let out = `  ${graphForTriple(df.fact, prefixes)}\n`;
-    for (let i = 0; i < props.length; i++) {
-      out += `    ${props[i]}${i === props.length - 1 ? '.' : ';'}\n`;
+    for (let i = 0; i < propertyGroups.length; i++) {
+      const group = propertyGroups[i];
+      out += renderPredicateObjects(group.predicate, group.objects, i === propertyGroups.length - 1).join('\n') + '\n';
     }
     return out.trimEnd();
   }
@@ -334,13 +348,18 @@ ${proofBody}
 
     const proofPrefixes = clonePrefixEnvWithProofVocabulary(prefixes);
     const derivedByKey = new Map();
-    for (const df of allDerived || []) {
-      if (!df || !df.fact) continue;
+    function addDerived(df) {
+      if (!df || !df.fact) return;
       const key = proofTripleKey(df.fact);
-      if (!derivedByKey.has(key)) derivedByKey.set(key, df);
+      let bucket = derivedByKey.get(key);
+      if (!bucket) {
+        bucket = [];
+        derivedByKey.set(key, bucket);
+      }
+      if (!bucket.includes(df)) bucket.push(df);
     }
-    // Do not insert query-wrapper output facts here: those wrappers often derive
-    // the same triple they use, and would hide the underlying fact/rule proof.
+    for (const df of allDerived || []) addDerived(df);
+    for (const df of selectedDerived) addDerived(df);
 
     const baseFactByKey = new Map();
     for (const tr of baseFacts || []) {