MiniAgda: Integrating Sized and Dependent Types

Abstract

Sized types are a modular and theoretically well-understood tool for checking termination of recursive and productivity of corecursive definitions. The essential idea is to track structural descent and guardedness in the type system to make termination checking robust and suitable for strong abstractions like higher-order functions and polymorphism. To study the application of sized types to proof assistants and programming languages based on dependent type theory, we have implemented a core language, MiniAgda, with explicit handling of sizes. New considerations were necessary to soundly integrate sized types with dependencies and pattern matching, which was made possible by modern concepts such as inaccessible patterns and parametric function spaces. This paper provides an introduction to MiniAgda by example and informal explanations of the underlying principles.

Type-Based Termination, Inflationary Fixed-Points, and Mixed Inductive-Coinductive Types

“…Inductive data constructors have type (∃ j < i. F (µ j F)) → µ i F, meaning that when we pattern match at inductive type µ i F, we get a fresh size variable j < i and a rest of type F (µ j F). This is the "good" way of matching that avoids paradoxes [Abe10]; find it also in Barras [Bar10a]. Coinductive data has type ν i F ∼ = ∀ j < i. F (ν j F), akin to a dependent function type.…”

“…Pattern matching on coinductive types is known to violate subject reduction in dependent type theory (detailed analysis by McBride [McB09]). Deep matching on sized types can lead to a surprising paradox [Abe10].…”

Size-based termination of higher-order rewriting

“…(x + y) + z → x + (y + z)), while termination criteria based on types with size annotations are restricted to matching on constructor symbols. Current implementations of termination checkers based on typing with size annotations include ATS (Xi, 2003;ATS, 2018), MiniAgda (Abel, 2010;MiniAgda, 2014), Agda (Agda, 2017), cicminus (Sacchini, 2011;cicminus, 2015) or HOT (HOT, 2012). Most of these tools assume given the annotated types of function symbols (e.g.…”

Flag-based big-step semantics

“…Indeed, Danielsson [25] leverages some of this support by using mutually recursive/corecursive functions (which Coq does not support) in his big-step functional operational semantics for the λ-calculus. Also working in Agda, Abel and Chapman [26] use sized types [32] for their proofs by coinduction.…”