Ontology Reshaping: Methods & Applications

• Ontology reshaping is a comprehensive process that adapts and refines ontological structures using formal operations and user-guided algorithms.
• It enhances data integration and knowledge graph construction by aligning ontologies with evolving standards and industry requirements.
• The methodology incorporates algebraic strategies, automated schema adaptations, and rigorous evaluation to ensure semantic robustness and operational effectiveness.

Ontology reshaping refers to the set of theoretical, algorithmic, and engineering strategies for systematically transforming, adapting, or refining ontologies to meet new data requirements, improve data integration, enable more effective knowledge graph (KG) construction, ensure alignment with evolving standards, or bridge conceptual modeling paradigms. The process encompasses algebraic operations on ontologies, automated schema adaptation, leveraging user feedback, optimizing for industrial analytics, supporting interoperability (e.g., via mapping to foundational ontologies), and employing formal evaluation criteria. Reshaping is essential for ensuring that ontologies remain both semantically robust and operationally effective in rapidly changing and heterogeneous data environments.

1. Formal Operations for Ontology Reshaping

Algebraic operations serve as foundational tools for reshaping ontologies, treating them as logical theories comprised of vocabularies and constraints. Major operations include:

• Projection: Given ontology $O_1 = (V_1, \Sigma_1)$ and $W \subseteq V_1$, projection yields $O_p = (W, \Sigma_p)$, where $\Sigma_p$ contains all (and only) constraints from $\Sigma_1$ over $W$. Formally, $$T[W](O_1) \models (e \sqsubseteq f) \iff O_1 \models (e \sqsubseteq f)$$ for every inclusion $e \sqsubseteq f$ on $W$ (Casanova et al., 2018).
• Deprecation: Removing constraints $Y \subseteq \Sigma_1$ from $O_1$, yielding $(V_1, \Sigma_1 \setminus Y)$. This precisely drops selected axioms while maintaining the vocabulary.
• Union, Intersection, Difference: Union merges vocabularies and constraints $(V_1 \cup V_2, \Sigma_1 \cup \Sigma_2)$; intersection operates over $V_1 \cap V_2$ and preserves only shared semantics; difference approximates the set-theoretic difference in theory closure—often requiring procedural heuristics due to logical closure properties.
• Constraint Minimization: Given a potentially redundant set of constraints, a minimal equivalent set is computed via graph-based transitive reduction and subsequent regeneration of the corresponding logical constraints, as in $\tau[\Sigma_1]=\tau[\Sigma_2]$ after minimization (Casanova et al., 2018).

These operations underpin ontology comparison, modularization, mediation schema design, and efficient transformation procedures.

2. Algorithmic and User-Guided Ontology Reshaping for KG Schemata

Contemporary reshaping in industrial and KG settings addresses the tension between knowledge-oriented (deep, axiomatic) and data-oriented (shallow, pragmatic) schema requirements (Zhou et al., 2022, Zheng et al., 2022).

Workflow and Algorithm (as formalized):

Given domain ontology $O$, relational data $D$ (tables and attributes), mapping $M$ from schema/table to ontology classes, a designated main class $MC$, and user preferences $I_U$, the reshaped KG schema $S$ is obtained by:

• Initializing $S = \{MC\}$.
• For each $T$ in $D$, if $M(T)$ yields a class in $O$, add to $S$.
• For each attribute $A$ in $D$, add classes/properties per $M$ if attribute names contain designated substrings (e.g., "ID", "Name") or per $I_U$.
• Direct and indirect relations among classes in $O$ are selectively added to $S$, prioritized by data correspondence and user feedback.
• Unattached classes are finally connected either via main class or per $I_U$ to guarantee schema connectivity.

The reshaped schema $S$ thus comprises only those classes and properties directly relevant to $D$, facilitating query efficiency, reducing superfluous nodes and depth, and incorporating domain-expert input at key steps (Zhou et al., 2022).

Reshaping algorithms operate in two distinct phases:

1. Subgraph Extraction: Identify all ontology elements corresponding to the data (e.g., mapped tables, attributes).
2. Schema Extension: Add minimal connecting elements for schema coherence; user feedback can dictate fusion or retention of particular subgraphs (Zheng et al., 2022).

3. Ontology Reshaping in Versioning, Evolution, and Alignment

Reshaping ontologies is essential for supporting versioning, evolution, and cross-ontology interoperability.

• Versioning and Evolution: The VersionGraph system integrates evolution and versioning by associating each atomic (or composite) change with a corresponding version step, using structures such as SchemaVersionGraph and InstanceVersionGraph, within a consistent OWL DL framework. The six-step evolution process (change detection, representation, semantic interpretation, implementation, propagation, validation) is mirrored by versioning steps (Pittet et al., 2012).
• Ontology Matching for Versioning (OM4OV pipeline): Ontology versioning is reframed as a matching problem, with entity mappings between successive ontology versions partitioned into ‘remain’, ‘update’, ‘add’, and ‘delete’ categories. Cross-reference mechanisms further leverage prior cross-ontology alignments to optimize version tracking. Formally, mappings are partitioned as:

$$\begin{align*} A_{\odot} &= \{(e_1, e_2, \equiv, c) \mid c = 1 \} \ A_{\otimes} &= \{(e_1, e_2, \equiv, c) \mid s \leq c < 1 \} \ A_{\oplus} &= O' \setminus A_{match} \ A_{\ominus} &= O \setminus A_{match} \end{align*}$$

(Qiang et al., 30 Sep 2024)

• Revision and Repair via Pre-trained LLMs: Reshaping is further enhanced by incorporating semantic ranking of axioms using transformer embeddings (e.g., BERT), allowing for ranking axioms in minimal unsatisfiability-preserving sets (MIPS) and guiding incision functions to select minimal, semantically disjoint axiom sets for deletion during revision (Ji et al., 2023).

4. Structural Engineering and Integration Patterns

In knowledge engineering and semantic data management, reshaping frequently targets explicit structure adaptation to support new platforms, storage backends, or KG frameworks.

• Axiom Patterns for Platform Adaptation: To align traditional ontologies with platforms like Wikibase/Wikidata, axiom patterns (e.g., domain and range restrictions, role chains, reification via hash nodes) are formulated in Description Logic and translated into platform-specific schema (e.g., splitting statements into main value, qualifiers, and references with explicit cardinality and inverse constraints). This systematic re-axiomatization is essential for reconciling paradigm gaps between symmetrical (object-oriented) and primary-value-centric (Wikibase) models (Shimizu et al., 2022).
• ABox Reshaping and Data-Model Integration: At scale, ontologies may be physically ‘reshaped’ so that classes/instances (ABox elements) are mapped to different, high-performance backends based on semantic annotations, data type, or access pattern, allowing for SPARQL queries and SHACL constraints to be executed seamlessly across hybrid stores (Gorshkov et al., 2021).

5. Semantic Alignment and Mapping for Interoperability

Ontology reshaping is a prerequisite for semantic interoperability between overlapping or hierarchical ontologies and for conformance with foundational standards.

• Semantic Mapping and Logical Criteria: To align ontologies (e.g., PROV-O with BFO), the process involves:
  • Explicit mapping via equivalence or subsumption (e.g., $prov:Activity \equiv bfo:process$).
  • Use of SWRL rules and OWL property chains for complex domain/range or property restrictions.
  • Formal criteria: coherence ($$\forall \varphi \in OM,~\exists M~(M \models \varphi)$$), consistency, and conservativity ($dedDiff(O, OM)=\emptyset$), systematically checked using automated reasoners and SPARQL queries for completeness (Prudhomme et al., 2 Aug 2024).
• Quality Assurance via Reuse: Practical ontology reuse highlights both design flaws and improvement opportunities in cross-ontology references, property usage, and entity representation, serving as a real-world, ongoing mechanism for ontology reshaping over time (Sowinski et al., 2022).

6. Algebraic Structure and Homomorphisms in Reshaping

Reshaping can be understood algebraically, especially in the context of large repositories or systems of ontologies (e.g., in geospatial domains):

• Clustering and Quotient Mappings: Structurally similar ontologies are grouped via equivalence relations; the natural surjection $T_p: D \to D/p$, $T_p(d) = [d]_p$, projects sets of ontologies into quotient clusters for simplification.
• Homomorphic Factorization: Any homomorphism between ontology systems factors as a surjection (clustering/quotient) followed by an embedding, preserving structure and operations, including alignment, merging, and natural partial orders.
• Closure Properties: Merging systems, partial orders, and closure operators commute with quotient formation, ensuring that transformed ontology systems maintain essential algebraic properties (Guo et al., 2023).

7. Evaluation, Guidelines, and Principles for Reshaping

Effective reshaping requires rigorous evaluation, quality assurance, and adherence to established principles:

• Evaluation Criteria: Gruber’s criteria (clarity, coherence, extendibility, minimal encoding bias, minimal ontological commitment), metric-based analyses (e.g., schema richness, class cohesion), and qualitative methods (e.g., OntoClean) (Slimani, 2015).
• Design Principles: Clarity, coherence, monotonic extendibility, modularity, and minimal commitment guide both manual and automated reshaping, ensuring the resulting ontologies are robust, extensible, and interoperable (Slimani, 2015).
• Quality Assurance Workflow: Automated and human-in-the-loop approaches—utilizing SPARQL, NLP, network analysis, and cross-ontology testing—are central to identifying and rectifying mismatches, redundancies, and misalignments (Sowinski et al., 2022).

---

Ontology reshaping is thus a multifaceted process, with strong foundations in both logical formalism and engineering pragmatics. By integrating algebraic operations, user-guided adaptation algorithms, semantic mapping, data-oriented optimization, and rigorous evaluation frameworks, practitioners ensure that ontologies remain adaptable, semantically precise, and operationally effective across diverse and evolving contexts.