Modular Ontology Modeling (MOMo)

• Modular Ontology Modeling is a methodology that decomposes complex ontologies into small, self-contained modules to enable efficient, incremental schema construction.
• Its workflow uses template-based instantiation and programmatically queryable libraries to facilitate scalable, precise ontology assembly with fine-grained annotation.
• MOMo leverages large language models for automated pattern extraction, significantly accelerating domain-specific ontology development and integration.

Modular Ontology Modeling (MOMo) is a principled methodology designed to accelerate ontology engineering by decomposing complex schemas into small, reusable, and programmatically queryable fragments called modules or ontology design patterns. Rooted in analogical and transfer learning paradigms, MOMo enables both human and automated agents to efficiently assemble domain ontologies, maintain alignment with conceptual boundaries, and accommodate evolving requirements through modular extensions or replacements. The approach has been instantiated in domains ranging from metadata schemas to large geospatial knowledge graphs and has been adapted to leverage LLMs for automated pattern extraction and ontology population (Eells et al., 28 Feb 2024).

1. Core Concepts and Methodological Principles

MOMo centers on a set of foundational principles and well-defined engineering steps:

• Modularization: Ontologies are broken into minimal, self-contained modules (“micropatterns”), each addressing a single, domain-invariant modeling problem (Eells et al., 28 Feb 2024).
• Template-based Instantiation: Patterns are adapted to specific use cases by adding/removing entities or renaming slots (Shimizu et al., 14 Nov 2024).
• Programmatically Queryable Libraries: Patterns are organized within modular ontology design libraries (MODLs) with rich, machine-readable metadata, enabling automated pattern selection and composition.
• Iterative Composition: Complex schemas are constructed by assembling modules, akin to human analogical reasoning (Eells et al., 28 Feb 2024, Hitzler et al., 2018).
• Fine-Grained Annotation: OPaL (Ontology Pattern Annotation Language) or OPLa is used to annotate modules with properties such as key concept, type, provenance, and semantic tags.

A module can formally be described as $M = (V_M, A_M, I_M, E_M)$, where $V_M$ is its vocabulary, $A_M$ its axioms, $I_M$ its imports, and $E_M$ its exported interface for inter-module links (Shimizu et al., 17 Oct 2024).

2. MOMo Workflow and Engineering Steps

MOMo prescribes a systematic, pattern-driven engineering workflow, as demonstrated in both domain-specific and generalized ontology construction efforts:

1. Domain and Use Case Scoping: Define application scenarios and competency questions to delineate the ontology’s purpose and required coverage (Hitzler et al., 2018, Shimizu et al., 17 Oct 2024).
2. Key Notion Extraction: Harvest central conceptual “chunks” or notions that warrant modularization (e.g., Recipe, Ingredient, HazardEvent, S2Cell) (Hitzler et al., 2018, Shimizu et al., 17 Oct 2024).
3. Pattern Selection and Module Instantiation: Select fitting ontology design patterns (ODPs) from catalogs or pattern libraries. Instantiate them with domain-specific vocabularies.
4. Module Integration: Combine modules via well-defined interfaces and minimal “bridge axioms” to form the complete ontology. Ensure correct naming, avoid unintended inferences, declare disjointness where appropriate, and document integration points (Hitzler et al., 2018, Rayan et al., 2023).
5. Axiom Refinement: Add formal logical constraints as needed (existentials, cardinalities, role chains), restricting them to the module’s semantic scope.
6. Validation and Documentation: Use reasoners, SHACL shapes, and human review to verify consistency; serialize modules separately for maintainability and clarity (Shimizu et al., 17 Oct 2024, Rayan et al., 2023).

These steps emphasize high intra-module cohesion and low inter-module coupling, a recurring theme in MOMo best practices (Rayan et al., 2023).

3. Ontology Design Patterns and Modular Libraries

ODPs serve as the atomic modeling units in MOMo:

• Micropatterns: Minimal RDFS/OWL pattern fragments, each capturing the schema for a recurring everyday object or relation (e.g., “Air,” “GasMixture,” “Temperature”) (Eells et al., 28 Feb 2024).
• Template Patterns: Reusable modeling templates—for example, the Plan pattern for actions, QuantityOfStuff for quantities, Role-Dependent Names for attributions, or the SOSA observation pattern for sensor data (Hitzler et al., 2018, Shimizu et al., 17 Oct 2024, Rayan et al., 2023).
• Curation and Annotation: Each pattern is a self-contained file with class/property declarations and basic axioms (domain, range, subclass), richly annotated for discoverability and provenance. Cross-pattern references are permitted to facilitate complex conceptual composition.
• Pattern Libraries: MODLs are compiled as indexed collections of patterns, searchable by tags, content, and semantic similarity. For instance, CS-MODL includes 104 micropatterns covering high-frequency English nouns, programmatically extracted from LLMs (Eells et al., 28 Feb 2024).

Table: Example Micropattern Structure (from CS-MODL "Air" pattern):

Component	Example	Annotation
Classes	Air, Humidity, Density, Temperature	opal:keyConcept: Air
Properties	hasHumidity (domain: Air, range: Humidity/xsd:float)	opal:patternType: micro
Cross-references	hasComposition (domain: Air, range: ChemicalComposition)

4. Automated and LLM-Assisted Pattern Extraction

MOMo has been adapted to utilize LLMs for large-scale, automated extraction and curation of ontology patterns:

• Prompt Engineering: Multiple variants and paraphrases are used to elicit LLM outputs covering target concepts (e.g., “Generate an ontology for [noun]…”). Responses are collected and parsed to extract Turtle/RDF triples (Eells et al., 28 Feb 2024).
• Curation Workflow: Outputs undergo cleaning, integration (merging overlapping properties/ranges), and voting-based pruning to build coverage-maximal micropatterns.
• Coverage and Quality: In CS-MODL, 104 nouns were selected for pattern induction. Patterns are RDFS-lite; more complex OWL constraints must be layered manually. Some property noise and semantic gaps are acknowledged, requiring downstream curation (Eells et al., 28 Feb 2024).
• Impact on Downstream Ontology Engineering: LLM-extracted modules dramatically increase bootstrap speed for common domains and enable automated agent workflows for ontology assembly, population, and extension (Shimizu et al., 14 Nov 2024).

5. Programmatic Composition, Querying, and Tool Support

MOMo adopts modular workflows that support both manual and automated knowledge engineering:

• SPARQL Discovery and Assembly: Patterns are indexed for key concepts, types, or tags, enabling queries like, “find all modules for physical entities” or “list properties of ‘Air’.” Selected modules are programmatically loaded, merged, and instantiated for new use cases.
• Template-based Customization: After selection, modules can be locally instantiated: classes/properties renamed, constrained, or pruned, and new axioms appended (Eells et al., 28 Feb 2024).
• Library Integration Tools: Standard OWL/RDF tools (e.g., rdflib, Protégé), pattern annotation languages (OPaL/OPLa), and custom pipelines for serialization, validation, and documentation are widely employed (Shimizu et al., 17 Oct 2024, Rayan et al., 2023).

Table: MOMo Workflow Steps

Step	Action	Tool/Artifact
Discovery	Query MODL for required patterns	SPARQL, OPaL-index
Instantiation	Customize classes/properties, add constraints	rdflib, Python
Integration	Merge with existing modules, compose bridge axioms	OWL, SHACL
Validation	Consistency and shape validation	Reasoner, SHACL

6. Application Domains and Case Studies

MOMo has been successfully applied in diverse domains:

• Commonsense Ontology Micropatterns (CS-MODL): LLM-based extraction of modular patterns for everyday nouns; example pattern “Air” formalized in RDFS/OWL with light axioms and programmatic composition (Eells et al., 28 Feb 2024).
• KnowWhereGraph Ontology: Modularization of a 30-layer geospatial KGs schema; each module aligned to spatial, temporal, observation, or domain constructs; extensive use of ODPs and pattern-first architectural principles (Shimizu et al., 17 Oct 2024).
• MODS Bibliographic Schema: Fine-grained modularization of a complex XML-based metadata standard, balancing pattern reuse with backward compatibility (Rayan et al., 2023).
• Cooking Recipes Ontology: Stepwise development from use cases to modules, integrating patterns for substances, quantities, plans, and stubs to ensure maintainability and reuse (Hitzler et al., 2018).
• Ontology Learning from Text: Use of term clustering, feature encoding (NMF), and affinity propagation to generate semantically coherent modules from text corpora, forming a basis for automated modular ontology acquisition (Xu et al., 2019).

7. Benefits, Limitations, and Best Practices

Benefits:

• Accelerates Schema Construction: Modules are readily composed for new domains.
• Granular Extension and Pruning: Local changes are isolated and reversible.
• LLM Synergy: Modular prompts dramatically improve ontology engineering task performance (e.g., ≈95% accuracy for complex alignment, ≈90% for population) compared to monolithic prompting (Shimizu et al., 14 Nov 2024).
• Automated Discovery: Rich annotation supports automated pattern matching and retrieval.
• Parallel Development: Explicit modules enable large teams to work in parallel with reduced risk of semantic entanglement (Shimizu et al., 17 Oct 2024).

Limitations:

• Expressivity Limit of Patterns: Initial patterns often lack full OWL expressivity; richer constraints must be layered manually.
• Noise from Automated Extraction: LLM-extracted patterns can include inconsistent or overly broad properties.
• Coverage Gaps: Commonsense pattern libraries may lack domain-specific constructs.
• Tooling Overhead: Pattern curation and modular integration may require additional tooling and rigorous annotation discipline (Eells et al., 28 Feb 2024, Rayan et al., 2023).

Best Practices:

• Design for modularity from the start; annotate modules with OPLa/OPaL for programmatic access (Shimizu et al., 14 Nov 2024).
• Employ pattern-first construction and maintain an evolving library of patterns.
• Apply two-stage or multi-stage prompt engineering for LLM-based processes, first selecting modules before detailed modeling or extraction.
• Use validation and testing pipelines (SHACL, OWL reasoners) for consistency.
• Document and version-control each module independently for traceable evolution and dependency management.

• (Eells et al., 28 Feb 2024) Commonsense Ontology Micropatterns
• (Hitzler et al., 2018) A Tutorial on Modular Ontology Modeling with Ontology Design Patterns: The Cooking Recipes Ontology
• (Shimizu et al., 17 Oct 2024) The KnowWhereGraph Ontology
• (Rayan et al., 2023) A Modular Ontology for MODS -- Metadata Object Description Schema
• (Shimizu et al., 14 Nov 2024) Accelerating Knowledge Graph and Ontology Engineering with LLMs
• (Xu et al., 2019) Comparing of Term Clustering Frameworks for Modular Ontology Learning
• (Paschke et al., 2015) Aspect OntoMaven - Aspect-Oriented Ontology Development and Configuration With OntoMaven