Linear vs. Branching Time: A Complexity-Theoretic Perspective Moshe Y. Vardi Rice University Abstract The discussion of the relative merits of lin- ear versus branching time frameworks goes back to early 1980s. One of the beliefs dominating this dis- cussion has been that “while specifying is easier in LTL (linear-temporal logic), verification is easier for CTL (branching-temporal logic)”. Indeed, the re- stricted syntax of CTL limits its expressive power and many important behaviors (e.g., strong fairness) can not be specified in CTL. On the other hand, while model checking for CTL can be done in time that is linear in the size of the specification, it takes time that is exponential in the specification for LTL. A closer examination of the the issue reveals, how- ever, that the computational superiority of the branch- ing time framework is perhaps illusory. In this talk we will compare the complexity of branching-time verification vs. linear-time verification in many sce- narios, and show that linear-time verification is not harder and often is even easier than branching-time verification. This suggests that the tradeoff between branching and linear time is not a simple tradeoff be- tween complexity and expressiveness. 1 Introduction Temporal logics, which are modal logics geared towards the description of the temporal ordering of events, have been adopted as a powerful tool for spec- ifying and verifying open programs [MP92a, MP95]. Two possible views regarding the nature of time in- duce two types of temporal logics [Lam80]. In lin- ear temporal logics, time is treated as if each moment Address: CS Department, Rice University, Houston TX 77005-1892, U.S.A. Email: vardi@cs.rice.edu , URL: http://www.cs.rice.edu/ vardi. Supported in part by NSF grants CCR-9628400 and CCR-9700061, and by a grant from the Intel Corporation. in time has a unique possible future. Thus, linear temporal logic formulas are interpreted over linear se- quences and we regard them as describing a behavior of a single computation of a program. In branching temporal logics, each moment in time may split into various possible futures. Accordingly, the structures over which branching temporal logic formulas are in- terpreted can be viewed as infinite computation trees, each describing the behavior of the possible compu- tations of a nondeterministic program. In the linear temporal logic LTL, formulas are com- posed from the set of atomic propositions using the usual Boolean connectives as well as the temporal op- erators (“always”), (“eventually”), (“next”), and (“until”). For example, the LTL formula req grant refers to the atomic propositions req and grant and is true in a computation iff every state in the computation in which req hold is followed by some state in the future in which grant holds. The branching temporal logic CTL augments LTL by the path quantifiers (“there exists a computation”) and (“for all computations”). For example, the CTL formula req grant is true in a com- putation tree iff in all its computations, every state in which req holds branches to at least one computation in which grant eventually holds. The branching tem- poral logic CTL is a fragement of CTL in which ev- ery temporal operator is preceded by a path quanti- fier. For example, while above is a CTL formula, the CTL formula req grant is not a CTL formula. The expressive powers of LTL and CTL are incomparable [Lam80], while CTL is more expres- sive than both LTL and CTL [EH86]. The discussion of the relative merits of linear ver- sus branching temporal logics is by now almost 20- years old [Lam80, CE81, QS81, Pnu81, BMP83,