Structural Patterns for OWL Ontology Reconciliation

from rdflib import Graph, URIRef, Namespace
from rdflib.namespace import OWL, RDF, RDFS

# Load both ontologies
g1 = Graph()
g1.parse("ontologies/sales.ttl")

g2 = Graph()
g2.parse("ontologies/insurance.ttl")

# Create a reconciliation graph
r = Graph()

SALES = Namespace("http://example.org/sales#")
INS = Namespace("http://example.org/insurance#")

# Assert that Person in sales ontology is equivalent to Customer in insurance ontology
r.add((SALES.Person, OWL.equivalentClass, INS.Customer))
r.add((SALES.Contract, OWL.equivalentClass, INS.Policy))

# Serialize the reconciliation as a separate alignment file
r.serialize("reconciliation/sales-insurance-alignment.ttl", format="ttl")

from rdflib import Graph, URIRef
from rdflib.namespace import RDFS, OWL, RDF

def find_leaf_classes(g):
    """Return all classes that have no subclasses in the given graph."""
    all_classes = set(g.subjects(RDF.type, OWL.Class))
    classes_with_subclasses = set(g.objects(None, RDFS.subClassOf))
    return all_classes - classes_with_subclasses

def get_class_hierarchy(g, cls):
    """Return the ancestor chain for a class, from cls up to the root."""
    ancestors = []
    current = cls
    while True:
        parents = list(g.objects(current, RDFS.subClassOf))
        if not parents:
            break
        current = parents[0]
        ancestors.append(current)
    return ancestors

def find_common_ancestor(g1, g2, cls1, cls2):
    """
    Find labels shared between the ancestor chains of cls1 (in g1)
    and cls2 (in g2), indicating a potential alignment point.
    """
    chain1 = {str(c) for c in get_class_hierarchy(g1, cls1)}
    chain2 = {str(c) for c in get_class_hierarchy(g2, cls2)}
    return chain1 & chain2

from rdflib import Graph, URIRef, Namespace
from rdflib.namespace import RDFS, OWL

MERGED = Namespace("http://example.org/merged#")

r = Graph()
r.bind("merged", MERGED)

# Bridge: InsurancePerson and SalesPerson both subclass the merged LegalEntity
r.add((URIRef("http://example.org/insurance#Person"), RDFS.subClassOf, MERGED.LegalEntity))
r.add((URIRef("http://example.org/sales#Person"), RDFS.subClassOf, MERGED.LegalEntity))
r.add((MERGED.LegalEntity, RDF.type, OWL.Class))

from rdflib import Graph, ConjunctiveGraph
from rdflib.namespace import RDF, RDFS, OWL

def find_property_candidates(g1, g2):
    """
    Find pairs of properties from g1 and g2 that share the same
    (local name) or compatible (domain, range) signatures.
    """
    props1 = set(g1.subjects(RDF.type, OWL.ObjectProperty))
    props2 = set(g2.subjects(RDF.type, OWL.ObjectProperty))

    candidates = []
    for p1 in props1:
        p1_local = p1.split('#')[-1].split('/')[-1].lower()
        for p2 in props2:
            p2_local = p2.split('#')[-1].split('/')[-1].lower()
            # Check for matching local names (case-insensitive)
            if p1_local == p2_local:
                candidates.append((p1, p2, "name_match"))
                continue
            # Check for matching domain and range
            p1_doms = set(g1.objects(p1, RDFS.domain))
            p2_doms = set(g2.objects(p2, RDFS.domain))
            p1_rans = set(g1.objects(p1, RDFS.range))
            p2_rans = set(g2.objects(p2, RDFS.range))
            if p1_doms & p2_doms and p1_rans & p2_rans:
                candidates.append((p1, p2, "domain_range_match"))
    return candidates

from rdflib import Graph, URIRef
from rdflib.namespace import OWL

r = Graph()
r.add((
    URIRef("http://example.org/sales#worksFor"),
    OWL.equivalentProperty,
    URIRef("http://example.org/hr#employedBy")
))

from rdflib import Graph, URIRef, Literal
from rdflib.namespace import OWL, RDFS, RDF

r = Graph()

SALES = "http://example.org/sales#"
HR = "http://example.org/hr#"

# worksFor is a subproperty of the more general employs
r.add((URIRef(SALES + "worksFor"), RDFS.subPropertyOf, URIRef(HR + "hasEmploymentRelation")))

# Document the conflict for future reviewers
r.add((
    URIRef(SALES + "worksFor"),
    RDFS.comment,
    Literal("Narrower than hr:hasEmploymentRelation — applies only to full-time employees")
))

from rdflib import ConjunctiveGraph, Graph

def build_merged_view(onto_paths: list, alignment_path: str) -> Graph:
    """
    Load multiple ontologies and an alignment file into a single merged graph.
    """
    merged = Graph()
    for path in onto_paths:
        g = Graph()
        g.parse(path)
        for triple in g:
            merged.add(triple)

    alignment = Graph()
    alignment.parse(alignment_path)
    for triple in alignment:
        merged.add(triple)

    return merged

# Usage
merged = build_merged_view(
    onto_paths=["ontologies/sales.ttl", "ontologies/insurance.ttl"],
    alignment_path="reconciliation/sales-insurance-alignment.ttl"
)

# The merged graph can now be used for schema extraction
from onto_utils import getSchemaFromOnto
schema = getSchemaFromOnto(merged)