2 research outputs found
Applications of Category Theory to Programming and Program Specification
Category theory is proving a useful tool in programming and program specification - not only as a descriptive language but as directly
applicable to programming and specification tasks.
Category theory achieves a level of generality of description at
which computation is still possible. We show that theorems from
category theory often have constructive proofs in the sense that they
may be encoded as programs. In particular we look at the computation
of colimits in categories showing that general theorems give rise to
routines which considerably simplify the rather awkward computation
of colimits.
The general routines arising from categorical constructions can be
used to build programs in the 'combinatorial' style of programming.
We show this with an example - a program to implement the semantics
of a specification language. More importantly, the intimate
relationship between these routines and algebraic specifications
allows us to develop programs from certain forms of specifications.
Later we turn to algebraic specifications themselves and look at
properties of "monadic theories". We establish that, under suitable
conditions:
1. Signatures and presentations may be defined for monadic
theories and free theories on a signature may be
constructed.
2. Theory morphisms give rise to ad junctions between
categories of algebras and moreover a collection of
algebras of a theory give rise to a new theory with
certain properties.
3. Finite colimits and certain factorisations exist in
categories of monadic theories.
4. Many-sorted, order-sorted and even category-sorted
theories may be handled by somewhat extending the notion
of monadic theories.
These results show that monadic theories are sufficiently
well-behaved to be used in the semantics of algebraic specification
languages. Some of the constructions can be encoded as programs by
the techniques mentioned above
Semantics, Implementation and Pragmatics of Clear, a Program Specification Language
Specifications are necessary for communicating decisions and
intentions and for documenting results at many stages of the program
development process. Informal specifications are typically used
today, but they are imprecise and often ambiguous. Formal
specifications are precise and exact but are more difficult to write
and understand. We present work aimed toward enabling the practical
use of formal specifications in program development, concentrating
on the Clear language for structured algebraic specification.
Two different but equivalent denotational semantics for Clear are
given. One is a version of a semantics due to Burstall and Goguen
with a few corrections, in which the category-theoretic notion of a
colimit is used to define Clear's structuring operations
independently of the underlying 'institution' (logical formalism).
The other semantics defines the same operations by means of
straightforward set-theoretic constructions; it is not institutionindependent
but it can be modified to handle all institutions of
apparent interest.
Both versions of the semantics have been implemented. The settheoretic
implementation is by far the more useful of the two, and
includes a parser and typechecker. An implementation is useful for
detecting syntax and type errors in specifications, and can be used
as a front end for systems which manipulate specifications. Several
large specifications which have been processed by the set-theoretic
implementation are presented.
A semi-automatic theorem prover for Clear built on top of the
Edinburgh LCF system is described. It takes advantage of the
structure of Clear specifications to restrict the available
information to that which seems relevant to proving the theorem at
hand. If the system is unable to prove a theorem automatically the
user can attempt the proof interactively using the high-level
primitives and inference rules provided.
We lay a theoretical foundation for the use of Clear in
systematic program development by investigating a new notion of the
implementation of a specification by a lower-level specification.
This notion extends to handle parameterised specifications. We show
that this implementation relation is transitive and commutes with
Clear's structuring operations under certain conditions. This means
that a large specification can be refined to a program in a gradual
and modular fashion, where the correctness of the individual
refinements guarantees the correctness of the resulting program