🔢 mathematics

Bidirectional Interpolation for the Lambda-Calculus -- Revisiting and Formalising Craig-Čubrić Interpolation

This paper presents a new proof of Čubrić's proof-relevant interpolation theorem for the simply-typed lambda-calculus using bidirectional typing principles and provides its formalization in the Rocq proof assistant.

Original authors: Meven Lennon Bertrand, Alexis Saurin

Published 2026-03-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Meven Lennon Bertrand, Alexis Saurin

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

The Big Picture: The "Translator" Problem

Imagine you have two people, Alice and Bob, who need to communicate.

Alice speaks a language with words like "Apple," "Red," and "Fruit."
Bob speaks a language with words like "Car," "Fast," and "Engine."
They want to pass a message from Alice to Bob, but they can't talk directly because their vocabularies are too different.

Craig's Interpolation Theorem (the old idea) says: "Don't worry! There is a Translator (an Interpolant) who only speaks words that both Alice and Bob know (like 'Object' or 'Thing'). Alice can explain her message to the Translator, and the Translator can explain it to Bob."

This paper is about a new, super-powerful version of this Translator. It doesn't just translate the words; it translates the logic and the proof of the message. It ensures that if you take Alice's original message, translate it to the Translator, and then to Bob, you get the exact same message back, step-for-step.

The Problem with the Old Method

The previous method for finding this Translator (developed by a mathematician named Čubrić) was like trying to solve a maze by guessing.

It worked, but the instructions were messy and confusing.
It relied on a "brute force" approach: "If this part of the sentence is too big, chop it off and replace it with a variable."
The authors of this paper looked at the old instructions and said, "This is ugly. There must be a cleaner way to do this."

The New Solution: "Bidirectional Typing"

The authors found a new way to build the Translator using a concept called Bidirectional Typing.

The Analogy: The Assembly Line vs. The Inspection Station
Imagine a factory making toys.

Inference (The Assembly Line): You look at a toy part and ask, "What is this?" You figure out its type based on its shape. (e.g., "This is a wheel.")
Checking (The Inspection Station): You are told, "This must be a wheel." You look at the part and verify, "Yes, it fits the definition of a wheel."

In computer science (specifically the Lambda Calculus, which is the math behind programming languages), "Bidirectional Typing" means switching between these two modes depending on what you are doing.

When you are building a complex structure (like a function), you check it against a known blueprint.
When you are using a structure (like applying a function to an argument), you infer what it does.

The authors realized that this "switching" method perfectly matches the "Normal Forms" (the cleanest, most efficient versions of a mathematical proof). By using this method, they could build their Translator much more cleanly than the old "brute force" method.

The "Sum" Problem (The Tricky Part)

The paper deals with a specific type of math called STLC+ (Simply Typed Lambda Calculus with Sums).

The "Sum" Analogy: Imagine a menu that says "Choose either a Burger OR a Pizza."
In math, handling "OR" statements is notoriously difficult. It's like trying to build a bridge where the road splits into two different directions, and you have to make sure the bridge holds up on both sides simultaneously.

Previous attempts to handle this "OR" split were messy. The authors discovered that their "Bidirectional" method handles these splits naturally. It's like having a smart traffic light that knows exactly when to send cars to the Burger lane and when to send them to the Pizza lane, ensuring no traffic jams (mathematical errors) occur.

The "Formal" Part: The Robot Lawyer

The authors didn't just write this down on paper; they built a Robot Lawyer (using a tool called Rocq, which is a proof assistant).

They fed their new rules into the robot.
The robot checked every single step of their logic to ensure there were no holes, no mistakes, and no "magic" assumptions.
Why do this? In math, humans make mistakes. A robot doesn't. If the robot says "This proof is correct," you can trust it 100%.

They also proved that their method works for Normalization.

Analogy: Imagine you have a messy, tangled ball of yarn (a complex proof).
Normalization is the process of untangling it until it's a perfect, neat ball.
The authors proved that their new method can untangle any valid proof, even the messy ones involving "OR" statements, which was a hard thing to prove before.

Why Should You Care?

Better Software: This math is the foundation of programming languages. If we understand how to "translate" code logic better, we can build compilers that catch bugs earlier and write safer software.
Cleaner Math: They took a messy, 60-year-old proof and cleaned it up, making it easier for future mathematicians to understand and build upon.
The "Proof-Relevant" Twist: Most math proofs just say "This is true." This paper says, "Here is exactly how it is true, and here is the recipe to rebuild the proof from scratch." It's the difference between being told "The cake is delicious" and being given the exact recipe to bake it again.

Summary in One Sentence

The authors took a messy, old mathematical puzzle about translating logic between different systems, solved it using a clever "two-way" checking method (Bidirectional Typing), and proved it works perfectly using a computer robot, making the whole process cleaner, faster, and more reliable.

1. Problem Statement

The paper addresses the problem of Proof-Relevant Interpolation in the Simply-Typed Lambda-Calculus with sums and empty types (STLC+).

