@oml/owl 0.19.3 → 0.20.1

package/out/owl/owl-abox.js

@@ -70,41 +70,48 @@ export class ABoxEntailmentCache {
 export class ABoxChainer {
     constructor(reasoningStore) {
         this.reasoningStore = reasoningStore;
+        // 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.
+        this.termCache = new Map();
+        this.ruleAnchorIndexCache = new WeakMap();
     }
     chain(modelUri, tboxIndex, readModelUris, deltaPlus, deltaMinus) {
-        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;
         if (fullRecompute) {
             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,
         };
     }
-    overdelete(scope, index, tbox, minusFacts, store) {
+    overdelete(scope, index, tbox, minusFacts) {
         const queue = [...minusFacts];
+        let cursor = 0;
         const overByKey = new Map();
-        while (queue.length > 0) {
-            const current = queue.shift();
+        while (cursor < queue.length) {
+            const current = queue[cursor];
+            cursor += 1;
             if (!current) {
                 continue;
             }
@@ -113,14 +120,14 @@ 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);
             }
         }
         return [...overByKey.values()];
     }
-    materializeAdd(scope, index, tbox, seedFacts, store) {
+    materializeAdd(scope, index, tbox, seedFacts, checkSupport) {
         const queue = [];
         const queued = new Set();
         let iterations = 0;
@@ -139,24 +146,38 @@ 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);
             }
@@ -200,6 +221,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));
                 }
@@ -215,6 +237,7 @@ export class ABoxChainer {
         return this.forwardRules(fact, index, tbox);
     }
     hasSupport(fact, index, tbox) {
+        this.ensureWorkingIndex(index);
         if (index.facts.has(this.factKey(fact))) {
             return true;
         }
@@ -303,133 +326,215 @@ export class ABoxChainer {
     }
     applyForwardRulesTriggeredByFact(fact, index, tbox) {
         const heads = [];
+        const anchors = this.forwardRuleAnchorsForFact(fact, tbox);
+        for (const anchor of anchors) {
+            const bindings = new Map();
+            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);
+    }
+    forwardRuleAnchorsForFact(fact, tbox) {
+        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) ?? [];
+    }
+    getForwardRuleAnchorIndex(tbox) {
+        const cached = this.ruleAnchorIndexCache.get(tbox);
+        if (cached) {
+            return cached;
+        }
+        const created = {
+            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());
-                if (!bindings) {
-                    return;
+                const anchor = { 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);
                 }
-                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);
-                        }
-                    }
+                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;
     }
     hasForwardRuleSupport(fact, index, tbox) {
         for (const rule of tbox.forwardRules) {
             for (const head of rule.head) {
-                const bindings = this.matchAtomToFact(head, fact, new Map());
-                if (!bindings) {
+                const bindings = new Map();
+                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;
                 }
             }
         }
         return false;
     }
