@oml/owl 0.7.0

package/src/owl/owl-tbox.ts

@@ -0,0 +1,727 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { DataFactory } from 'n3';
+import type { NamedNode, Quad, Store, Term } from 'n3';
+import type { Ontology, Rule, Argument, Literal, Predicate, RelationEntity } from '@oml/language';
+import type { OwlImportGraph, OwlStore, OwlTBoxIndexCache } from './owl-interfaces.js';
+import {
+    isBooleanLiteral,
+    isBuiltInPredicate,
+    isDecimalLiteral,
+    isDescription,
+    isDifferentFromPredicate,
+    isDoubleLiteral,
+    isIntegerLiteral,
+    isPropertyPredicate,
+    isQuotedLiteral,
+    isRelationEntity,
+    isRelationEntityPredicate,
+    isRule,
+    isSameAsPredicate,
+    isTypePredicate,
+    isVocabulary,
+} from '@oml/language';
+
+const { namedNode, quad } = DataFactory;
+
+const RDF = {
+    type: namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+};
+
+const RDFS = {
+    subClassOf: namedNode('http://www.w3.org/2000/01/rdf-schema#subClassOf'),
+    subPropertyOf: namedNode('http://www.w3.org/2000/01/rdf-schema#subPropertyOf'),
+    Literal: namedNode('http://www.w3.org/2000/01/rdf-schema#Literal'),
+};
+
+const OWL = {
+    equivalentClass: namedNode('http://www.w3.org/2002/07/owl#equivalentClass'),
+    equivalentProperty: namedNode('http://www.w3.org/2002/07/owl#equivalentProperty'),
+    sameAs: namedNode('http://www.w3.org/2002/07/owl#sameAs'),
+    differentFrom: namedNode('http://www.w3.org/2002/07/owl#differentFrom'),
+    inverseOf: namedNode('http://www.w3.org/2002/07/owl#inverseOf'),
+    FunctionalProperty: namedNode('http://www.w3.org/2002/07/owl#FunctionalProperty'),
+    InverseFunctionalProperty: namedNode('http://www.w3.org/2002/07/owl#InverseFunctionalProperty'),
+    SymmetricProperty: namedNode('http://www.w3.org/2002/07/owl#SymmetricProperty'),
+    TransitiveProperty: namedNode('http://www.w3.org/2002/07/owl#TransitiveProperty'),
+    subPropertyOf: namedNode('http://www.w3.org/2002/07/owl#subPropertyOf'),
+};
+
+const OML = {
+    hasSource: namedNode('http://opencaesar.io/oml#hasSource'),
+    hasTarget: namedNode('http://opencaesar.io/oml#hasTarget'),
+};
+
+export interface TBoxIndex {
+    superClasses: Map<string, string[]>;
+    subProperties: Map<string, string[]>;
+    domain: Map<string, string[]>;
+    objectRange: Map<string, string[]>;
+    datatypeRange: Map<string, string[]>;
+    inverseRoles: Map<string, string[]>;
+    forwardRules: ForwardRuleDefinition[];
+    symmetricProperties: Set<string>;
+    transitiveProperties: Set<string>;
+    functionalProperties: Set<string>;
+    inverseFunctionalProperties: Set<string>;
+}
+
+export interface ForwardRuleDefinition {
+    iri: string;
+    body: RuleAtom[];
+    head: RuleAtom[];
+}
+
+export type RuleAtom =
+    | { kind: 'class'; classIri: string; argument: RuleTermPattern }
+    | { kind: 'property'; propertyIri: string; argument1: RuleTermPattern; argument2: RuleTermPattern };
+
+export type RuleTermPattern =
+    | { kind: 'variable'; name: string }
+    | { kind: 'named'; iri: string }
+    | { kind: 'literal'; value: string; datatype: string; language: string };
+
+export class TBoxIndexBuilder {
+    constructor(
+        private readonly reasoningStore: OwlStore,
+        private readonly tboxIndexCache: OwlTBoxIndexCache,
+        private readonly importGraph: OwlImportGraph,
+    ) {}
+
+    buildOwn(modelUri: string, ontology?: Ontology): TBoxIndex {
+        const graphs = this.reasoningStore.graphs(modelUri);
+        const store = this.reasoningStore.getStore();
+        const quads = this.allQuads(store, graphs, null, null, null);
+        const index = this.emptyIndex();
+
+        for (const q of quads) {
+            if (q.subject.termType !== 'NamedNode') {
+                continue;
+            }
+
+            if (q.predicate.value === RDF.type.value && q.object.termType === 'NamedNode') {
+                if (q.object.value === OWL.FunctionalProperty.value) {
+                    index.functionalProperties.add(q.subject.value);
+                } else if (q.object.value === OWL.InverseFunctionalProperty.value) {
+                    index.inverseFunctionalProperties.add(q.subject.value);
+                } else if (q.object.value === OWL.SymmetricProperty.value) {
+                    index.symmetricProperties.add(q.subject.value);
+                } else if (q.object.value === OWL.TransitiveProperty.value) {
+                    index.transitiveProperties.add(q.subject.value);
+                }
+                continue;
+            }
+
+            if (q.object.termType !== 'NamedNode') {
+                continue;
+            }
+
+            if (q.predicate.value === RDFS.subClassOf.value) {
+                this.pushMapArrayUnique(index.superClasses, q.subject.value, q.object.value);
+                continue;
+            }
+            if (q.predicate.value === OWL.equivalentClass.value) {
+                this.pushMapArrayUnique(index.superClasses, q.subject.value, q.object.value);
+                this.pushMapArrayUnique(index.superClasses, q.object.value, q.subject.value);
+                continue;
+            }
+            if (q.predicate.value === RDFS.subPropertyOf.value || q.predicate.value === OWL.subPropertyOf.value) {
+                this.pushMapArrayUnique(index.subProperties, q.subject.value, q.object.value);
+                continue;
+            }
+            if (q.predicate.value === OWL.equivalentProperty.value) {
+                this.pushMapArrayUnique(index.subProperties, q.subject.value, q.object.value);
+                this.pushMapArrayUnique(index.subProperties, q.object.value, q.subject.value);
+                continue;
+            }
+            if (q.predicate.value === 'http://www.w3.org/2000/01/rdf-schema#domain') {
+                this.pushMapArrayUnique(index.domain, q.subject.value, q.object.value);
+                continue;
+            }
+            if (q.predicate.value === 'http://www.w3.org/2000/01/rdf-schema#range') {
+                if (this.isDatatypeIri(q.object.value)) {
+                    this.pushMapArrayUnique(index.datatypeRange, q.subject.value, q.object.value);
+                } else {
+                    this.pushMapArrayUnique(index.objectRange, q.subject.value, q.object.value);
+                }
+                continue;
+            }
+            if (q.predicate.value === OWL.inverseOf.value) {
+                this.pushMapArrayUnique(index.inverseRoles, q.subject.value, q.object.value);
+                this.pushMapArrayUnique(index.inverseRoles, q.object.value, q.subject.value);
+            }
+        }
+
+        if (ontology && isVocabulary(ontology)) {
+            index.forwardRules.push(...this.buildForwardRules(ontology));
+        }
+
+        this.closeSuperClassesTransitively(index.superClasses);
+        this.closeSubPropertiesTransitively(index.subProperties);
+        return index;
+    }
+
+    buildMerged(modelUri: string): TBoxIndex {
+        const closure = this.importGraph.dependenciesOf(modelUri);
+        const allUris = [modelUri, ...closure];
+        const visited = new Set<string>();
+        const merged = this.emptyIndex();
+
+        for (const uri of allUris) {
+            if (visited.has(uri)) {
+                continue;
+            }
+            visited.add(uri);
+
+            const own = this.tboxIndexCache.getOwn(uri);
+            if (!own) {
+                continue;
+            }
+
+            this.mergeStringArrayMap(merged.superClasses, own.superClasses);
+            this.mergeStringArrayMap(merged.subProperties, own.subProperties);
+            this.mergeStringArrayMap(merged.domain, own.domain);
+            this.mergeStringArrayMap(merged.objectRange, own.objectRange);
+            this.mergeStringArrayMap(merged.datatypeRange, own.datatypeRange);
+            this.mergeStringArrayMap(merged.inverseRoles, own.inverseRoles);
+            this.mergeForwardRules(merged.forwardRules, own.forwardRules);
+            this.mergeSet(merged.symmetricProperties, own.symmetricProperties);
+            this.mergeSet(merged.transitiveProperties, own.transitiveProperties);
+            this.mergeSet(merged.functionalProperties, own.functionalProperties);
+            this.mergeSet(merged.inverseFunctionalProperties, own.inverseFunctionalProperties);
+        }
+
+        this.closeSuperClassesTransitively(merged.superClasses);
+        this.closeSubPropertiesTransitively(merged.subProperties);
+        return merged;
+    }
+
+    private allQuads(store: Store, graphs: { own: NamedNode; entailments: NamedNode }, s: Term | null, p: Term | null, o: Term | null): Quad[] {
+        return [
+            ...store.getQuads(s, p, o, graphs.own),
+            ...store.getQuads(s, p, o, graphs.entailments),
+        ];
+    }
+
+    private pushMapArrayUnique(map: Map<string, string[]>, key: string, value: string): void {
+        const values = map.get(key) ?? [];
+        if (!values.includes(value)) {
+            values.push(value);
+            map.set(key, values);
+        }
+    }
+
+    private emptyIndex(): TBoxIndex {
+        return {
+            superClasses: new Map<string, string[]>(),
+            subProperties: new Map<string, string[]>(),
+            domain: new Map<string, string[]>(),
+            objectRange: new Map<string, string[]>(),
+            datatypeRange: new Map<string, string[]>(),
+            inverseRoles: new Map<string, string[]>(),
+            forwardRules: [],
+            symmetricProperties: new Set<string>(),
+            transitiveProperties: new Set<string>(),
+            functionalProperties: new Set<string>(),
+            inverseFunctionalProperties: new Set<string>(),
+        };
+    }
+
+    private mergeStringArrayMap(target: Map<string, string[]>, source: Map<string, string[]>): void {
+        for (const [key, values] of source.entries()) {
+            const existing = target.get(key) ?? [];
+            for (const value of values) {
+                if (!existing.includes(value)) {
+                    existing.push(value);
+                }
+            }
+            target.set(key, existing);
+        }
+    }
+
+    private mergeSet(target: Set<string>, source: Set<string>): void {
+        for (const value of source) {
+            target.add(value);
+        }
+    }
+
+    private mergeForwardRules(target: ForwardRuleDefinition[], source: ForwardRuleDefinition[]): void {
+        const merged = new Map<string, ForwardRuleDefinition>();
+        for (const rule of target) {
+            merged.set(rule.iri, rule);
+        }
+        for (const rule of source) {
+            merged.set(rule.iri, rule);
+        }
+        target.length = 0;
+        target.push(...merged.values());
+    }
+
+    private buildForwardRules(ontology: Ontology & { ownedStatements?: unknown[] }): ForwardRuleDefinition[] {
+        const rules: ForwardRuleDefinition[] = [];
+        for (const statement of ontology.ownedStatements ?? []) {
+            if (isRule(statement) && !statement.ref) {
+                const lowered = this.lowerOmlRule(statement, ontology);
+                if (lowered) {
+                    rules.push(lowered);
+                }
+                continue;
+            }
+            if (isRelationEntity(statement)) {
+                const lowered = this.lowerRelationEntityRule(statement, ontology);
+                if (lowered) {
+                    rules.push(lowered);
+                }
+            }
+        }
+        return rules;
+    }
+
+    private lowerRelationEntityRule(relation: RelationEntity, ontology: Ontology): ForwardRuleDefinition | undefined {
+        const relationEntityIri = this.memberIri(relation, ontology);
+        const forwardName = relation.forwardRelation?.name;
+        const namespace = this.normalizeNamespace((ontology as any).namespace ?? '');
+        if (!relationEntityIri || !namespace || !forwardName) {
+            return undefined;
+        }
+        const forwardIri = `${namespace}${forwardName}`;
+        return {
+            iri: `${forwardIri}__derivation`,
+            body: [
+                { kind: 'class', classIri: relationEntityIri, argument: { kind: 'variable', name: 'r' } },
+                { kind: 'property', propertyIri: OML.hasSource.value, argument1: { kind: 'variable', name: 'r' }, argument2: { kind: 'variable', name: 's' } },
+                { kind: 'property', propertyIri: OML.hasTarget.value, argument1: { kind: 'variable', name: 'r' }, argument2: { kind: 'variable', name: 't' } },
+            ],
+            head: [
+                { kind: 'property', propertyIri: forwardIri, argument1: { kind: 'variable', name: 's' }, argument2: { kind: 'variable', name: 't' } },
+            ],
+        };
+    }
+
+    private lowerOmlRule(rule: Rule, ontology: Ontology): ForwardRuleDefinition | undefined {
+        const iri = this.memberIri(rule, ontology);
+        if (!iri) {
+            return undefined;
+        }
+        const body = this.lowerPredicates(rule.antecedent, ontology);
+        const head = this.lowerPredicates(rule.consequent, ontology);
+        if (!body || !head) {
+            return undefined;
+        }
+        return { iri, body, head };
+    }
+
+    private lowerPredicates(predicates: Predicate[], ontology: Ontology): RuleAtom[] | undefined {
+        const atoms: RuleAtom[] = [];
+        for (const predicate of predicates) {
+            if (isBuiltInPredicate(predicate)) {
+                return undefined;
+            }
+            if (isTypePredicate(predicate)) {
+                const classIri = this.resolveRefIri(predicate.type, ontology);
+                const argument = this.lowerArgument(predicate.argument, ontology);
+                if (!classIri || !argument) {
+                    return undefined;
+                }
+                atoms.push({ kind: 'class', classIri, argument });
+                continue;
+            }
+            if (isRelationEntityPredicate(predicate)) {
+                const relationEntityIri = this.resolveRefIri(predicate.type, ontology);
+                const relationArg = this.lowerArgument(predicate.argument, ontology);
+                const sourceArg = this.lowerArgument(predicate.argument1, ontology);
+                const targetArg = this.lowerArgument(predicate.argument2, ontology);
+                if (!relationEntityIri || !relationArg || !sourceArg || !targetArg) {
+                    return undefined;
+                }
+                atoms.push({ kind: 'class', classIri: relationEntityIri, argument: relationArg });
+                atoms.push({ kind: 'property', propertyIri: OML.hasSource.value, argument1: relationArg, argument2: sourceArg });
+                atoms.push({ kind: 'property', propertyIri: OML.hasTarget.value, argument1: relationArg, argument2: targetArg });
+                continue;
+            }
+            if (isPropertyPredicate(predicate)) {
+                const propertyIri = this.resolveRefIri(predicate.property, ontology);
+                const argument1 = this.lowerArgument(predicate.argument1, ontology);
+                const argument2 = this.lowerArgument(predicate.argument2, ontology);
+                if (!propertyIri || !argument1 || !argument2) {
+                    return undefined;
+                }
+                atoms.push({ kind: 'property', propertyIri, argument1, argument2 });
+                continue;
+            }
+            if (isSameAsPredicate(predicate) || isDifferentFromPredicate(predicate)) {
+                const argument1 = this.lowerArgument(predicate.argument1, ontology);
+                const argument2 = this.lowerArgument(predicate.argument2, ontology);
+                if (!argument1 || !argument2) {
+                    return undefined;
+                }
+                atoms.push({
+                    kind: 'property',
+                    propertyIri: isSameAsPredicate(predicate) ? OWL.sameAs.value : OWL.differentFrom.value,
+                    argument1,
+                    argument2,
+                });
+                continue;
+            }
+            return undefined;
+        }
+        return atoms;
+    }
+
+    private lowerArgument(argument: Argument, ontology: Ontology): RuleTermPattern | undefined {
+        if (argument.variable) {
+            return { kind: 'variable', name: argument.variable };
+        }
+        if (argument.instance) {
+            const iri = this.resolveRefIri(argument.instance, ontology);
+            return iri ? { kind: 'named', iri } : undefined;
+        }
+        if (argument.literal) {
+            return this.lowerLiteral(argument.literal, ontology);
+        }
+        return undefined;
+    }
+
+    private lowerLiteral(literalValue: Literal, ontology: Ontology): RuleTermPattern | undefined {
+        if (isBooleanLiteral(literalValue)) {
+            return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#boolean', language: '' };
+        }
+        if (isIntegerLiteral(literalValue)) {
+            return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#integer', language: '' };
+        }
+        if (isDecimalLiteral(literalValue)) {
+            return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#decimal', language: '' };
+        }
+        if (isDoubleLiteral(literalValue)) {
+            return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#double', language: '' };
+        }
+        if (isQuotedLiteral(literalValue)) {
+            if (literalValue.type) {
+                const datatype = this.resolveRefIri(literalValue.type, ontology);
+                return datatype ? { kind: 'literal', value: literalValue.value, datatype, language: '' } : undefined;
+            }
+            return {
+                kind: 'literal',
+                value: literalValue.value,
+                datatype: literalValue.langTag ? 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString' : 'http://www.w3.org/2001/XMLSchema#string',
+                language: literalValue.langTag ?? '',
+            };
+        }
+        return undefined;
+    }
+
+    private resolveRefIri(ref: { ref?: unknown; name?: string }, ontology: Ontology): string | undefined {
+        const target = (ref as any)?.ref ?? ref;
+        if (!target) {
+            return undefined;
+        }
+        return this.memberIri(target as { name?: string; $container?: unknown }, ontology);
+    }
+
+    private memberIri(member: { name?: string; $container?: unknown }, fallbackOntology: Ontology): string | undefined {
+        const name = member?.name;
+        if (!name) {
+            return undefined;
+        }
+        const ontology = this.ontologyOf(member) ?? fallbackOntology;
+        const namespace = this.normalizeNamespace((ontology as any).namespace ?? '');
+        return namespace ? `${namespace}${name.replace(/^\^/, '')}` : undefined;
+    }
+
+    private ontologyOf(node: { $container?: unknown }): Ontology | undefined {
+        let current: any = node;
+        while (current && !isVocabulary(current) && !isDescription(current)) {
+            current = current.$container;
+        }
+        return current as Ontology | undefined;
+    }
+
+    private normalizeNamespace(value: string): string {
+        return value.replace(/^<|>$/g, '');
+    }
+
+    private closeSuperClassesTransitively(superClasses: Map<string, string[]>): void {
+        for (const [clazz, directSupers] of superClasses.entries()) {
+            const visited = new Set<string>();
+            const worklist = [...directSupers];
+            const closure: string[] = [];
+
+            while (worklist.length > 0) {
+                const next = worklist.shift();
+                if (!next || visited.has(next)) {
+                    continue;
+                }
+                visited.add(next);
+                closure.push(next);
+                worklist.push(...(superClasses.get(next) ?? []));
+            }
+
+            superClasses.set(clazz, closure);
+        }
+    }
+
+    private closeSubPropertiesTransitively(subProperties: Map<string, string[]>): void {
+        for (const [property, directSupers] of subProperties.entries()) {
+            const visited = new Set<string>();
+            const worklist = [...directSupers];
+            const closure: string[] = [property];
+
+            while (worklist.length > 0) {
+                const next = worklist.shift();
+                if (!next || visited.has(next)) {
+                    continue;
+                }
+                visited.add(next);
+                closure.push(next);
+                worklist.push(...(subProperties.get(next) ?? []));
+            }
+
+            subProperties.set(property, [...new Set(closure)].sort());
+        }
+    }
+
+    private isDatatypeIri(iri: string): boolean {
+        return iri.startsWith('http://www.w3.org/2001/XMLSchema#') || iri === RDFS.Literal.value;
+    }
+}
+
+export class TBoxIndexCache {
+    private readonly ownIndexes = new Map<string, TBoxIndex>();
+    private readonly mergedIndexes = new Map<string, TBoxIndex>();
+    private readonly dirtyMerged = new Set<string>();
+
+    getOwn(modelUri: string): TBoxIndex | undefined {
+        return this.ownIndexes.get(modelUri);
+    }
+
+    setOwn(modelUri: string, index: TBoxIndex): void {
+        this.ownIndexes.set(modelUri, index);
+    }
+
+    hasOwn(modelUri: string): boolean {
+        return this.ownIndexes.has(modelUri);
+    }
+
+    invalidateOwn(modelUri: string): void {
+        this.ownIndexes.delete(modelUri);
+    }
+
+    getMerged(modelUri: string): TBoxIndex | undefined {
+        return this.mergedIndexes.get(modelUri);
+    }
+
+    setMerged(modelUri: string, index: TBoxIndex): void {
+        this.mergedIndexes.set(modelUri, index);
+        this.dirtyMerged.delete(modelUri);
+    }
+
+    hasMerged(modelUri: string): boolean {
+        return this.mergedIndexes.has(modelUri);
+    }
+
+    isMergedDirty(modelUri: string): boolean {
+        return this.dirtyMerged.has(modelUri);
+    }
+
+    invalidateMerged(modelUri: string): void {
+        this.dirtyMerged.add(modelUri);
+    }
+
+    invalidateMergedAll(modelUris: string[]): void {
+        for (const modelUri of modelUris) {
+            this.invalidateMerged(modelUri);
+        }
+    }
+}
+
+export class TBoxChainer {
+    private static readonly MAX_CHAIN_ITERATIONS = 1000;
+
+    constructor(private readonly reasoningStore: OwlStore) {}
+
+    chain(modelUri: string): void {
+        const graphs = this.reasoningStore.graphs(modelUri);
+        const store = this.reasoningStore.getStore();
+        this.reasoningStore.clearEntailments(modelUri);
+
+        let iterations = 0;
+        while (true) {
+            iterations += 1;
+            if (iterations > TBoxChainer.MAX_CHAIN_ITERATIONS) {
+                throw new Error(
+                    `TBox chaining did not converge for '${modelUri}' `
+                    + `after ${TBoxChainer.MAX_CHAIN_ITERATIONS} iterations.`,
+                );
+            }
+
+            const pending: Quad[] = [];
+            const pendingKeys = new Set<string>();
+            const iteration = this.collectIterationData(store, graphs);
+
+            this.fireT1(store, graphs, iteration, pending, pendingKeys);
+            this.fireT2(store, graphs, iteration, pending, pendingKeys);
+            this.fireT3(store, graphs, iteration, pending, pendingKeys);
+            this.fireT4(store, graphs, iteration, pending, pendingKeys);
+            this.fireT5(store, graphs, iteration, pending, pendingKeys);
+
+            if (pending.length === 0) {
+                break;
+            }
+            store.addQuads(pending);
+        }
+    }
+
+    private fireT1(
+        store: Store,
+        graphs: { own: NamedNode; entailments: NamedNode },
+        iteration: TBoxIterationData,
+        pending: Quad[],
+        pendingKeys: Set<string>,
+    ): void {
+        for (const edge of iteration.subClassEdges) {
+            for (const parent of iteration.subClassBySub.get(edge.object.value) ?? []) {
+                this.pushIfNew(store, quad(edge.subject, RDFS.subClassOf, parent, graphs.entailments), pending, pendingKeys);
+            }
+        }
+    }
+
+    private fireT2(
+        store: Store,
+        graphs: { own: NamedNode; entailments: NamedNode },
+        iteration: TBoxIterationData,
+        pending: Quad[],
+        pendingKeys: Set<string>,
+    ): void {
+        for (const edge of iteration.subPropertyEdges) {
+            for (const parent of iteration.subPropertyBySub.get(edge.object.value) ?? []) {
+                this.pushIfNew(store, quad(edge.subject, RDFS.subPropertyOf, parent, graphs.entailments), pending, pendingKeys);
+            }
+        }
+    }
+
+    private fireT3(
+        store: Store,
+        graphs: { own: NamedNode; entailments: NamedNode },
+        iteration: TBoxIterationData,
+        pending: Quad[],
+        pendingKeys: Set<string>,
+    ): void {
+        for (const [left, right] of iteration.equivalentClasses) {
+            this.pushIfNew(store, quad(namedNode(left), RDFS.subClassOf, namedNode(right), graphs.entailments), pending, pendingKeys);
+            this.pushIfNew(store, quad(namedNode(right), RDFS.subClassOf, namedNode(left), graphs.entailments), pending, pendingKeys);
+        }
+    }
+
+    private fireT4(
+        store: Store,
+        graphs: { own: NamedNode; entailments: NamedNode },
+        iteration: TBoxIterationData,
+        pending: Quad[],
+        pendingKeys: Set<string>,
+    ): void {
+        for (const [left, right] of iteration.equivalentProperties) {
+            this.pushIfNew(store, quad(namedNode(left), RDFS.subPropertyOf, namedNode(right), graphs.entailments), pending, pendingKeys);
+            this.pushIfNew(store, quad(namedNode(right), RDFS.subPropertyOf, namedNode(left), graphs.entailments), pending, pendingKeys);
+        }
+    }
+
+    private fireT5(
+        store: Store,
+        graphs: { own: NamedNode; entailments: NamedNode },
+        iteration: TBoxIterationData,
+        pending: Quad[],
+        pendingKeys: Set<string>,
+    ): void {
+        for (const [role, inverseRoles] of iteration.inverseByRole.entries()) {
+            for (const inverseRole of inverseRoles) {
+                this.pushIfNew(store, quad(inverseRole, OWL.inverseOf, namedNode(role), graphs.entailments), pending, pendingKeys);
+            }
+        }
+    }
+
+    private collectIterationData(store: Store, graphs: { own: NamedNode; entailments: NamedNode }): TBoxIterationData {
+        const quads = [
+            ...store.getQuads(null, null, null, graphs.own),
+            ...store.getQuads(null, null, null, graphs.entailments),
+        ];
+
+        const subClassEdges: Array<{ subject: NamedNode; object: NamedNode }> = [];
+        const subClassBySub = new Map<string, NamedNode[]>();
+        const subPropertyEdges: Array<{ subject: NamedNode; object: NamedNode }> = [];
+        const subPropertyBySub = new Map<string, NamedNode[]>();
+        const equivalentClasses: Array<[string, string]> = [];
+        const equivalentProperties: Array<[string, string]> = [];
+        const inverseByRole = new Map<string, NamedNode[]>();
+
+        for (const q of quads) {
+            if (q.subject.termType !== 'NamedNode' || q.object.termType !== 'NamedNode') {
+                continue;
+            }
+            if (q.predicate.value === RDFS.subClassOf.value) {
+                subClassEdges.push({ subject: q.subject, object: q.object });
+                const parents = subClassBySub.get(q.subject.value) ?? [];
+                parents.push(q.object);
+                subClassBySub.set(q.subject.value, parents);
+                continue;
+            }
+            if (q.predicate.value === RDFS.subPropertyOf.value || q.predicate.value === OWL.subPropertyOf.value) {
+                subPropertyEdges.push({ subject: q.subject, object: q.object });
+                const parents = subPropertyBySub.get(q.subject.value) ?? [];
+                parents.push(q.object);
+                subPropertyBySub.set(q.subject.value, parents);
+                continue;
+            }
+            if (q.predicate.value === OWL.equivalentClass.value) {
+                equivalentClasses.push([q.subject.value, q.object.value]);
+                continue;
+            }
+            if (q.predicate.value === OWL.equivalentProperty.value) {
+                equivalentProperties.push([q.subject.value, q.object.value]);
+                continue;
+            }
+            if (q.predicate.value === OWL.inverseOf.value) {
+                const entries = inverseByRole.get(q.subject.value) ?? [];
+                if (!entries.some((entry) => entry.value === q.object.value)) {
+                    entries.push(q.object);
+                }
+                inverseByRole.set(q.subject.value, entries);
+            }
+        }
+
+        return {
+            subClassEdges,
+            subClassBySub,
+            subPropertyEdges,
+            subPropertyBySub,
+            equivalentClasses,
+            equivalentProperties,
+            inverseByRole,
+        };
+    }
+
+    private pushIfNew(store: Store, inferred: Quad, pending: Quad[], pendingKeys: Set<string>): void {
+        if (store.has(inferred)) {
+            return;
+        }
+        const key = this.quadKey(inferred);
+        if (pendingKeys.has(key)) {
+            return;
+        }
+        pending.push(inferred);
+        pendingKeys.add(key);
+    }
+
+    private quadKey(q: Quad): string {
+        return `${q.subject.id}|${q.predicate.id}|${q.object.id}|${q.graph.id}`;
+    }
+}
+
+interface TBoxIterationData {
+    subClassEdges: Array<{ subject: NamedNode; object: NamedNode }>;
+    subClassBySub: Map<string, NamedNode[]>;
+    subPropertyEdges: Array<{ subject: NamedNode; object: NamedNode }>;
+    subPropertyBySub: Map<string, NamedNode[]>;
+    equivalentClasses: Array<[string, string]>;
+    equivalentProperties: Array<[string, string]>;
+    inverseByRole: Map<string, NamedNode[]>;
+}