Cross-Ontology Queries: Techniques & Challenges

• Cross-ontology queries are formal queries that traverse multiple autonomous ontologies to enable integrated data access, inference, and data mining.
• Key methodologies include query rewriting under alignment correspondences, hybrid reasoning approaches, and leveraging large language models for natural query mapping.
• Practical systems demonstrate scalable performance using schema closure, NTGA-based execution, and compatibility metrics in large, heterogeneous data environments.

Cross-ontology queries are formal queries that traverse or integrate multiple ontologies, typically to enable data access, inference, or data mining across autonomous, semantically heterogeneous sources. Mechanisms for cross-ontology querying are essential for semantic data integration, knowledge discovery in domains with orthogonal ontologies (e.g., biomedical sciences), and linked data federation. Such queries must address syntactic, semantic, and inferential heterogeneity, as well as computational and schema-compatibility constraints. Cross-ontology query frameworks encompass formal query rewriting, import-by-query reasoning, data mining with semantic metrics, and schema compatibility assessment.

1. Formal Problem Space and Core Definitions

Cross-ontology querying presupposes the existence of multiple ontologies $O_1,\dots,O_n$, each with its own signature and possibly distinct description logic (DL) expressivity, along with data repositories annotated per ontology, and cross-ontology mappings $M$ (e.g., $\mathtt{owl:sameAs}$, $\mathtt{skos:exactMatch}$, or alignment correspondences). The unified schema $O = \bigcup_i O_i \cup M$ supports graph-structured queries $Q$—typically in SPARQL or conjunctive query (CQ) form—issued against an integrated knowledge base $G$.

A cross-ontology query aims to retrieve the certain answers $\operatorname{ans}(q, T)$, where $q$ is the user CQ and $T$ the raw triples from all sources, but subject to the closure $M$0 under an entailment regime $M$1 (RDFS/OWL rules) (Kim et al., 2016).

Compatibility of a query $M$2 with an existing ontology $M$3 is quantified using semantic similarity metrics and schema-centric compatibility scores, notably coverage and flexibility (Zhao et al., 2021).

2. Query Rewriting and Alignment Approaches

The principal technique for interoperable cross-ontology querying is query rewriting under ontology alignments. Given source and target ontologies $M$4 and $M$5, and an alignment $M$6 composed of equivalence ($M$7) and subsumption ($M$8) correspondences (both simple and complex, i.e., $M$9, $\mathtt{owl:sameAs}$0, $\mathtt{owl:sameAs}$1 for atomic and DL expressions), a rewriting function $\mathtt{owl:sameAs}$2 transforms a source query $\mathtt{owl:sameAs}$3 to a target query $\mathtt{owl:sameAs}$4 over $\mathtt{owl:sameAs}$5 (Ondo et al., 2 May 2025).

Complex alignments are handled via recursive decomposition: if a $\mathtt{owl:sameAs}$6 correspondence specifies that a conjunctive DL formula $\mathtt{owl:sameAs}$7 in $\mathtt{owl:sameAs}$8 is equivalent to $\mathtt{owl:sameAs}$9 in $\mathtt{skos:exactMatch}$0, the rewriting function matches and rewrites graph patterns at the formula level, supporting nested and disjunctive expansions.

Algorithmically, the process scans the triple patterns in $\mathtt{skos:exactMatch}$1, matches components against alignment correspondences, and recursively rewrites or expands subpatterns based on the correspondence type, with worst-case output size $\mathtt{skos:exactMatch}$2 for $\mathtt{skos:exactMatch}$3 input triple patterns and maximum alignment branching $\mathtt{skos:exactMatch}$4 at nesting depth $\mathtt{skos:exactMatch}$5.

Practical systems integrate large-LLMs, such as GPT-4, to map natural-language queries to formal subgraph queries, which are then rewritten cross-ontology via the alignment machinery (Ondo et al., 2 May 2025).

3. Reasoning and Inference over Integrated Ontologies

Reasoning across ontologies with partially hidden or restricted content necessitates specialized frameworks. The import-by-query approach formalizes reasoning with hidden ontologies $\mathtt{skos:exactMatch}$6 accessed only via an oracle interface (concept-satisfiability, ABox-satisfiability, or ABox-entailment) and a querying ontology $\mathtt{skos:exactMatch}$7 (Grau et al., 2014).

Key components:

