rdf-reasoner-konclude 0.3.2 → 0.4.0

package/dist/entailmentProbe.d.ts

@@ -0,0 +1,12 @@
+import type { Quad } from "@rdfjs/types";
+export type ProbeKind = "subClassOf" | "type" | "unsupported";
+export interface ProbePlan {
+    kind: ProbeKind;
+    probeQuads: Quad[];
+    probeKeys: Set<string>;
+    reason?: string;
+}
+export declare function tripleKey(s: string, p: string, o: string): string;
+export declare function classifyAxiom(predicateIri: string, objectIsClassLike: boolean): ProbeKind;
+export declare function buildEntailmentProbe(subjectIri: string, predicateIri: string, objectIri: string, objectIsClassLike: boolean, probeId?: string): ProbePlan;
+//# sourceMappingURL=entailmentProbe.d.ts.map

package/dist/entailmentProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entailmentProbe.d.ts","sourceRoot":"","sources":["../ts/entailmentProbe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAQzC,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,IAAI,EAAE,CAAC;IACnB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,aAAa,CAC3B,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,OAAO,GACzB,SAAS,CAKX;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,OAAO,EAC1B,OAAO,SAAO,GACb,SAAS,CA0CX"}

package/dist/entailmentProbe.js

@@ -0,0 +1,57 @@
+import { DataFactory } from "n3";
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const RDFS_SUBCLASSOF = "http://www.w3.org/2000/01/rdf-schema#subClassOf";
+const OWL_CLASS = "http://www.w3.org/2002/07/owl#Class";
+const OWL_COMPLEMENT_OF = "http://www.w3.org/2002/07/owl#complementOf";
+export function tripleKey(s, p, o) {
+    return `${s}\0${p}\0${o}`;
+}
+export function classifyAxiom(predicateIri, objectIsClassLike) {
+    if (!objectIsClassLike)
+        return "unsupported";
+    if (predicateIri === RDFS_SUBCLASSOF)
+        return "subClassOf";
+    if (predicateIri === RDF_TYPE)
+        return "type";
+    return "unsupported";
+}
+export function buildEntailmentProbe(subjectIri, predicateIri, objectIri, objectIsClassLike, probeId = "p0") {
+    const kind = classifyAxiom(predicateIri, objectIsClassLike);
+    if (kind === "unsupported") {
+        return {
+            kind,
+            probeQuads: [],
+            probeKeys: new Set(),
+            reason: objectIsClassLike
+                ? `predicate ${predicateIri} is not a supported entailment shape`
+                : "object is a literal; the entailment reduction requires an IRI object",
+        };
+    }
+    const { namedNode, blankNode, quad, defaultGraph } = DataFactory;
+    const g = defaultGraph();
+    const owlClass = namedNode(OWL_CLASS);
+    const negClass = blankNode(`vg_neg_${probeId}`);
+    const objNode = namedNode(objectIri);
+    const quads = [];
+    const keys = new Set();
+    const push = (s, sKey, p, o, oKey) => {
+        quads.push(quad(s, namedNode(p), o, g));
+        keys.add(tripleKey(sKey, p, oKey));
+    };
+    const negClassKey = `vg_neg_${probeId}`;
+    push(negClass, negClassKey, RDF_TYPE, owlClass, OWL_CLASS);
+    push(negClass, negClassKey, OWL_COMPLEMENT_OF, objNode, objectIri);
+    if (kind === "subClassOf") {
+        const subjNode = namedNode(subjectIri);
+        const witness = blankNode(`vg_wit_${probeId}`);
+        const witnessKey = `vg_wit_${probeId}`;
+        push(subjNode, subjectIri, RDFS_SUBCLASSOF, negClass, negClassKey);
+        push(witness, witnessKey, RDF_TYPE, subjNode, subjectIri);
+    }
+    else {
+        const subjNode = namedNode(subjectIri);
+        push(subjNode, subjectIri, RDF_TYPE, negClass, negClassKey);
+    }
+    return { kind, probeQuads: quads, probeKeys: keys };
+}
+//# sourceMappingURL=entailmentProbe.js.map

