Results 1  10
of
15
Truly modular (co)datatypes for Isabelle/HOL
, 2014
"... We extended Isabelle/HOL with a pair of definitional commands for datatypes and codatatypes. They support mutual and nested (co)recursion through wellbehaved type constructors, including mixed recursion–corecursion, and are complemented by syntaxes for introducing primitively (co)recursive functi ..."
Abstract

Cited by 9 (8 self)
 Add to MetaCart
We extended Isabelle/HOL with a pair of definitional commands for datatypes and codatatypes. They support mutual and nested (co)recursion through wellbehaved type constructors, including mixed recursion–corecursion, and are complemented by syntaxes for introducing primitively (co)recursive functions and by a general proof method for reasoning coinductively. As a case study, we ported Isabelle’s Coinductive library to use the new commands, eliminating the need for tedious ad hoc constructions.
Guarded dependent type theory with coinductive types, 2015, submitted for publication. Available online at http://userscs.au.dk/birke/papers/gdttconf.pdf
"... We present guarded dependent type theory, gDTT, an extensional dependent type theory with a ‘later ’ modality and clock quantifiers for programming and proving with guarded recursive and coinductive types. The later modality is used to ensure the productivity of recursive definitions in a modular, ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We present guarded dependent type theory, gDTT, an extensional dependent type theory with a ‘later ’ modality and clock quantifiers for programming and proving with guarded recursive and coinductive types. The later modality is used to ensure the productivity of recursive definitions in a modular, type based, way. Clock quantifiers are used for controlled elimination of the later modality and for encoding coinductive types using guarded recursive types. We demonstrate the expressiveness of gDTT via a range of examples. Key to the development of gDTT are novel type and term formers involving what we call ‘delayed substitutions’. These generalise the applicative functor rules for the later modality considered in earlier work, and are crucial for programming and proving with dependent types. We show soundness of the type theory using a denotational model.
Corecursion in SessionTyped Processes
"... Abstract—Session types are widely accepted as a useful expressive discipline for structuring communications in concurrent and distributed systems. In order to express infinitely unbounded sessions, as required to model the behaviour of realistic distributed systems, session typed languages often i ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract—Session types are widely accepted as a useful expressive discipline for structuring communications in concurrent and distributed systems. In order to express infinitely unbounded sessions, as required to model the behaviour of realistic distributed systems, session typed languages often introduce general recursion operators at both the program and the type level. Unfortunately, general recursion, in particular when combined with name passing and mobility, may easily introduce undesirable divergence, e.g., infinite unobservable reduction sequences. In this paper we address, by means of typing, the challenge of ensuring nondivergence in a sessiontyped picalculus with general (co)recursion, while still allowing interesting infinite behaviours to be definable, as necessary to model realistic open process networks and distributed systems. Our approach builds on a CurryHoward correspondence between our type system and a standard system of linear logic extended with coinductive types, for which our nondivergence property implies consistency. We prove type safety for our framework, implying protocol compliance and global progress of welltyped processes. Remarkably, we also establish through a logical relations argumentthat welltyped processes are compositionally nondivergent, in the sense that no welltyped composition of processes, including compositions dynamically assembled through name passing, can result in divergent behaviour, a property of practical relevance. I.
Corecursion and NonDivergence in Session Types
"... Abstract. Session types are widely accepted as an expressive discipline for structuring communications in concurrent and distributed systems. In order to express infinitely unbounded sessions, session typed languages often include general recursion which may introduce undesirable divergence, e.g., i ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Session types are widely accepted as an expressive discipline for structuring communications in concurrent and distributed systems. In order to express infinitely unbounded sessions, session typed languages often include general recursion which may introduce undesirable divergence, e.g., infinite unobservable reduction sequences. In this paper we address, by means of typing, the challenge of ensuring nondivergence in a sessiontyped πcalculus with general (co)recursion, while still allowing interesting infinite behaviors to be definable. Our approach builds on a CurryHoward correspondence between our type system and linear logic extended with coinductive types, for which our nondivergence property implies consistency. We prove type safety for our framework, implying protocol compliance and global progress of welltyped processes. We also establish, using a logical relation argument, that welltyped processes are compositionally nondivergent, that is, that no welltyped composition of processes, including those dynamically assembled via name passing, can result in divergent behavior. 1
Foundational Extensible Corecursion
, 2014
"... This paper presents a theoretical framework for defining corecursive functions safely in a total setting, based on corecursion upto and relational parametricity. The end product is a general corecursor that allows corecursive (and even recursive) calls under wellbehaved operations, including con ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
This paper presents a theoretical framework for defining corecursive functions safely in a total setting, based on corecursion upto and relational parametricity. The end product is a general corecursor that allows corecursive (and even recursive) calls under wellbehaved operations, including constructors. Corecursive functions that are well behaved can be registered as such, thereby increasing the corecursor’s expressiveness. To the extensible corecursor corresponds an equally flexible coinduction principle. The metatheory is formalized in the Isabelle proof assistant and forms the core of a prototype tool. The approach is foundational: The corecursor is derived from first principles, without requiring new axioms or extensions of the logic. This ensures that no inconsistencies can be introduced by omissions in a termination or productivity check.
How to Reason Coinductively Informally
, 2015
"... We start by giving an overview of the theory of indexed inductively and coinductively defined sets. We consider the theory of strictly positive indexed inductive definitions in a set theoretic setting. We show the equivalence between the definition as an indexed initial algebra, the definition via ..."
Abstract
 Add to MetaCart