• Shared signature $\mathtt{skos:exactMatch}$8 specifies the interface vocabulary.
• Necessary restrictions include prohibiting nominals in $\mathtt{skos:exactMatch}$9, ensuring deductive modularity and HT-safety in $O = \bigcup_i O_i \cup M$0, enforcing $O = \bigcup_i O_i \cup M$1-role acyclicity in $O = \bigcup_i O_i \cup M$2, and matching oracle interface capabilities to the logical expressivity required.
• The hypertableau-based import-by-query algorithm preprocesses $O = \bigcup_i O_i \cup M$3, checks restrictions, simulates a tableau with cuts for $O = \bigcup_i O_i \cup M$4, and invokes oracles only when $O = \bigcup_i O_i \cup M$5-components block further expansion.
• Complexity for general DLs is at least N2EXPTIME, but for EL fragments reasoning can be tractable (PTIME).

The approach provides sound, complete cross-ontology reasoning without full exposure of $O = \bigcup_i O_i \cup M$6, situating itself strictly between monolithic import and oblivious reuse. Comparison with module extraction and uniform interpolation highlights trade-offs in confidentiality, completeness, and computational cost.

4. Scalable Execution and Big Data Integration

In large-scale linked data environments (e.g., life sciences), efficient cross-ontology query processing hinges on (a) ontology integration via schema closure, (b) query rewriting (mainly RDFS and limited OWL-RL rules), and (c) execution on distributed frameworks (Kim et al., 2016).

Key processes:

• Schema closure is materialized offline using inheritance, subproperty, and equivalence axioms.
• Rule-based query rewriting transforms user SPARQL patterns into unions of conjunctive queries (UCQ) equivalent to deductive closure semantics.
• Nested TripleGroup Algebra (NTGA) leverages star-shaped pattern grouping and shared join logic to collapse large UCQs into minimal MapReduce jobs.
• Performance evaluations on multi-billion triple datasets (UniProt, Chem2Bio2RDF) show that the NTGA/RAPID+ system achieves 3–9$O = \bigcup_i O_i \cup M$7 better efficiency on complex union queries versus naïve plans, while scaling to hundreds of gigabytes (Kim et al., 2016).

Limitations include current restriction to RDFS and basic OWL-RL, and challenges with incremental ontology evolution and federated execution.

5. Statistical Data Mining and Interestingness in Cross-Ontology Context

Data mining over cross-ontology-annotated corpora seeks to discover and rank relationships (e.g., $O = \bigcup_i O_i \cup M$8, $O = \bigcup_i O_i \cup M$9, $Q$0) statistically supported by joint annotations (Manda et al., 2015). The canonical workflow encompasses:

• Ontology-guided generalization: Propagation of annotation terms to their ancestors via transitive "is-a" closure, filtering out uninformative terms by normalized information content ($Q$1).
• Frequent itemset mining (e.g., Apriori) targeting cross-ontology rules, where left and right sides are from different ontologies.
• Ranking rules by IRIC (Integrated Rule Information Content), a composite metric:

$Q$2

where $Q$3 is normalized cross-ontology mutual information, and $Q$4 are weights (Manda et al., 2015).

• Integration into a query engine: Pre-calculate and index mined rules, delivering query-time recommendations or associations via a RESTful endpoint.

Qualitative evaluation establishes that IRIC combines semantic specificity and statistical association, outperforming traditional support, confidence, lift, and information gain metrics in terms of sensitivity to ontology structure and informative co-occurrence.

6. Schema Compatibility and Ontology Selection

Schema-level assessment of cross-ontology compatibility quantifies how well an ontology $Q$5 can support a query $Q$6 or legacy schemas $Q$7. The method computes:

• Etype similarity at label, property, and instance levels, aggregated with tunable thresholds.
• Coverage $Q$8: the fraction of query classes mapped to $Q$9, weighted by structural centrality (degree).
• Flexibility $G$0: the proportion of $G$1's classes not required to answer $G$2.
• Compatibility score $G$3, providing a numeric criterion for ontology selection (Zhao et al., 2021).

The algorithm is lightweight (operating at the knowledge graph schema level), but is sensitive to parameter tuning and does not capture deep logical or data property constraints.

7. Limitations, Variants, and Extensions

Cross-ontology querying remains limited by the expressivity of rewriting and execution frameworks (RDFS and partial OWL-RL are practical limits for scalable integration), the difficulty of handling complex alignments (especially arbitrary DL expressions), and the tractability of reasoning with hidden content oracles.

Frameworks such as import-by-query are inapplicable when ontologies use nominals or cyclic dependencies in the shared signature, or when concept-only oracles are insufficient due to quantifier interactions. Methods such as module extraction and uniform interpolation trade query completeness for confidentiality but face computational blow-up and limitations on existence.

Future extensions encompass richer structural similarity metrics (e.g., ontology embeddings), cost-based optimization for federated or distributed execution, incremental maintenance, and learning parameter settings for compatibility metrics from empirical use (Grau et al., 2014, Zhao et al., 2021, Ondo et al., 2 May 2025, Kim et al., 2016).