💻 computer science

A Graded Modal Dependent Type Theory with Erasure, Formalized

This paper presents a fully formalized graded modal dependent type theory in Agda that enforces properties like erasure via grade-based variable tracking, and establishes key meta-theoretic results including normalization, decidability, and the soundness of an extraction function that removes erasable content while preserving program values.

Original authors: Andreas Abel, Nils Anders Danielsson, Oskar Eriksson

Published 2026-04-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Andreas Abel, Nils Anders Danielsson, Oskar Eriksson

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a chef running a high-end restaurant. You have a massive recipe book (your computer program) that tells you exactly how to cook every dish. But sometimes, the recipe includes steps that are crucial for the chef to know (like "this ingredient is organic" or "this step ensures food safety"), but the diner doesn't actually need to see or taste those details. In fact, if the chef spends time explaining the organic certification to the diner, it slows down the service.

This paper is about building a super-smart recipe book that automatically knows which parts of the instructions are "diner-visible" (essential for the result) and which are "chef-only" (essential for correctness but can be thrown away before serving).

Here is a breakdown of the paper's ideas using everyday analogies:

1. The "Grade" System: A Labeling Machine

In standard cooking, every step is treated the same. In this new system, every ingredient and every instruction gets a grade (a label).

Grade 0 (The "Ghost" Label): This ingredient is invisible. It's like a secret sauce that makes the dish taste right but isn't actually in the final bowl. You can use it to prove the dish is safe, but you don't need to carry the bottle to the table.
Grade 1 or More (The "Real" Label): This is the meat, the potatoes, the actual food. It must be cooked, served, and eaten.

The authors created a mathematical framework (a "Type Theory") where these grades are part of the language itself. It's like having a recipe book where every line of text is color-coded: Red means "Keep this," and Blue means "You can delete this later."

2. The "Erasure" Magic Trick

The main goal of the paper is Erasure. Imagine you have a long, complicated letter written to a friend. Half of it is the actual message, and the other half is you explaining why you decided to send the letter (the logic).

The Problem: If you send the whole letter, it's heavy and slow to read.
The Solution: You want to strip out the "why" and just send the "what."
The Risk: What if you accidentally delete a part of the "what" because you thought it was just "why"? That would be a disaster.

The authors built a mathematical safety net. They proved that if you follow their specific rules for labeling (the "grades"), you can surgically remove all the "Blue" (Grade 0) parts of the code, and the remaining "Red" code will still do exactly the same thing. It's like proving that if you remove the scaffolding from a finished building, the building doesn't fall down.

3. The "Consistent Context" Rule

There's a tricky scenario: What if your recipe relies on a "magic ingredient" that doesn't actually exist?

The Scenario: "If the dragon is real, cook the steak rare. If the dragon is fake, cook it well-done."
The Problem: If you erase the part about the dragon, the computer might get confused. "Wait, was the dragon real or fake? I can't decide!"
The Fix: The authors say, "We can only erase the dragon part if we know for a fact the dragon is fake (or real) before we start cooking." In technical terms, they require the "context" (the list of assumptions) to be consistent. If your assumptions contradict each other (e.g., "The dragon is real" AND "The dragon is dead"), you can't safely erase anything.

4. The "Two Kinds of Pairs" (Strong vs. Weak)

Imagine you are packing a suitcase.

Strong Pair (The "Tied" Suitcase): You tie the suitcase shut. To get the contents out, you must cut the string (a specific action). If you cut the string, you get both items out. You can't just peek at one without opening the whole thing.
Weak Pair (The "Zipper" Suitcase): You can unzip it and take out just the socks, leaving the pants inside.

The paper shows how to handle both types of "suitcases" in the code.

If you have a "Weak" suitcase with a "Ghost" (Grade 0) item inside, you can't just unzip it and look at the ghost item unless you promise to throw away the result immediately.
The authors proved that their system handles these different "suitcase" rules correctly, ensuring you never accidentally try to open a suitcase that was supposed to be invisible.

5. The "Formal Proof" (The Double-Check)

The most impressive part of this paper isn't just the idea; it's the proof.
The authors didn't just say, "Hey, this looks like it works." They wrote the entire system and the proof that it works inside a computer program called Agda.

Think of Agda as a super-strict math teacher who checks every single step of your logic.
The teacher verified that:
1. The rules for labeling are consistent.
2. If you follow the rules, the code never crashes.
3. If you erase the "Ghost" parts, the final result is identical to the original.

Why Does This Matter?

In the real world, this technology helps make software:

Faster: By deleting unnecessary code before the program runs, the computer has less work to do.
Safer: It guarantees that you aren't accidentally deleting important logic.
Smarter: It allows programmers to write complex proofs about their code (like "this function is secure") without slowing down the actual program that users run.

In a nutshell: The authors built a rigorous, computer-checked system that acts like a "smart eraser." It knows exactly which parts of a program are just "proofs" or "metadata" and can safely delete them, leaving behind a lean, fast, and perfectly functional program.

1. Problem Statement

