@oml/owl 0.19.3 → 0.20.0

package/src/owl/owl-abox.ts

@@ -1,7 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { DataFactory } from 'n3';
-import type { NamedNode, Quad, Store, Term } from 'n3';
+import type { NamedNode, Quad, Term } from 'n3';
 import type { OwlStore } from './owl-interfaces.js';
 import type { HasValueRestriction, RuleAtom, RuleTermPattern, TBoxIndex } from './owl-tbox.js';
 
@@ -23,24 +23,43 @@ interface Fact {
 }
 
 interface ScopeData {
+    modelUri: string;
     ownEntailmentGraph: NamedNode;
     ownBaseFacts: Fact[];
     baseKeys: Set<string>;
     importEntKeys: Set<string>;
     ownEntKeys: Set<string>;
     facts: Map<string, Fact>;
+    index: WorkingIndex;
 }
 
 interface WorkingIndex {
     facts: Map<string, Fact>;
+    indexed: boolean;
+    indexEdgesByObject: boolean;
+    indexSubjectsByPropertyObject: boolean;
     typesBySubject: Map<string, Set<string>>;
     subjectsByType: Map<string, Set<string>>;
+    edgeFactsBySubject: Map<string, Fact[]>;
+    edgeFactsByObject: Map<string, Fact[]>;
     edgeFactsBySubjectProperty: Map<string, Fact[]>;
     edgeFactsByProperty: Map<string, Fact[]>;
     subjectsByPropertyObject: Map<string, Set<string>>;
     termByKey: Map<string, Term>;
 }
 
