@oml/owl 0.7.0

package/src/owl/owl-abox.ts

@@ -0,0 +1,930 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DataFactory } from 'n3';
+import type { NamedNode, Quad, Store, Term } from 'n3';
+import type { OwlStore } from './owl-interfaces.js';
+import type { RuleAtom, RuleTermPattern, TBoxIndex } from './owl-tbox.js';
+
+const { namedNode, quad } = DataFactory;
+
+const RDF_TYPE = namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+
+export interface ChainingResult {
+    complete: boolean;
+    iterations: number;
+    newQuadsCount: number;
+    validationWarnings: string[];
+}
+
+interface Fact {
+    subject: Term;
+    predicate: NamedNode;
+    object: Term;
+}
+
+interface ScopeData {
+    ownEntailmentGraph: NamedNode;
+    ownBaseFacts: Fact[];
+    baseKeys: Set<string>;
+    importEntKeys: Set<string>;
+    ownEntKeys: Set<string>;
+    facts: Map<string, Fact>;
+}
+
+interface WorkingIndex {
+    facts: Map<string, Fact>;
+    typesBySubject: Map<string, Set<string>>;
+    subjectsByType: Map<string, Set<string>>;
+    edgeFactsBySubjectProperty: Map<string, Fact[]>;
+    edgeFactsByProperty: Map<string, Fact[]>;
+    subjectsByPropertyObject: Map<string, Set<string>>;
+    termByKey: Map<string, Term>;
+}
+
+export class ABoxEntailmentCache {
+    private readonly state = new Map<string, 'clean' | 'dirty' | 'absent'>();
+    private readonly deltaPlus = new Map<string, Map<string, Quad>>();
+    private readonly deltaMinus = new Map<string, Map<string, Quad>>();
+    private readonly validationWarnings = new Map<string, string[]>();
+
+    markDirty(modelUri: string): void {
+        this.state.set(modelUri, 'dirty');
+    }
+
+    markDirtyWithDelta(modelUri: string, asserted: Quad[], retracted: Quad[]): void {
+        if (asserted.length > 0) {
+            const plus = this.deltaPlus.get(modelUri) ?? new Map<string, Quad>();
+            for (const q of asserted) {
+                plus.set(this.quadKey(q), q);
+            }
+            this.deltaPlus.set(modelUri, plus);
+        }
+        if (retracted.length > 0) {
+            const minus = this.deltaMinus.get(modelUri) ?? new Map<string, Quad>();
+            for (const q of retracted) {
+                minus.set(this.quadKey(q), q);
+            }
+            this.deltaMinus.set(modelUri, minus);
+        }
+        this.markDirty(modelUri);
+    }
+
+    markClean(modelUri: string): void {
+        this.state.set(modelUri, 'clean');
+    }
+
+    markDirtyAll(modelUris: string[]): void {
+        for (const modelUri of modelUris) {
+            this.markDirty(modelUri);
+        }
+    }
+
+    isDirty(modelUri: string): boolean {
+        return this.state.get(modelUri) === 'dirty';
+    }
+
+    isAbsent(modelUri: string): boolean {
+        const value = this.state.get(modelUri);
+        return value === undefined || value === 'absent';
+    }
+
+    consumeDelta(modelUri: string): { plus: Quad[]; minus: Quad[] } {
+        const plus = [...(this.deltaPlus.get(modelUri)?.values() ?? [])];
+        const minus = [...(this.deltaMinus.get(modelUri)?.values() ?? [])];
+        this.deltaPlus.delete(modelUri);
+        this.deltaMinus.delete(modelUri);
+        return { plus, minus };
+    }
+
+    getValidationWarnings(modelUri: string): string[] {
+        return this.validationWarnings.get(modelUri) ?? [];
+    }
+
+    setValidationWarnings(modelUri: string, warnings: string[]): void {
+        this.validationWarnings.set(modelUri, [...new Set(warnings)]);
+    }
+
+    invalidate(modelUri: string): void {
+        this.state.delete(modelUri);
+        this.deltaPlus.delete(modelUri);
+        this.deltaMinus.delete(modelUri);
+        this.validationWarnings.delete(modelUri);
+    }
+
+    private quadKey(q: Quad): string {
+        return `${q.subject.id}|${q.predicate.id}|${q.object.id}|${q.graph.id}`;
+    }
+}
+
+export class ABoxChainer {
+    constructor(private readonly reasoningStore: OwlStore) {}
+
+    chain(
+        modelUri: string,
+        tboxIndex: TBoxIndex,
+        readModelUris: ReadonlyArray<string>,
+        deltaPlus: Quad[],
+        deltaMinus: Quad[],
+    ): ChainingResult {
+        const scope = this.resolveScope(modelUri, readModelUris);
+        const store = this.reasoningStore.getStore();
+        const index = this.buildIndex(scope.facts);
+
+        const plusFacts = deltaPlus.map((q) => this.asFact(q));
+        const minusFacts = deltaMinus.map((q) => this.asFact(q));
+        const fullRecompute = plusFacts.length === 0 && minusFacts.length === 0;
+
+        let iterations = 0;
+        let newQuadsCount = 0;
+
+        if (fullRecompute) {
+            for (const key of [...scope.ownEntKeys]) {
+                const fact = scope.facts.get(key);
+                if (fact) {
+                    this.removeOwnEntailedFact(scope, index, store, fact);
+                }
+            }
+        }
+
+        const over = fullRecompute ? [] : this.overdelete(scope, index, tboxIndex, minusFacts, store);
+        const seed = fullRecompute ? scope.ownBaseFacts : [...plusFacts, ...over];
+
+        const result = this.materializeAdd(scope, index, tboxIndex, seed, store);
+        iterations += result.iterations;
+        newQuadsCount += result.newQuads;
+
+        return {
+            complete: true,
+            iterations,
+            newQuadsCount,
+            validationWarnings: this.collectValidationWarnings(index, tboxIndex),
+        };
+    }
+
+    private overdelete(
+        scope: ScopeData,
+        index: WorkingIndex,
+        tbox: TBoxIndex,
+        minusFacts: Fact[],
+        store: Store,
+    ): Fact[] {
+        const queue = [...minusFacts];
+        const overByKey = new Map<string, Fact>();
+
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            for (const head of this.reverseAnchoredHeads(current, index, tbox)) {
+                const key = this.factKey(head);
+                if (!scope.ownEntKeys.has(key)) {
+                    continue;
+                }
+                this.removeOwnEntailedFact(scope, index, store, head);
+                overByKey.set(key, head);
+                queue.push(head);
+            }
+        }
+
+        return [...overByKey.values()];
+    }
+
+    private materializeAdd(
+        scope: ScopeData,
+        index: WorkingIndex,
+        tbox: TBoxIndex,
+        seedFacts: Fact[],
+        store: Store,
+    ): { iterations: number; newQuads: number } {
+        const queue: Fact[] = [];
+        const queued = new Set<string>();
+        let iterations = 0;
+        let newQuads = 0;
+
+        const enqueue = (fact: Fact) => {
+            const key = this.factKey(fact);
+            if (queued.has(key)) {
+                return;
+            }
+            queue.push(fact);
+            queued.add(key);
+        };
+
+        for (const seed of seedFacts) {
+            const key = this.factKey(seed);
+            if (scope.baseKeys.has(key)) {
+                enqueue(seed);
+                continue;
+            }
+            if (!this.canInsertEntailedFact(scope, seed) || !this.hasSupport(seed, index, tbox)) {
+                continue;
+            }
+            this.insertOwnEntailedFact(scope, index, store, seed);
+            newQuads += 1;
+            enqueue(seed);
+        }
+
+        while (queue.length > 0) {
+            const fact = queue.shift();
+            if (!fact) {
+                continue;
+            }
+            iterations += 1;
+            for (const head of this.forwardRules(fact, index, tbox)) {
+                if (!this.canInsertEntailedFact(scope, head) || !this.hasSupport(head, index, tbox)) {
+                    continue;
+                }
+                this.insertOwnEntailedFact(scope, index, store, head);
+                newQuads += 1;
+                enqueue(head);
+            }
+        }
+
+        return { iterations, newQuads };
+    }
+
+    private forwardRules(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): Fact[] {
+        const heads: Fact[] = [];
+
+        if (this.isTypeFact(fact)) {
+            for (const superClass of this.getSuperClasses(tbox, fact.object.value)) {
+                if (superClass !== fact.object.value) {
+                    heads.push(this.typeFact(fact.subject, superClass));
+                }
+            }
+        }
+
+        const p = fact.predicate.value;
+        const x = fact.subject;
+        const y = fact.object;
+
+        for (const q of this.getSuperProperties(tbox, p)) {
+            if (q !== p) {
+                heads.push(this.edgeFact(x, q, y));
+            }
+        }
+
+        for (const d of this.getDomains(tbox, p)) {
+            heads.push(this.typeFact(x, d));
+        }
+
+        if (y.termType !== 'Literal') {
+            for (const c of this.getObjectRanges(tbox, p)) {
+                heads.push(this.typeFact(y, c));
+            }
+            for (const inverse of this.getInverses(tbox, p)) {
+                heads.push(this.edgeFact(y, inverse, x));
+            }
+            if (this.isSymmetricProperty(tbox, p)) {
+                heads.push(this.edgeFact(y, p, x));
+            }
+            if (this.isTransitiveProperty(tbox, p)) {
+                for (const next of this.getEdgeFacts(index, y, p)) {
+                    heads.push(this.edgeFact(x, p, next.object));
+                }
+                for (const prev of this.getIncomingEdgesByProperty(index, x, p)) {
+                    heads.push(this.edgeFact(prev.subject, p, y));
+                }
+            }
+        }
+
+        heads.push(...this.applyForwardRulesTriggeredByFact(fact, index, tbox));
+
+        return this.uniqueFacts(heads);
+    }
+
+    private reverseAnchoredHeads(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): Fact[] {
+        return this.forwardRules(fact, index, tbox);
+    }
+
+    private hasSupport(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): boolean {
+        if (index.facts.has(this.factKey(fact))) {
+            return true;
+        }
+
+        if (this.isTypeFact(fact)) {
+            const types = this.getTypes(index, fact.subject);
+            for (const type of types) {
+                if (type === fact.object.value || this.getSuperClasses(tbox, type).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+
+            for (const edge of this.getOutgoingEdges(index, fact.subject)) {
+                if (this.getDomains(tbox, edge.predicate.value).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+
+            for (const edge of this.getIncomingEdges(index, fact.subject)) {
+                if (edge.object.termType !== 'Literal' && this.getObjectRanges(tbox, edge.predicate.value).includes(fact.object.value)) {
+                    return true;
+                }
+            }
+
+            if (this.hasForwardRuleSupport(fact, index, tbox)) {
+                return true;
+            }
+
+            return false;
+        }
+
+        const x = fact.subject;
+        const p = fact.predicate.value;
+        const y = fact.object;
+
+        for (const edge of this.getOutgoingEdges(index, x)) {
+            if (edge.object.id === y.id && this.getSuperProperties(tbox, edge.predicate.value).includes(p)) {
+                return true;
+            }
+        }
+
+        if (y.termType !== 'Literal') {
+            for (const edge of this.getOutgoingEdges(index, y)) {
+                if (edge.object.id === x.id && this.getInverses(tbox, edge.predicate.value).includes(p)) {
+                    return true;
+                }
+                if (edge.object.id === x.id && edge.predicate.value === p && this.isSymmetricProperty(tbox, p)) {
+                    return true;
+                }
+            }
+
+            if (this.isTransitiveProperty(tbox, p) && this.hasTransitiveSupport(index, x, p, y)) {
+                return true;
+            }
+        }
+
+        if (this.hasForwardRuleSupport(fact, index, tbox)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private hasTransitiveSupport(index: WorkingIndex, subject: Term, property: string, object: Term): boolean {
+        for (const left of this.getEdgeFacts(index, subject, property)) {
+            if (left.object.id === object.id || left.object.termType === 'Literal') {
+                continue;
+            }
+            for (const right of this.getEdgeFacts(index, left.object, property)) {
+                if (right.object.id === object.id) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private applyForwardRulesTriggeredByFact(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): Fact[] {
+        const heads: Fact[] = [];
+        for (const rule of tbox.forwardRules) {
+            rule.body.forEach((atom, anchorIndex) => {
+                const bindings = this.matchAtomToFact(atom, fact, new Map<string, Term>());
+                if (!bindings) {
+                    return;
+                }
+                for (const resolved of this.resolveRuleBody(rule.body, index, bindings, anchorIndex)) {
+                    for (const head of rule.head) {
+                        const inferred = this.instantiateRuleAtom(head, resolved);
+                        if (inferred) {
+                            heads.push(inferred);
+                        }
+                    }
+                }
+            });
+        }
+        return this.uniqueFacts(heads);
+    }
+
+    private hasForwardRuleSupport(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): boolean {
+        for (const rule of tbox.forwardRules) {
+            for (const head of rule.head) {
+                const bindings = this.matchAtomToFact(head, fact, new Map<string, Term>());
+                if (!bindings) {
+                    continue;
+                }
+                const resolved = this.resolveRuleBody(rule.body, index, bindings, -1);
+                if (resolved.length > 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private resolveRuleBody(
+        body: RuleAtom[],
+        index: WorkingIndex,
+        bindings: Map<string, Term>,
+        satisfiedIndex: number,
+    ): Array<Map<string, Term>> {
+        const pending = body.filter((_atom, index) => index !== satisfiedIndex);
+        return this.resolvePendingAtoms(pending, index, bindings);
+    }
+
+    private resolvePendingAtoms(
+        pending: RuleAtom[],
+        index: WorkingIndex,
+        bindings: Map<string, Term>,
+    ): Array<Map<string, Term>> {
+        if (pending.length === 0) {
+            return [bindings];
+        }
+
+        const [current, ...rest] = pending;
+        const matches = this.findMatchesForAtom(current, index, bindings);
+        const resolved: Array<Map<string, Term>> = [];
+        for (const nextBindings of matches) {
+            resolved.push(...this.resolvePendingAtoms(rest, index, nextBindings));
+        }
+        return resolved;
+    }
+
+    private findMatchesForAtom(atom: RuleAtom, index: WorkingIndex, bindings: Map<string, Term>): Array<Map<string, Term>> {
+        const matches: Array<Map<string, Term>> = [];
+        for (const fact of this.candidateFacts(atom, index, bindings)) {
+            const nextBindings = this.matchAtomToFact(atom, fact, bindings);
+            if (nextBindings) {
+                matches.push(nextBindings);
+            }
+        }
+        return matches;
+    }
+
+    private candidateFacts(atom: RuleAtom, index: WorkingIndex, bindings: Map<string, Term>): Fact[] {
+        if (atom.kind === 'class') {
+            const bound = this.resolvePatternTerm(atom.argument, bindings);
+            if (bound) {
+                return [...this.getTypes(index, bound)].map((classIri) => this.typeFact(bound, classIri));
+            }
+            const subjects = index.subjectsByType.get(atom.classIri) ?? new Set<string>();
+            return [...subjects]
+                .map((subjectKey) => index.termByKey.get(subjectKey))
+                .filter((term): term is Term => Boolean(term))
+                .map((subject) => this.typeFact(subject, atom.classIri));
+        }
+
+        const left = this.resolvePatternTerm(atom.argument1, bindings);
+        const right = this.resolvePatternTerm(atom.argument2, bindings);
+        if (left) {
+            return this.getEdgeFacts(index, left, atom.propertyIri);
+        }
+        if (right) {
+            return this.getIncomingEdgesByProperty(index, right, atom.propertyIri);
+        }
+        return index.edgeFactsByProperty.get(atom.propertyIri) ?? [];
+    }
+
+    private matchAtomToFact(atom: RuleAtom, fact: Fact, bindings: Map<string, Term>): Map<string, Term> | undefined {
+        if (atom.kind === 'class') {
+            if (!this.isTypeFact(fact) || fact.object.value !== atom.classIri) {
+                return undefined;
+            }
+            return this.matchPattern(atom.argument, fact.subject, bindings);
+        }
+        if (fact.predicate.value !== atom.propertyIri) {
+            return undefined;
+        }
+        const afterLeft = this.matchPattern(atom.argument1, fact.subject, bindings);
+        if (!afterLeft) {
+            return undefined;
+        }
+        return this.matchPattern(atom.argument2, fact.object, afterLeft);
+    }
+
+    private matchPattern(pattern: RuleTermPattern, term: Term, bindings: Map<string, Term>): Map<string, Term> | undefined {
+        if (pattern.kind === 'variable') {
+            const existing = bindings.get(pattern.name);
+            if (existing) {
+                return this.sameTerm(existing, term) ? bindings : undefined;
+            }
+            const next = new Map(bindings);
+            next.set(pattern.name, term);
+            return next;
+        }
+        if (pattern.kind === 'named') {
+            return term.termType === 'NamedNode' && term.value === pattern.iri ? bindings : undefined;
+        }
+        if (term.termType !== 'Literal') {
+            return undefined;
+        }
+        return term.value === pattern.value
+            && term.datatype.value === pattern.datatype
+            && term.language === pattern.language
+            ? bindings
+            : undefined;
+    }
+
+    private resolvePatternTerm(pattern: RuleTermPattern, bindings: Map<string, Term>): Term | undefined {
+        if (pattern.kind === 'variable') {
+            return bindings.get(pattern.name);
+        }
+        if (pattern.kind === 'named') {
+            return namedNode(pattern.iri);
+        }
+        return DataFactory.literal(pattern.value, pattern.language || namedNode(pattern.datatype));
+    }
+
+    private instantiateRuleAtom(atom: RuleAtom, bindings: Map<string, Term>): Fact | undefined {
+        if (atom.kind === 'class') {
+            const subject = this.resolvePatternTerm(atom.argument, bindings);
+            if (!subject || subject.termType === 'Literal') {
+                return undefined;
+            }
+            return this.typeFact(subject, atom.classIri);
+        }
+        const subject = this.resolvePatternTerm(atom.argument1, bindings);
+        const object = this.resolvePatternTerm(atom.argument2, bindings);
+        if (!subject || !object || subject.termType === 'Literal') {
+            return undefined;
+        }
+        return this.edgeFact(subject, atom.propertyIri, object);
+    }
+
+    private sameTerm(left: Term, right: Term): boolean {
+        return left.termType === right.termType
+            && left.value === right.value
+            && (left.termType !== 'Literal'
+                || (right.termType === 'Literal'
+                    && left.datatype.value === right.datatype.value
+                    && left.language === right.language));
+    }
+
+    private resolveScope(modelUri: string, readModelUris: ReadonlyArray<string>): ScopeData {
+        const store = this.reasoningStore.getStore();
+        const facts = new Map<string, Fact>();
+        const baseKeys = new Set<string>();
+        const importEntKeys = new Set<string>();
+        const ownEntKeys = new Set<string>();
+        const ownBaseFacts: Fact[] = [];
+        const ownGraphs = this.reasoningStore.graphs(modelUri);
+
+        for (const uri of readModelUris) {
+            let graphs;
+            try {
+                graphs = this.reasoningStore.graphs(uri);
+            } catch {
+                continue;
+            }
+
+            for (const q of store.getQuads(null, null, null, graphs.own)) {
+                const fact = this.asFact(q);
+                const key = this.factKey(fact);
+                facts.set(key, fact);
+                baseKeys.add(key);
+                if (uri === modelUri) {
+                    ownBaseFacts.push(fact);
+                }
+            }
+
+            for (const q of store.getQuads(null, null, null, graphs.entailments)) {
+                const fact = this.asFact(q);
+                const key = this.factKey(fact);
+                facts.set(key, fact);
+                if (uri === modelUri) {
+                    ownEntKeys.add(key);
+                } else {
+                    importEntKeys.add(key);
+                }
+            }
+        }
+
+        return {
+            ownEntailmentGraph: ownGraphs.entailments,
+            ownBaseFacts: this.uniqueFacts(ownBaseFacts),
+            baseKeys,
+            importEntKeys,
+            ownEntKeys,
+            facts,
+        };
+    }
+
+    private buildIndex(facts: Map<string, Fact>): WorkingIndex {
+        const typesBySubject = new Map<string, Set<string>>();
+        const subjectsByType = new Map<string, Set<string>>();
+        const edgeFactsBySubjectProperty = new Map<string, Fact[]>();
+        const edgeFactsByProperty = new Map<string, Fact[]>();
+        const subjectsByPropertyObject = new Map<string, Set<string>>();
+        const termByKey = new Map<string, Term>();
+
+        for (const fact of facts.values()) {
+            const sKey = fact.subject.id;
+            const oKey = fact.object.id;
+            termByKey.set(sKey, fact.subject);
+            termByKey.set(oKey, fact.object);
+
+            if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+                const values = typesBySubject.get(sKey) ?? new Set<string>();
+                values.add(fact.object.value);
+                typesBySubject.set(sKey, values);
+                const subjects = subjectsByType.get(fact.object.value) ?? new Set<string>();
+                subjects.add(sKey);
+                subjectsByType.set(fact.object.value, subjects);
+                continue;
+            }
+
+            const spKey = `${sKey}|${fact.predicate.value}`;
+            const bySp = edgeFactsBySubjectProperty.get(spKey) ?? [];
+            bySp.push(fact);
+            edgeFactsBySubjectProperty.set(spKey, bySp);
+            const byProperty = edgeFactsByProperty.get(fact.predicate.value) ?? [];
+            byProperty.push(fact);
+            edgeFactsByProperty.set(fact.predicate.value, byProperty);
+
+            const poKey = `${fact.predicate.value}|${oKey}`;
+            const subjects = subjectsByPropertyObject.get(poKey) ?? new Set<string>();
+            subjects.add(sKey);
+            subjectsByPropertyObject.set(poKey, subjects);
+        }
+
+        return {
+            facts,
+            typesBySubject,
+            subjectsByType,
+            edgeFactsBySubjectProperty,
+            edgeFactsByProperty,
+            subjectsByPropertyObject,
+            termByKey,
+        };
+    }
+
+    private insertOwnEntailedFact(scope: ScopeData, index: WorkingIndex, store: Store, fact: Fact): void {
+        const key = this.factKey(fact);
+        if (scope.ownEntKeys.has(key)) {
+            return;
+        }
+        scope.ownEntKeys.add(key);
+        scope.facts.set(key, fact);
+        index.facts.set(key, fact);
+        this.indexAdd(index, fact);
+        store.addQuad(quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
+    }
+
+    private removeOwnEntailedFact(scope: ScopeData, index: WorkingIndex, store: Store, fact: Fact): void {
+        const key = this.factKey(fact);
+        if (!scope.ownEntKeys.has(key)) {
+            return;
+        }
+        scope.ownEntKeys.delete(key);
+        scope.facts.delete(key);
+        index.facts.delete(key);
+        this.indexRemove(index, fact);
+        store.removeQuad(quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
+    }
+
+    private canInsertEntailedFact(scope: ScopeData, fact: Fact): boolean {
+        const key = this.factKey(fact);
+        return !scope.baseKeys.has(key) && !scope.importEntKeys.has(key) && !scope.ownEntKeys.has(key);
+    }
+
+    private getTypes(index: WorkingIndex, subject: Term): Set<string> {
+        return index.typesBySubject.get(subject.id) ?? new Set<string>();
+    }
+
+    private getEdgeFacts(index: WorkingIndex, subject: Term, property: string): Fact[] {
+        return index.edgeFactsBySubjectProperty.get(`${subject.id}|${property}`) ?? [];
+    }
+
+    private getOutgoingEdges(index: WorkingIndex, subject: Term): Fact[] {
+        const edges: Fact[] = [];
+        const prefix = `${subject.id}|`;
+        for (const [key, facts] of index.edgeFactsBySubjectProperty.entries()) {
+            if (key.startsWith(prefix)) {
+                edges.push(...facts);
+            }
+        }
+        return edges;
+    }
+
+    private getIncomingEdges(index: WorkingIndex, object: Term): Fact[] {
+        const edges: Fact[] = [];
+        const suffix = `|${object.id}`;
+        for (const [key, subjects] of index.subjectsByPropertyObject.entries()) {
+            if (!key.endsWith(suffix)) {
+                continue;
+            }
+            const property = key.slice(0, key.length - suffix.length);
+            for (const subjectKey of subjects) {
+                const subject = index.termByKey.get(subjectKey);
+                if (subject) {
+                    edges.push(...this.getEdgeFacts(index, subject, property));
+                }
+            }
+        }
+        return edges;
+    }
+
+    private getIncomingEdgesByProperty(index: WorkingIndex, object: Term, property: string): Fact[] {
+        const subjects = index.subjectsByPropertyObject.get(`${property}|${object.id}`) ?? new Set<string>();
+        const edges: Fact[] = [];
+        for (const subjectKey of subjects) {
+            const subject = index.termByKey.get(subjectKey);
+            if (subject) {
+                edges.push(...this.getEdgeFacts(index, subject, property));
+            }
+        }
+        return edges;
+    }
+
+    private getSuperClasses(tbox: TBoxIndex, clazz: string): string[] {
+        return tbox.superClasses.get(clazz) ?? [];
+    }
+
+    private getSuperProperties(tbox: TBoxIndex, property: string): string[] {
+        return tbox.subProperties.get(property) ?? [property];
+    }
+
+    private getDomains(tbox: TBoxIndex, property: string): string[] {
+        return tbox.domain.get(property) ?? [];
+    }
+
+    private getObjectRanges(tbox: TBoxIndex, property: string): string[] {
+        return tbox.objectRange.get(property) ?? [];
+    }
+
+    private getInverses(tbox: TBoxIndex, property: string): string[] {
+        return tbox.inverseRoles.get(property) ?? [];
+    }
+
+    private isSymmetricProperty(tbox: TBoxIndex, property: string): boolean {
+        return tbox.symmetricProperties.has(property);
+    }
+
+    private isTransitiveProperty(tbox: TBoxIndex, property: string): boolean {
+        return tbox.transitiveProperties.has(property);
+    }
+
+    private typeFact(subject: Term, classIri: string): Fact {
+        return { subject, predicate: RDF_TYPE, object: namedNode(classIri) };
+    }
+
+    private edgeFact(subject: Term, propertyIri: string, object: Term): Fact {
+        return { subject, predicate: namedNode(propertyIri), object };
+    }
+
+    private isTypeFact(fact: Fact): fact is Fact & { object: NamedNode } {
+        return fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode';
+    }
+
+    private asFact(q: Quad): Fact {
+        return {
+            subject: q.subject,
+            predicate: q.predicate as NamedNode,
+            object: q.object,
+        };
+    }
+
+    private asQuadSubject(term: Term): Quad['subject'] {
+        if (term.termType === 'NamedNode' || term.termType === 'BlankNode' || term.termType === 'Variable') {
+            return term;
+        }
+        throw new Error(`Invalid inferred subject term '${term.termType}'.`);
+    }
+
+    private asQuadObject(term: Term): Quad['object'] {
+        if (term.termType === 'NamedNode'
+            || term.termType === 'BlankNode'
+            || term.termType === 'Variable'
+            || term.termType === 'Literal') {
+            return term;
+        }
+        throw new Error(`Invalid inferred object term '${term.termType}'.`);
+    }
+
+    private factKey(fact: Fact): string {
+        return `${fact.subject.id}|${fact.predicate.id}|${fact.object.id}`;
+    }
+
+    private uniqueFacts(facts: Fact[]): Fact[] {
+        const byKey = new Map<string, Fact>();
+        for (const fact of facts) {
+            byKey.set(this.factKey(fact), fact);
+        }
+        return [...byKey.values()];
+    }
+
+    private indexAdd(index: WorkingIndex, fact: Fact): void {
+        index.termByKey.set(fact.subject.id, fact.subject);
+        index.termByKey.set(fact.object.id, fact.object);
+        if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+            const values = index.typesBySubject.get(fact.subject.id) ?? new Set<string>();
+            values.add(fact.object.value);
+            index.typesBySubject.set(fact.subject.id, values);
+            const subjects = index.subjectsByType.get(fact.object.value) ?? new Set<string>();
+            subjects.add(fact.subject.id);
+            index.subjectsByType.set(fact.object.value, subjects);
+            return;
+        }
+        const spKey = `${fact.subject.id}|${fact.predicate.value}`;
+        const bySp = index.edgeFactsBySubjectProperty.get(spKey) ?? [];
+        bySp.push(fact);
+        index.edgeFactsBySubjectProperty.set(spKey, bySp);
+        const byProperty = index.edgeFactsByProperty.get(fact.predicate.value) ?? [];
+        byProperty.push(fact);
+        index.edgeFactsByProperty.set(fact.predicate.value, byProperty);
+
+        const poKey = `${fact.predicate.value}|${fact.object.id}`;
+        const subjects = index.subjectsByPropertyObject.get(poKey) ?? new Set<string>();
+        subjects.add(fact.subject.id);
+        index.subjectsByPropertyObject.set(poKey, subjects);
+    }
+
+    private indexRemove(index: WorkingIndex, fact: Fact): void {
+        if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
+            const values = index.typesBySubject.get(fact.subject.id);
+            if (!values) {
+                return;
+            }
+            values.delete(fact.object.value);
+            if (values.size === 0) {
+                index.typesBySubject.delete(fact.subject.id);
+            }
+            const subjects = index.subjectsByType.get(fact.object.value);
+            if (subjects) {
+                subjects.delete(fact.subject.id);
+                if (subjects.size === 0) {
+                    index.subjectsByType.delete(fact.object.value);
+                }
+            }
+            return;
+        }
+
+        const spKey = `${fact.subject.id}|${fact.predicate.value}`;
+        const bySp = index.edgeFactsBySubjectProperty.get(spKey) ?? [];
+        const nextBySp = bySp.filter((entry) => this.factKey(entry) !== this.factKey(fact));
+        if (nextBySp.length === 0) {
+            index.edgeFactsBySubjectProperty.delete(spKey);
+        } else {
+            index.edgeFactsBySubjectProperty.set(spKey, nextBySp);
+        }
+        const byProperty = index.edgeFactsByProperty.get(fact.predicate.value) ?? [];
+        const nextByProperty = byProperty.filter((entry) => this.factKey(entry) !== this.factKey(fact));
+        if (nextByProperty.length === 0) {
+            index.edgeFactsByProperty.delete(fact.predicate.value);
+        } else {
+            index.edgeFactsByProperty.set(fact.predicate.value, nextByProperty);
+        }
+
+        const poKey = `${fact.predicate.value}|${fact.object.id}`;
+        const subjects = index.subjectsByPropertyObject.get(poKey);
+        if (!subjects) {
+            return;
+        }
+        const stillHas = nextBySp.some((entry) => entry.object.id === fact.object.id);
+        if (!stillHas) {
+            subjects.delete(fact.subject.id);
+        }
+        if (subjects.size === 0) {
+            index.subjectsByPropertyObject.delete(poKey);
+        }
+    }
+
+    private collectValidationWarnings(index: WorkingIndex, tbox: TBoxIndex): string[] {
+        const warnings: string[] = [];
+
+        for (const fact of index.facts.values()) {
+            if (fact.predicate.value === RDF_TYPE.value) {
+                continue;
+            }
+            const ranges = tbox.datatypeRange.get(fact.predicate.value) ?? [];
+            if (ranges.length === 0) {
+                continue;
+            }
+            if (fact.object.termType !== 'Literal') {
+                warnings.push(`Datatype range violation on ${fact.predicate.value}: expected literal object.`);
+                continue;
+            }
+            if (!ranges.includes(fact.object.datatype.value)) {
+                warnings.push(
+                    `Datatype range violation on ${fact.predicate.value}: expected ${ranges.join(', ')}, got ${fact.object.datatype.value}.`,
+                );
+            }
+        }
+
+        for (const [subjectProperty, facts] of index.edgeFactsBySubjectProperty.entries()) {
+            const [subjectId, property] = subjectProperty.split('|', 2);
+            if (subjectId.length === 0 || !tbox.functionalProperties.has(property)) {
+                continue;
+            }
+            const objectIds = [...new Set(facts.map((fact) => fact.object.id))];
+            if (objectIds.length > 1) {
+                warnings.push(`Functional property violation on ${property}: ${facts[0]?.subject.value ?? subjectId} has ${objectIds.length} distinct values.`);
+            }
+        }
+
+        for (const [propertyObject, subjectIds] of index.subjectsByPropertyObject.entries()) {
+            const split = propertyObject.indexOf('|');
+            const property = split >= 0 ? propertyObject.slice(0, split) : propertyObject;
+            const objectId = split >= 0 ? propertyObject.slice(split + 1) : '';
+            if (!tbox.inverseFunctionalProperties.has(property) || subjectIds.size <= 1) {
+                continue;
+            }
+            const object = index.termByKey.get(objectId);
+            const objectLabel = object?.value ?? objectId;
+            warnings.push(`Inverse-functional property violation on ${property}: ${objectLabel} has ${subjectIds.size} distinct sources.`);
+        }
+
+        return [...new Set(warnings)];
+    }
+}