On the semantics of fair parallelism

Suppose that a programming language involves, among other familiar ways of composing commands Ci, a "parallel" construct (C1 par C2) . One expects, when using this language, that a sequence such as x := O; y := 1; (x := 1 par (while x=0 do y := y+1)) should be guaranteed to terminate in whatever context it is executed

PROCESSES AND FORMALISMS FOR UNBOUNDED CHOICE

In the field of program refinement a specification construct has been proposed that does not have a standard operational interpretation. Its weakest preconditions are monotone but not necessarily conjunctive. In order to develop a corresponding calculus we introduce specification algebras. These algebras may have two choice operators: demonic choice and angelic choice. The wish to allow unbounded choice, of both modalities, leads to the question of defining and constructing completions of specification algebras. It is shown that, in general, a specification algebra need not have a completion. On the other hand, a formalism is developed that allows for any specific combination of unbounded demonic choice, unbounded angelic choice and sequential composition. The formalism is based on transition systems. It is related to the processes of De Bakker and Zucker.</p

Expression Refinement

This thesis presents a refinement calculus for expressions. The aim of refinement calculi is to make programming a mathematical activity, and thereby improve the correctness of programs. To achieve this, a refinement calculus provides a formal language and a set of rules that allow transformations of the language terms. Using a refinement calculus, to produce a correct program, the programmer writes a possibly non-algorithmic or inefficient term that nevertheless obviously describes the intended program. This term is the specification, and it is transformed into an efficient program by syntactic transformation, using the rules of the refinement calculus. This transformation is refinement

Programs as Diagrams: From Categorical Computability to Computable Categories

This is a draft of the textbook/monograph that presents computability theory using string diagrams. The introductory chapters have been taught as graduate and undergraduate courses and evolved through 8 years of lecture notes. The later chapters contain new ideas and results about categorical computability and some first steps into computable category theory. The underlying categorical view of computation is based on monoidal categories with program evaluators, called *monoidal computers*. This categorical structure can be viewed as a single-instruction diagrammatic programming language called Run, whose only instruction is called RUN. This version: improved text, moved the final chapter to the next volume. (The final version will continue lots of exercises and workouts, but already this version has severely degraded graphics to meet the size bounds.)Comment: 150 pages, 81 figure

Predicate Abstraction with Indexed Predicates

Predicate abstraction provides a powerful tool for verifying properties of infinite-state systems using a combination of a decision procedure for a subset of first-order logic and symbolic methods originally developed for finite-state model checking. We consider models containing first-order state variables, where the system state includes mutable functions and predicates. Such a model can describe systems containing arbitrarily large memories, buffers, and arrays of identical processes. We describe a form of predicate abstraction that constructs a formula over a set of universally quantified variables to describe invariant properties of the first-order state variables. We provide a formal justification of the soundness of our approach and describe how it has been used to verify several hardware and software designs, including a directory-based cache coherence protocol.Comment: 27 pages, 4 figures, 1 table, short version appeared in International Conference on Verification, Model Checking and Abstract Interpretation (VMCAI'04), LNCS 2937, pages = 267--28