Michael J. C. Gordon

A Metalanguage for interactive proof in LCF

LCF (Icqic for Caqmtable Functions) is a prcof generating system mnsisting of an interactive programing language MG (MetaLmguage) for mnducting prcofs in PPA (Polynmrphic Predicate A-calculus) , a deductive calculus suitable for the formalisation of reasoning almut recursively defined functions, in particular about the syntax, semantics and iq?lementations of many prqrcmming languages. PPI is an enrichment (in respect of type structure and expressive pcwer) of an extended a-calculus due to Dana Scott and is fully discussed elsewhere [ 22 I . The puxposes of this paper are (a) to illustrate the features of ML which me it of general interest in language design quite independently of its use for machine assistd formal pxcof, (b) to illustrate ML applied to PPA, in encoding interesting prcof -finding-andperfonning procedures, and (c) to convey a methodology for controlled semiautomatic proof.

General concepts and notation

This chapter is rather long and tedious—it is a ’user manual’ for the notation and concepts we shall need. On first reading one should only look in detail at 3.1. and 3.2., the other sections should be quickly skimmed and then referred to later when their contents are used. Here is a quick overview of the main sections: 3.1. We explain the concept of ‘abstract syntax’—the kind of syntactic description convenient for semantics. 3.2. We explain why we use ”domains” rather than sets and discuss informally the role of the underlying mathematical theories. 3.3. We describe different kinds of domains and ways of building them. 3.4. We discuss the concept of a function and then describe numerous notations for manipulating them.

Denotational description of TINY

The purpose of the battery of abbreviatory conventions described in the preceding chapter is to provide a set of notations which are both powerful and concise. We would like the expressions and definitions we write— semantic clauses for example—to be both brief and readable. Unfortunately there is some conflict between these two requirements-compact notations are often hard to understand, but, conversely, long descriptions often hide the really important facts in a confusing morass of minor detail. Exactly how to trade off compactness versus explicit detail is still a matter of controversy and the reader must decide for himself whether powerful abbreviations (like the sequencing operator ⋆ of 3.4.12.2. for example) are a help or hinderance to understanding.

A second example: the Language SMALL

The language SMALL described in this chapter has two roles: (i) To illustrate the main ideas of standard semantics. (ii) To provide a ’kernel language’ which we shall extend as we discuss the semantics of various constructs in later chapters.

A first example: the language TINY

In this chapter we shall describe the syntax and semantics of a little programming language called TINY. Our purpose is to provide a vehicle for illustrating various formal concepts in use. In subsequent chapters we shall describe these concepts systematically but here we just sketch out the main ideas and associated techniques.

Various kinds of procedures and functions

In this chapter we discuss a number of ’dimensions’ along which procedures (and functions) can be varied. In outline these are: (i) Number of parameters. (ii) Possibility of recursion. (iii) Environment used to bind free identifiers (i.e. identifiers in the body which are not formal parameters). (iv) Coercion of the actual parameter value. (v) Evaluation of the actual parameter expression.

Escapes and Jumps

In this chapter we describe various constructs which change the ’flow of control’. From a semantic viewpoint the normal continuation is ignored and control passes to some other one. Constructs of this sort are sometimes called sequencers.