Reduction: a method of proving properties of parallel programs

  title={Reduction: a method of proving properties of parallel programs},
  author={Richard J. Lipton},
  journal={Commun. ACM},
  • R. Lipton
  • Published 1 December 1975
  • Computer Science
  • Commun. ACM
When proving that a parallel program has a given property it is often convenient to assume that a statement is indivisible, i.e. that the statement cannot be interleaved with the rest of the program. Here sufficient conditions are obtained to show that the assumption that a statement is indivisible can be relaxed and still preserve properties such as halting. Thus correctness proofs of a parallel system can often be greatly simplified. 

Parallel program correctness through refinement

A theory for the correctness of asynchronous parallel programs and a technique for showing that a parallel program is correct with respect to this criterion is developed.

Using Transformation to Verify Parallel Programs

This work argues that the verification of parallel programs can be considerably simplified by using program transformations, and proves correctness of two parallel programs under the assumption of fairness: asynchronous fixed point computation and parallel zero search.

A reduction theorem for concurrent object-oriented programs

This paper introduces a programming notation for concurrent object-oriented programs, called Seuss, and shows that concurrent executions of its programs are, under certain conditions, equivalent to serial executions.

Modular progress proofs of asynchronous programs

The usual way to reason about a concurrent program is to prove that it preserves certain state predicates; such predicates are said to be stable. However, many important techniques of concurrent

Parallel Programs with Synchronization

To formulate waiting conditions for parallel programs whose components can synchronize with each other, the program syntax of Section 6.1 is extended by a synchronization construct, the await-statement introduced in Owicki and Gries [1976a].

On abstractions of parallel programs

It is shown that, for a large class of schedulers, a process can become deadlocked in the original program iff it can become Deadlock in the abstracted program.

Livelocks in parallel programs

It is shown that livelocks are not preserved by reduction, implying that reduction cannot be used directly in proving the absence of livelocks.

On Reductions of Parallel Programs

By a reduction of a parallel program, as informally introduced by Lipton, the number of possible execution sequences is decreased, which facilitates analysis and verification. This method is extended

Proving Isolation Properties for Software Transactional Memory

This work provides a formalization of an STM algorithm that is explicit about all aspects required for a correctness proof: effects of operations, nondeterminism, and modeling rollback.

Brief Announcement: On the Impossibility of Detecting Concurrency

We identify a general principle of distributed computing: one cannot force two processes running in parallel to see each other. This principle is formally stated in the context of asynchronous



Proving Assertions about Parallel Programs

The application of program-proving techniques to the verification of synchronization processes

  • K. Levitt
  • Computer Science
    AFIPS '72 (Fall, part I)
  • 1972
The purpose of this paper is to establish the applicability of program-proving techniques to the verification of operating systems, control programs and synchronization programs and the techniques discussed are applicable to any set of such control primitives.

Synchronization of communicating processes

The formal description of the synchronization mechanism makes it very easy to prove that the buffer will neither overflow nor underflow, that senders and receivers will never operate on the same message frame in the buffer nor will they run into a deadlock.

Correctness in operating systems


  • Dep. of Applied Analysis and Computer Sci., U. of Waterloo
  • 1973

Part 1, 1972 Fall Joint Computer Conference

  • Proc. Montvale, N.J
  • 1972