Dependent type theories (like Agda and Idris) are powerful tools for verifying program correctness, but they often include "proof" terms or metadata that are irrelevant to the runtime execution of a program. Compilers must perform erasure to remove these terms to generate efficient code. However, ensuring that erasure is sound (i.e., removing these parts does not alter the program's observable behavior or value) is non-trivial, especially in the presence of:

Open programs: Programs with free variables that are marked as erasable.
Inconsistent contexts: Scenarios where axioms or impossible types (like the empty type $\bot$ ) are present.
Complex type structures: Dependent types, large eliminations (computing types from terms), and various modalities (linearity, affine types, information flow).

Previous approaches often relied on syntactic arguments or restricted settings (e.g., closed programs only). There was a lack of a unified, fully formalized framework that handles erasure soundness for open programs in a general dependent type theory with a universe and large eliminations.

2. Methodology

The authors present a Graded Modal Dependent Type Theory ( $\lambda\Sigma\Pi\mathbb{N}^M$ ) parameterized by a modality structure.

A. Theoretical Framework

Modality Structure: The theory is parameterized by a partially ordered semiring $(M, +, \cdot, \wedge, nr, 0, 1)$ $(M, +, \cdot, \land, n r, 0, 1)$ . Elements of $M$ $M$ (grades) track variable usage.
- Operations: Addition ( $+$ ) combines usage for parallel components; Multiplication ( $\cdot$ ) scales usage; Meet ( $\wedge$ ) handles branching (taking the intersection of usage); and a special function $nr$ handles natural number recursion.
- Instances: The framework supports various interpretations, including Erasure (grades $\{0, \omega\}$ ), Linear/Affine Types, and Information Flow lattices.
Separation of Judgments: The authors separate the typing judgment ( $\Gamma \vdash t : A$ ) from the usage judgment ( $\gamma \triangleright t$ ). The usage judgment assigns grades to free variables to ensure resources are tracked correctly without interfering with the core type system's equality.
Syntax: The language includes $\Pi$ -types, weak and strong $\Sigma$ -types, a universe $\mathbb{U}$ , natural numbers $\mathbb{N}$ , an empty type $\bot$ , and unit types. It supports large eliminations (computing types from terms).

B. Formalization

The entire theory and its meta-theory are fully formalized in Agda (approx. 110,000 lines of code).
The formalization uses well-scoped syntax and is based on a previous formalization of decidability of type conversion (Abel et al., 2017).
It employs a Kripke logical relation as the core mechanism for proving meta-theoretic properties.

C. Erasure Case Study

The authors define a specific instance of the modality structure for erasure, where grade $0$ means "erasable" and $\omega$ means "relevant."
They define an extraction function ( $\cdot^\bullet$ $\cdot^{∙}$ ) that translates terms from the source language to an untyped $\lambda$ $λ$ -calculus (target language).
- Non-strict (Call-by-Name): Erased terms are replaced with a looping term ( $\loop$ ) to ensure they are never evaluated.
- Strict (Call-by-Value): Erased terms are replaced with a dummy value ( $\_$ ) to prevent evaluation.
They prove Soundness of Extraction: If a program computes a natural number, its extracted version computes the same natural number, even if the program is open (has free variables), provided the context is consistent and variables are marked erasable.

3. Key Contributions

General Graded Modal Type Theory: A fully formalized dependent type theory with grades that supports both terms and types usage tracking. It is the first full formalization of the meta-theory for a graded dependent type theory with a universe and large eliminations.
Refined Recursion Handling: Introduction of a new $nr$ function (replacing the previous natrec-star operator) to handle grade assignment for natural number recursion. This allows for more flexible and correct modeling of linearity and erasure in recursive definitions.
Usage Inference and Decidability: A decidable algorithm for inferring usage contexts ( $\gamma$ ) from terms, proving that the usage relation is algorithmic and satisfies a principality property (the inferred context is the most specific valid one).
Soundness of Erasure for Open Programs: A proof of extraction soundness using a logical relation indexed by types. Crucially, this holds for open programs as long as:
- All free variables are in erasable positions.
- The context is consistent (no proofs of $\bot$ ).
- Erased matches on weak $\Sigma$ -types are disallowed (to prevent stuck terms).
Extensions:
- Implementation of Weak and Strong Unit Types with appropriate usage rules.
- Extension to Graded $\Sigma$ -types (modeled after Atkey's dependent tensors) allowing erased fields in data structures, supported by a "moded" grading system (distinguishing between erased/compile-time and present/run-time modes).

4. Results

The formalization establishes the following meta-theoretic properties:

Subject Reduction: Usage grades are preserved under reduction ( $\gamma \triangleright t$ and $t \to u \implies \gamma \triangleright u$ ).
Substitution Lemma: Usage contexts behave linearly under substitution, allowing for the composition of usage analysis.
Normalization: The system is strongly normalizing.
Decidability: Definitional equality and type checking are decidable for the presented fragment.
Extraction Soundness:
- Theorem 6.9: For a consistent context $\Delta$ , if $\Delta \vdash t : \mathbb{N}$ and $0 \triangleright t$ (all variables are erasable), then $t$ reduces to a numeral $n$ , and its extracted form $t^\bullet$ also reduces to $n$ .
- This holds for both strict and non-strict target semantics.

5. Significance

Correctness by Construction: By mechanizing the proofs in Agda, the authors eliminate the possibility of subtle errors in the meta-theory (such as the substitution failure found in earlier work by McBride).
Practical Compilation: The work provides a rigorous foundation for compilers in dependently typed languages (like Agda and Idris) to safely erase proof terms and irrelevant arguments, optimizing runtime performance without sacrificing correctness guarantees.
Handling Open Programs: Unlike many previous works that only guarantee soundness for closed programs, this framework supports open programs with erasable assumptions, which is essential for practical modular programming and verification.
Flexibility: The parameterized modality structure allows the same theoretical framework to be reused for different static analyses, including linearity, affine types, and information flow control, not just erasure.
Handling Edge Cases: The paper explicitly addresses the complexities of erased matches (pattern matching on erased data) and inconsistent contexts, providing clear boundaries (e.g., disallowing erased matches on weak $\Sigma$ -types in open contexts) where soundness is guaranteed.

In summary, this paper delivers a robust, machine-checked foundation for graded modal type theories, demonstrating that complex features like erasure, linearity, and dependent types can coexist with sound program extraction and strong meta-theoretic guarantees.