Functional programmers often reason about programs as if they were written in a total language, expecting the results to carry over to non-total (partial) languages. We justify such reasoning.

This article is a tutorial on four methods for proving properties of corecursive programs: fixpoint induction, the approximation lemma, coinduction, and fusion.

Corecursive programs produce values of greatest fixpoint types, in contrast to recursive programs, which consume values of least fixpoint types. There are a number of widely used methods for proving properties of corecursive programs, including fixpoint induction, the take lemma, and coinduction. However, these methods are all rather low-level, in the sense that they do not exploit the common structure that is often present in corecursive definitions. We argue for a more structured approach to proving properties of corecursive programs. In particular, we show that by writing corecursive programs using an operator called unfold that encapsulates a common pattern of corecursive de nition, we can then use high-level algebraic properties of this operator to conduct proofs in a purely calculational style that avoids the use of either induction or coinduction.

Abstract not found

Abstract. This work is a case study in program verification: We have written a simple parser and a corresponding pretty-printer in a nonstrict functional programming language with lifted pairs and functions (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 in the domains makes this exercise interesting, and having lifted types adds an extra spice to the task. We have tackled the problem in different ways, and this is a report on the merits of those approaches. More specifically, we first describe a method for testing properties of programs in the presence of partial and infinite values. By testing before proving we avoid wasting time trying to prove statements that are not valid. Then we prove that the programs we have written are in fact (more or less) inverses using first fixpoint induction and then the approximation lemma. 1

Whilst the relationship between initial algebras and monads is well-understood, the relationship between nal coalgebras and comonads is less well explored. This paper shows that the problem is more subtle and that final coalgebras can just as easily form monads as comonads and dually, that initial algebras form both monads and comonads. In developing these theories we strive to provide them with an associated notion of syntax. In the case of initial algebras and monads this corresponds to the standard notion of algebraic theories consisting of signatures and equations: models of such algebraic theories are precisely the algebras of the representing monad. We attempt to emulate this result for the coalgebraic case by defining a notion cosignature and coequation and then proving the models of this syntax are precisely the coalgebras of the representing comonad.

This paper shows that the problem is more subtle than might appear at first glance: final coalgebras can form monads just as easily as comonads and dually, initial algebras form both monads and comonads

The results reported in Part III consist of joint work with Martín Escardó [14]. All the other results reported in this thesis are due to the author, except for background results, which are clearly stated as such. Some of the results in Part IV have already appeared as [28]. Note This version of the thesis, produced on October 31, 2006, is the result of completing all the minor modifications as suggested by both the examiners in the viva report (Ref: CLM/AC/497773). We develop an operational domain theory to reason about programs in sequential functional languages. The central idea is to export domaintheoretic techniques of the Scott denotational semantics directly to the study of contextual pre-order and equivalence. We investigate to what extent this can be done for two deterministic functional programming languages: PCF (Programming-language for Computable Functionals) and FPC (Fixed Point Calculus).