Type-based termination of recursive definitions

Abstract

This paper introduces λ , a simply typed lambda calculus supporting inductive types and recursive function definitions with termination ensured by types. The system is shown to enjoy subject reduction, strong normalisation of typable terms and to be stronger than a related system λ G in which termination is ensured by a syntactic guard condition. The system can, at will, be extended to support coinductive types and corecursive function definitions also.Type-based termination of recursive definitions 103 2 ι-reduction → ι is defined as the compatible closure of the rulewhere # a = ar(c i ). 3 µ-reduction → µ is defined as the compatible closure of the ruleRemark 2.4. Our formulation of the β-and µ-reduction rules relies on a variable convention: in the β-rule, the bound variables of e are assumed to be different from the free variables of e ; in the µ-rule, the bound and the free variables of e are assumed to be different.The mechanics of the reduction calculus is illustrated by the following example. Example 2.5. Consider the inductive type of natural numbers Nat with C(Nat) = {o, s}. Let plus ≡ (letrec plus = λx. λy. case x of {o ⇒ y | s ⇒ λx . s (plus x y)}). The following is a reduction sequence that computes one plus two, where, as usual, β denotes the reflexive and transitive closure of → β . plus (s o) (s (s o)) → µ (λx. λy. case x of {o ⇒ y | s ⇒ λx . s (plus x y)}) (s o) (s (s o)) β case s o of {o ⇒ s (s o) | s ⇒ λx . s (plus x (s (s o)))} → ι (λx . s (plus x (s (s o)))) o → β s (plus o (s (s o))) → µ s ((λx. λy. case x of {o ⇒ y | s ⇒ λx . s (plus x y)}) o (s(s o))) β s (case o of {o ⇒ s (s o) | s ⇒ λx . s (plus x (s (s o)))}) → ι s (s (s o)) Types and typing systemWe now assume we are given two denumerable sets V T of type variables and V S of stage variables, and adopt the naming convention that α, α , α i , β, δ, . . . range over V T , and ı, , . . . range over V S . Proceeding from these, we define stage and type expressions. Stage expressions are built of stage variables, a symbol for the successor function on stages, and a symbol for the limit stage. A type expression is either a type variable, a function type expression or a datatype approximation expression. Definition 2.6 (Stages and types).1 The set S of stage expressions is given by the abstract syntax: s, r ::= ı | ∞ | s.

Automated Termination Analysis for Haskell: From Term Rewriting to Programming Languages

“…Any Haskell-program (without type classes and built-in data structures) 2 can automatically be transformed into a program from this subset [15]. 3 For example, in our implementation lambda abstractions are removed by replacing every Haskell-term "\ t 1 ...t n → t" with the free variables x 1 , ..., x m by "f x 1 . .…”

“…Methods for first-order languages with strict evaluation strategy were developed in [5,11,17]. For higher-order languages, [1,3,18] study how to ensure termination by typing and [16] defines a restricted language where all evaluations terminate. A successful approach for automated termination proofs for a small Haskell-like language was developed in [12].…”

“…Sect. 3. But in contrast to [12], then our method transforms the termination graph into dependency pair problems which can be handled by existing techniques from term rewriting (Sect.…”

Defining and Reasoning About Recursive Functions: A Practical Tool for the Coq Proof Assistant

“…Another approach is to increase the class of recursive functions that are accepted by Coq's termination criterion by introducing increasingly powerful syntactic schemes [8], or more semantical schemes based on size information [4] (the latter also bears some resemblance with work of Xi [25] on enforcing termination using restricted dependent types). In fact, the implementation of the ad-hoc predicate approach could be significantly simplified by abandoning the guard predicate in favor of type-based termination methods, especially for inversion lemmas.…”

“…We automatically generate a proof script for this definition 4 . During the proof, applications of the induction hypothesis are justified using compatibility properties previously discharged by the user.…”