💻 computer science

Proof Theory and Dependent Type Theory: Distinct Foundations for Designing Proof Assistants

This paper argues that modern structural proof theory, exemplified by the sequent calculus and implemented in the Abella theorem prover, offers a compelling alternative to dependent type theory for designing proof assistants by better separating logic from proof structure, strategically utilizing non-determinism, avoiding complex typing issues, and providing an elegant approach to handling bindings.

Original authors: Dale Miller (Inria Saclay,LIX, Institut Polytechnique de Paris)

Published 2026-07-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Dale Miller (Inria Saclay,LIX, Institut Polytechnique de Paris)

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 trying to build the ultimate "Proof Assistant"—a super-smart robot that helps humans check their math and logic homework to make sure it's 100% correct. For decades, most of these robots have been built using a specific blueprint called Dependent Type Theory (DTT). It's like building a robot out of a very complex, high-tech Lego set where every single brick has a specific label, and the robot checks if the labels match perfectly before letting you snap them together.

But in this paper, author Dale Miller suggests that there's another, perhaps better, way to build these robots. He argues that we should look at Structural Proof Theory, specifically a framework called the Sequent Calculus. Think of this not as a rigid Lego set, but as a dynamic, moving puzzle where the pieces can slide around and change shape as long as the logic holds up.

Here is the breakdown of why Miller thinks this "puzzle" approach might be superior to the "Lego" approach, using six key ideas:

1. Separating the "What" from the "How"

In the Lego world (DTT), the robot decides two things at once: what logic you are using and how the proof is built. It's like saying, "We are only allowed to build towers using red bricks, and the only way to stack them is straight up."
Miller suggests we should separate these. We can decide on the logic (the rules of the game) and then choose any proof structure we want to solve it. It's like deciding you want to play soccer, but then realizing you can score goals by kicking, heading, or even using a net-cannon if the rules allow. The Sequent Calculus lets you use many different "moves" (like natural deduction, tableaux, or resolution) without forcing you into a single, rigid style.

2. The Problem with "Proofs as Code"

The Lego approach treats a proof like a computer program (a λ-term). While computers are great at running programs, they can be picky. Sometimes, the program takes a weird path to get to the answer, or it gets stuck because it's waiting for a specific type of input.
Miller points out that the Lego approach has to deal with messy issues like "universe levels" (a complex way of organizing types so they don't crash into each other) and "proof irrelevance" (wasting time checking parts of the proof that don't actually matter). The Sequent Calculus approach is simpler; it doesn't need to worry about these heavy typing rules because it treats the proof structure more directly, like a flowchart rather than a complex code script.

3. Handling "Classical" Logic (The Either/Or Problem)

