Proofs Of Programs Research Articles

A Linear Programming Proof of Kantorovich's Inequality

Abstract A simple linear programming proof of Kantorovich's inequality is given in this article. This inequality is usually used to compare the variances of the best linear estimates and least squares estimates in regression models.

Assertive comments in APL programming

Current practice in APL programming (and in most other languages) is to use comments to describe what is intended by subsequent lines within a function. An alternative approach to commenting is described, wherein assertions (a concept borrowed from program proof techniques) are inserted into APL code, specifying the present state of relevant variables, etc. It is shown that this approach is especially appropriate for APL, as most APL design is accomplished by working from a desired end result, backwards.

Program derivation through transformations: The evolution of list-copying algorithms

The introduction of Hoare Logic made it feasible to supply correctness proofs of small sequential programs. While correctness proofs of larger programs could be given in principle, the increased size of such a proof warranted additional organization. The present paper puts emphasis on the technique of program transformation to show the derivability and to prove the correctness of some fast list-copying algorithms developed by Robson, Fisher and Clark. This subject was motivated by an earlier paper on the same topic by Lee, De Roever and Gerhart. Some transformation rules necessary for the correctness proofs are given. Other proof techniques used include data refinement and the use of auxiliary variables and structures.

A logic for the description of non-deterministic programs and their properties

We present a logic, called Synchronization Tree Logic (STL), for the specification and proof of programs described in a simple term language obtained from a constant Nil by using a set A of unary operators, a binary operator + and recursion. The elements of A represent names of actions, + represents non-deterministic choice, and Nil is the program preforming no action. The language of formulas of the logic proposed, contains the term language used for the description of programs, i.e., programs are formulas of the logic. This provides a uniform frame to deal with programs and their properties as the verification of anassertion t ⊨ f (t is a program, f is a formula) is reduced to the proof of the validity of the formula t ⊃ f. We propose a sound and under some conditions complete deductive system for synchronization tree logics and discuss their relation with modal logics used for the specification of programs.

The automated proof of a trace transformation for a bitonic sort

In his third volume of The Art of Computer Programming, Knuth presents Batcher's bitonic sorting network. With concurrency, this sorting network can be executed in logarithmic time. Knuth suggests a formal argument for the correctness of the bitonic sorting algorithm (as an exercise), but addresses the question of concurrency only informally. We develop a program for the bitonic sort by (1) deriving a stepwise refinement from Knuth's informal description of the algorithm, (2) deriving from the refinement a sequential execution or ‘trace’ of order O ( n log n) in the length n of the sequence to be sorted, and (3) transforming the sequential trace into a parallel trace of order O(log n) while preserving its semantics. We shall be informal in Steps 1 and 2—although these steps can be formalized. But we will provide a formal treatment of Step 3 and report on the certification of this treatment in a mechanized logic. This work is a contribution to the optimization of programs (via concurrency) through transformation and the automation of program proofs.

Verification of Register Transfer Level Parallel Control Sequences

This correspondence presents a method for proof of correctness of register transfer level (RTL) parallel control sequences that describe hardware behavior. An RTL language endowed with parallel constructs is presented and its semantics is defined. The semantics includes temporal behavior. An assertion-based proof method is presented for verification of parallel control sequences described in this language. An example is given and comparisons are drawn between proofs of parallel register transfer level sequences and parallel programs. The temporal semantics associated with the language permits the construction and proof of parallel sequences that are not possible with parallel programs. Accessing shared resources outside critical regions is possible and is illustrated.

A logic covering undefinedness in program proofs

Recursive definition often results in partial functions; iteration gives rise to programs which may fail to terminate for some imputs. Proofs about such functions or programs should be conducted in logical systems which reflect the possibility of "undefined values". This paper provides an axiomatization of such a logic together with examples of its use.

An Early Program Proof by Alan Turing

The paper reproduces, with typographical corrections and comments, a 1949 paper by Alan Turing that foreshadows much subsequent work in program proving.

A methodology for assessing the correctness of control programs