Background: Craig's Interpolation Theorem states that if $A \vdash B$ , there exists an interpolant $I$ using only the common vocabulary of $A$ and $B$ such that $A \vdash I$ and $I \vdash B$ .
Proof-Relevance: A stronger version requires that the proofs (terms) composing the entailment can be factored through the interpolant. Specifically, if $x:A \vdash t:B$ , there should exist a type $C$ (the interpolant) and terms $u: A \to C$ and $v: C \to B$ such that the composition $(\lambda y. v) u$ reduces to the original term $t$ .
The Gap: While Čubrić established this result for STLC+, his original proof was:
1. Complex: It relied on a size-based induction on terms, replacing subterms with variables, which obscured the underlying structure.
2. Flawed: It contained a specific case (Subcase 6.3.2) that was dismissed as "similar" to a previous case but was actually distinct and required different handling.
3. Unformalised: The complexity made it difficult to verify mechanically.
The Challenge: In STLC+, standard $\beta$ -normal forms do not satisfy the subformula property (a key requirement for interpolation) when sums and empty types are present. One must normalize with respect to commuting conversions (pushing eliminations past other eliminations) to recover a class of normal forms with the necessary structural properties.

2. Methodology

The authors propose a new proof strategy that leverages Bidirectional Typing to characterize normal forms, replacing the ad-hoc induction of the original proof.

A. Bidirectional Characterization of Normal Forms

The authors define a bidirectional type system (splitting judgments into inference $\Gamma \vdash t \triangleright A$ and checking $\Gamma \vdash t \triangleleft A$ ) that exactly captures the normal forms of STLC+ under $\beta$ -reduction and commuting conversions.

Neutrals (Inference): Terms that are "stuck" eliminations (e.g., variables, projections of neutrals, applications of neutrals to checked terms).
Normals (Checking): Terms that are fully constructed (constructors like $\lambda$ , pairs, injections) or specific eliminations of positive types (like raise and if) applied to neutrals.
Key Insight: The authors demonstrate that the subformula property inherent in these bidirectional normal forms corresponds naturally to the flow of information in bidirectional typing. This allows for a clean, mutual induction on the structure of normal forms rather than a size-based induction.

B. Normalization via Logical Relations

To apply the interpolation theorem to arbitrary well-typed terms (not just those already in normal form), the authors prove Normalization for STLC+ with commuting conversions.

They use a Logical Relations argument (inspired by Abel and Sattler).
They introduce a concept of "Covering" to handle positive types ( $+$ and $\bot$ ). Since eliminations on these types (like if or raise) are not neutrals, they define a "covering" predicate that captures terms shaped like case trees, ensuring that the leaves of the tree satisfy the reducibility conditions.
This leads to a proof that every well-typed term reduces to a normal form satisfying the subformula property.

C. The Interpolation Proof

Using the bidirectional characterization, the authors perform a mutual induction on the structure of normal forms and neutrals:

They maintain a context partition ( $\Gamma = \Gamma_s \cup \Gamma_t$ ) to track which variables belong to the source ( $A$ ) and target ( $B$ ) vocabularies.
For each rule in the bidirectional system, they construct the interpolant type $M$ and the terms $l$ (source to $M$ ) and $r$ ( $M$ to target) such that the composition reconstructs the original term.
Handling Reversals: A novel aspect of their proof is handling cases where the "source" and "target" roles of the context swap (e.g., in the Demote rule), which the original proof struggled with.

3. Key Contributions

New Proof of Čubrić's Theorem: The authors provide a corrected and structurally clearer proof of proof-relevant interpolation for STLC+. By utilizing bidirectional typing, they avoid the pitfalls of the original size-based induction and fix the erroneous case handling.
Formalization in Rocq: The entire meta-theory is formalized in the Rocq proof assistant (formerly Coq). This includes:
- The first formalized proof of normalization for STLC+ with commuting conversions.
- A complete formalization of the proof-relevant interpolation theorem.
- The code is approximately 4,000 lines of code (LoC), significantly more compact than previous formalizations of similar logic properties.
Connection between Bidirectional Typing and Subformula Property: The paper explicitly establishes that bidirectional typing systems naturally characterize normal forms with the subformula property, a connection previously suspected but not rigorously exploited for interpolation in the presence of sums.
Handling Constants and Equations: The theorem is generalized to include arbitrary constants and equational theories, showing the robustness of the approach.

4. Results

Theorem (Interpolation): For any well-typed term $x:A \vdash t:B$ in STLC+, there exists a type $C$ built from the common vocabulary of $A$ and $B$ , and terms $u: A \to C$ and $v: C \to B$ , such that $(\lambda y. v) u \twoheadrightarrow^* t$ .
Normalization: Every well-typed term in STLC+ reduces to a normal form (under $\beta$ and commuting conversions).
Formal Verification: The proofs are machine-checked in Rocq. The formalization uses automation tools like AutoSubst2 for substitution calculus and setoid rewriting for reduction steps, though the authors note performance challenges with current solvers.

5. Significance

Correctness and Reliability: By formalizing the proof, the authors expose and correct subtle errors in Čubrić's original 1990s work, providing a verified foundation for proof-relevant interpolation.
Methodological Shift: The paper advocates for using bidirectional typing as a primary tool for proving structural properties (like interpolation) in type theory, moving away from traditional, often messy, size-based inductions.
Categorical Implications: Since STLC+ is the internal language of Bi-Cartesian Closed Categories (biCCCs), the result provides categorical corollaries, offering a "categorification" of interpolation results for Heyting algebras.
Future Directions: The authors outline paths to extend this work to:
- Non-normal terms: Interpolating terms with redexes (cuts) by restricting the vocabulary of the cut formulas.
- Uniform Interpolation: Generating a single interpolant for a whole sub-language.
- Dependent Types: Extending the theorem to dependent type theory, though this faces challenges regarding the well-typedness of commuting conversions in dependent contexts (e.g., the "convoy pattern").

In summary, this paper successfully modernizes and verifies a classic result in proof theory by bridging the gap between logical interpolation, categorical semantics, and modern type-theoretic techniques like bidirectional typing and logical relations.