M-CODE: Materials Categorization via Ontology, Dimensionality and Evolution

This paper introduces M-CODE, an open-source, ontology-based categorization system that classifies materials structures by dimensionality, complexity, and evolutionary provenance to support standardized data management and reproducible dataset generation in AI-driven materials science.

The Gist

Imagine you are trying to build a massive library of LEGO structures.

For a long time, scientists building materials for computers have mostly been building perfect, idealized castles. They have blueprints for perfect cubes and flawless towers. But in the real world, materials aren't perfect castles. They are cracked walls, half-built bridges, surfaces covered in dust, and complex interfaces where two different materials meet.

The problem is that while everyone agrees on what a "perfect castle" looks like, nobody agrees on how to describe a "cracked wall with a missing brick." One scientist calls it a "defect," another calls it a "void," and a third calls it a "surface reconstruction." Because they use different words and different blueprints, their data doesn't talk to each other. It's like trying to build a city where one person speaks English, another speaks French, and a third speaks a language made entirely of hand gestures.

Enter M-CODE.

Think of M-CODE as a universal translator and a standardized LEGO instruction manual rolled into one. It's a new system designed to describe any material structure, no matter how messy or complex, in a way that both humans and computers can understand perfectly.

Here is how it works, broken down into simple concepts:

1. The "Lego Brick" Philosophy (Ontology)

Instead of trying to describe a whole complex machine in one giant paragraph, M-CODE breaks everything down into building blocks (called Entities) and actions (called Operations).

• The Bricks (Entities): These are the basic ingredients. You have a "Crystal" (a perfect block), a "Vacuum" (empty space), a "Vacancy" (a missing brick), or a "Slab" (a flat layer).
• The Actions (Operations): These are the instructions on what to do with the bricks. You can "Stack" them, "Stretch" them, "Merge" them, or "Cut" them.

The Analogy:
Imagine you want to describe a sandwich.

• Old Way: "A messy sandwich with a bite taken out of the corner, sitting on a slightly squished plate." (Hard to reproduce exactly).
• M-CODE Way:
  1. Take a Bread Entity.
  2. Take a Cheese Entity.
  3. Stack them.
  4. Cut a triangle out of the corner (Operation).
  5. Result: A perfect, reproducible description of that specific sandwich.

2. The "Evolution" Story (Provenance)

One of the coolest parts of M-CODE is that it doesn't just tell you what the material is; it tells you how it was made. It keeps a "receipt" or a "birth certificate" for every structure.

If you have a defective crystal, M-CODE records the history: "We started with a perfect crystal, then we removed an atom here, then we stretched it by 5%."

The Analogy:
Think of it like a cooking recipe that includes a video of the chef making the dish. If the cake tastes weird, you don't just know it's a "bad cake." You can look at the recipe and see, "Ah, the chef forgot to add the baking soda before mixing the eggs." This allows scientists to fix mistakes and reproduce the exact same "mistake" later if they need to study it.

3. The "Zip Code" System (Tags)

To make things easy to find, M-CODE gives every type of structure a short, catchy code, like a zip code.

• P-2D-SLB-S might mean: Pristine (perfect) 2D (flat) Slab, Simple version.
• D-0D-VAC might mean: Defective 0D (point) VACancy.

This allows computers to instantly sort materials. If a scientist wants to study only "twisted interfaces," they can just ask the computer to find all items with the "Twisted Interface" tag, and it will instantly find them, regardless of which database they are in.

4. Why Does This Matter? (The "AI" Connection)

Artificial Intelligence (AI) is getting very good at predicting how materials will behave. But AI is only as smart as the data it is fed.

• If you feed an AI only perfect castles, it will think the world is made of perfect castles.
• If you feed it M-CODE data, the AI learns about cracks, interfaces, and defects.

M-CODE helps organize this messy, real-world data so AI can learn to predict how real materials (like the battery in your phone or the solar panel on your roof) actually work, rather than just how perfect theoretical models work.

Summary

M-CODE is a new language for materials science.

• It stops scientists from speaking different dialects.
• It breaks complex materials down into simple, reusable LEGO-like blocks.
• It keeps a detailed diary of how every material was built.
• It gives everything a unique "zip code" so computers can find and sort them instantly.

By doing this, it helps scientists build better AI, create more realistic simulations, and ultimately discover new materials faster. It turns the chaotic mess of real-world materials into an organized, searchable, and reproducible library.

Technical Summary

1. Problem Statement

Modern materials science relies heavily on data-driven approaches and machine learning (ML). However, a significant gap exists between the idealized training data (mostly perfect 3D bulk crystals) and real-world material structures (surfaces, interfaces, defects, low-dimensional systems, and disordered phases) that dictate actual device performance.

Current challenges include:

