Edward A. Ashcroft

Lucid, a nonprocedural language with iteration

Lucid is a formal system in which programs can be written and proofs of programs carried out. The proofs are particularly easy to follow and straightforward to produce because the statements in a Lucid program are simply axioms from which the proof proceeds by (almost) conventional logical reasoning, with the help of a few axioms and rules of inference for the special Lucid functions. As a programming language, Lucid is unconventional because, among other things, the order of statements is irrelevant and assignment statements are equations. Nevertheless, Lucid programs need not look much different than iterative programs in a conventional structured programming language using assignment and conditional statements and loops.

Lucid—A Formal System for Writing and Proving Programs

Lucid is both a programming language and a formal system for proving properties of Lucid programs. The programming language is unconventional in many ways, although programs are readily understood as using assignment statements and loops in a “structured” fashion. Semantically, an assignment statement is really an equation between “histories”, and a whole program is simply an unordered set of such equations.From these equations, properties of the program can be derived by straightforward mathematical reasoning, using the Lucid formal system. The rules of this system are mainly those of first order logic, together with extra axioms and rules for the special Lucid functions.This paper formally describes the syntax and semantics of programs, and justifies the axioms and rules of the formal system.

Decidable Properties of Monadic Functional Schemas

A class of (monadic) functional schemas which properly includes “Ianov” flowchart schemas is defined. It is shown that the termination, divergence, and freedom problems for functional schemas are decidable. Although it is possible to translate a large class of non-free functional schemas into equivalent free functional schemas, it is shown that in general this cannot be done. It is also shown that the equivalence problem for free functional schemas is decidable. Most of the results are obtained from well-known results in formal languages and automata theory.

A mathematical semantics for a nondeterministic typed λ-calculus

Abstract This paper is concerned with the problems encountered in defining the semantics of nondeterministic algorithms. A nondeterministic control structure is added to a typed λ-calculus and the usual operational semantics for the deterministic language is generalized to take into account the more complex behaviour of nondeterministic algorithms. A mathematical model is then given for the language and the relationship between the denotational and operational semantics is explored.

Translating Program Schemas to While-Schemas

While-schemas are defined as program schemas without goto statements, in which iteration is achieved using while statements. We present two translations of program schemas into equivalent while-schemas, the first one by adding extra program variables, and the second one by adding extra logical variables. In both cases we aim to preserve as much of the structure of the original program schemas as possible.We also show that, in general, any translation must add variables.

Parameter-passing mechanisms and nondeterminism

The problem of defining an adequate semantics for recursive definitions which allow various types of parameter-passing mechanisms has generated a considerable amount of interest in the literature. (See [B1], [M4], [R3], [V2]) Consider for example the well-known recursive definition F <X, Y> <&equil; IF X&equil;0 THEN 0 ELSE F<X−1,F<X, Y>>. Interpreted as a fixpoint equation over the flat cpo of non-negative integers it has as its least solution f(x, y) = 0 if x&equil;m for any non-negative integer m &equil; @@@@ otherwise (“@@@@” means undefined) This also happens to coincide with the computed function if a call-by-name (or outside-in) evaluation mechanism is used. However if a call-by-value (or inside-out) evaluation mechanism is used the computed function is fv (x, y) &equil; 0 if x&equil;0 &equil; @@@@ otherwise In [Vl] the conclusion is drawn that the call-by-value evaluation mechanism is incorrect and should not be considered.

DECIDABLE PROPERTIES OF MONADIC FUNCTIONAL SCHEMAS

We define a class of (monadic) functional schemas which properly includes ‘Ianov’ flowchart schemas. We show that the termination, divergence and freedom problems for functional schemas are decidable. Although it is possible to translate a large class of non-free functional schemas into equivalent free functional schemas, we show that this cannot be done in general. We show also that the equivalence problem for free functional schemas is decidable. Most of the results are obtained from well-known results in Formal Languages and Automata Theory.

A generalized setting for fixpoint theory

Abstract The mathematical semantics of programming languages is based largely on certain algebraic structures, usually complete lattices or complete partial orders. The usefulness of these structures is based on the existence of fixpoints of functions defined on the structures, and the fact that these classes of structures are closed under such operations as taking cross-products, disjoint unions or function spaces. This paper proposes more general versions of these structures which still retain the above desirable properties. Thus the techniques of mathematical semantics should become applicable in a wider context than heretofore. One important application is given, which in fact motivated the whole development. It is shown that in the generalized setting the existence of unique minimal solutions for recursive definitions of functions are guaranteed without having to resort to informal arguments of any sort.