package/dist/entailmentProbe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entailmentProbe.js","sourceRoot":"","sources":["../ts/entailmentProbe.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAEjC,MAAM,QAAQ,GAAG,iDAAiD,CAAC;AACnE,MAAM,eAAe,GAAG,iDAAiD,CAAC;AAC1E,MAAM,SAAS,GAAG,qCAAqC,CAAC;AACxD,MAAM,iBAAiB,GAAG,4CAA4C,CAAC;AAWvE,MAAM,UAAU,SAAS,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;IACvD,OAAO,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,aAAa,CAC3B,YAAoB,EACpB,iBAA0B;IAE1B,IAAI,CAAC,iBAAiB;QAAE,OAAO,aAAa,CAAC;IAC7C,IAAI,YAAY,KAAK,eAAe;QAAE,OAAO,YAAY,CAAC;IAC1D,IAAI,YAAY,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC;IAC7C,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,oBAAoB,CAClC,UAAkB,EAClB,YAAoB,EACpB,SAAiB,EACjB,iBAA0B,EAC1B,OAAO,GAAG,IAAI;IAEd,MAAM,IAAI,GAAG,aAAa,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;IAC5D,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;QAC3B,OAAO;YACL,IAAI;YACJ,UAAU,EAAE,EAAE;YACd,SAAS,EAAE,IAAI,GAAG,EAAE;YACpB,MAAM,EAAE,iBAAiB;gBACvB,CAAC,CAAC,aAAa,YAAY,sCAAsC;gBACjE,CAAC,CAAC,sEAAsE;SAC3E,CAAC;IACJ,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,WAAW,CAAC;IACjE,MAAM,CAAC,GAAG,YAAY,EAAE,CAAC;IACzB,MAAM,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,OAAO,EAAE,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;IAErC,MAAM,KAAK,GAAW,EAAE,CAAC;IACzB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,IAAI,GAAG,CAAC,CAA8D,EAAE,IAAY,EAAE,CAAS,EAAE,CAA8D,EAAE,IAAY,EAAQ,EAAE;QAC3L,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAQ,EAAE,SAAS,CAAC,CAAC,CAAQ,EAAE,CAAQ,EAAE,CAAC,CAAS,CAAC,CAAC;QACrE,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IACrC,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,UAAU,OAAO,EAAE,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC3D,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,iBAAiB,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IAEnE,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,OAAO,EAAE,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,UAAU,OAAO,EAAE,CAAC;QACvC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;QACnE,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC5D,CAAC;SAAM,CAAC;QACN,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;QACvC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AACtD,CAAC"}

package/dist/index.d.ts

@@ -14,9 +14,9 @@
  */
 import type { Quad } from "@rdfjs/types";
 import { Store } from "n3";
-export type { ReasoningOptions, ReasoningResult, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ClassWarning, ValidationResult, ValidateOptions } from "./types.js";
+export type { ReasoningOptions, ReasoningResult, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ClassWarning, ValidationResult, ValidateOptions, RdfReasonerOptions, EntailmentResult, ExplainEntailmentOptions, LaconicPart, LaconicJustification, LaconicExplainOptions } from "./types.js";
 export { INFERRED_GRAPH_IRI, HYPOTHETICAL_IRI } from "./types.js";