Some logic is "intuitionistic" (you must prove something exists by building it), and some is "classical" (you can prove something exists just by showing it's impossible for it not to exist).
The Lego approach struggles to handle the "classical" style smoothly. It often has to add extra, clunky rules to make it work. Miller argues that the Sequent Calculus was designed from the start to handle both styles equally well, like a universal adapter that fits any plug without needing a bulky converter.

4. Embracing "Maybe" (Non-Determinism)

This is a big one. The Lego robots are built to be "deterministic," meaning they must follow a single, straight path to check a proof. If they hit a dead end, they stop.
Miller suggests that allowing a little bit of "non-determinism" (guessing and backtracking) is actually a superpower. Imagine a maze. A deterministic robot walks one path and stops if it hits a wall. A non-deterministic robot can try a path, hit a wall, say "oops," and instantly try a different one.
Miller argues that by letting the proof-checker "guess" and backtrack, we can make the "proof certificates" (the homework you hand in) much smaller. The robot does the heavy lifting of searching, so you don't have to write down every single step. It's a trade-off: a smaller homework sheet for a robot that has to think a bit harder.

5. The Magic of "Moving Binders"

This is the paper's most exciting trick. In logic, we often deal with variables that are "bound" (like the "x" in "for all x..."). In the Lego world, these variables are often stuck in place, and handling them is a nightmare of technical headaches (like the famous POPLMark challenge).
Miller proposes a view where these variables are mobile. He calls this λ-tree syntax.
Imagine a variable is a name tag on a person. In the Lego world, if you move the person, the name tag might fall off or get confused. In Miller's world, the name tag is glued to the person. No matter how you move the person around the room (or the proof), the name tag stays with them.
He introduces a special tool called the ∇-quantifier (pronounced "nabla"). Think of this as a "local scope" button. When you press it, it says, "This variable belongs only to this specific part of the proof, and it can never escape." This makes it incredibly easy to reason about languages that have complex rules, like programming languages or the π-calculus (a way to model how computers talk to each other).

6. The Abella Robot

Miller doesn't just talk about this; he built a robot to prove it works. It's called Abella.
Abella is a theorem prover built entirely on these Sequent Calculus principles. It uses the "moving binders" and the ∇-quantifier to handle complex logic about languages and bindings with ease. While the Lego-based robots (like Coq or Lean) are very popular and have huge libraries of pre-built proofs, Abella suggests that for certain tricky problems—especially those involving how variables are named and moved around—this new approach is more natural and elegant.

The Bottom Line

Miller isn't saying the Lego robots (Dependent Type Theory) are bad or that they should be thrown away. He acknowledges they are mature, widely used, and great for many things.
However, he suggests that for the foundations of how we design these proof assistants, the Sequent Calculus offers a more flexible, simpler, and more powerful toolkit. It separates logic from structure, embraces smart guessing, and handles the tricky business of "moving variables" with a elegance that the current standard struggles to match. It's an invitation to look at the problem from a different angle, using a framework that has been successful in many other areas of logic but hasn't yet taken the spotlight in the world of interactive proof assistants.

Problem
The paper addresses the foundational design choices underlying interactive theorem provers (proof assistants). While the dominant paradigm in major systems (e.g., Coq, Lean, Agda) relies on Dependent Type Theory (DTT) and the "proofs-as-terms" paradigm—where proofs are represented as dependently typed $\lambda$ -terms—the author argues that modern structural proof theory, specifically the sequent calculus, offers a compelling, yet underutilized, alternative framework. The paper posits that the DTT approach conflates the logic being formalized with the structure of the proof, leading to complexities in handling classical logic, non-determinism, and syntactic bindings that a proof-theoretic perspective could resolve more elegantly.

Methodology
The author employs a comparative theoretical analysis, contrasting the design narratives of DTT-based systems with those derived from structural proof theory. The methodology involves:

Historical and Theoretical Survey: Tracing the origins of natural deduction and sequent calculus (Gentzen) and their subsequent applications in consistency proofs, independence proofs, and logic programming.
Conceptual Decomposition: Separating the question of "which logic is being formalized" from "what constitutes a proof," arguing that DTT often fixes the proof structure (natural deduction encoded as $\lambda$ -terms) alongside the logic, whereas proof theory allows for diverse proof structures (sequent calculus, tableaux, resolution) for a single logic.
Critical Analysis of DTT Limitations: Examining specific technical hurdles in DTT, such as the conflation of proof irrelevance, universe levels, and implicit arguments, and the difficulties in uniformly handling classical logic (e.g., the exclusion of multiple-conclusion sequents).
Proposal of Proof-Theoretic Mechanisms: Introducing specific proof-theoretic concepts—polarity, focusing, and notably, the mobility of binders via $\lambda$ -tree syntax and the $\nabla$ -quantifier—as superior mechanisms for handling syntactic bindings and meta-theoretic reasoning.
Illustration via Implementation: Using the Abella theorem prover as a concrete realization of these principles to demonstrate how the theoretical framework functions in practice.

Key Contributions
The paper identifies six specific topics where the proof-theoretic perspective offers distinct advantages over DTT:

Separation of Logic and Proof Structure: Unlike DTT, which often ties a specific logic to a specific proof encoding (natural deduction as $\lambda$ -terms), proof theory allows for multiple proof structures (sequent calculus, tableaux, etc.) for the same logic, facilitating diverse inference strategies (forward/backward chaining).
Avoidance of DTT Complications: The proof-theoretic approach sidesteps complex typing disciplines inherent to DTT, such as managing universe levels, handling proof irrelevance, and dealing with the redundancy of explicit vs. implicit typing.
Handling Classical Logic: While DTT struggles to uniformly represent classical logic (often requiring axioms like the excluded middle), the sequent calculus (specifically multiple-conclusion) provides a natural, uniform framework for both classical and intuitionistic logic, supporting structures like Herbrand disjunctions and resolution refutations.
Strategic Use of Non-Determinism: The paper argues that proof checkers need not be strictly deterministic. Allowing non-determinism (e.g., via backtracking search) in the kernel enables valuable trade-offs between the size of proof certificates and the time required for checking, a resource often ignored in functional, deterministic DTT kernels.
Treatment of Bindings (Binder Mobility): This is presented as the most significant contribution. The paper advocates for treating binders not as function spaces (extensional view) but as movable abstractions over syntax (intensional view). This is achieved through $\lambda$ -tree syntax, where binders can move from term-level to formula-level to proof-level (eigenvariables) without ever becoming free.
The $\nabla$ -Quantifier: The introduction of the $\nabla$ -quantifier (a new formula-level binder) allows for the specification of generic judgments and the handling of local binding signatures. It is self-dual and interacts naturally with equality, providing a robust mechanism for reasoning about syntax with bindings.

Results
The paper does not present new experimental benchmarks or empirical data but rather a theoretical synthesis and a demonstration of feasibility through the Abella theorem prover.

Abella's Capabilities: Abella is shown to successfully leverage $\lambda$ -tree syntax and the $\nabla$ -quantifier to reason about the meta-theory of languages and logics involving complex binding.
Specific Applications: The paper cites successful specifications within Abella, including:
- Formulations of the $\lambda$ -cube and higher-ranked polymorphic type inference.
- Formalizations of Barendregt's theory of the lambda-calculus.
- Operational semantics and meta-theory of the $\pi$ -calculus, including distinctions between open and closed bisimulation and the capture of modal operators.
Theoretical Equivalence: The paper demonstrates that the formula $\forall w. \lambda x.x \neq \lambda x.w$ is provable in this framework because the higher-order unification problem $(\lambda x.x = \lambda x.w)$ has no unifiers, illustrating the power of the intensional view of binders.

Significance
The paper claims that modern structural proof theory offers a "robust and compelling foundational alternative" to the DTT paradigm for designing interactive theorem provers. Its significance lies in:

Reframing the Design Narrative: It challenges the assumption that dependently typed $\lambda$ -calculus is the only or best way to represent proofs, suggesting that the sequent calculus provides a more flexible and natural framework, particularly for meta-theoretic reasoning.
Solving Binding Problems: It proposes that the "mobility of binders" approach resolves long-standing challenges in encoding syntactic bindings (referenced as the POPLMark challenge), offering a canonical treatment that avoids the need for complex encodings like de Bruijn indices or named variables in the user's logical specification.
Foundational Clarity: By separating logic from proof structure and embracing non-determinism, the approach allows for more direct and elegant specifications of complex systems, as evidenced by the capabilities of the Abella prover.

The author concludes that while DTT has mature implementations and widespread adoption, the proof-theoretic perspective provides a deeper and more flexible design foundation, particularly for systems requiring sophisticated reasoning about binding and meta-theory.