Browse Books

Reviewer: Andreas Ramses Heckler

A reactive system is a nonterminating system of concurrent processes. Their activities may sometimes require some coordination (such as in a producer-consumer relationship), and this task may be fulfilled by the processes involved or by additional controlling processes. The linear time approach models reactive systems as sets of infinite state sequences called computations. A state is modeled as an assignment for the relevant variables in the program. The mathematical model of a reactive system, according to the linear-time approach, answers questions such as “What states may be reached by the system at execution time__?__” “In which order may the reachable states arise, that is, what are possible computations__?__” and “Is it possible that something is first consumed by a process and then produced by another__?__” The model does not allow explicit reasoning about parallel activities, because they are considered as interleaved. An elegant means of describing models according to the linear time approach is temporal logic (TL), which allows abstract descriptions (specifications) of sets of infinite state sequences. Such a description abstracts from implementation details (such as concrete processes) their explicit coordination and their realization by means of assignments, loops, cooperation statements, communication via channels, and so on. In order to define these details (that is, to implement a reactive system), one can use the Simple Programming Language (SPL). The connection between TL and SPL is provided by the computational model for SPL. Each program in SPL is associated with a fair transition system, and fair transition systems describe computations (sets of infinite state sequences). A program <__?__Pub Fmt italic>P<__?__Pub Fmt /italic> has a property expressed by a temporal formula &fgr; (“<__?__Pub Fmt italic>P<__?__Pub Fmt /italic> is correct with respect to &fgr;”) if every computation of <__?__Pub Fmt italic>P<__?__Pub Fmt /italic> is specified by the formula &fgr;. Verification is the process of formally proving the correctness of a given program <__?__Pub Fmt italic>P<__?__Pub Fmt /italic> with respect to a given temporal formula &fgr;. Temporal verification not only relates to the temporal logic TL, but also indicates that the underlying first-order logic and the problem of verifying programs with respect to first-order formulas are not the book's main issues (though they are not completely ignored). The notion of “safety” relates to a classification of <__?__Pub Fmt nolinebreak>temporal<__?__Pub Fmt /nolinebreak> formulas (and temporal properties) that distinguishes “safety formulas/properties” from “progress formulas/properties” and subdivides the latter into “reactivity, response, persistence, obligation” and “guarantee formulas/properties.” Informally speaking, a safety formula specifies that nothing bad ever happens, whereas a progress formula specifies that something good eventually happens. The main interest is the verification of arbitrary SPL programs with respect to safety formulas. This book is the second in a sequence of three volumes organized as follows. Volume 1, <__?__Pub Fmt italic>The temporal logic of reactive and concurrent systems: specifications<__?__Pub Fmt /italic>, studies in great detail the computational model, the system description language, the language of temporal logic, and its use for specifying system properties. Volume 2, the book under review, presents verification techniques for proving safety properties. I refer to this volume as the safety book. Volume 3, <__?__Pub Fmt italic>Temporal verification of reactive systems: progress<__?__Pub Fmt /italic>, presents verification techniques for proving progress properties. The safety book is organized as follows. Chapter 0 introduces fair transition systems, SPL, and TL.<__?__Pub Fmt eos-space>C<__?__Pub Caret1>hapters 1 through 3 present a deductive approach for proving arbitrary SPL programs correct with respect to special kinds of safety formulas. Each of sections 2.6, 3.6, and 4.10 also provides an algorithmic approach for proving finite-state programs (programs <__?__Pub Fmt italic>P<__?__Pub Fmt /italic> whose system variables assume only finitely many values in all computations of <__?__Pub Fmt italic>P<__?__Pub Fmt /italic>) correct with respect to special kinds of safety formulas and general safety formulas respectively. Chapter 5 extends this algorithmic approach to the verification of finite-state programs with respect to arbitrary temporal formulas. The book is intended for people who are interested in the formal verification of reactive systems and its theoretical foundations. The book is not a guide for implementing verification tools. The reader should have some familiarity with programming, programming languages, basic concurrency concepts, first-order logic, and the notions of validity and provability by deductive systems. However, no knowledge of TL, SPL, and fair transition systems is needed, since these topics are introduced in chapter 0. Even though the book is the second of three volumes, it is indeed “largely self-contained and can be studied or taught independently of the first volume.” The presentation is clear and concise. Many concepts are first developed for a simple case and then extended for the general (and hence more difficult) case. All concepts, and even minor definitions, are illustrated by examples. Moreover, many figures are provided to assist the reader in understanding. The end of each chapter features exercises and bibliographic remarks.