@oml/cli 0.7.0

package/src/commands/closure.ts

@@ -0,0 +1,624 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { Quad } from '@rdfjs/types';
+import { DataFactory } from 'n3';
+import type { Concept, Ontology, RelationEntity, Vocabulary, VocabularyBundle } from '@oml/language';
+import { isConcept, isRelationEntity, isVocabulary, isVocabularyBundle } from '@oml/language';
+
+const RDF_TYPE_IRI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDF_FIRST_IRI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';
+const RDF_REST_IRI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';
+const RDF_NIL_IRI = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';
+const RDFS_SUBCLASS_OF_IRI = 'http://www.w3.org/2000/01/rdf-schema#subClassOf';
+const OWL_CLASS_IRI = 'http://www.w3.org/2002/07/owl#Class';
+const OWL_THING_IRI = 'http://www.w3.org/2002/07/owl#Thing';
+const OWL_NOTHING_IRI = 'http://www.w3.org/2002/07/owl#Nothing';
+const OWL_COMPLEMENT_OF_IRI = 'http://www.w3.org/2002/07/owl#complementOf';
+const OWL_INTERSECTION_OF_IRI = 'http://www.w3.org/2002/07/owl#intersectionOf';
+const OWL_UNION_OF_IRI = 'http://www.w3.org/2002/07/owl#unionOf';
+const OWL_DISJOINT_WITH_IRI = 'http://www.w3.org/2002/07/owl#disjointWith';
+const OWL_ALL_DISJOINT_CLASSES_IRI = 'http://www.w3.org/2002/07/owl#AllDisjointClasses';
+const OWL_MEMBERS_IRI = 'http://www.w3.org/2002/07/owl#members';
+
+const { blankNode, namedNode, quad } = DataFactory;
+
+type ClosureMember = Concept | RelationEntity;
+
+type ClassExpression =
+    | { kind: 'named'; iri: string; key: string }
+    | { kind: 'universal'; key: string }
+    | { kind: 'empty'; key: string }
+    | { kind: 'complement'; operand: ClassExpression; key: string }
+    | { kind: 'intersection'; operands: ClassExpression[]; key: string }
+    | { kind: 'union'; operands: ClassExpression[]; key: string };
+
+interface Edge {
+    parent: string;
+    child: string;
+}
+
+interface TaxonomyNode {
+    expr: ClassExpression;
+    parents: Set<string>;
+    children: Set<string>;
+}
+
+type ClosureAxiom =
+    | { kind: 'subclass'; sub: ClassExpression; sup: ClassExpression }
+    | { kind: 'disjoint'; expressions: ClassExpression[] };
+
+const UNIVERSAL: ClassExpression = { kind: 'universal', key: 'U' };
+const EMPTY: ClassExpression = { kind: 'empty', key: 'E' };
+
+export class VocabularyBundleClosureBuilder {
+    constructor(private readonly ontologyByNamespace: ReadonlyMap<string, Ontology>) {}
+
+    buildClosureQuads(bundle: VocabularyBundle): Quad[] {
+        const vocabularies = this.collectBundledVocabularies(bundle);
+        const members = this.collectClosureMembers(vocabularies);
+        if (members.length < 2) {
+            return [];
+        }
+
+        const memberIris = new Set(members.map((member) => this.memberIri(member)));
+        const vertices = members
+            .map((member) => this.named(this.memberIri(member)))
+            .sort((left, right) => left.key.localeCompare(right.key));
+        const edges = this.transitiveReduce(this.collectNamedEdges(members, memberIris));
+        const rooted = this.rootAtUniversal(this.createTaxonomy(vertices, edges));
+        const tree = this.treeify(rooted);
+        const axioms = this.generateClosureAxioms(tree);
+        return this.serializeAxioms(axioms);
+    }
+
+    private collectBundledVocabularies(bundle: VocabularyBundle): Vocabulary[] {
+        const vocabularies = new Map<string, Vocabulary>();
+        const visitedBundles = new Set<string>();
+        const visitedVocabularies = new Set<string>();
+
+        const visitVocabulary = (vocabulary: Vocabulary): void => {
+            const iri = normalizeNamespace(vocabulary.namespace);
+            if (visitedVocabularies.has(iri)) {
+                return;
+            }
+            visitedVocabularies.add(iri);
+            vocabularies.set(iri, vocabulary);
+            for (const ownedImport of vocabulary.ownedImports ?? []) {
+                if (ownedImport.kind !== 'extends') {
+                    continue;
+                }
+                const imported = ownedImport.imported?.ref;
+                if (imported && isVocabulary(imported)) {
+                    visitVocabulary(imported);
+                }
+            }
+        };
+
+        const visitBundle = (vocabularyBundle: VocabularyBundle): void => {
+            const iri = normalizeNamespace(vocabularyBundle.namespace);
+            if (visitedBundles.has(iri)) {
+                return;
+            }
+            visitedBundles.add(iri);
+            for (const ownedImport of vocabularyBundle.ownedImports ?? []) {
+                const imported = ownedImport.imported?.ref;
+                if (!imported) {
+                    continue;
+                }
+                if (ownedImport.kind === 'includes' && isVocabulary(imported)) {
+                    visitVocabulary(imported);
+                    continue;
+                }
+                if (ownedImport.kind === 'extends' && isVocabularyBundle(imported)) {
+                    visitBundle(imported);
+                    continue;
+                }
+                const importedNamespace = this.importedOntologyNamespace(imported);
+                if (!importedNamespace) {
+                    continue;
+                }
+                const resolved = this.ontologyByNamespace.get(importedNamespace);
+                if (!resolved) {
+                    continue;
+                }
+                if (ownedImport.kind === 'includes' && isVocabulary(resolved)) {
+                    visitVocabulary(resolved);
+                } else if (ownedImport.kind === 'extends' && isVocabularyBundle(resolved)) {
+                    visitBundle(resolved);
+                }
+            }
+        };
+
+        visitBundle(bundle);
+        return [...vocabularies.values()];
+    }
+
+    private collectClosureMembers(vocabularies: ReadonlyArray<Vocabulary>): ClosureMember[] {
+        const members = new Map<string, ClosureMember>();
+        for (const vocabulary of vocabularies) {
+            for (const statement of vocabulary.ownedStatements ?? []) {
+                if (!isConcept(statement) && !isRelationEntity(statement)) {
+                    continue;
+                }
+                members.set(this.memberIri(statement), statement);
+            }
+        }
+        return [...members.values()];
+    }
+
+    private collectNamedEdges(
+        members: ReadonlyArray<ClosureMember>,
+        memberIris: ReadonlySet<string>,
+    ): Edge[] {
+        const edges = new Map<string, Edge>();
+        for (const member of members) {
+            const childIri = this.memberIri(member);
+            for (const specialization of member.ownedSpecializations ?? []) {
+                const superTerm = specialization.superTerm?.ref;
+                if (!superTerm || (!isConcept(superTerm) && !isRelationEntity(superTerm))) {
+                    continue;
+                }
+                const parentIri = this.memberIri(superTerm);
+                if (!memberIris.has(parentIri)) {
+                    continue;
+                }
+                edges.set(`${parentIri}|${childIri}`, { parent: parentIri, child: childIri });
+            }
+        }
+        return [...edges.values()].sort((left, right) =>
+            `${left.parent}|${left.child}`.localeCompare(`${right.parent}|${right.child}`),
+        );
+    }
+
+    private transitiveReduce(edges: ReadonlyArray<Edge>): Edge[] {
+        const vertices = new Set<string>();
+        const childrenByParent = new Map<string, Set<string>>();
+        for (const edge of edges) {
+            vertices.add(edge.parent);
+            vertices.add(edge.child);
+            const children = childrenByParent.get(edge.parent) ?? new Set<string>();
+            children.add(edge.child);
+            childrenByParent.set(edge.parent, children);
+        }
+
+        const hasAlternatePath = (parent: string, child: string): boolean => {
+            const visited = new Set<string>([parent]);
+            const worklist = [...(childrenByParent.get(parent) ?? [])].filter((candidate) => candidate !== child);
+            while (worklist.length > 0) {
+                const next = worklist.pop()!;
+                if (next === child) {
+                    return true;
+                }
+                if (visited.has(next)) {
+                    continue;
+                }
+                visited.add(next);
+                worklist.push(...(childrenByParent.get(next) ?? []));
+            }
+            return false;
+        };
+
+        return edges.filter((edge) => !hasAlternatePath(edge.parent, edge.child));
+    }
+
+    private rootAtUniversal(taxonomy: Map<string, TaxonomyNode>): Map<string, TaxonomyNode> {
+        const rooted = this.cloneTaxonomy(taxonomy);
+        this.ensureNode(rooted, UNIVERSAL);
+        const roots = [...rooted.values()]
+            .filter((node) => node.expr.kind !== 'universal' && node.parents.size === 0)
+            .map((node) => node.expr);
+        for (const root of roots) {
+            this.addEdge(rooted, UNIVERSAL, root);
+        }
+        return rooted;
+    }
+
+    private treeify(taxonomy: Map<string, TaxonomyNode>): Map<string, TaxonomyNode> {
+        const child = this.lowestMultiParentChild(taxonomy);
+        if (!child) {
+            return taxonomy;
+        }
+        return this.treeify(this.reduceChild(this.bypassIsolate(taxonomy, child), child));
+    }
+
+    private bypassIsolate(taxonomy: Map<string, TaxonomyNode>, child: ClassExpression): Map<string, TaxonomyNode> {
+        const next = new Map<string, TaxonomyNode>();
+        const parents = this.parentsOf(taxonomy, child);
+        const parentKeys = new Set(parents.map((parent) => parent.key));
+        const grandparents = new Map<string, ClassExpression>();
+        for (const parent of parents) {
+            for (const grandparent of this.parentsOf(taxonomy, parent)) {
+                grandparents.set(grandparent.key, grandparent);
+            }
+        }
+        const replacements = new Map<string, ClassExpression>();
+        for (const parent of parents) {
+            replacements.set(parent.key, this.difference(parent, child));
+        }
+
+        for (const node of taxonomy.values()) {
+            if (!parentKeys.has(node.expr.key)) {
+                this.ensureNode(next, node.expr);
+            }
+        }
+        for (const replacement of replacements.values()) {
+            this.ensureNode(next, replacement);
+        }
+
+        for (const node of taxonomy.values()) {
+            for (const childKey of node.children) {
+                const source = node.expr;
+                const target = taxonomy.get(childKey)?.expr;
+                if (!target) {
+                    continue;
+                }
+                if (parentKeys.has(source.key)) {
+                    if (target.key !== child.key) {
+                        this.addEdge(next, replacements.get(source.key)!, target);
+                    }
+                    continue;
+                }
+                if (parentKeys.has(target.key)) {
+                    this.addEdge(next, source, replacements.get(target.key)!);
+                    continue;
+                }
+                this.addEdge(next, source, target);
+            }
+        }
+
+        for (const grandparent of grandparents.values()) {
+            this.addEdge(next, grandparent, child);
+        }
+        return next;
+    }
+
+    private reduceChild(taxonomy: Map<string, TaxonomyNode>, child: ClassExpression): Map<string, TaxonomyNode> {
+        const next = new Map<string, TaxonomyNode>();
+        for (const node of taxonomy.values()) {
+            this.ensureNode(next, node.expr);
+        }
+        for (const node of taxonomy.values()) {
+            for (const childKey of node.children) {
+                const target = taxonomy.get(childKey)?.expr;
+                if (!target || target.key === child.key) {
+                    continue;
+                }
+                this.addEdge(next, node.expr, target);
+            }
+        }
+        for (const parent of this.directParentsOf(taxonomy, child)) {
+            this.addEdge(next, parent, child);
+        }
+        return next;
+    }
+
+    private generateClosureAxioms(taxonomy: Map<string, TaxonomyNode>): ClosureAxiom[] {
+        const axioms = new Map<string, ClosureAxiom>();
+        const orderedParents = [...taxonomy.values()]
+            .filter((node) => node.children.size > 0)
+            .map((node) => node.expr)
+            .sort((left, right) => left.key.localeCompare(right.key));
+
+        for (const parent of orderedParents) {
+            const children = this.childrenOf(taxonomy, parent)
+                .sort((left, right) => left.key.localeCompare(right.key));
+            for (const child of children) {
+                axioms.set(
+                    `subclass|${child.key}|${parent.key}`,
+                    { kind: 'subclass', sub: child, sup: parent },
+                );
+            }
+            if (children.length > 1) {
+                axioms.set(
+                    `disjoint|${children.map((child) => child.key).join('|')}`,
+                    { kind: 'disjoint', expressions: children },
+                );
+            }
+        }
+        return [...axioms.values()];
+    }
+
+    private serializeAxioms(axioms: ReadonlyArray<ClosureAxiom>): Quad[] {
+        const quads: Quad[] = [];
+        const expressionNodes = new Map<string, ReturnType<typeof namedNode> | ReturnType<typeof blankNode>>();
+        const listNodes = new Map<string, ReturnType<typeof blankNode> | ReturnType<typeof namedNode>>();
+
+        const termForExpression = (expr: ClassExpression): ReturnType<typeof namedNode> | ReturnType<typeof blankNode> => {
+            const cached = expressionNodes.get(expr.key);
+            if (cached) {
+                return cached;
+            }
+            if (expr.kind === 'named') {
+                const node = namedNode(expr.iri);
+                expressionNodes.set(expr.key, node);
+                return node;
+            }
+            if (expr.kind === 'universal') {
+                const node = namedNode(OWL_THING_IRI);
+                expressionNodes.set(expr.key, node);
+                return node;
+            }
+            if (expr.kind === 'empty') {
+                const node = namedNode(OWL_NOTHING_IRI);
+                expressionNodes.set(expr.key, node);
+                return node;
+            }
+
+            const node = blankNode();
+            expressionNodes.set(expr.key, node);
+            quads.push(quad(node, namedNode(RDF_TYPE_IRI), namedNode(OWL_CLASS_IRI)));
+            if (expr.kind === 'complement') {
+                quads.push(quad(node, namedNode(OWL_COMPLEMENT_OF_IRI), termForExpression(expr.operand)));
+                return node;
+            }
+            const predicate = expr.kind === 'intersection' ? OWL_INTERSECTION_OF_IRI : OWL_UNION_OF_IRI;
+            quads.push(quad(node, namedNode(predicate), listForExpressions(expr.operands)));
+            return node;
+        };
+
+        const listForExpressions = (expressions: ReadonlyArray<ClassExpression>) => {
+            const key = expressions.map((expr) => expr.key).join('|');
+            const cached = listNodes.get(key);
+            if (cached) {
+                return cached;
+            }
+            if (expressions.length === 0) {
+                return namedNode(RDF_NIL_IRI);
+            }
+            const head = blankNode();
+            listNodes.set(key, head);
+            let current = head;
+            expressions.forEach((expr, index) => {
+                quads.push(quad(current, namedNode(RDF_FIRST_IRI), termForExpression(expr)));
+                const isLast = index === expressions.length - 1;
+                const restNode = isLast ? namedNode(RDF_NIL_IRI) : blankNode();
+                quads.push(quad(current, namedNode(RDF_REST_IRI), restNode));
+                if (!isLast && restNode.termType === 'BlankNode') {
+                    current = restNode;
+                }
+            });
+            return head;
+        };
+
+        for (const axiom of axioms) {
+            if (axiom.kind === 'subclass') {
+                quads.push(quad(termForExpression(axiom.sub), namedNode(RDFS_SUBCLASS_OF_IRI), termForExpression(axiom.sup)));
+                continue;
+            }
+            if (axiom.expressions.length === 2) {
+                quads.push(quad(
+                    termForExpression(axiom.expressions[0]),
+                    namedNode(OWL_DISJOINT_WITH_IRI),
+                    termForExpression(axiom.expressions[1]),
+                ));
+                continue;
+            }
+            const node = blankNode();
+            quads.push(quad(node, namedNode(RDF_TYPE_IRI), namedNode(OWL_ALL_DISJOINT_CLASSES_IRI)));
+            quads.push(quad(node, namedNode(OWL_MEMBERS_IRI), listForExpressions(axiom.expressions)));
+        }
+        return quads;
+    }
+
+    private createTaxonomy(vertices: ReadonlyArray<ClassExpression>, edges: ReadonlyArray<Edge>): Map<string, TaxonomyNode> {
+        const taxonomy = new Map<string, TaxonomyNode>();
+        for (const vertex of vertices) {
+            this.ensureNode(taxonomy, vertex);
+        }
+        for (const edge of edges) {
+            this.addEdge(taxonomy, this.named(edge.parent), this.named(edge.child));
+        }
+        return taxonomy;
+    }
+
+    private cloneTaxonomy(taxonomy: Map<string, TaxonomyNode>): Map<string, TaxonomyNode> {
+        const clone = new Map<string, TaxonomyNode>();
+        for (const node of taxonomy.values()) {
+            clone.set(node.expr.key, {
+                expr: node.expr,
+                parents: new Set(node.parents),
+                children: new Set(node.children),
+            });
+        }
+        return clone;
+    }
+
+    private ensureNode(taxonomy: Map<string, TaxonomyNode>, expr: ClassExpression): TaxonomyNode {
+        const existing = taxonomy.get(expr.key);
+        if (existing) {
+            return existing;
+        }
+        const created: TaxonomyNode = {
+            expr,
+            parents: new Set<string>(),
+            children: new Set<string>(),
+        };
+        taxonomy.set(expr.key, created);
+        return created;
+    }
+
+    private addEdge(taxonomy: Map<string, TaxonomyNode>, parent: ClassExpression, child: ClassExpression): void {
+        if (parent.key === child.key) {
+            return;
+        }
+        const parentNode = this.ensureNode(taxonomy, parent);
+        const childNode = this.ensureNode(taxonomy, child);
+        parentNode.children.add(child.key);
+        childNode.parents.add(parent.key);
+    }
+
+    private childrenOf(taxonomy: Map<string, TaxonomyNode>, expr: ClassExpression): ClassExpression[] {
+        const node = taxonomy.get(expr.key);
+        if (!node) {
+            return [];
+        }
+        return [...node.children]
+            .map((key) => taxonomy.get(key)?.expr)
+            .filter((entry): entry is ClassExpression => !!entry);
+    }
+
+    private parentsOf(taxonomy: Map<string, TaxonomyNode>, expr: ClassExpression): ClassExpression[] {
+        const node = taxonomy.get(expr.key);
+        if (!node) {
+            return [];
+        }
+        return [...node.parents]
+            .map((key) => taxonomy.get(key)?.expr)
+            .filter((entry): entry is ClassExpression => !!entry);
+    }
+
+    private ancestorsOf(taxonomy: Map<string, TaxonomyNode>, expr: ClassExpression): Set<string> {
+        const ancestors = new Set<string>();
+        const worklist = this.parentsOf(taxonomy, expr);
+        while (worklist.length > 0) {
+            const next = worklist.pop()!;
+            if (ancestors.has(next.key)) {
+                continue;
+            }
+            ancestors.add(next.key);
+            worklist.push(...this.parentsOf(taxonomy, next));
+        }
+        return ancestors;
+    }
+
+    private directParentsOf(taxonomy: Map<string, TaxonomyNode>, expr: ClassExpression): ClassExpression[] {
+        const parents = this.parentsOf(taxonomy, expr);
+        const ancestorParents = new Set<string>();
+        for (const parent of parents) {
+            for (const ancestor of this.ancestorsOf(taxonomy, parent)) {
+                ancestorParents.add(ancestor);
+            }
+        }
+        return parents.filter((parent) => !ancestorParents.has(parent.key));
+    }
+
+    private lowestMultiParentChild(taxonomy: Map<string, TaxonomyNode>): ClassExpression | undefined {
+        const roots = [...taxonomy.values()]
+            .filter((node) => node.parents.size === 0)
+            .map((node) => node.expr)
+            .sort((left, right) => left.key.localeCompare(right.key));
+        const visited = new Set<string>();
+        const postorder: ClassExpression[] = [];
+        const visit = (expr: ClassExpression): void => {
+            if (visited.has(expr.key)) {
+                return;
+            }
+            visited.add(expr.key);
+            const children = this.childrenOf(taxonomy, expr).sort((left, right) => left.key.localeCompare(right.key));
+            for (const child of children) {
+                visit(child);
+            }
+            postorder.push(expr);
+        };
+        for (const root of roots) {
+            visit(root);
+        }
+        return postorder.find((expr) => this.directParentsOf(taxonomy, expr).length > 1);
+    }
+
+    private named(iri: string): ClassExpression {
+        return { kind: 'named', iri, key: `N:${iri}` };
+    }
+
+    private complement(expr: ClassExpression): ClassExpression {
+        if (expr.kind === 'universal') {
+            return EMPTY;
+        }
+        if (expr.kind === 'empty') {
+            return UNIVERSAL;
+        }
+        if (expr.kind === 'complement') {
+            return expr.operand;
+        }
+        return { kind: 'complement', operand: expr, key: `C:${expr.key}` };
+    }
+
+    private intersection(left: ClassExpression, right: ClassExpression): ClassExpression {
+        return this.combine('intersection', left, right);
+    }
+
+    private difference(left: ClassExpression, right: ClassExpression): ClassExpression {
+        if (left.kind === 'empty' || right.kind === 'universal' || left.key === right.key) {
+            return EMPTY;
+        }
+        if (right.kind === 'empty') {
+            return left;
+        }
+        return this.intersection(left, this.complement(right));
+    }
+
+    private combine(kind: 'intersection' | 'union', left: ClassExpression, right: ClassExpression): ClassExpression {
+        const isIntersection = kind === 'intersection';
+        if (left.key === right.key) {
+            return left;
+        }
+        if (isIntersection && (left.kind === 'empty' || right.kind === 'empty')) {
+            return EMPTY;
+        }
+        if (!isIntersection && (left.kind === 'universal' || right.kind === 'universal')) {
+            return UNIVERSAL;
+        }
+        if (isIntersection && left.kind === 'universal') {
+            return right;
+        }
+        if (isIntersection && right.kind === 'universal') {
+            return left;
+        }
+        if (!isIntersection && left.kind === 'empty') {
+            return right;
+        }
+        if (!isIntersection && right.kind === 'empty') {
+            return left;
+        }
+
+        const operands = new Map<string, ClassExpression>();
+        const addOperand = (expr: ClassExpression): void => {
+            if (expr.kind === kind) {
+                for (const operand of expr.operands) {
+                    operands.set(operand.key, operand);
+                }
+                return;
+            }
+            operands.set(expr.key, expr);
+        };
+        addOperand(left);
+        addOperand(right);
+
+        const sorted = [...operands.values()].sort((a, b) => a.key.localeCompare(b.key));
+        if (sorted.length === 1) {
+            return sorted[0];
+        }
+        if (isIntersection) {
+            const operandKeys = new Set(sorted.map((expr) => expr.key));
+            if (sorted.some((expr) => expr.kind === 'complement' && operandKeys.has(expr.operand.key))) {
+                return EMPTY;
+            }
+            return {
+                kind: 'intersection',
+                operands: sorted,
+                key: `I:${sorted.map((expr) => expr.key).join('&')}`,
+            };
+        }
+        return {
+            kind: 'union',
+            operands: sorted,
+            key: `U:${sorted.map((expr) => expr.key).join('|')}`,
+        };
+    }
+
+    private memberIri(member: ClosureMember): string {
+        const namespace = normalizeNamespace((member.$container as Vocabulary).namespace);
+        return `${namespace}${member.name}`;
+    }
+
+    private importedOntologyNamespace(ontology: Ontology): string | undefined {
+        const namespace = (ontology as { namespace?: string }).namespace;
+        return typeof namespace === 'string' && namespace.length > 0
+            ? normalizeNamespace(namespace)
+            : undefined;
+    }
+}
+
+function normalizeNamespace(value: string): string {
+    return value.replace(/^<|>$/g, '');
+}