Control programs occur in a number of critical systems, such as process control systems, ballistic missile defense systems, air-traffic control systems, etc. It is important to accurately determine the correctness of a control program prior to using it, since any failures can be disastrous. Ideally it is preferable to prove that the program is correct. However, program proofs are not adequate since the specification itself can be incorrect or incomplete due to the complexity of the requirements. Hence, they have to be supplemented with systematic testing. In this paper we first analyze the role of program proofs in estimating the correctness of control programs. Then we develop a fuzzy-set-based measure of the correctness possibility of these programs. The input domain is partitioned into a set of hierarchical fuzzy equivalence classes. We estimate the computational and control flow correctness of each equivalence class. The computational correctness possibility is derived from an estimate of the complexity of the computations performed by the equivalence class. The control flow correctness possibility is based on the boundary value aspects and cohesiveness of the equivalence class. The model also incorporates the development history of the program. This is used to minimize the number of test cases.

Correctness proofs of CSP programs

In a research report we have proposed an axiomatic semantics for the language of communicating sequential processes (CSP) of Hoare (1978). In this paper, we use the axiomatic semantics to prove the correctness of a number of CSP programs.

A correctness proof of an indenting program

AbstractThe correctness of an indenting program for Pascal is proved at an intermediate level of rigour. The specifications of the program are given in the companion paper.1 The program is approximately 330 lines long and consists of four modules: io, lex, stack and indent. We prove first that the individual procedures contained in these modules meet their specifications as given by the entry and exit assertions. A global proof of the main routine then establishes that the interaction between modules is such that the main routine meets the specification of the entire program. We argue that correctness proofs at the level of rigour used here serve very well to transfer one's understanding of a program to others. We believe proofs at this level should become commonplace before more formal proofs can take over to reduce traditional testing to an inconsequential place.

Data processing and computer science theory

Theoretical results have had much greater impact on computing practice than we are normally aware of, and the practical significance of theoretical results can be expected to become more prominent in the future. We discuss the past and present significance for data processing specialists of some results in analysis of algorithms, languages, and program proofs, and argue for a greater emphasis on computer science theory in data processing curricula.

Proofs by induction in equational theories with constructors

We show how to prove (and disprove) theorems in the initial algebra of an equational variety by a simple extension of the Knuth-Bendix completion algorithm. This allows us to prove by purely equational reasoning theorems whose proof usually requires induction. We show applications of this method to proofs of programs computing over data structures, and to proofs of algebraic-summation identities. This work extends and simplifies recent results of Musser, “Proc., 7th Annual ACM Symposium on Principles of Programming Languages,” Las Vegas, January 1980, pp. 154–162, and Goguen, “Proc., 5th Conf. on Automated Deduction,” Les Arcs, July 1980, pp. 356–373.

Recursive assertions and parallel programs

We prove that recursive assertions are enough for proofs of parallel programs considered in Owicki and Gries [7]. In other words, we prove that for any parallel program S and recursive assertions p and q if {p} S{q} is true under the standard interpretation in natural numbers then all intermediate assertions needed in the proof can be chosen recursive. Finally, we show that if auxiliary variables are used only as program counters then the above result does not hold.

Facial disjunctive programs and sequence of cutting-planes

A cutting-plane procedure for facial disjunctive programs is presented. At each step the point to be cut away and the disjunction used to generate the cut may be chosen freely. Some general comments on finiteness proofs for discrete programs are also given.

Derivation of Invariant Assertions During Program Development by Transformation

Two approaches to the development of efficient and correct iterative programs are contrasted: the construction of an iterative program and a proof of its correctness using invariant assertions of loops, and the construction and proof of a recursive program with a subsequent transformation into an iterative version by schematically applying suitable recursion removal rules. The connection between the approaches is demonstrated by augmenting such transformation rules by inductive assertions. It is argued that the latter approach to program development is superior since the correctness proof of a recursive program is easier in most cases. Considerable verification overhead can be avoided this way, in particular, some difficulties with the interaction of successive loops and their associated invariants.

Social processes and proofs of theorems and programs

Social processes and proofs of theorems and programs

A note on the proof of a concurrent program

A note on the proof of a concurrent program

An Exercise in Automatic Program Verification

This paper describes in some detail the computer-aided proof of a permutation program obtained using the Stanford Pascal verifier. We emphasize the systematic way in which a proof can be developed from an intuitive understanding of the program. The paper fillustrates the current state of the art in automatic program verification.

Social processes and proofs of theorems and programs

It is argued that formal verifications of programs, no matter how obtained, will not play the same key role in the development of computer science and software engineering as proofs do in mathematics. Furthermore the absence of continuity, the inevitability of change, and the complexity of specification of significantly many real programs make the formal verification process difficult to justify and manage. It is felt that ease of formal verification should not dominate program language design.