Well-founded recursion with copatterns and sized types

@article{Abel2016WellfoundedRW,
  title={Well-founded recursion with copatterns and sized types},
  author={Andreas Abel and Brigitte Pientka},
  journal={Journal of Functional Programming},
  year={2016},
  volume={26}
}
Abstract In this paper, we study strong normalization of a core language based on System ${\mathsf{F}_\omega}$ which supports programming with finite and infinite structures. Finite data such as finite lists and trees is defined via constructors and manipulated via pattern matching, while infinite data such as streams and infinite trees is defined by observations and synthesized via copattern matching. Taking a type-based approach to strong normalization, we track size information about finite… 
An operational interpretation of coinductive types.
TLDR
An approximation theorem is proved which essentially states that if a term reduces to an arbitrarily large finite approximation of an infinite object in the interpretation of a coinductive type, then it infinitarily reduces to one of these objects in theinterpretation of this type.
Type-Based Termination for Futures
TLDR
This paper extends the semi-axiomatic sequent calculus, a subsuming paradigm for futures-based functional concurrency, and its underlying operational semantics with recursion and arithmetic refinements, and enables a new and highly general sized type scheme the authors call sized type refinements.
A case study in programming coinductive proofs: Howe’s method
TLDR
This paper describes mechanizing the property that similarity in the call-by-name lambda calculus is a pre-congruence using Howe’s method in the Beluga formal reasoning system, using higher order abstract syntax (HOAS) encoding of lambda terms together with their operational semantics as intrinsically typed terms.
Is Sized Typing for Coq Practical?
TLDR
CIC∗̂, a sized type theory based on CIC, which extends past work on sized types in CIC with additional Coq features such as global and local definitions and concludes that using size inference as a replacement for syntactic checking is wildly impractical in terms of performance.
Circular Proofs as Session-Typed Processes: A Local Validity Condition
TLDR
This paper describes the computational interpretation of the resulting infinitary proof system as session-typed processes, and provides an effectively decidable local criterion to recognize mutually recursive processes corresponding to valid circular proofs as introduced by Fortier and Santocanale.
Normalization by Evaluation in the Delay Monad
TLDR
An Agda formalization of a normalization proof for simply-typed lambda terms that serves as a proof-of-concept for coinductive programming and reasoning using sized types and copatterns and the soundness and completeness proofs are new.
Circular Proofs as Processes: Type-Based Termination via Arithmetic Refinements
TLDR
This paper extends a core language for persistent shared memory concurrency based on the semi-axiomatic sequent calculus with recursive types and arithmetic refinements to express size indexing and develops a compositional validity condition for recursive concurrent programs viewed as circular proofs that guarantees termination.
The clocks are ticking: no more delays!: reduction semantics for type theory with guarded recursion
TLDR
Clocked Type Theory is presented, a new type theory for guarded recursion that is more suitable for reduction semantics than the existing ones, and it is proved confluence, strong normalisation and canonicity for its reduction semantics, constructing the theoretical basis for a future implementation.
An infinitary rewriting interpretation of coinductive types
TLDR
Using the approximation theorem, it is shown that each well-typed term has a well-defined interpretation in the infinitary rewriting semantics, which gives an operational interpretation of typable terms which takes into account the "limits" of infinite reduction sequences.
Normalization by evaluation for sized dependent types
TLDR
This article integrates dependent types and sized types with higher-rank size polymorphism, which is essential for generic programming and abstraction, and introduces a size quantifier ∀ which lets us ignore sizes in terms for equality checking, alongside with a second quantifiers for abstracting over sizes that do affect the semantics of types and terms.
...
...

References

SHOWING 1-10 OF 60 REFERENCES
Copatterns: programming infinite structures by observations
TLDR
This paper presents a core language for programming with infinite structures by observations together with its operational semantics based on (co)pattern matching, and develops the concept of copattern matching, which allows us to synthesize infinite data.
Type-Based Termination, Inflationary Fixed-Points, and Mixed Inductive-Coinductive Types
TLDR
This article considers inflationary iteration in type systems, and demonstrates how this leads to a more principled type system, with recursion based on well-founded induction, with prototypical implementation, MiniAgda.
Analysis of a Guard Condition in Type Theory (Extended Abstract)
TLDR
It is shown that the proposed type system subsumes those studied by Coquand and Gimenez while still enjoying the basic syntactic properties of subject reduction and strong normalization with respect to a confluent rewriting system first put forward by Gimenez.
Type-Based Termination with Sized Products
TLDR
This type system features prenex stage polymorphism, a weakening of existential quantification over stages, and is precise enough to type quicksort as a non-size increasing function, and accomodate stage addition with all positive inductive types.
Beating the Productivity Checker Using Embedded Languages
TLDR
This paper gives a method for turning a productive program into a guarded program by defining a problem-specific language as a data type, writing the program in the problemspecific language, and writing a guarded interpreter for this language.
Semi-Continuous Sized Types and Termination
TLDR
To explore the space of admissible functions in the presence of higher-kinded data types and impredicative polymorphism, a semantics is developed where sized types are interpreted as functions from ordinals into sets of strongly normalizing terms.
A concurrent logical framework I: Judgments and properties
TLDR
The present report, the first of two technical reports describing CLF, presents the frame- work itself and its metatheory, and a novel, algorithmic formulation of the underlying type theory concentrating on canonical forms leads to a simple notion of definitional equality for concurrent computations in which the order of independent steps cannot be distinguished.
Type-based termination of recursive definitions
TLDR
The system is shown to enjoy subject reduction, strong normalisation of typable terms and to be stronger than a related system $\lambda_{\mathcal{G}}$ in which termination is ensured by a syntactic guard condition.
Combining Typing and Size Constraints for Checking the Termination of Higher-Order Conditional Rewrite Systems
TLDR
This work gives the first termination criterion for higher-order conditional rewriting taking into account the conditions in termination, and allows to describe more precisely how the size of the output of a function depends on thesize of its inputs.
MiniAgda: Integrating Sized and Dependent Types
TLDR
This paper has implemented a core language, MiniAgda, with explicit handling of sizes, to study the application of sized types to proof assistants and programming languages based on dependent type theory.
...
...