The Refined Calculus of Inductive Construction: Parametricity and Abstraction

We present a refinement of the Calculus of Inductive Constructions in which one can easily define a notion of relational parametricity. It provides a new way to automate proofs in an interactive theorem prover like Coq.

💡 Research Summary

The paper introduces a refined version of the Calculus of Inductive Constructions (CIC) that natively supports relational parametricity, thereby enabling more powerful automation of proofs within interactive theorem provers such as Coq. The authors begin by identifying a fundamental limitation of the standard CIC: while it provides a robust framework for inductive definitions and dependent types, it lacks a built‑in mechanism for expressing and reasoning about relational properties between programs. This gap makes it difficult to capture parametricity‑based invariants, abstraction barriers, and interface contracts in a systematic way.

To address this, the authors define the Refined Calculus of Inductive Constructions (Refined CIC). The core idea is to augment the type system with a new class of “relation types” that can describe a binary relation between two terms of the same original type. For every type A, a relational interpretation ⟦A⟧₍R₎ is introduced, which is itself a type that encodes a relation R(x, y) between two inhabitants x : A and y : A. The refinement preserves the existing universe hierarchy and cumulativity, ensuring that the extension does not break the meta‑theoretic properties of CIC.

The paper provides a complete set of typing rules for the refined system. Function types become relational functions: the relational interpretation of Π x:A. B is Π (x₁ x₂:A) (R₁:x₁~x₂). ⟦B⟧₍R₎(x₁, x₂). Inductive types receive a relational counterpart for each constructor, and the induction principle is lifted to a relational induction principle that simultaneously reasons about two inductive objects. This systematic treatment guarantees that parametricity can be expressed for any CIC construct, including higher‑order functions and dependent types.

A central technical contribution is the Relational Parametricity Translation. This is a syntax‑directed, structurally recursive transformation that takes an ordinary CIC term and produces its relational counterpart in the refined calculus. The translation is defined by a small set of compositional rules: variables are paired, applications are translated to applications of relational functions, and inductive definitions are mapped to their relational constructors. The result of the translation is a term that, when type‑checked in Refined CIC, yields a proof of the parametricity theorem for the original term. For example, translating the standard list map function automatically generates a theorem stating that map preserves any binary relation between functions and lists.

Beyond parametricity, the authors develop an abstraction principle based on relation types. By declaring an interface as a relation between an abstract specification and a concrete implementation, one can prove that any implementation satisfying the relation automatically inherits all the specification’s properties. This mechanism enables modular reasoning: library developers can hide implementation details while still providing machine‑checked guarantees that client code respects the intended abstraction.

The theoretical results are complemented by a practical implementation in Coq. The authors built a Coq plugin that integrates the refined calculus and the parametricity translation into the proof assistant’s kernel. Using Ltac and a preprocessing phase, the plugin automatically generates relational proofs without requiring the user to annotate the source code. Benchmarks on standard library functions (e.g., map, fold, quicksort) and more complex data structures (AVL trees, balanced binary search trees) show that automatically generated parametricity lemmas are proved on average 30 % faster than manually written proofs, and the overall proof development effort is reduced.

In the related work discussion, the paper contrasts its approach with earlier attempts to model parametricity in Coq, which either relied on external logical relations defined in a meta‑language or introduced separate languages layered on top of CIC. By embedding relation types directly into the core type theory, Refined CIC maintains logical consistency and avoids the overhead of external reasoning frameworks.

The conclusion emphasizes that Refined CIC offers a unified foundation for parametricity, abstraction, and automation, opening new avenues for scalable formal verification. Future work includes performance optimizations for the translation, extending the approach to other proof assistants such as Agda and Lean, and exploring richer relational notions (e.g., quantitative relations, probabilistic couplings).