+interface RuleAnchor {
+    rule: RuleAtom[];
+    head: RuleAtom[];
+    atom: RuleAtom;
+    anchorIndex: number;
+}
+
+interface ForwardRuleAnchorIndex {
+    byClass: Map<string, RuleAnchor[]>;
+    byProperty: Map<string, RuleAnchor[]>;
+}
+
 export class ABoxEntailmentCache {
     private readonly state = new Map<string, 'clean' | 'dirty' | 'absent'>();
     private readonly deltaPlus = new Map<string, Map<string, Quad>>();
@@ -117,6 +136,12 @@ export class ABoxEntailmentCache {
 }
 
 export class ABoxChainer {
+    // Interned terms for rule pattern constants (NamedNode/Literal). Pattern constants are
+    // immutable and recur across every fact match, so re-creating them per call was a top
+    // allocator; equality elsewhere compares by value/id, so identity reuse is safe.
+    private readonly termCache = new Map<string, Term>();
+    private readonly ruleAnchorIndexCache = new WeakMap<TBoxIndex, ForwardRuleAnchorIndex>();
+
     constructor(private readonly reasoningStore: OwlStore) {}
 
     chain(
@@ -126,13 +151,11 @@ export class ABoxChainer {
         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;
+        const scope = this.resolveScope(modelUri, readModelUris, tboxIndex, !fullRecompute);
+        const index = scope.index;
 
         let iterations = 0;
         let newQuadsCount = 0;
@@ -141,23 +164,25 @@ export class ABoxChainer {
             for (const key of [...scope.ownEntKeys]) {
                 const fact = scope.facts.get(key);
                 if (fact) {
-                    this.removeOwnEntailedFact(scope, index, store, fact);
+                    this.removeOwnEntailedFact(scope, index, fact);
                 }
             }
         }
 
-        const over = fullRecompute ? [] : this.overdelete(scope, index, tboxIndex, minusFacts, store);
+        const over = fullRecompute ? [] : this.overdelete(scope, index, tboxIndex, minusFacts);
         const seed = fullRecompute ? scope.ownBaseFacts : [...plusFacts, ...over];
 
-        const result = this.materializeAdd(scope, index, tboxIndex, seed, store);
+        const result = this.materializeAdd(scope, index, tboxIndex, seed, !fullRecompute);
         iterations += result.iterations;
         newQuadsCount += result.newQuads;
 
+        const validationWarnings = this.collectValidationWarnings(index, tboxIndex);
+
         return {
             complete: true,
             iterations,
             newQuadsCount,
-            validationWarnings: this.collectValidationWarnings(index, tboxIndex),
+            validationWarnings,
         };
     }
 
@@ -166,13 +191,14 @@ export class ABoxChainer {
         index: WorkingIndex,
         tbox: TBoxIndex,
         minusFacts: Fact[],
-        store: Store,
     ): Fact[] {
         const queue = [...minusFacts];
+        let cursor = 0;
         const overByKey = new Map<string, Fact>();
 
-        while (queue.length > 0) {
-            const current = queue.shift();
+        while (cursor < queue.length) {
+            const current = queue[cursor];
+            cursor += 1;
             if (!current) {
                 continue;
             }
@@ -181,7 +207,7 @@ export class ABoxChainer {
                 if (!scope.ownEntKeys.has(key)) {
                     continue;
                 }
-                this.removeOwnEntailedFact(scope, index, store, head);
+                this.removeOwnEntailedFact(scope, index, head);
                 overByKey.set(key, head);
                 queue.push(head);
             }
@@ -195,7 +221,7 @@ export class ABoxChainer {
         index: WorkingIndex,
         tbox: TBoxIndex,
         seedFacts: Fact[],
-        store: Store,
+        checkSupport: boolean,
     ): { iterations: number; newQuads: number } {
         const queue: Fact[] = [];
         const queued = new Set<string>();
@@ -217,25 +243,39 @@ export class ABoxChainer {
                 enqueue(seed);
                 continue;
             }
-            if (!this.canInsertEntailedFact(scope, seed) || !this.hasSupport(seed, index, tbox)) {
+            if (!this.canInsertEntailedFact(scope, seed)) {
                 continue;
             }
-            this.insertOwnEntailedFact(scope, index, store, seed);
+            if (checkSupport) {
+                const supported = this.hasSupport(seed, index, tbox);
+                if (!supported) {
+                    continue;
+                }
+            }
+            this.insertOwnEntailedFact(scope, index, seed);
             newQuads += 1;
             enqueue(seed);
         }
 
-        while (queue.length > 0) {
-            const fact = queue.shift();
+        let cursor = 0;
+        while (cursor < queue.length) {
+            const fact = queue[cursor];
+            cursor += 1;
             if (!fact) {
                 continue;
             }
             iterations += 1;
             for (const head of this.forwardRules(fact, index, tbox)) {
-                if (!this.canInsertEntailedFact(scope, head) || !this.hasSupport(head, index, tbox)) {
+                if (!this.canInsertEntailedFact(scope, head)) {
                     continue;
                 }
-                this.insertOwnEntailedFact(scope, index, store, head);
+                if (checkSupport) {
+                    const supported = this.hasSupport(head, index, tbox);
+                    if (!supported) {
+                        continue;
+                    }
+                }
+                this.insertOwnEntailedFact(scope, index, head);
                 newQuads += 1;
                 enqueue(head);
             }
@@ -286,6 +326,7 @@ export class ABoxChainer {
                 heads.push(this.edgeFact(y, p, x));
             }
             if (this.isTransitiveProperty(tbox, p)) {
+                this.ensureWorkingIndex(index);
                 for (const next of this.getEdgeFacts(index, y, p)) {
                     heads.push(this.edgeFact(x, p, next.object));
                 }
@@ -305,6 +346,7 @@ export class ABoxChainer {
     }
 
     private hasSupport(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): boolean {
+        this.ensureWorkingIndex(index);
         if (index.facts.has(this.factKey(fact))) {
             return true;
         }
@@ -408,34 +450,71 @@ export class ABoxChainer {
 
     private applyForwardRulesTriggeredByFact(fact: Fact, index: WorkingIndex, tbox: TBoxIndex): Fact[] {
         const heads: Fact[] = [];
+        const anchors = this.forwardRuleAnchorsForFact(fact, tbox);
+        for (const anchor of anchors) {
+            const bindings = new Map<string, Term>();
+            if (this.matchAtomToFactMut(anchor.atom, fact, bindings) === null) {
+                continue;
+            }
+            this.ensureWorkingIndex(index);
+            for (const resolved of this.resolveRuleBody(anchor.rule, index, bindings, anchor.anchorIndex)) {
+                for (const head of anchor.head) {
+                    const inferred = this.instantiateRuleAtom(head, resolved);
+                    if (inferred) {
+                        heads.push(inferred);
+                    }
+                }
+            }
+        }
+        return this.uniqueFacts(heads);
+    }
+
+    private forwardRuleAnchorsForFact(fact: Fact, tbox: TBoxIndex): RuleAnchor[] {
+        if (tbox.forwardRules.length === 0) {
+            return [];
+        }
+        const anchorIndex = this.getForwardRuleAnchorIndex(tbox);
+        if (this.isTypeFact(fact)) {
+            return anchorIndex.byClass.get(fact.object.value) ?? [];
+        }
+        return anchorIndex.byProperty.get(fact.predicate.value) ?? [];
+    }
+
+    private getForwardRuleAnchorIndex(tbox: TBoxIndex): ForwardRuleAnchorIndex {
+        const cached = this.ruleAnchorIndexCache.get(tbox);
+        if (cached) {
+            return cached;
+        }
+        const created: ForwardRuleAnchorIndex = {
+            byClass: new Map(),
+            byProperty: new Map(),
+        };
         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);
-                        }
-                    }
+                const anchor: RuleAnchor = { rule: rule.body, head: rule.head, atom, anchorIndex };
+                if (atom.kind === 'class') {
+                    const anchors = created.byClass.get(atom.classIri) ?? [];
+                    anchors.push(anchor);
+                    created.byClass.set(atom.classIri, anchors);
+                } else {
+                    const anchors = created.byProperty.get(atom.propertyIri) ?? [];
+                    anchors.push(anchor);
+                    created.byProperty.set(atom.propertyIri, anchors);
                 }
             });
         }
-        return this.uniqueFacts(heads);
+        this.ruleAnchorIndexCache.set(tbox, created);
+        return created;
     }
 
     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) {
+                const bindings = new Map<string, Term>();
+                if (this.matchAtomToFactMut(head, fact, bindings) === null) {
                     continue;
                 }
-                const resolved = this.resolveRuleBody(rule.body, index, bindings, -1);
-                if (resolved.length > 0) {
+                for (const _resolved of this.resolveRuleBody(rule.body, index, bindings, -1)) {
                     return true;
                 }
             }
@@ -443,107 +522,135 @@ export class ABoxChainer {
         return false;
     }
 
-    private resolveRuleBody(
+    // Join the (non-anchor) rule body atoms against the working index, yielding each complete
+    // variable binding. The bindings Map is mutated in place and backtracked, and yielded by
+    // reference: consumers must read the binding fully before requesting the next one (they do —
+    // they instantiate the rule head synchronously). This avoids the per-binding Map copies that
+    // dominated allocation. Semantics are identical to the prior copy-based cartesian expansion.
+    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);
+    ): Generator<Map<string, Term>> {
+        const pending: RuleAtom[] = [];
+        for (let i = 0; i < body.length; i += 1) {
+            if (i !== satisfiedIndex) {
+                pending.push(body[i]);
+            }
+        }
+        yield* this.resolvePending(pending, 0, index, bindings);
     }
 
-    private resolvePendingAtoms(
+    private *resolvePending(
         pending: RuleAtom[],
+        pos: number,
         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));
+    ): Generator<Map<string, Term>> {
+        if (pos === pending.length) {
+            yield bindings;
+            return;
         }
-        return resolved;
-    }
-
-    private findMatchesForAtom(atom: RuleAtom, index: WorkingIndex, bindings: Map<string, Term>): Array<Map<string, Term>> {
-        const matches: Array<Map<string, Term>> = [];
+        const atom = pending[pos];
         for (const fact of this.candidateFacts(atom, index, bindings)) {
-            const nextBindings = this.matchAtomToFact(atom, fact, bindings);
-            if (nextBindings) {
-                matches.push(nextBindings);
+            const added = this.matchAtomToFactMut(atom, fact, bindings);
+            if (added === null) {
+                continue;
+            }
+            yield* this.resolvePending(pending, pos + 1, index, bindings);
+            for (const key of added) {
+                bindings.delete(key);
             }
         }
-        return matches;
     }
 
-    private candidateFacts(atom: RuleAtom, index: WorkingIndex, bindings: Map<string, Term>): Fact[] {
+    private *candidateFacts(atom: RuleAtom, index: WorkingIndex, bindings: Map<string, Term>): Generator<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));
+                for (const classIri of this.getTypes(index, bound)) {
+                    yield this.typeFact(bound, classIri);
+                }
+                return;
             }
-            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 subjects = index.subjectsByType.get(atom.classIri);
+            if (!subjects) {
+                return;
+            }
+            for (const subjectKey of subjects) {
+                const subject = index.termByKey.get(subjectKey);
+                if (subject) {
+                    yield this.typeFact(subject, atom.classIri);
+                }
+            }
+            return;
         }
 
         const left = this.resolvePatternTerm(atom.argument1, bindings);
         const right = this.resolvePatternTerm(atom.argument2, bindings);
         if (left) {
-            return this.getEdgeFacts(index, left, atom.propertyIri);
+            yield* this.getEdgeFacts(index, left, atom.propertyIri);
+            return;
         }
         if (right) {
-            return this.getIncomingEdgesByProperty(index, right, atom.propertyIri);
+            yield* this.getIncomingEdgesByProperty(index, right, atom.propertyIri);
+            return;
         }
-        return index.edgeFactsByProperty.get(atom.propertyIri) ?? [];
+        yield* index.edgeFactsByProperty.get(atom.propertyIri) ?? [];
     }
 
-    private matchAtomToFact(atom: RuleAtom, fact: Fact, bindings: Map<string, Term>): Map<string, Term> | undefined {
+    // Match an atom against a fact, mutating `bindings` in place. Returns the list of variable
+    // names newly bound (for the caller to backtrack), or null if the atom does not match.
+    // On a partial-then-failed match the names bound so far are undone before returning null.
+    private matchAtomToFactMut(atom: RuleAtom, fact: Fact, bindings: Map<string, Term>): string[] | null {
+        const added: string[] = [];
         if (atom.kind === 'class') {
             if (!this.isTypeFact(fact) || fact.object.value !== atom.classIri) {
-                return undefined;
+                return null;
+            }
+            if (!this.matchPatternMut(atom.argument, fact.subject, bindings, added)) {
+                this.undoBindings(bindings, added);
+                return null;
             }
-            return this.matchPattern(atom.argument, fact.subject, bindings);
+            return added;
         }
         if (fact.predicate.value !== atom.propertyIri) {
-            return undefined;
+            return null;
         }
-        const afterLeft = this.matchPattern(atom.argument1, fact.subject, bindings);
-        if (!afterLeft) {
-            return undefined;
+        if (!this.matchPatternMut(atom.argument1, fact.subject, bindings, added)
+            || !this.matchPatternMut(atom.argument2, fact.object, bindings, added)) {
+            this.undoBindings(bindings, added);
+            return null;
         }
-        return this.matchPattern(atom.argument2, fact.object, afterLeft);
+        return added;
     }
 
-    private matchPattern(pattern: RuleTermPattern, term: Term, bindings: Map<string, Term>): Map<string, Term> | undefined {
+    private matchPatternMut(pattern: RuleTermPattern, term: Term, bindings: Map<string, Term>, added: string[]): boolean {
         if (pattern.kind === 'variable') {
             const existing = bindings.get(pattern.name);
             if (existing) {
-                return this.sameTerm(existing, term) ? bindings : undefined;
+                return this.sameTerm(existing, term);
             }
-            const next = new Map(bindings);
-            next.set(pattern.name, term);
-            return next;
+            bindings.set(pattern.name, term);
+            added.push(pattern.name);
+            return true;
         }
         if (pattern.kind === 'named') {
-            return term.termType === 'NamedNode' && term.value === pattern.iri ? bindings : undefined;
+            return term.termType === 'NamedNode' && term.value === pattern.iri;
         }
         if (term.termType !== 'Literal') {
-            return undefined;
+            return false;
         }
         return term.value === pattern.value
             && term.datatype.value === pattern.datatype
-            && term.language === pattern.language
-            ? bindings
-            : undefined;
+            && term.language === pattern.language;
+    }
+
+    private undoBindings(bindings: Map<string, Term>, added: string[]): void {
+        for (const key of added) {
+            bindings.delete(key);
+        }
     }
 
     private resolvePatternTerm(pattern: RuleTermPattern, bindings: Map<string, Term>): Term | undefined {
@@ -551,9 +658,29 @@ export class ABoxChainer {
             return bindings.get(pattern.name);
         }
         if (pattern.kind === 'named') {
-            return namedNode(pattern.iri);
+            return this.internNamed(pattern.iri);
+        }
+        return this.internLiteral(pattern.value, pattern.datatype, pattern.language);
+    }
+
+    private internNamed(iri: string): Term {
+        const key = `N|${iri}`;
+        let term = this.termCache.get(key);
+        if (!term) {
+            term = namedNode(iri);
+            this.termCache.set(key, term);
+        }
+        return term;
+    }
+
+    private internLiteral(value: string, datatype: string, language: string): Term {
+        const key = `L|${value}|${datatype}|${language}`;
+        let term = this.termCache.get(key);
+        if (!term) {
+            term = DataFactory.literal(value, language || namedNode(datatype));
+            this.termCache.set(key, term);
         }
-        return DataFactory.literal(pattern.value, pattern.language || namedNode(pattern.datatype));
+        return term;
     }
 
     private instantiateRuleAtom(atom: RuleAtom, bindings: Map<string, Term>): Fact | undefined {
@@ -581,105 +708,96 @@ export class ABoxChainer {
                     && left.language === right.language));
     }
 
-    private resolveScope(modelUri: string, readModelUris: ReadonlyArray<string>): ScopeData {
-        const store = this.reasoningStore.getStore();
+    private resolveScope(modelUri: string, readModelUris: ReadonlyArray<string>, tbox: TBoxIndex, eagerIndex: boolean): ScopeData {
         const facts = new Map<string, Fact>();
+        const index = this.emptyWorkingIndex(facts, tbox, eagerIndex || tbox.transitiveProperties.size > 0);
         const baseKeys = new Set<string>();
         const importEntKeys = new Set<string>();
         const ownEntKeys = new Set<string>();
-        const ownBaseFacts: Fact[] = [];
+        const ownBaseFactsByKey = new Map<string, Fact>();
         const ownGraphs = this.reasoningStore.graphs(modelUri);
 
         for (const uri of readModelUris) {
-            let graphs;
             try {
-                graphs = this.reasoningStore.graphs(uri);
+                this.reasoningStore.graphs(uri);
             } catch {
                 continue;
             }
+            const isOwn = uri === modelUri;
 
-            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);
+            this.reasoningStore.forEachAssertedFact(uri, (subject, predicate, object, key) => {
+                const fact: Fact = { subject, predicate, object };
+                this.addResolvedScopeFact(facts, index, key, fact);
                 baseKeys.add(key);
-                if (uri === modelUri) {
-                    ownBaseFacts.push(fact);
+                if (isOwn) {
+                    ownBaseFactsByKey.set(key, 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) {
+            this.reasoningStore.forEachEntailedFact(uri, (subject, predicate, object, key) => {
+                const fact: Fact = { subject, predicate, object };
+                this.addResolvedScopeFact(facts, index, key, fact);
+                if (isOwn) {
                     ownEntKeys.add(key);
                 } else {
                     importEntKeys.add(key);
                 }
-            }
+            });
         }
 
         return {
+            modelUri,
             ownEntailmentGraph: ownGraphs.entailments,
-            ownBaseFacts: this.uniqueFacts(ownBaseFacts),
+            ownBaseFacts: [...ownBaseFactsByKey.values()],
             baseKeys,
             importEntKeys,
             ownEntKeys,
             facts,
+            index,
         };
     }
 
-    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);
-        }
-
+    private emptyWorkingIndex(facts: Map<string, Fact>, tbox: TBoxIndex, indexed: boolean): WorkingIndex {
+        const hasTransitiveProperties = tbox.transitiveProperties.size > 0;
+        const indexEdgesByObject = tbox.objectRange.size > 0;
+        const indexSubjectsByPropertyObject = hasTransitiveProperties;
         return {
             facts,
-            typesBySubject,
-            subjectsByType,
-            edgeFactsBySubjectProperty,
-            edgeFactsByProperty,
-            subjectsByPropertyObject,
-            termByKey,
+            indexed,
+            indexEdgesByObject,
+            indexSubjectsByPropertyObject,
+            typesBySubject: new Map(),
+            subjectsByType: new Map(),
+            edgeFactsBySubject: new Map(),
+            edgeFactsByObject: new Map(),
+            edgeFactsBySubjectProperty: new Map(),
+            edgeFactsByProperty: new Map(),
+            subjectsByPropertyObject: new Map(),
+            termByKey: new Map(),
         };
     }
 
-    private insertOwnEntailedFact(scope: ScopeData, index: WorkingIndex, store: Store, fact: Fact): void {
+    private addResolvedScopeFact(facts: Map<string, Fact>, index: WorkingIndex, key: string, fact: Fact): void {
+        if (facts.has(key)) {
+            return;
+        }
+        facts.set(key, fact);
+        if (index.indexed) {
+            this.indexAdd(index, fact);
+        }
+    }
+
+    private ensureWorkingIndex(index: WorkingIndex): void {
+        if (index.indexed) {
+            return;
+        }
+        index.indexed = true;
+        for (const fact of index.facts.values()) {
+            this.indexAdd(index, fact);
+        }
+    }
+
+    private insertOwnEntailedFact(scope: ScopeData, index: WorkingIndex, fact: Fact): void {
         const key = this.factKey(fact);
         if (scope.ownEntKeys.has(key)) {
             return;
@@ -687,11 +805,13 @@ export class ABoxChainer {
         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));
+        if (index.indexed) {
+            this.indexAdd(index, fact);
+        }
+        this.reasoningStore.addEntailment(scope.modelUri, quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
     }
 
-    private removeOwnEntailedFact(scope: ScopeData, index: WorkingIndex, store: Store, fact: Fact): void {
+    private removeOwnEntailedFact(scope: ScopeData, index: WorkingIndex, fact: Fact): void {
         const key = this.factKey(fact);
         if (!scope.ownEntKeys.has(key)) {
             return;
@@ -699,8 +819,10 @@ export class ABoxChainer {
         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));
+        if (index.indexed) {
+            this.indexRemove(index, fact);
+        }
+        this.reasoningStore.removeEntailment(scope.modelUri, quad(this.asQuadSubject(fact.subject), fact.predicate, this.asQuadObject(fact.object), scope.ownEntailmentGraph));
     }
 
     private canInsertEntailedFact(scope: ScopeData, fact: Fact): boolean {
@@ -717,35 +839,20 @@ export class ABoxChainer {
     }
 
     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;
+        return index.edgeFactsBySubject.get(subject.id) ?? [];
     }
 
     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));
-                }
-            }
+        if (!index.indexEdgesByObject) {
+            return [];
         }
-        return edges;
+        return index.edgeFactsByObject.get(object.id) ?? [];
     }
 
     private getIncomingEdgesByProperty(index: WorkingIndex, object: Term, property: string): Fact[] {
+        if (!index.indexSubjectsByPropertyObject) {
+            return (index.edgeFactsByProperty.get(property) ?? []).filter((fact) => fact.object.id === object.id);
+        }
         const subjects = index.subjectsByPropertyObject.get(`${property}|${object.id}`) ?? new Set<string>();
         const edges: Fact[] = [];
         for (const subjectKey of subjects) {
@@ -858,6 +965,14 @@ export class ABoxChainer {
             index.subjectsByType.set(fact.object.value, subjects);
             return;
         }
+        const bySubject = index.edgeFactsBySubject.get(fact.subject.id) ?? [];
+        bySubject.push(fact);
+        index.edgeFactsBySubject.set(fact.subject.id, bySubject);
+        if (index.indexEdgesByObject) {
+            const byObject = index.edgeFactsByObject.get(fact.object.id) ?? [];
+            byObject.push(fact);
+            index.edgeFactsByObject.set(fact.object.id, byObject);
+        }
         const spKey = `${fact.subject.id}|${fact.predicate.value}`;
         const bySp = index.edgeFactsBySubjectProperty.get(spKey) ?? [];
         bySp.push(fact);
@@ -866,10 +981,12 @@ export class ABoxChainer {
         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);
+        if (index.indexSubjectsByPropertyObject) {
+            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 {
@@ -892,42 +1009,71 @@ export class ABoxChainer {
             return;
         }
 
+        const bySubject = index.edgeFactsBySubject.get(fact.subject.id) ?? [];
+        const nextBySubject = this.removeFactFromArray(bySubject, fact);
+        if (nextBySubject.length === 0) {
+            index.edgeFactsBySubject.delete(fact.subject.id);
+        } else {
+            index.edgeFactsBySubject.set(fact.subject.id, nextBySubject);
+        }
+        if (index.indexEdgesByObject) {
+            const byObject = index.edgeFactsByObject.get(fact.object.id) ?? [];
+            const nextByObject = this.removeFactFromArray(byObject, fact);
+            if (nextByObject.length === 0) {
+                index.edgeFactsByObject.delete(fact.object.id);
+            } else {
+                index.edgeFactsByObject.set(fact.object.id, nextByObject);
+            }
+        }
         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));
+        const nextBySp = this.removeFactFromArray(bySp, 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));
+        const nextByProperty = this.removeFactFromArray(byProperty, 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);
+        if (index.indexSubjectsByPropertyObject) {
+            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 removeFactFromArray(facts: Fact[], target: Fact): Fact[] {
+        return facts.filter((fact) =>
+            fact.subject.id !== target.subject.id
+            || fact.predicate.id !== target.predicate.id
+            || fact.object.id !== target.object.id
+        );
+    }
+
     private collectValidationWarnings(_index: WorkingIndex, _tbox: TBoxIndex): string[] {
         const warnings: string[] = [];
+        if (!_index.indexed) {
+            return this.collectValidationWarningsFromFacts(_index.facts.values(), _tbox);
+        }
 
         for (const propertyIri of _tbox.functionalProperties) {
             const bySubject = new Map<string, Set<string>>();
-            const facts = _index.edgeFactsByProperty.get(propertyIri) ?? [];
+            const facts = this.validationFactsForProperty(_index, propertyIri);
             for (const fact of facts) {
                 const objects = bySubject.get(fact.subject.id) ?? new Set<string>();
                 objects.add(fact.object.id);
@@ -942,7 +1088,7 @@ export class ABoxChainer {
 
         for (const propertyIri of _tbox.inverseFunctionalProperties) {
             const byObject = new Map<string, Set<string>>();
-            const facts = _index.edgeFactsByProperty.get(propertyIri) ?? [];
+            const facts = this.validationFactsForProperty(_index, propertyIri);
             for (const fact of facts) {
                 const subjects = byObject.get(fact.object.id) ?? new Set<string>();
                 subjects.add(fact.subject.id);
@@ -957,4 +1103,59 @@ export class ABoxChainer {
 
         return warnings;
     }
+
+    private collectValidationWarningsFromFacts(facts: Iterable<Fact>, tbox: TBoxIndex): string[] {
+        const functionalByPropertySubject = new Map<string, Set<string>>();
+        const inverseFunctionalByPropertyObject = new Map<string, Set<string>>();
+
+        for (const fact of facts) {
+            const propertyIri = fact.predicate.value;
+            if (tbox.functionalProperties.has(propertyIri)) {
+                const key = `${propertyIri}|${fact.subject.id}`;
+                const objects = functionalByPropertySubject.get(key) ?? new Set<string>();
+                objects.add(fact.object.id);
+                functionalByPropertySubject.set(key, objects);
+            }
+            if (tbox.inverseFunctionalProperties.has(propertyIri)) {
+                const key = `${propertyIri}|${fact.object.id}`;
+                const subjects = inverseFunctionalByPropertyObject.get(key) ?? new Set<string>();
+                subjects.add(fact.subject.id);
+                inverseFunctionalByPropertyObject.set(key, subjects);
+            }
+        }
+
+        const warnings: string[] = [];
+        for (const [key, objects] of functionalByPropertySubject) {
+            if (objects.size <= 1) {
+                continue;
+            }
+            const separator = key.lastIndexOf('|');
+            const propertyIri = key.slice(0, separator);
+            const subjectId = key.slice(separator + 1);
+            warnings.push(`Functional property violation: ${propertyIri} has multiple values for subject ${subjectId}`);
+        }
+        for (const [key, subjects] of inverseFunctionalByPropertyObject) {
+            if (subjects.size <= 1) {
+                continue;
+            }
+            const separator = key.lastIndexOf('|');
+            const propertyIri = key.slice(0, separator);
+            const objectId = key.slice(separator + 1);
+            warnings.push(`Inverse-functional property violation: ${propertyIri} has multiple subjects for object ${objectId}`);
+        }
+        return warnings;
+    }
+
+    private validationFactsForProperty(index: WorkingIndex, propertyIri: string): Fact[] {
+        if (index.indexed) {
+            return index.edgeFactsByProperty.get(propertyIri) ?? [];
+        }
+        const facts: Fact[] = [];
+        for (const fact of index.facts.values()) {
+            if (fact.predicate.value === propertyIri) {
+                facts.push(fact);
+            }
+        }
+        return facts;
+    }
 }