Rod M. Burstall’s research while affiliated with University of Edinburgh and other places

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. A later version of this paper is Pebble: A kernel language for modules and abstract data types, Information and Computation 76, 2/3 (Feb./Mar. 1988), pp 278-346

There is a population explosion among the logical systems being used in computer science. Examples include first order logic (with and without equality), equational logic, Horn clause logic, second order logic, higher order logic, infinitary logic, dynamic logic, process logic, temporal logic, and modal logic; moreover, there is a tendency for each theorem prover to have its own idiosyncratic logical system. Yet it is usual to give many of the same results and applications for each logical system; of course, this is natural in so far as there are basic results in computer science that are independent of the logical system in which they happen to be expressed. But we should not have to do the same things over and over again; instead, we should generalize, and do the essential things once and for all! Also, we should ask what are the relationships among all these different logical systems. This paper shows how some parts of computer science can be done in any suitable logical system, by introducing the notion of an institution as a precise generalization of the informal notion of a "logical system." A first main result shows that if an institution is such that interface declarations expressed in it can be glued together, then theories (which are just sets of sentences) in that institution can also be glued together. A second main result gives conditions under which a theorem prover for one institution can be validly used on theories from another; this uses the notion of an institution morphism. A third main result shows that institutions admiting free models can be extended to institutions whose theories may include, in addition to the original sentences, various kinds of constraints upon interpretations; such constraints are useful for defining abstract data types, and include so-called "data," "hierarchy," and "generating" constraints. Further results show how to define insitutions that mix sentences from one institution with constraints from another, and even mix sentences and (various kinds of) constraints from several different institutions. It is noted that general results about institutions apply to such "multiplex" institutions, including the result mentioned above about gluing together theories. Finally, this paper discusses some applications of these results to specification languages, showing that much of that subject is in fact independent of the institution used.

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 str~tngies for proof in structured theories are also discussed.

Using the program transformation technique we derive some algorithms for evaluating linear recurrence relations in logarithmic time. The particular case of the Fibonacci function is first considered and a comparison with the conventional matrix exponentiation algorithm is made. This comparison allows us also to contrast the transformation technique and the stepwise refinement technique underlining some interesting features of the former one. Through the examples given we also explain why those features are interesting for a useful and reliable program construction methodology.

In the last ten years or so a lot of algebraic ideas have wormed their way into Computer Science, particularly in work connected with correctness of compilers, with abstract data types and with specification. We have been among those responsible [Burstall and Goguen 1980, 1981]. Most papers begin with a compressed section of definitions, but it is difficult for the well-disposed outsider to make much of these. Reference to books for algebraists, such as Graetzer [1979], or even to those angled towards automata theory [Arbib and Manes 1975] may not be encouraging. So it is perhaps worthwhile to present some of the key algebraic ideas in a leisurely and, we hope, intuitive form, emphasising the Computer Science connection. Some water has flowed under the bridge since one of us was last involved in an attempt to do this [Goguen, Thatcher, Wagner and Wright 1975].

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.

An abstract is not available.