Results 1  10
of
10
Infinite Objects in Type Theory
"... . We show that infinite objects can be constructively understood without the consideration of partial elements, or greatest fixedpoints, through the explicit consideration of proof objects. We present then a proof system based on these explanations. According to this analysis, the proof expressions ..."
Abstract

Cited by 101 (2 self)
 Add to MetaCart
. We show that infinite objects can be constructively understood without the consideration of partial elements, or greatest fixedpoints, through the explicit consideration of proof objects. We present then a proof system based on these explanations. According to this analysis, the proof expressions should have the same structure as the program expressions of a pure functional lazy language: variable, constructor, application, abstraction, case expressions, and local let expressions. 1 Introduction The usual explanation of infinite objects relies on the use of greatest fixedpoints of monotone operators, whose existence is justified by the impredicative proof of Tarski's fixed point theorem. The proof theory of such infinite objects, based on the so called coinduction principle, originally due to David Park [21] and explained with this name for instance in the paper [18], reflects this explanation. Constructively, to rely on such impredicative methods is somewhat unsatisfactory (see fo...
Interactive Programs in Dependent Type Theory
, 2000
"... . We propose a representation of interactive systems in dependent ..."
Abstract

Cited by 41 (10 self)
 Add to MetaCart
. We propose a representation of interactive systems in dependent
Fast and Loose Reasoning is Morally Correct
, 2006
"... Functional programmers often reason about programs as if they were written in a total language, expecting the results to carry over to nontotal (partial) languages. We justify such reasoning. ..."
Abstract

Cited by 32 (1 self)
 Add to MetaCart
Functional programmers often reason about programs as if they were written in a total language, expecting the results to carry over to nontotal (partial) languages. We justify such reasoning.
Specifying Interactions With Dependent Types
 In Workshop on subtyping and dependent types in programming