-import type { ReasoningOptions, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ValidationResult, ValidateOptions } from "./types.js";
+import type { ReasoningOptions, StoreReasoningOptions, MaterializeOptions, MaterializeStoreOptions, ClassifyPropertiesStoreOptions, InferenceDelta, WhatIfOptions, ExplainOptions, ValidationResult, ValidateOptions, RdfReasonerOptions, EntailmentResult, ExplainEntailmentOptions, LaconicJustification, LaconicExplainOptions } from "./types.js";
 export declare class RdfReasoner {
     /** Resolves when the Worker WASM module is ready; rejects on init failure. */
     readonly ready: Promise<void>;
@@ -33,7 +33,8 @@ export declare class RdfReasoner {
     private _materializeCache;
     private _classifyPropertiesCache;
     private _consistencyCache;
-    constructor();
+    private _entailmentProbeCounter;
+    constructor(opts?: RdfReasonerOptions);
     /**
      * Send a method call to the Worker and return a Promise for the result.
      * Pass `transfer` to transfer ownership of ArrayBuffers (zero-copy).
@@ -214,6 +215,9 @@ export declare class RdfReasoner {
      * Safe to call from inside a _queue body.
      */
     private _checkUnsatisfiabilityDirect;
+    private _isSubClassOfDirect;
+    private _isInstanceOfDirect;
+    private _isSatisfiableClassDirect;
     /** Compute minimal justifications for an axiom using the BlackBox algorithm.
      *
      * Returns a list of minimal subsets of the store's base quads, each of which
@@ -234,6 +238,31 @@ export declare class RdfReasoner {
      * owl:Thing rdfs:subClassOf owl:Nothing being emitted as an inferred triple.
      */
     explainInconsistency(store: Store, opts?: ExplainOptions): Promise<Quad[][]>;
+    /** Compute MIPS justifications for an inconsistent ontology and post-process
+     *  each via the Horridge laconic algorithm to identify exactly which part of
+     *  each axiom drives the clash.
+     *
+     *  Returns [] if the ontology is consistent.
+     *  Returns [] if `opts.maxJustifications === 0`.
+     *  When the cost cap (`laconicMaxAxioms` / `laconicMaxParts`) is exceeded for
+     *  a justification, that entry has `laconic.skipped === true`.
+     */
+    explainInconsistencyLaconic(store: Store, opts?: LaconicExplainOptions): Promise<Array<{
+        justification: Quad[];
+        laconic: LaconicJustification;
+    }>>;
+    /** Explain why a triple (subjectIri, predicateIri, objectIri) is entailed
+     *  by the ontology, using entailment-as-unsatisfiability reduction.
+     *
+     *  Returns an `EntailmentResult` containing:
+     *  - `isEntailed` — `true/false/null` (null when ontology is inconsistent)
+     *  - `justifications` — minimal justifications (each is a Quad[] subset)
+     *  - `ontologyInconsistent` / `vacuous` — special-case flags
+     *
+     *  Supports rdfs:subClassOf and rdf:type shapes. Returns unsupported for
+     *  other predicates (isEntailed reflects only asserted facts).
+     */
+    explainEntailment(store: Store, subjectIri: string, predicateIri: string, objectIri: string, opts?: ExplainEntailmentOptions): Promise<EntailmentResult>;
     /** Run a combined diagnostic: check consistency, find unsatisfiable classes,
      *  and (optionally) compute minimal justifications for each.
      *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -16,6 +16,8 @@ import { Store, DataFactory } from "n3";
 import { encodeToBuffers, decodeBuffers, computeStoreFingerprint } from "./intern.js";
 export { INFERRED_GRAPH_IRI, HYPOTHETICAL_IRI } from "./types.js";
 import { INFERRED_GRAPH_IRI, HYPOTHETICAL_IRI } from "./types.js";
+import { buildEntailmentProbe, tripleKey as probeTripleKey } from "./entailmentProbe.js";
+import { computeLaconicAsync, groupQuadsIntoAxioms, splitAxiom, axiomKey } from "./laconicJustification.js";
 // ---------------------------------------------------------------------------
 // OWL/RDF predicate IRIs used by explain
 // ---------------------------------------------------------------------------
@@ -52,8 +54,12 @@ export class RdfReasoner {
     _materializeCache = null;
     _classifyPropertiesCache = null;
     _consistencyCache = null;
-    constructor() {
-        this.worker = new Worker(new URL("./worker.js", import.meta.url), {
+    _entailmentProbeCounter = 0;
+    constructor(opts) {
+        const url = opts?.workerUrl
+            ? (typeof opts.workerUrl === "string" ? new URL(opts.workerUrl) : opts.workerUrl)
+            : new URL("./worker.js", import.meta.url);
+        this.worker = new Worker(url, {
             type: "module",
         });
         // Store the readyReject handle so the onerror handler can use it if the
@@ -716,6 +722,15 @@ export class RdfReasoner {
         const raw = (await this._callDirect("getUnsatisfiableClassBuffer", []));
         return raw.split('\n').filter(Boolean).includes(classIRI);
     }
+    async _isSubClassOfDirect(sub, sup) {
+        return (await this._callDirect("isSubClassOf", [sub, sup]));
+    }
+    async _isInstanceOfDirect(indi, cls) {
+        return (await this._callDirect("isInstanceOf", [indi, cls]));
+    }
+    async _isSatisfiableClassDirect(cls) {
+        return (await this._callDirect("isSatisfiableClass", [cls]));
+    }
     // -------------------------------------------------------------------------
     // explain()
     // -------------------------------------------------------------------------
@@ -1003,6 +1018,375 @@ export class RdfReasoner {
         return result;
     }
     // -------------------------------------------------------------------------
+    // explainInconsistencyLaconic()
+    // -------------------------------------------------------------------------
+    /** Compute MIPS justifications for an inconsistent ontology and post-process
+     *  each via the Horridge laconic algorithm to identify exactly which part of
+     *  each axiom drives the clash.
+     *
+     *  Returns [] if the ontology is consistent.
+     *  Returns [] if `opts.maxJustifications === 0`.
+     *  When the cost cap (`laconicMaxAxioms` / `laconicMaxParts`) is exceeded for
+     *  a justification, that entry has `laconic.skipped === true`.
+     */
+    explainInconsistencyLaconic(store, opts) {
+        const maxAxioms = opts?.laconicMaxAxioms ?? 20;
+        const maxParts = opts?.laconicMaxParts ?? 40;
+        const result = this._queue.then(async () => {
+            // Get MIPS justifications (reuse explainInconsistency logic inline)
+            const allBase = store.getQuads(null, null, null, null).filter(q => {
+                const g = q.graph.value;
+                return g !== INFERRED_GRAPH_IRI && g !== HYPOTHETICAL_IRI;
+            });
+            const fingerprint = computeStoreFingerprint(store.getQuads(null, null, null, null));
+            let consistent;
+            if (this._consistencyCache?.hash === fingerprint) {
+                consistent = this._consistencyCache.result;
+            }
+            else {
+                consistent = !(await this._checkInconsistencyDirect(allBase));
+                this._consistencyCache = { hash: fingerprint, result: consistent };
+            }
+            this._classifyCache = null;
+            this._materializeCache = null;
+            this._classifyPropertiesCache = null;
+            if (consistent)
+                return [];
+            const maxJustifications = opts?.maxJustifications ?? 1;
+            if (maxJustifications === 0)
+                return [];
+            const allCandidates = store.getQuads(null, null, null, null).filter(q => {
+                const g = q.graph.value;
+                if (g === INFERRED_GRAPH_IRI || g === HYPOTHETICAL_IRI)
+                    return false;
+                if (opts?.axiomFilter && !opts.axiomFilter(q))
+                    return false;
+                return true;
+            });
+            this._classifyCache = null;
+            this._materializeCache = null;
+            this._classifyPropertiesCache = null;
+            this._consistencyCache = null;
+            if (!(await this._checkInconsistencyDirect(allCandidates)))
+                return [];
+            // Find MIPS (same inline BlackBox as explainInconsistency)
+            const findOne = async (cands) => {
+                let w = [...cands];
+                let changed = true;
+                while (changed && w.length > 1) {
+                    changed = false;
+                    const mid = Math.floor(w.length / 2);
+                    const [fh, sh] = [w.slice(0, mid), w.slice(mid)];
+                    if (await this._checkInconsistencyDirect(fh)) {
+                        w = fh;
+                        changed = true;
+                        continue;
+                    }
+                    if (await this._checkInconsistencyDirect(sh)) {
+                        w = sh;
+                        changed = true;
+                        continue;
+                    }
+                    break;
+                }
+                let i = 0;
+                while (i < w.length) {
+                    if (w.length === 1)
+                        break;
+                    const without = [...w.slice(0, i), ...w.slice(i + 1)];
+                    if (await this._checkInconsistencyDirect(without)) {
+                        w = without;
+                    }
+                    else {
+                        i++;
+                    }
+                }
+                return w;
+            };
+            const justifications = [];
+            const j1 = await findOne(allCandidates);
+            if (!j1 || j1.length === 0)
+                return [];
+            justifications.push(j1);
+            if (maxJustifications > 1) {
+                const hsQueue = [
+                    { excluded: new Set(), justification: j1 },
+                ];
+                const explored = new Set();
+                const keyOf = (q) => `${q.subject.value}\0${q.predicate.value}\0${q.object.value}`;
+                while (hsQueue.length > 0 && justifications.length < maxJustifications) {
+                    const { excluded, justification: curJ } = hsQueue.shift();
+                    const eKey = [...excluded].sort().join("|");
+                    if (explored.has(eKey))
+                        continue;
+                    explored.add(eKey);
+                    for (const ax of curJ) {
+                        const newExcl = new Set(excluded);
+                        newExcl.add(keyOf(ax));
+                        const nKey = [...newExcl].sort().join("|");
+                        if (explored.has(nKey))
+                            continue;
+                        const reduced = allCandidates.filter(q => !newExcl.has(keyOf(q)));
+                        if (!(await this._checkInconsistencyDirect(reduced)))
+                            continue;
+                        const jN = await findOne(reduced);
+                        if (!jN || jN.length === 0)
+                            continue;
+                        const jKey = jN.map(keyOf).sort().join("|");
+                        if (!justifications.some(j => j.map(keyOf).sort().join("|") === jKey)) {
+                            justifications.push(jN);
+                            if (justifications.length >= maxJustifications)
+                                break;
+                            hsQueue.push({ excluded: newExcl, justification: jN });
+                        }
+                    }
+                }
+            }
+            // Post-process each justification with laconic
+            const out = [];
+            for (const j of justifications) {
+                const { axioms, sourceQuads } = groupQuadsIntoAxioms(j, allBase);
+                const totalParts = axioms.reduce((n, ax) => n + splitAxiom(ax).length, 0);
+                if (axioms.length > maxAxioms || totalParts > maxParts) {
+                    out.push({
+                        justification: j,
+                        laconic: {
+                            parts: axioms.map(ax => ({
+                                quad: ax[0],
+                                sourceQuad: ax[0],
+                                isPartOf: false,
+                            })),
+                            sharpened: false,
+                            skipped: true,
+                        },
+                    });
+                    continue;
+                }
+                // Map split-part keys → original source quads so the oracle can
+                // resolve any sub-part back to its parent axiom's full RDF encoding.
+                const partKeyToSource = new Map();
+                for (const ax of axioms) {
+                    const src = sourceQuads.get(axiomKey(ax)) ?? ax;
+                    for (const part of splitAxiom(ax)) {
+                        partKeyToSource.set(axiomKey(part), src);
+                    }
+                    // Also map the original axiom key itself
+                    partKeyToSource.set(axiomKey(ax), src);
+                }
+                const entails = async (parts) => {
+                    const quads = [];
+                    for (const p of parts) {
+                        const k = axiomKey(p);
+                        const src = partKeyToSource.get(k);
+                        quads.push(...(src ?? p));
+                    }
+                    return this._checkInconsistencyDirect(quads);
+                };
+                const { laconic, sources } = await computeLaconicAsync(axioms, entails);
+                const sharpened = laconic.length !== axioms.length
+                    || laconic.some(p => !sourceQuads.has(axiomKey(p)));
+                out.push({
+                    justification: j,
+                    laconic: {
+                        parts: laconic.map(part => {
+                            const source = sources.get(part) ?? part;
+                            return {
+                                quad: part[0],
+                                sourceQuad: source[0],
+                                isPartOf: axiomKey(part) !== axiomKey(source),
+                            };
+                        }),
+                        sharpened,
+                        skipped: false,
+                    },
+                });
+            }
+            return out;
+        });
+        this._queue = result.then(() => { }, () => { });
+        return result;
+    }
+    // -------------------------------------------------------------------------
+    // explainEntailment()
+    // -------------------------------------------------------------------------
+    /** Explain why a triple (subjectIri, predicateIri, objectIri) is entailed
+     *  by the ontology, using entailment-as-unsatisfiability reduction.
+     *
+     *  Returns an `EntailmentResult` containing:
+     *  - `isEntailed` — `true/false/null` (null when ontology is inconsistent)
+     *  - `justifications` — minimal justifications (each is a Quad[] subset)
+     *  - `ontologyInconsistent` / `vacuous` — special-case flags
+     *
+     *  Supports rdfs:subClassOf and rdf:type shapes. Returns unsupported for
+     *  other predicates (isEntailed reflects only asserted facts).
+     */
+    explainEntailment(store, subjectIri, predicateIri, objectIri, opts) {
+        const maxJustifications = opts?.maxJustifications ?? 1;
+        const objectIsClassLike = opts?.objectIsClassLike ?? true;
+        const result = this._queue.then(async () => {
+            const allBase = store.getQuads(null, null, null, null).filter(q => {
+                const g = q.graph.value;
+                return g !== INFERRED_GRAPH_IRI && g !== HYPOTHETICAL_IRI;
+            });
+            // C1: ontology must be consistent for the reduction to be sound
+            if (await this._checkInconsistencyDirect(allBase)) {
+                return {
+                    isEntailed: null,
+                    justifications: [],
+                    ontologyInconsistent: true,
+                    reason: "Ontology is already inconsistent; entailment is vacuous.",
+                };
+            }
+            // Asserted-triple short circuit
+            const asserted = allBase.some(q => q.subject.value === subjectIri &&
+                q.predicate.value === predicateIri &&
+                q.object.value === objectIri);
+            const probeId = `probe_${++this._entailmentProbeCounter}`;
+            const probe = buildEntailmentProbe(subjectIri, predicateIri, objectIri, objectIsClassLike, probeId);
+            if (probe.kind === "unsupported") {
+                return { isEntailed: asserted, justifications: [] };
+            }
+            // O ∪ ¬α — test entailment via the consistency oracle
+            const withProbe = [...allBase, ...probe.probeQuads];
+            const entailed = await this._checkInconsistencyDirect(withProbe);
+            if (!entailed) {
+                return { isEntailed: false, justifications: [] };
+            }
+            // C2: vacuous-truth detection for subClassOf — an unsatisfiable class
+            // is a subclass of everything (vacuous truth, not a useful justification).
+            if (probe.kind === "subClassOf") {
+                const { tripleBuffer, strTableBuffer } = encodeToBuffers(allBase);
+                await this._callDirect("loadTripleBuffer", [tripleBuffer, strTableBuffer, false], [tripleBuffer, strTableBuffer]);
+                await this._callDirect("classification", []);
+                const sat = await this._isSatisfiableClassDirect(subjectIri);
+                if (!sat) {
+                    return {
+                        isEntailed: true,
+                        justifications: [],
+                        vacuous: true,
+                        reason: "Subject class is unsatisfiable; it is a subclass of anything (vacuous truth).",
+                    };
+                }
+            }
+            if (maxJustifications === 0) {
+                return { isEntailed: true, justifications: [] };
+            }
+            // Invalidate caches — sub-calls modify WASM state
+            this._classifyCache = null;
+            this._materializeCache = null;
+            this._classifyPropertiesCache = null;
+            this._consistencyCache = null;
+            // Partition into justification candidates vs background declarations.
+            // Background (rdf:type owl:Class etc.) must be passed to every oracle
+            // call so Konclude recognises classes/properties, but is never returned
+            // as part of a justification.
+            const ontologyCandidates = [];
+            const background = [];
+            for (const q of allBase) {
+                if (this._isBuiltInDeclaration(q)) {
+                    background.push(q);
+                }
+                else {
+                    ontologyCandidates.push(q);
+                }
+            }
+            const filteredCandidates = opts?.axiomFilter
+                ? ontologyCandidates.filter(q => opts.axiomFilter(q))
+                : ontologyCandidates;
+            const keyOf = (q) => `${q.subject.value}\0${q.predicate.value}\0${q.object.value}`;
+            const stripProbe = (j) => j.filter(q => !probe.probeKeys.has(probeTripleKey(q.subject.value, q.predicate.value, q.object.value)));
+            const justifications = [];
+            // BlackBox find one justification — probe quads are PINNED: only ontology
+            // candidates participate in bisection/deletion, probe quads are always
+            // re-added before each oracle call so they are never lost.
+            const findOne = async (ontCandidates) => {
+                let working = [...ontCandidates];
+                // Shrink phase: binary partition (ontology candidates only)
+                let changed = true;
+                while (changed && working.length > 1) {
+                    changed = false;
+                    const mid = Math.floor(working.length / 2);
+                    const fh = working.slice(0, mid);
+                    const sh = working.slice(mid);
+                    if (await this._checkInconsistencyDirect([...fh, ...probe.probeQuads, ...background])) {
+                        working = fh;
+                        changed = true;
+                        continue;
+                    }
+                    if (await this._checkInconsistencyDirect([...sh, ...probe.probeQuads, ...background])) {
+                        working = sh;
+                        changed = true;
+                        continue;
+                    }
+                    break;
+                }
+                // Deletion pass: remove each ontology candidate that is not individually required
+                let i = 0;
+                while (i < working.length) {
+                    if (working.length === 0)
+                        break;
+                    const without = [...working.slice(0, i), ...working.slice(i + 1)];
+                    if (await this._checkInconsistencyDirect([...without, ...probe.probeQuads, ...background])) {
+                        working = without;
+                    }
+                    else {
+                        i++;
+                    }
+                }
+                return working.length > 0 ? [...working, ...probe.probeQuads] : null;
+            };
+            // Verify full candidate set + probe is inconsistent
+            if (!(await this._checkInconsistencyDirect([...filteredCandidates, ...probe.probeQuads, ...background]))) {
+                return { isEntailed: true, justifications: [] };
+            }
+            const j1 = await findOne(filteredCandidates);
+            if (!j1 || j1.length === 0) {
+                return { isEntailed: true, justifications: [] };
+            }
+            justifications.push(stripProbe(j1));
+            // HSDAG for additional justifications
+            if (maxJustifications > 1) {
+                const hsQueue = [
+                    { excluded: new Set(), justification: j1 },
+                ];
+                const explored = new Set();
+                while (hsQueue.length > 0 && justifications.length < maxJustifications) {
+                    const { excluded, justification: curJ } = hsQueue.shift();
+                    const eKey = [...excluded].sort().join("|");
+                    if (explored.has(eKey))
+                        continue;
+                    explored.add(eKey);
+                    for (const ax of curJ) {
+                        // Never exclude probe quads from the hitting set
+                        if (probe.probeKeys.has(probeTripleKey(ax.subject.value, ax.predicate.value, ax.object.value)))
+                            continue;
+                        const newExcl = new Set(excluded);
+                        newExcl.add(keyOf(ax));
+                        const nKey = [...newExcl].sort().join("|");
+                        if (explored.has(nKey))
+                            continue;
+                        const reduced = filteredCandidates.filter(q => !newExcl.has(keyOf(q)));
+                        if (!(await this._checkInconsistencyDirect([...reduced, ...probe.probeQuads, ...background])))
+                            continue;
+                        const jNew = await findOne(reduced);
+                        if (!jNew || jNew.length === 0)
+                            continue;
+                        const jKey = stripProbe(jNew).map(keyOf).sort().join("|");
+                        if (!justifications.some(j => j.map(keyOf).sort().join("|") === jKey)) {
+                            justifications.push(stripProbe(jNew));
+                            if (justifications.length >= maxJustifications)
+                                break;
+                            hsQueue.push({ excluded: newExcl, justification: jNew });
+                        }
+                    }
+                }
+            }
+            return { isEntailed: true, justifications };
+        });
+        this._queue = result.then(() => { }, () => { });
+        return result;
+    }
+    // -------------------------------------------------------------------------
     // validate()
     // -------------------------------------------------------------------------
     /** Run a combined diagnostic: check consistency, find unsatisfiable classes,