Rod M. Burstall

A Transformation System for Developing Recursive Programs

A system of rules for transforming programs is described, with the programs in the form of recursion equations. An initially very simple, lucid, and hopefully correct program is transformed into a more efficient one by altering the recursion structure. Illustrative examples of program transformations are given, and a tentative implementation is described. Alternative structures for programs are shown, and a possible initial phase for an automatic or semiautomatic program-manipulation system is indicated.

Institutions: abstract model theory for specification and programming

There is a population explosion among the logical systems used in computing science. Examples include first-order logic, equational logic, Horn-clause logic, higher-order logic, infinitary logic, dynamic logic, intuitionistic logic, order-sorted logic, and temporal logic; moreover, there is a tendency for each theorem prover to have its own idiosyncratic logical system. The concept of institution is introduced to formalize the informal notion of “logical system.” The major requirement is that there is a satisfaction relation between models and sentences that is consistent under change of notation. Institutions enable abstracting away from syntactic and semantic detail when working on language structure “in-the-large”; for example, we can define language features for building large logical system. This applies to both specification languages and programming languages. Institutions also have applications to such areas as database theory and the semantics of artificial and natural languages. A first main result of this paper says that any institution such that signatures (which define notation) can be glued together, also allows gluing together theories (which are just collections of sentences over a fixed signature). A second main result considers when theory structuring is preserved by institution morphisms. A third main result gives conditions under which it is sound to use a theorem prover for one institution on theories from another. A fourth main result shows how to extend institutions so that their theories may include, in addition to the original sentences, various kinds of constraint that are useful for defining abstract data types, including both “data” and “hierarchy” constraints. Further results show how to define institutions that allow sentences and constraints from two or more institutions. All our general results apply to such “duplex” and “multiplex” institutions.

The Semantics of CLEAR, A Specification Language

This paper gives a semantics for the Clear language for specifying problems and programs, described by Burstall and Goguen in 1977. A blend of denotational semantics with categorical ideas is used.

A system which automatically improves programs

SummaryHere we give methods of mechanically converting programs that are easy to understand into more efficient ones, converting recursion equations using high level operations into lower level flowchart programs.The main transformations involved are (i) recursion removal (ii) eliminating common subexpressions and combining loops (iii) replacing procedure calls by their bodies (iv) introducing assignments which overwrite list cells no longer in use (compiletime garbage collection).

A versatile system for computer-controlled assembly

Abstract A versatile assembly system, using TV cameras and computer-controlled arm and moving table, is described. It makes simple assemblies such as a peg and rings and a toy car. It separates parts from a heap, recognizing them with an overhead camera, then assembles them by feel. It can be instructed to perform a new task with different parts by spending an hour or two showing it the parts and a day programming the assembly manipulations. A hierarchical description of parts, views, outlines, etc. is used to construct models, and a structure matching algorithm is used in recognition.

Some fundamental algebraic tools for the semantics of computation, part 3: indexed categories

Abstract This paper presents indexed categories which model uniformly defined families of categories, and suggests that they are a useful tool for the working computer scientist. An indexed category gives rise to a single flattened category as a disjoint union of its component categories plus some additional morphisms. Similarly, an indexed functor (which is a uniform family of functors between the components categories) induces a flattened functor between the corresponding flattened categories. Under certain assumptions, flattened categories are (co)complete if all their components are, and flattened functors have left adjoints if all their components do. Several examples are given. Although this paper is Part 3 of the series “Some fundamental algebraic tools for the semantics of computation”, it is entirely independent of Parts 1 and 2.

A kernel language for abstract data types and modules.

A small set of constructs can simulate a wide variety of apparently distinct features in modern programming languages. Using typed lambda calculus with bindings, declarations, and types as first-class values, we show how to build modules, interfaces and implementations, abstract data types, generic types, recursive types, and unions. The language has a concise operational semantics given by inference rules.

Structured Theories in LCF

An extension to the Edinburgh LCF interactive theorem-proving system is described which provides new ways of constructing theories, drawing upon ideas from the Clear specification language. A new theory can be built from an existing theory in two new ways: by renaming its types and constants, or by abstraction (forgetting some types and constants and perhaps renaming the rest). A way of providing parameterised theories is described. These theory-building operations — together with operations for forming a primitive theory and for taking the union of theories — allow large theories to be built in a flexible and well-structured fashion. Inference rules and strategies for proof in structured theories are also discussed.

Some fundamental algebraic tools for the semantics of computation: Part 1: Comma Categories, Colimits, Signatures and Theories

Abstract This paper develops a number of fundamental tools from category theory and applies them to problems in computation. The tools include algebraic theories, colimits, comma categories and two-dimensional categories. The applications concern making program specifications understandable by expressing them as interconnections of smaller ‘mind sized’ specifications in a variety of ways, as in our language spCLEAR. The link between these tools and applications is the idea of using algebraic theories as program specifications. To carry out this programme requires developing a formal calculus of operations for constructing, modifying and interconnecting theories. These operations include: constructing free theories, combining given theories, deriving new computational functions from old, abstracting (or ‘hiding’) parts of theories, inductively completing a theory, and applying a theory-valued procedure to an actual theory. Because a number of different notions of theory are relevant to computation, this paper also sketches an axiomatically based calculus of operations applicable to any notion of theory which satisfies certain axioms. The paper also presents a number of sample calculations illustrating how the various tools can be used, and proves some general theorems which justify such calculations. Part 1 develops comma categories, colimits, signatures and sorted theories, while Part 2 (to appear in Theoretical Computer Science 31 (3)) introduces signed theories, abstract theories, and further applications to specification.

A categorical unification algorithm

This is a case study in the design of computer programs based upon the twin themes of abstraction and constructivity. We consider the unification of t e rms-a symbol-manipulative task widely used in computa t ion-and derive a unification algorithm based upon constructions in category theory. This hinges on two observations. Firstly, unification may be considered as an instance of something more abstract--as a colimit in a suitable category. Secondly, general constructions of colimits provide recursive procedures for computing the unification of terms.