• Terminology Fragmentation: Terms like "slab," "monolayer," or "vacancy" are used inconsistently across subfields.
• Implementation Incompatibility: Different codebases re-encode the same concepts in incompatible ways, making dataset curation difficult and model comparison impossible.
• Lack of Provenance: It is often unclear how a specific structure was constructed, making it hard to reproduce results or track the evolution from a parent material to a complex structure.
• Data Silos: Existing standards (like OPTIMADE or NOMAD) focus on querying or archiving data but lack a shared, machine-readable vocabulary for the construction and evolution of realistic structures.

2. Methodology

M-CODE (Materials Categorization via Ontology, Dimensionality and Evolution) addresses these issues by creating a compact categorization system that links domain-science terminology to reusable software entities and operations.

Core Philosophy: Construction as Transformation

Instead of defining structures as static objects, M-CODE treats materials generation as a sequence of explicit transformations with provenance. A structure is defined by:

1. Configuration: Input structures and physical parameters.
2. Builder: The process combining inputs.
3. Result: The final material with metadata describing the transformation.

Technical Implementation

• Foundation: Built on JSON Schema for data organization, validation, and exchange.
• Language Agnostic: Schemas serve as the "single source of truth," automatically generating language bindings (Python, TypeScript) to ensure consistency across implementations.
• Entity-Operation Model:
  • Entities: Grouped into Core (irreducible physical pieces like bulk crystals, vacuum, atoms), Auxiliary (descriptors like Miller indices, strain matrices), and Reusable (validated macro-blocks like supercells or nanoribbons).
  • Operations: Algorithms that modify or combine entities.
    • Modifications: Strain, repeat, perturb.
    • Combinations: Stack (layering), merge (boolean union).

Categorization Dimensions

M-CODE classifies structures along four axes:

1. Domain (Evolution):
   • Pristine: Derived from a single parent (e.g., slab from crystal).
   • Compound Pristine: Derived from multiple parents (e.g., interfaces, heterostacks).
   • Defective: Involves insertion/removal/replacement of atoms (e.g., vacancies, substitutions).
   • Processed: Involves physical/chemical processing (e.g., annealing, passivation).
2. Dimensionality: 3D, 2D, 1D, 0D.
3. Category: Specific types (e.g., slab, interface, nanowire).
4. Variants: Construction choices (e.g., simple vs. reconstructed, ZSL vs. twisted).

3. Key Contributions

1. Compact M-CODE Tags: A stable, short identifier system (e.g., P-2D-SLB-S for a Pristine 2D Simple Slab) that allows for concise annotation of workflows and datasets while linking to detailed schema definitions.
2. Executable Ontology: A software-oriented ontology where scientific concepts are mapped directly to JSON schemas, classes, and methods. This allows a scientific description to be translated into a machine-readable configuration that can be reproducibly built.
3. Provenance-Aware Metadata: The system records the full "build graph" (sequence of entities and operations) as metadata within the generated material, enabling exact regeneration and tracking of structural evolution.
4. Open-Source Reference Implementation: The release of mat3ra-esse (available on PyPI and NPM), which includes JSON schemas, Python/TypeScript interfaces, and example artifacts.

4. Results and Artifacts

The paper presents the following concrete artifacts:

• Categorization Tables: Comprehensive lists mapping domain science terms to M-CODE tags (e.g., D-0D-VAC for a 0D Vacancy).
• Schema Examples:
  • Interface: Defined as a stack of two strained supercells and vacuum.
  • Substitutional Defect: Defined as a merge operation where a specific site is replaced.
  • Nanoribbon: Defined recursively as a nanotape (lattice lines + vacuum) stacked with additional vacuum.
• Visualizations: Diagrams illustrating the "Configuration $\to$ Build $\to$ Result" workflow and examples of target structures (e.g., MoS2 monolayers, twisted interfaces, grain boundaries) annotated with their tags.

5. Significance and Impact

• FAIR Data Principles: M-CODE directly supports Findability (via tags), Accessibility (open schemas), Interoperability (shared vocabulary across tools/languages), and Reusability (provenance metadata).
• AI/ML Readiness:
  • Enables filtering and balancing of training sets by structural category.
  • Allows for category-specific model evaluation rather than aggregate metrics.
  • Helps detect data leakage by tracking shared parent materials or transformation paths between training and test sets.
• Workflow Automation: Downstream tools can automatically select appropriate simulation parameters based on the structure's tag (e.g., routing a P-2D-SLB-S to a surface-energy workflow with dipole corrections).
• Community Standardization: By providing a permissive, open-source standard, M-CODE aims to unify the fragmented landscape of materials data generation, reducing duplication and ensuring that digital artifacts (code, UI, data directories) remain consistent as new structure classes are added.

In summary, M-CODE provides the missing "intermediate layer" between raw scientific concepts and executable code, enabling the systematic generation, validation, and reuse of realistic, complex material structures for next-generation AI-driven materials discovery.