, 2000
"... this paper we consider how to express specications of interactions in dependent type theory. The results so far are modest, though we hope we have identied some key structures for describing contracts between independent agents, and shown how to dene them in a dependently typed framework. These are ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
(Show Context)
this paper we consider how to express specications of interactions in dependent type theory. The results so far are modest, though we hope we have identied some key structures for describing contracts between independent agents, and shown how to dene them in a dependently typed framework. These are called below transition systems (2.2) and interaction systems (2.3). Both are coalgebras; transition systems for a functor Fam , and interaction systems for its composite with itself, Fam (Fam ). These structures seems to have interesting connections with predicate transformer semantics for imperative programs, as initiated by Dijkstra, and also with the renement calculus of Back and von Wright as described in their book [2]. We restrict attention to situations in which the system and its environment communicate by exchanging messages in strict alternation, as with the moves in a two player game.
Interactive programs and weakly final coalgebras (extended version
 Dependently typed programming, number 04381 in Dagstuhl Seminar Proceedings, 2004. Available via http://drops.dagstuhl.de/opus
"... GR/S30450/01. 2 A. Setzer, P. Hancock 1 Introduction According to MartinL"of [19]: "... I do not think that the search for logically ever more satisfactory high level programming languages can stop short of anything but ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
GR/S30450/01. 2 A. Setzer, P. Hancock 1 Introduction According to MartinL&quot;of [19]: &quot;... I do not think that the search for logically ever more satisfactory high level programming languages can stop short of anything but
A.: Guarded induction and weakly final coalgebras in dependent type theory
 From Sets and Types to Topology and Analysis. Towards Practicable Foundations for Constructive Mathematics
"... ..."
Infinite Objects In Type Theory
, 1997
"... Contents 1. Introduction 1 2. Lazy Evaluation and Infinite Objects 3 3. Mathematics of Infinity 10 3.1. The extension of type theory with an external infinite object 11 4. Models of Type Theory 18 4.1. The Structure of a Model for Type Theory 19 4.2. The Comma Model 24 4.3. Necessity 26 5. Mathemat ..."
Abstract
 Add to MetaCart
Contents 1. Introduction 1 2. Lazy Evaluation and Infinite Objects 3 3. Mathematics of Infinity 10 3.1. The extension of type theory with an external infinite object 11 4. Models of Type Theory 18 4.1. The Structure of a Model for Type Theory 19 4.2. The Comma Model 24 4.3. Necessity 26 5. Mathematics of Infinity Formalized 27 5.1. The term model 27 5.2. T ff 30 5.3. The standard model 33 5.4. Nonstandard truth 39 6. Examples 43 6.1. Infinity 43 6.2. Linear Search 45 7. Conclusions 50 References 52 1. Introduction It is one of the purposes of this work to explore type theory as a programming language where programs come out correct by construction. This has already been done to some extent following the correspondence types/specifications/propositions and objects /programs/proofs. In our case we will be interested in a particular analysis of streams and other infinite objects as they occur in lazy functio
Interactive Programs in Dependent Type Theory
, 2000
"... . We propose a representation of interactive systems in dependent type theory. This is meant as a basis for an execution environment for dependently typed programs, and for reasoning about their construction; there may be wider applications. The inspiration is the `I/Omonad' of Haskell. The fu ..."
Abstract
 Add to MetaCart
. We propose a representation of interactive systems in dependent type theory. This is meant as a basis for an execution environment for dependently typed programs, and for reasoning about their construction; there may be wider applications. The inspiration is the `I/Omonad' of Haskell. The fundamental notion is an I/Otree; its definition is parameterised over a general notion of dependently typed, commandresponse interactions called a world. I/Otrees represent strategies for one of the parties in a command/response interaction  the notion is not confined to functional programming. The definitions make essential use of the expressive strength of dependent typing. We present I/Otrees in two forms that we call `nonnormalising' and `normalising'. The first form, which is simpler, is suitable for Turingcomplete functional programming languages with general recursion. The second is definable within (ordinary) normalising type theory and we identify programs written in it as `normal...
Precise Reasoning About Nonstrict Functional Programs
"... This thesis consists of two parts. Both concern reasoning about nonstrict functional programming languages with partial and infinite values and lifted types, including lifted function spaces. The first part is a case study in program verification: We have written a simple parser and a corresponding ..."
Abstract
 Add to MetaCart
(Show Context)
This thesis consists of two parts. Both concern reasoning about nonstrict functional programming languages with partial and infinite values and lifted types, including lifted function spaces. The first part is a case study in program verification: We have written a simple parser and a corresponding prettyprinter in Haskell. A natural aim is to prove that the programs are, in some sense, each other’s inverses. The presence of partial and infinite values makes this exercise interesting. We have tackled the problem in different ways, and report on the merits of those approaches. More specifically, first a method for testing properties of programs in the presence of partial and infinite values is described. By testing before proving we avoid wasting time trying to prove statements that are not valid. Then it is proved that the programs we have written are in fact (more or less) inverses using first fixpoint induction and then the approximation lemma.
Dependently Typed Programming
"... Abstract. We reconsider the representation of interactive programs in dependent type theory that the authors proposed in earlier papers. Whereas in previous versions the type of interactive programs was introduced in an ad hoc way, it is here defined as a weakly final coalgebra for a general form of ..."
Abstract
 Add to MetaCart
Abstract. We reconsider the representation of interactive programs in dependent type theory that the authors proposed in earlier papers. Whereas in previous versions the type of interactive programs was introduced in an ad hoc way, it is here defined as a weakly final coalgebra for a general form of polynomial functor. The are two versions: in the first the interface with the real world is fixed, while in the second the potential interactions can depend on the history of previous interactions. The second version may be appropriate for working with specifications of interactive programs. We focus on commandresponse interfaces, and consider both client and server programs, that run on opposite sides such an interface. We give formation/introduction/elimination/equality rules for these coalgebras. These are explored in two dimensions: coiterative versus corecursive, and monadic versus nonmonadic. We also comment upon the relationship of the corresponding rules with guarded induction. It turns out that the introduction rules are nothing but a slightly restricted form of guarded induction. However, the form in which we write guarded induction is not recursive equations (which would break normalisation – we show that type checking becomes undecidable), but instead involves an elimination operator in a crucial way.