# Reduction: a method of proving properties of parallel programs

@article{Lipton1975ReductionAM, title={Reduction: a method of proving properties of parallel programs}, author={Richard J. Lipton}, journal={Commun. ACM}, year={1975}, volume={18}, pages={717-721} }

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.

## 500 Citations

### Parallel program correctness through refinement

- Computer SciencePOPL
- 1977

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

- Computer ScienceAlgebraic Methods
- 1989

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

- Computer Science
- 2003

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

- Computer Science
- 1993

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

- Computer Science
- 1991

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

- Computer ScienceSTOC '76
- 1976

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

- Computer Science
- 1981

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

- Computer ScienceICALP
- 1979

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

- Computer ScienceESOP
- 2011

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

- Computer ScienceDISC
- 2018

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…

## References

SHOWING 1-6 OF 6 REFERENCES

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

- Computer ScienceAFIPS '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

- Computer ScienceCACM
- 1972

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.

### CS-73-01

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

### Part 1, 1972 Fall Joint Computer Conference

- Proc. Montvale, N.J
- 1972