eyeling 1.25.5 → 1.26.0

package/index.d.ts

@@ -151,6 +151,7 @@ declare module 'eyeling' {
   }
 
   export interface ReasonOptions {
+    proof?: boolean;
     proofComments?: boolean;
     noProofComments?: boolean;
     args?: string[];

package/index.js

@@ -19,21 +19,24 @@ function reason(opt = {}, input = '') {
 
   const args = [];
 
-  // default: proof comments OFF for API output (machine-friendly)
-  // set { proofComments: true } to keep them
-  const proofCommentsSpecified = typeof opt.proofComments === 'boolean' || typeof opt.noProofComments === 'boolean';
-
-  const proofComments =
-    typeof opt.proofComments === 'boolean'
-      ? opt.proofComments
-      : typeof opt.noProofComments === 'boolean'
-        ? !opt.noProofComments
-        : false;
+  // default: proof output OFF for API output (machine-friendly)
+  // set { proof: true } to include N3 proof explanations.
+  // proofComments/noProofComments are accepted as legacy aliases.
+  const proofSpecified =
+    typeof opt.proof === 'boolean' || typeof opt.proofComments === 'boolean' || typeof opt.noProofComments === 'boolean';
+
+  const proof =
+    typeof opt.proof === 'boolean'
+      ? opt.proof
+      : typeof opt.proofComments === 'boolean'
+        ? opt.proofComments
+        : typeof opt.noProofComments === 'boolean'
+          ? !opt.noProofComments
+          : false;
 
   // Only pass a flag when the caller explicitly asked.
-  // (CLI default is now: no proof comments.)
-  if (proofCommentsSpecified) {
-    if (proofComments) args.push('--proof-comments');
+  if (proofSpecified) {
+    if (proof) args.push('--proof');
     else args.push('--no-proof-comments');
   }
 

package/lib/cli.js

@@ -106,7 +106,7 @@ function main() {
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +
-      `  -p, --proof-comments         Enable proof explanations.\n` +
+      `  -p, --proof                  Enable proof explanations.\n` +
       `  -r, --rdf                    Enable RDF/TriG input/output compatibility.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
@@ -161,8 +161,8 @@ function main() {
     if (typeof engine.setDeterministicSkolemEnabled === 'function') engine.setDeterministicSkolemEnabled(true);
   }
 
-  // --proof-comments / -p: enable proof explanations
-  if (argv.includes('--proof-comments') || argv.includes('-p')) {
+  // --proof / -p: enable proof explanations as N3 proof graphs
+  if (argv.includes('--proof') || argv.includes('--proof-comments') || argv.includes('-p')) {
     engine.setProofCommentsEnabled(true);
   }
 
@@ -211,6 +211,7 @@ function main() {
           baseIri: __sourceLabelToBaseIri(sourceLabel),
           label: sourceLabel,
           collectUsedPrefixes: streamMode,
+          collectSourceLocations: engine.getProofCommentsEnabled(),
           keepSourceArtifacts: false,
           rdf: rdfMode,
         }),
@@ -301,7 +302,7 @@ function main() {
   const hasQueries = Array.isArray(qrules) && qrules.length;
   const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
 
-  if (streamMode && !hasQueries && !mayAutoRenderOutputStrings) {
+  if (streamMode && !hasQueries && !mayAutoRenderOutputStrings && !engine.getProofCommentsEnabled()) {
     const usedInInput = mergedDocument.usedPrefixes instanceof Set ? new Set(mergedDocument.usedPrefixes) : new Set();
     const outPrefixes = restrictPrefixEnv(prefixes, usedInInput);
 
@@ -366,6 +367,11 @@ function main() {
     return;
   }
 
+  if (engine.getProofCommentsEnabled()) {
+    process.stdout.write(engine.renderProofDocument(outDerived, derived, triples, prefixes, brules));
+    return;
+  }
+
   let bodyText = '';
   if (rdfMode && !engine.getProofCommentsEnabled()) {
     bodyText = outTriples.map((tr) => engine.tripleToRdfCompatible(tr, prefixes)).join('\n');

package/lib/engine.js

@@ -780,9 +780,11 @@ const { evalBuiltin, isBuiltinPred } = makeBuiltins({
 });
 
 // Initialize proof/output helpers (implemented in lib/explain.js).
-const { printExplanation, collectOutputStringsFromFacts } = makeExplain({
+const { printExplanation, renderProofDocument, collectOutputStringsFromFacts } = makeExplain({
   applySubstTerm,
   skolemKeyFromTerm,
+  isBuiltinPred,
+  findBackwardProofForGoal,
 });
 
 function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
@@ -2433,6 +2435,217 @@ 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
@@ -3947,11 +4160,19 @@ function reasonStream(input, opts = {}) {
         ? facts
         : derived.map((d) => d.fact);
 
-  const closureN3 = useRdfCompatibility
-    ? closureTriples.map((t) => tripleToRdfCompatible(t, prefixes)).join('\n')
-    : Array.isArray(logQueryRules) && logQueryRules.length && !proof
-      ? prettyPrintQueryTriples(closureTriples, prefixes)
-      : closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n');
+  const closureN3 = proof
+    ? renderProofDocument(
+        Array.isArray(logQueryRules) && logQueryRules.length ? queryDerived : derived,
+        derived,
+        triples,
+        prefixes,
+        brules,
+      ).replace(/\n$/g, '')
+    : useRdfCompatibility
+      ? closureTriples.map((t) => tripleToRdfCompatible(t, prefixes)).join('\n')
+      : Array.isArray(logQueryRules) && logQueryRules.length
+        ? prettyPrintQueryTriples(closureTriples, prefixes)
+        : closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n');
 
   const __out = {
     prefixes,
@@ -4078,6 +4299,7 @@ module.exports = {
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
   collectOutputStringsFromFacts,
+  renderProofDocument,
   main,
   version,
   N3SyntaxError,

package/lib/entry.js

@@ -32,6 +32,7 @@ module.exports = {
   materializeRdfLists: engine.materializeRdfLists,
   isGroundTriple: engine.isGroundTriple,
   printExplanation: engine.printExplanation,
+  renderProofDocument: engine.renderProofDocument,
   tripleToN3: engine.tripleToN3,
   collectOutputStringsFromFacts: engine.collectOutputStringsFromFacts,
   prettyPrintQueryTriples: engine.prettyPrintQueryTriples,

package/lib/explain.js

@@ -6,7 +6,7 @@
  */
 'use strict';
 
-const { LOG_NS, Literal, Iri, Blank, Var, varsInRule, literalParts } = require('./prelude');
+const { LOG_NS, Literal, Iri, Blank, Var, GraphTerm, varsInRule, literalParts, PrefixEnv } = require('./prelude');
 
 const { termToN3, tripleToN3 } = require('./printing');
 const { parseNumericLiteralInfo, termToJsString } = require('./builtins');
@@ -14,6 +14,8 @@ const { parseNumericLiteralInfo, termToJsString } = require('./builtins');
 function makeExplain(deps) {
   const applySubstTerm = deps.applySubstTerm;
   const skolemKeyFromTerm = deps.skolemKeyFromTerm;
+  const isBuiltinPred = typeof deps.isBuiltinPred === 'function' ? deps.isBuiltinPred : () => false;
+  const findBackwardProofForGoal = typeof deps.findBackwardProofForGoal === 'function' ? deps.findBackwardProofForGoal : null;
 
   function printExplanation(df, prefixes) {
     console.log('# ----------------------------------------------------------------------');
@@ -111,6 +113,282 @@ function makeExplain(deps) {
     console.log('# ----------------------------------------------------------------------\n');
   }
 
+
+  const PE_NS = 'https://eyereasoner.github.io/pe#';
+
+  function n3String(value) {
+    return JSON.stringify(String(value));
+  }
+
+  function lineIndent(text, prefix) {
+    return String(text)
+      .split(/\r?\n/)
+      .map((line) => (line.length ? prefix + line : line))
+      .join('\n');
+  }
+
+  function graphForTriple(tr, prefixes) {
+    const body = tripleToN3(tr, prefixes).trimEnd();
+    if (!body.includes('\n')) return `{ ${body} }`;
+    return `{
+${lineIndent(body, '    ')}
+}`;
+  }
+
+
+  function clonePrefixEnvWithProofVocabulary(prefixes) {
+    const map = { ...(prefixes && prefixes.map ? prefixes.map : {}) };
+    if (!map.pe) map.pe = PE_NS;
+    return new PrefixEnv(map, (prefixes && prefixes.baseIri) || '');
+  }
+
+  function proofTripleKey(tr) {
+    if (!tr) return '';
+    return `${skolemKeyFromTerm(tr.s)}\t${skolemKeyFromTerm(tr.p)}\t${skolemKeyFromTerm(tr.o)}`;
+  }
+
+  function sourceLabelForProof(source) {
+    if (!source || typeof source.label !== 'string' || !source.label) return '<unknown>';
+    // Keep proof output stable when the CLI is invoked with paths such as examples/foo.n3.
+    return source.label.replace(/\\/g, '/').split('/').pop() || source.label;
+  }
+
+  function byBlankNode(kind, source) {
+    const src = source || {};
+    const props = [`pe:${kind} ${n3String(sourceLabelForProof(src))}`];
+    if (Number.isInteger(src.line) && src.line > 0) props.push(`pe:line ${src.line}`);
+    return `[ ${props.join('; ')} ]`;
+  }
+
+  function renderBindingList(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 '';
+    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(', ');
+  }
+
+  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 proofEntryKey(kind, fact, source, extra) {
+    return `${kind}\t${proofTripleKey(fact)}\t${proofSourceKey(source)}\t${extra || ''}`;
+  }
+
+  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 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 visitProofNode(proof, fallbackTriple) {
+      if (!proof) {
+        visitFactTriple(fallbackTriple);
+        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 });
+      }
+    }
+
+    function visitFactTriple(tr) {
+      const tripleKey = proofTripleKey(tr);
+      if (!tripleKey) return;
+      const df = derivedByKey.get(tripleKey);
+      if (df) {
+        visitDerivedFact(df);
+        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 });
+        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 });
+        return;
+      }
+      if (resolveBackwardProof) {
+        const proof = resolveBackwardProof(tr);
+        if (proof) {
+          visitProofNode(proof, tr);
+          return;
+        }
+      }
+      const key = proofEntryKey('fact', tr, null);
+      if (seen.has(key)) return;
+      seen.add(key);
+      entries.push({ 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 (Array.isArray(children) && children.length) {
+        for (const child of children) visitProofNode(child);
+        return;
+      }
+      for (const prem of df.premises || []) visitFactTriple(prem);
+    }
+
+    visitDerivedFact(rootDf);
+    return entries;
+  }
+
+  function collectProofOutputTriples(outputDerived) {
+    const out = [];
+    const seen = new Set();
+    for (const df of outputDerived || []) {
+      if (!df || !df.fact) continue;
+      const key = proofTripleKey(df.fact);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(df.fact);
+    }
+    return out;
+  }
+
+  function renderProofEntry(entry, prefixes) {
+    if (!entry) return '';
+    if (entry.kind === 'fact') {
+      return `  ${graphForTriple(entry.fact, prefixes)}\n    pe:by ${byBlankNode('fact', entry.source)}.`;
+    }
+    if (entry.kind === 'builtin') {
+      return `  ${graphForTriple(entry.fact, prefixes)}\n    pe:by [ pe:builtin ${termToN3(entry.builtin, prefixes)} ].`;
+    }
+
+    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(', ')}`);
+    }
+
+    let out = `  ${graphForTriple(df.fact, prefixes)}\n`;
+    for (let i = 0; i < props.length; i++) {
+      out += `    ${props[i]}${i === props.length - 1 ? '.' : ';'}\n`;
+    }
+    return out.trimEnd();
+  }
+
+  function renderProofBlock(rootDf, derivedByKey, baseFactByKey, prefixes, resolveBackwardProof) {
+    const entries = collectProofEntries(rootDf, derivedByKey, baseFactByKey, resolveBackwardProof);
+    const rootGraph = graphForTriple(rootDf.fact, prefixes);
+    const proofBody = entries.map((entry) => renderProofEntry(entry, prefixes)).join('\n\n');
+    const proofGraph = proofBody ? `{
+${proofBody}
+}` : '{}';
+    return `${rootGraph} pe:why ${proofGraph}.`;
+  }
+
+  function renderProofDocument(outputDerived, allDerived, baseFacts, prefixes, backRules) {
+    const selectedDerived = Array.isArray(outputDerived) ? outputDerived.filter((df) => df && df.fact) : [];
+    if (!selectedDerived.length) return '';
+
+    const proofPrefixes = clonePrefixEnvWithProofVocabulary(prefixes);
+    const derivedByKey = new Map();
+    for (const df of allDerived || []) {
+      if (!df || !df.fact) continue;
+      const key = proofTripleKey(df.fact);
+      if (!derivedByKey.has(key)) derivedByKey.set(key, 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.
+
+    const baseFactByKey = new Map();
+    for (const tr of baseFacts || []) {
+      if (!tr) continue;
+      const key = proofTripleKey(tr);
+      if (!baseFactByKey.has(key)) baseFactByKey.set(key, tr);
+    }
+
+    const resolveBackwardProof = findBackwardProofForGoal
+      ? (tr) => findBackwardProofForGoal(tr, baseFacts || [], backRules || [], { maxDepth: 64 })
+      : null;
+
+    const outputTriples = collectProofOutputTriples(selectedDerived);
+    const proofRelationTriples = [];
+    for (const df of selectedDerived) {
+      proofRelationTriples.push({ s: new GraphTerm([df.fact]), p: new Iri(PE_NS + 'why'), o: new GraphTerm([]) });
+      for (const entry of collectProofEntries(df, derivedByKey, baseFactByKey, resolveBackwardProof)) {
+        const fact = entry.kind === 'rule' ? entry.df.fact : entry.fact;
+        const byObject = entry.kind === 'builtin' && entry.builtin ? entry.builtin : new Iri(PE_NS + 'source');
+        proofRelationTriples.push({ s: new GraphTerm([fact]), p: new Iri(PE_NS + 'by'), o: byObject });
+        if (entry.kind === 'rule') {
+          for (const prem of entry.df.premises || []) proofRelationTriples.push({ s: new GraphTerm([fact]), p: new Iri(PE_NS + 'uses'), o: new GraphTerm([prem]) });
+        }
+      }
+    }
+
+    const usedPrefixes = proofPrefixes.prefixesUsedForOutput(outputTriples.concat(proofRelationTriples));
+    if (!usedPrefixes.some(([pfx]) => pfx === 'pe')) usedPrefixes.push(['pe', PE_NS]);
+    usedPrefixes.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+
+    const parts = [];
+    for (const [pfx, base] of usedPrefixes) {
+      if (!base) continue;
+      if (pfx === '') parts.push(`@prefix : <${base}> .`);
+      else parts.push(`@prefix ${pfx}: <${base}> .`);
+    }
+    if (parts.length) parts.push('');
+
+    parts.push(...outputTriples.map((tr) => tripleToN3(tr, proofPrefixes)));
+    parts.push('');
+    for (let i = 0; i < selectedDerived.length; i++) {
+      if (i > 0) parts.push('');
+      parts.push(renderProofBlock(selectedDerived[i], derivedByKey, baseFactByKey, proofPrefixes, resolveBackwardProof));
+    }
+
+    return parts.join('\n').replace(/[ \t]+$/gm, '').replace(/\s*$/g, '') + '\n';
+  }
+
   // ===========================================================================
   // CLI entry point
   // ===========================================================================
@@ -217,7 +495,7 @@ function makeExplain(deps) {
     return addMarkdownHardBreaks(pairs.map((p) => p.text).join(''));
   }
 
-  return { printExplanation, collectOutputStringsFromFacts };
+  return { printExplanation, renderProofDocument, collectOutputStringsFromFacts };
 }
 
 module.exports = { makeExplain };