. A coalgebra is introduced here as a model of a certain signature consisting of a type X with various "destructor" function symbols, satisfying certain equations. These destructor function symbols are like methods and attributes in object-oriented programming: they provide access to the type (or state) X. We show that the category of such coalgebras and structure preserving functions is comonadic over sets. Therefore we introduce the notion of a `mongruence' (predicate) on a coalgebra. It plays the dual role of a congrence (relation) on an algebra. An algebra is a set together with a number of operations on this set which tell how to form (derived) elements in this set, possibly satisfying some equations. A typical example is a monoid, given by a set M with operations 1 ! M , M \Theta M ! M . Here 1 = f;g is a singleton set. In mathematics one usually considers only single-typed algebras, but in computer science one more naturally uses many-typed algebras like 1 ! list(A), A \Theta l...

We investigate the development of theories of types and computability via realizability.

Lax logical relations are a categorical generalisation of logical relations; though they preserve product types, they need not preserve exponential types. But, like logical relations, they are preserved by the meanings of all lambda-calculus terms. We show that lax logical relations coincide with the correspondences of Schoett, the algebraic relations of Mitchell and the pre-logical relations of Honsell and Sannella on Henkin models, but also generalise naturally to models in cartesian closed categories and to richer languages.

We give a canonical program refinement calculus based on the lambda calculus and classical first-order predicate logic, and study its proof theory and semantics. The intention is to construct a metalanguage for refinement in which basic principles of program development can be studied. The idea is that it should be possible to induce a refinement calculus in a generic manner from a programming language and a program logic. For concreteness, we adopt the simply-typed lambda calculus augmented with primitive recursion as a paradigmatic typed functional programming language, and use classical first-order logic as a simple program logic. A key feature is the construction of the refinement calculus in a modular fashion, as the combination of two orthogonal extensions to the underlying programming language (in this case, the simply-typed lambda calculus). The crucial observation is that a refinement calculus is given by extending a programming language to allow indeterminate expressions (or ‘stubs’) involving the construction ‘some program x such that P ’. Factoring this into ‘some x...’

Coalgebras of polynomial functors constructed from set of observable elements have been found useful in modelling various kinds of data types and state-transition systems. This paper continues the study of equational logic and model theory for polynomial coalgebras begun in [6], where it was shown that Boolean combinations of equations between terms of observable type form a natural language of observable formulas for specifying properties of polynomial coalgebras, and for giving a Hennessy-Milner style logical characterisation of observational indistinguishability (bisimilarity) of states. Here we give a structural characterisation of classes of coalgebras definable by observable formulas. This is an analogue for polynomial coalgebras of Birkhoff's celebrated characterisation of equationally definable classes of abstract algebras as being those closed under homomorphic images, subalgebras, and direct products. The coalgebraic characterisation involves a new notion of an observational ultrapower of a coalgebra, obtained from the usual notion of ultrapower by deleting states that assign "nonstandard" values to terms of observable type. A class of polynomial coalgebras is shown to be the class of all models of a set of observable formulas if, and only if, it is closed under images of bisimilarity relations, disjoint unions and observational ultrapowers.

Introduction Quotients are used throughout mathematics for constructing new objects from old, by collapsing part of the structure, see for example any textbook on algebra or topology. Here we give a completely general description of such quotients in a type theoretic language. We assume a simple type theory, together with a predicate logic to reason about types and terms. Then quotients can be described as a left adjoint to a certain equality-predicate functor. This gives us all the rules we need: formation, introduction, elimination and (fi)- and (j)-conversions for quotients. These will be described in the next section below. Subsequently, the new syntax is put to use in constructing Z from N, a poset from a preorder, the abelianization of a group, and tensor products\Omega and sums \Phi of abelian groups. All these constructions involve taking a suitable quotient. They will be de

We introduce a semantic framework which generalises algebraic specifications by equipping algebras with descriptions of evaluation strategies. The semantic objects are not merely algebras, but algebras with associated data dependencies. The latter provide separate means for modeling computational concerns along with the functional specifications usually captured by an algebra. The formalization of evaluation strategies allows the formal manipulation of how the operations of an algebra are to be evaluated. This formalization introduces (1) increased portability among different hardware platforms, as well as (2) allowing a potential increase in execution efficiency, since a chosen evaluation strategy may be tailored to a particular platform. We present the development process where algebraic specifications are equipped with data dependencies, the latter are then refined and, finally, mapped to actual hardware architectures. 1 Introduction The creed of algebraic specification is abstract...

5.1 Definition and Examples 5.1.1 Definition and Definability Results A tripos is a weak tripos with disjunction which has a (weak) generic object. Explicitly we define: