Andrzej Blikle

The clean termination of iterative programs

SummaryThe paper is devoted to a program-correctness concept which captures partial correctness, termination (nonlooping) and clean termination (nonabortion). The underlying proof method offers a one-stage proof of all the three properties. This method is proved consistent and algebraically complete. It is first discussed for the general case of arbitrary possibly nondeterministic iterative programs. Next, this case is restricted to arbitrary deterministic iterative programs and finally to structured programs. The presented approach is compared with partial correctness, total correctness and weakest precondition methods. The concluding example shows the verification of an arithmetical program in machine-bounded arithmetics. As a side effect of the verification procedure one finds input boundary conditions which guarantee clean termination.

A three-valued logic for software specification and validation

Different calculi of partial or three-valued predicates have been used and studied by several authors in the context of software specification, development and validation. This paper offers a critical survey on the development of three-valued logics based on such calculi.

On the Development of Correct Specified Programs

The paper describes a method of program development which guarantees correctness. Our programs consist of an operational part, called instruction, and a specification. Both these parts are subject to the development and the refinement process. The specification consists of a pre-and postcondition called global specification and a set of assertions called local specification. A specified program is called correct if: 1) the operational part is totally correct w.r.t. the pre-and postcondition, 2) the precondition guarantees nonabortion, 3) local assertions are adequate for the proof of 1) and 2). The requirement of nonabortion leads to the use of a three-valued predicate calculus. We use McCarthys calculus in that place. The paper contains a description of an experimental programming language PROMET-1 designed for our style of programming. The method is illustrated by the derivation of a bubblesort procedure.

Proving Programs by Sets of Computations

By a computation of a program we mean any finite or infinite sequence of consecutive data-vector states generated by the program during a run. The set of all such computations can be considered as the program meaning. Analysing programs by sets of computations permits one to deal not only with input-output properties like correctness or termination, but also with properties of runs independently are they finite or not. In particular one can analyse system-like programs, where no output at all is expected. Given a program to be analysed we split it into a finite number of modules each of them simple enough for the set of all its computations to be obvioust. Sets of computations associated to modules are combined then into a global set in a way that is described by operational semantics. This semantics — being of litle use for program analysis — is supplemented then by a fixed point semantics that is proved equivalent to the former. Two examples of program analysis are considered: the McCarthys 91-procedure and a consumer-producer system-like program.

Denotational Engineering or from Denotations to Syntax

This paper is devoted to the methodology of using denotational techniques in software design. Since denotations describe the mechanisms of a system and syntax is only a user-visible representation of these mechanisms, we suggest that denotations be developed in the first place and that syntax be derived from them later. That viewpoint is opposite to the traditional (descriptive) style where denotational techniques are used in assigning a meaning to some earlier defined syntax. Our methodology is discussed on an algebraic ground where both denotations and syntax constitute many-sorted algebras and where denotational semantics is a homomorphism between them. On that ground the construction of a denotational model of a software system may be regarded as a derivation of a sequence of algebras. We discuss some mathematical techniques which may support that process especially this part where syntax is derived from denotations. The suggested methodology is illustrated on an example where we develop a toy programming language with rendezvous mechanisms.

On conservative extensions of syntax in system development

In a method called denorational engineering [6] the development of a denotational model of a software system consists of two major steps: first we develop an algebra of denotations Den, then we derive an appropriate algebra of syntax Syn. The latter is constructed in such a way that there exists a unique homomorphism (a denotational semantics) from Syn to Den. As usual, we assume that the syntax is described by a context-free grammar. However, unlike in traditional approaches to denotational semantics, we allow the grammar to be ambiguous. This frequently contributes to the clarity of the underlying definition of semantics and can also make parsing more efficient [2]. The YACC system is a well-known example of a standard computersupport tool where some form of such a possibility has been incorporated: YACC allows for grammars with typical ambiguities justified, for example, by the associativity of an operation or by the use of priority rules. In real-life applications the construction of syntax is not necessarily a one-way process. It may involve backtracking to denotations since after having derived a syntax we may wish to modify denotations and thus have to modify the syntax as well. This may happen both at the stage of the original system design and later, when new versions of an already existing and used system are developed. Every modification of a software system may be described as a combination of two steps: a restriction, where we remove some existing mechanisms, and an extension, where we add some new ones. In the former case the modification of syntax is rather easy: we just have to remove some productions from the corresponding grammar. The latter case, however, may be more complicated. Any extension

Addressless Units for Carrying Out Loop-Free Computations

The paper deMs with the problem of how to design a computer so that the loop-free parts of computations performed by it are handled in the most efficient and rapid manner. In particular, the question is how to design a unit to carry out loop-free computations and how to design the unit-oriented language. Clearly, the sensitive area here is the storing and accessing of intermediate results. I t is assumed that the unit reads the appropriate program step-bystep, performs successive operations serially and stores the intermediate results in a sequence as the computation progresses. Now a problem arises how the unit should extract intermediate results from the sequence when needed. I t is shown that the optimM solution is addressless units (the unit-oriented programs are address-free formulas) which operate in double-endedqueue disciplines, i.e. in disciplines where the actually extracted intermediate result is always either the first or the last element of the stored sequence. The paper follows and extends some ideas given by Z. Pawlak in a number of his papers. I t gives the mathematical background and extentions of Pawlaks results which have been formulated originally in a rather descriptive and informM way. The reader is not assumed to be familiar with Pawlaks papers.

A guided tour of the mathematics of MetaSoft `88

Presentation succinte de letat actuel de la premiere phase du projet Meta Soft, concernant le developpement des bases et des methodes mathematiques