The complexity of probabilistic verification

Reviewer: Moshe Vardi

Program verification has always been a desirable task, but never an easy one. The advent of concurrent programming has made it significantly more necessary and difficult. Indeed, the conceptual complexity of concurrency increases the likelihood of a program containing errors. In the traditional approach to concurrent program verification, the correctness of the program is expressed as a formula in first-order temporal logic. To prove that the program is correct, one has to prove that the correctness formula is a theorem of a certain deductive system. This proof is constructed manually and is usually quite difficult to construct. It often requires an intimate understanding of the program. Furthermore, there is no hope of constructing the proof completely algorithmically. The only extent of automation that one can hope for is to have the proof checked by a machine and, possibly, to have some limited heuristic help in finding the proof. A different approach was introduced in the early 1980s [1] for finite-state programs, that is, programs in which the variables range over finite domains. The significance of this class follows from the fact that a significant number of the communication and synchronization protocols studied in the literature are, in essence, finite-state programs. Thus, to verify the correctness of the program, one has only to check algorithmically that the program, viewed as a finite-state transition system, satisfies (is a model of) a propositional temporal logic specification. This approach, called “verification by model checking,” was described by Apt and Kozen as “one of the most exciting developments in the theory of program correctness.” An extension of the model-checking approach to probabilistic programs was proposed in my paper [2]. Here, the program is modeled as a finite sequential Markov chain or finite concurrent Markov chain. Instead of attempting to verify that all computations of the program satisfy the specification (given by a linear temporal formula), one attempts to verify that the specification holds with probability 1, that is, that the set of computations that satisfy the specification has probability 1. This can be called probabilistic verification. The probability is relative to the probabilistic steps of the program and the worst possible scheduling of the various processes. This definitive paper continues the investigation by studying the complexity of probabilistic verification. It provides tight upper and lower bound. For sequential programs, the problem is shown to be PSPACE-complete, and for concurrent programs, the problem is 2EXPTIME-complete. (2EXPTIME denotes the class of problems that can be solved in doubly exponential time.) In either case, the source of the high complexity is the linear temporal specification; the algorithms run in time that is linear in the size of the program. The fundamental idea is to reduce model checking to the checking of certain graph-theoretic properties of the underlying Markov chain. It turns out that the precise numeric value of the probabilities is irrelevant.