-    resolveRuleBody(body, index, bindings, satisfiedIndex) {
-        const pending = body.filter((_atom, index) => index !== satisfiedIndex);
-        return this.resolvePendingAtoms(pending, index, bindings);
-    }
-    resolvePendingAtoms(pending, index, bindings) {
-        if (pending.length === 0) {
-            return [bindings];
-        }
-        const [current, ...rest] = pending;
-        const matches = this.findMatchesForAtom(current, index, bindings);
-        const resolved = [];
-        for (const nextBindings of matches) {
-            resolved.push(...this.resolvePendingAtoms(rest, index, nextBindings));
+    // 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.
+    *resolveRuleBody(body, index, bindings, satisfiedIndex) {
+        const pending = [];
+        for (let i = 0; i < body.length; i += 1) {
+            if (i !== satisfiedIndex) {
+                pending.push(body[i]);
+            }
         }
-        return resolved;
+        yield* this.resolvePending(pending, 0, index, bindings);
     }
-    findMatchesForAtom(atom, index, bindings) {
-        const matches = [];
+    *resolvePending(pending, pos, index, bindings) {
+        if (pos === pending.length) {
+            yield bindings;
+            return;
+        }
+        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;
     }
-    candidateFacts(atom, index, bindings) {
+    *candidateFacts(atom, index, bindings) {
         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);
+            if (!subjects) {
+                return;
+            }
+            for (const subjectKey of subjects) {
+                const subject = index.termByKey.get(subjectKey);
+                if (subject) {
+                    yield this.typeFact(subject, atom.classIri);
+                }
             }
-            const subjects = index.subjectsByType.get(atom.classIri) ?? new Set();
-            return [...subjects]
-                .map((subjectKey) => index.termByKey.get(subjectKey))
-                .filter((term) => Boolean(term))
-                .map((subject) => 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) ?? [];
     }
-    matchAtomToFact(atom, fact, bindings) {
+    // 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.
+    matchAtomToFactMut(atom, fact, bindings) {
+        const added = [];
         if (atom.kind === 'class') {
             if (!this.isTypeFact(fact) || fact.object.value !== atom.classIri) {
-                return undefined;
+                return null;
             }
-            return this.matchPattern(atom.argument, fact.subject, bindings);
+            if (!this.matchPatternMut(atom.argument, fact.subject, bindings, added)) {
+                this.undoBindings(bindings, added);
+                return null;
+            }
+            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;
     }
-    matchPattern(pattern, term, bindings) {
+    matchPatternMut(pattern, term, bindings, added) {
         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;
+    }
+    undoBindings(bindings, added) {
+        for (const key of added) {
+            bindings.delete(key);
+        }
     }
     resolvePatternTerm(pattern, bindings) {
         if (pattern.kind === 'variable') {
             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);
+    }
+    internNamed(iri) {
+        const key = `N|${iri}`;
+        let term = this.termCache.get(key);
+        if (!term) {
+            term = namedNode(iri);
+            this.termCache.set(key, term);
+        }
+        return term;
+    }
+    internLiteral(value, datatype, language) {
+        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;
     }
     instantiateRuleAtom(atom, bindings) {
         if (atom.kind === 'class') {
@@ -454,96 +559,90 @@ export class ABoxChainer {
                     && left.datatype.value === right.datatype.value
                     && left.language === right.language));
     }
-    resolveScope(modelUri, readModelUris) {
-        const store = this.reasoningStore.getStore();
+    resolveScope(modelUri, readModelUris, tbox, eagerIndex) {
         const facts = new Map();
+        const index = this.emptyWorkingIndex(facts, tbox, eagerIndex || tbox.transitiveProperties.size > 0);
         const baseKeys = new Set();
         const importEntKeys = new Set();
         const ownEntKeys = new Set();
-        const ownBaseFacts = [];
+        const ownBaseFactsByKey = new Map();
         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;
             }
-            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);
+            const isOwn = uri === modelUri;
+            this.reasoningStore.forEachAssertedFact(uri, (subject, predicate, object, key) => {
+                const 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 = { 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,
         };
     }
-    buildIndex(facts) {
-        const typesBySubject = new Map();
-        const subjectsByType = new Map();
-        const edgeFactsBySubjectProperty = new Map();
-        const edgeFactsByProperty = new Map();
-        const subjectsByPropertyObject = new Map();
-        const termByKey = new Map();
-        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();
-                values.add(fact.object.value);
-                typesBySubject.set(sKey, values);
-                const subjects = subjectsByType.get(fact.object.value) ?? new Set();
-                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();
-            subjects.add(sKey);
-            subjectsByPropertyObject.set(poKey, subjects);
-        }
+    emptyWorkingIndex(facts, tbox, indexed) {
+        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(),
         };
     }
-    insertOwnEntailedFact(scope, index, store, fact) {
+    addResolvedScopeFact(facts, index, key, fact) {
+        if (facts.has(key)) {
+            return;
+        }
+        facts.set(key, fact);
+        if (index.indexed) {
+            this.indexAdd(index, fact);
+        }
+    }
+    ensureWorkingIndex(index) {
+        if (index.indexed) {
+            return;
+        }
+        index.indexed = true;
+        for (const fact of index.facts.values()) {
+            this.indexAdd(index, fact);
+        }
+    }
+    insertOwnEntailedFact(scope, index, fact) {
         const key = this.factKey(fact);
         if (scope.ownEntKeys.has(key)) {
             return;
@@ -551,10 +650,12 @@ 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));
     }
-    removeOwnEntailedFact(scope, index, store, fact) {
+    removeOwnEntailedFact(scope, index, fact) {
         const key = this.factKey(fact);
         if (!scope.ownEntKeys.has(key)) {
             return;
@@ -562,8 +663,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));
     }
     canInsertEntailedFact(scope, fact) {
         const key = this.factKey(fact);
@@ -576,33 +679,18 @@ export class ABoxChainer {
         return index.edgeFactsBySubjectProperty.get(`${subject.id}|${property}`) ?? [];
     }
     getOutgoingEdges(index, subject) {
-        const edges = [];
-        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) ?? [];
     }
     getIncomingEdges(index, object) {
-        const edges = [];
-        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) ?? [];
     }
     getIncomingEdgesByProperty(index, object, property) {
+        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();
         const edges = [];
         for (const subjectKey of subjects) {
@@ -697,6 +785,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);
@@ -704,10 +800,12 @@ export class ABoxChainer {
         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();
-        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();
+            subjects.add(fact.subject.id);
+            index.subjectsByPropertyObject.set(poKey, subjects);
+        }
     }
     indexRemove(index, fact) {
         if (fact.predicate.value === RDF_TYPE.value && fact.object.termType === 'NamedNode') {
@@ -728,9 +826,27 @@ 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);
         }
@@ -738,31 +854,41 @@ export class ABoxChainer {
             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);
+            }
         }
     }
+    removeFactFromArray(facts, target) {
+        return facts.filter((fact) => fact.subject.id !== target.subject.id
+            || fact.predicate.id !== target.predicate.id
+            || fact.object.id !== target.object.id);
+    }
     collectValidationWarnings(_index, _tbox) {
         const warnings = [];
+        if (!_index.indexed) {
+            return this.collectValidationWarningsFromFacts(_index.facts.values(), _tbox);
+        }
         for (const propertyIri of _tbox.functionalProperties) {
             const bySubject = new Map();
-            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();
                 objects.add(fact.object.id);
@@ -776,7 +902,7 @@ export class ABoxChainer {
         }
         for (const propertyIri of _tbox.inverseFunctionalProperties) {
             const byObject = new Map();
-            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();
                 subjects.add(fact.subject.id);
@@ -790,5 +916,56 @@ export class ABoxChainer {
         }
         return warnings;
     }
+    collectValidationWarningsFromFacts(facts, tbox) {
+        const functionalByPropertySubject = new Map();
+        const inverseFunctionalByPropertyObject = new Map();
+        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();
+                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();
+                subjects.add(fact.subject.id);
+                inverseFunctionalByPropertyObject.set(key, subjects);
+            }
+        }
+        const warnings = [];
+        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;
+    }
+    validationFactsForProperty(index, propertyIri) {
+        if (index.indexed) {
+            return index.edgeFactsByProperty.get(propertyIri) ?? [];
+        }
+        const facts = [];
+        for (const fact of index.facts.values()) {
+            if (fact.predicate.value === propertyIri) {
+                facts.push(fact);
+            }
+        }
+        return facts;
+    }
 }
 //# sourceMappingURL=owl-abox.js.map