(Show Context)
We start by giving an overview of the theory of indexed inductively and coinductively defined sets. We consider the theory of strictly positive indexed inductive definitions in a set theoretic setting. We show the equivalence between the definition as an indexed initial algebra, the definition via an induction principle, and the set theoretic definition of indexed inductive definitions. We review as well the equivalence of unique iteration, unique primitive recursion, and induction. Then we review the theory of indexed coinductively defined sets or final coalgebras. We construct indexed coinductively defined sets set theoretically, and show the equivalence between the category theoretic definition, the principle of unique coiteration, of unique corecursion, and of iteration together with bisimulation as equality. Bisimulation will be defined as an indexed coinductively defined set. Therefore proofs of bisimulation can be carried out corecursively. This fact can be considered together with bisimulation implying equality as the coinduction principle for the underlying coinductively defined set. Finally we introduce various schemata for reasoning about coinductively defined sets in an informal way: the schemata of corecursion, of indexed corecursion, of coinduction, and of corecursion for coinductively defined relations. This allows to reason about coinductively defined sets similarly as one does when reasoning about inductively defined sets using schemata of induction. We obtain the notion of a coinduction hypothesis, which is the dual of an induction hypothesis. 1
unknown title
, 2015
"... A model of guarded recursion with clock synchronisation ..."
(Show Context)
Programming and Reasoning with Infinite Structures Using Copatterns and Sized Types ∗
"... Inductive data such as lists and trees is modeled categorytheoretically as algebra where construction is the primary concept and elimination is obtained by initiality. In a more practical setting, functions are programmed by pattern matching on inductive data. Dually, coinductive structures such as ..."
Abstract
 Add to MetaCart
Inductive data such as lists and trees is modeled categorytheoretically as algebra where construction is the primary concept and elimination is obtained by initiality. In a more practical setting, functions are programmed by pattern matching on inductive data. Dually, coinductive structures such as streams and processes are modeled as coalgebras where destruction (or transition) is primary and construction rests on finality [Hag87]. Due to the coincidence of least and greatest fixedpoint types [SP82] in lazy languages such as Haskell, the distinction between inductive and coinductive types is blurred in partial functional programming. As a consequence, coinductive structures are treated just as infinitely deep (or, nonwellfounded) trees, and pattern matching on coinductive data is the dominant programming style. In total functional programming, which is underlying the dependentlytyped proof assistants Coq [INR12] and Agda [Nor07], the distinction between induction and coinduction is vital for the soundness, and pattern matching on coinductive data leads to the loss of subject reduction [Gim96]. Further, in terms of expressive power, the productivity checker for definitions by coinduction lacks behind the termination checker for inductively defined functions.
A Formalized Proof of Strong Normalization for Guarded Recursive Types
"... Abstract. We consider a simplified version of Nakano’s guarded fixedpoint types in a presentation of infinite type expression, defined coinductively. Smallstep reduction is parametrized by a natural number “depth ” that expresses under how many guards we may step during evaluation. We prove that r ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We consider a simplified version of Nakano’s guarded fixedpoint types in a presentation of infinite type expression, defined coinductively. Smallstep reduction is parametrized by a natural number “depth ” that expresses under how many guards we may step during evaluation. We prove that reduction is strongly normalizing for any depth. The proof involves a typed inductive notion of strong normalization and a Kripke model of types in two dimensions: depth and typing context. Our results have been formalized in Agda and serve as a case study of reasoning about a language with coinductive type expressions. 1