Linear vs. branching time: a complexity-theoretic perspective

The discussion of the relative merits of linear versus branching time frameworks goes back to early 1980s. One of the beliefs dominating this discussion has been that "while specifying is easier in LTL (linear-temporal logic), verification is easier for CTL (branching-temporal logic)". Indeed, the restricted syntax of CTL limits its expressive power and many important behaviours (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, however, that the computational superiority of the branching time framework is perhaps illusory. In this talk we will compare the complexity of branching-time verification vs. Linear-time verification in many scenarios, 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 between complexity and expressiveness.

[1]  Joseph Y. Halpern,et al.  Decision procedures and expressiveness in the temporal logic of branching time , 1982, STOC '82.

[2]  Orna Kupferman,et al.  Verification of Fair Transition Systems , 1998, Chic. J. Theor. Comput. Sci..

[3]  Richard E. Ladner,et al.  Propositional Dynamic Logic of Regular Programs , 1979, J. Comput. Syst. Sci..

[4]  Leslie Lamport,et al.  Specifying Concurrent Program Modules , 1983, TOPL.

[5]  R. Kurshan,et al.  Formal Verification In A Commercial Setting , 1997, Proceedings of the 34th Design Automation Conference.

[6]  Amir Pnueli,et al.  On the Development of Reactive Systems , 1989, Logics and Models of Concurrent Systems.

[7]  Edmund M. Clarke,et al.  Symbolic Model Checking: 10^20 States and Beyond , 1990, Inf. Comput..

[8]  Pierre Wolper,et al.  Synthesis of Communicating Processes from Temporal Logic Specifications , 1981, TOPL.

[9]  Pierre Wolper,et al.  An automata-theoretic approach to branching-time model checking , 2000, JACM.

[10]  Amir Pnueli,et al.  In Transition From Global to Modular Temporal Reasoning about Programs , 1989, Logics and Models of Concurrent Systems.

[11]  A. Udaya Shankar,et al.  Protocol Verification via Projections , 1984, IEEE Transactions on Software Engineering.

[12]  José L. Balcázar,et al.  Deciding Bisimilarity is P-Complete , 1992, Formal Aspects Comput..

[13]  Leslie Lamport,et al.  "Sometime" is sometimes "not never": on the temporal logic of programs , 1980, POPL '80.

[14]  Colin Stirling,et al.  Comparing Linear and Branching Time Temporal Logics , 1987, Temporal Logic in Specification.

[15]  Bernhard Josko,et al.  Verifying the Correctness of AADL Modules Using Model Checking , 1989, REX Workshop.

[16]  Robin Milner,et al.  An Algebraic Definition of Simulation Between Programs , 1971, IJCAI.

[17]  Martín Abadi,et al.  The existence of refinement mappings , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[18]  Zohar Manna,et al.  Temporal Specification and Verification of Reactive Modules , 1992 .

[19]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.

[20]  Albert R. Meyer,et al.  The Equivalence Problem for Regular Expressions with Squaring Requires Exponential Space , 1972, SWAT.

[21]  Orna Grumberg,et al.  Generation of Reduced Models for Checking Fragments of CTL , 1993, CAV.

[22]  Amir Pnueli,et al.  Impartiality, Justice and Fairness: The Ethics of Concurrent Termination , 1981, ICALP.

[23]  K. Mani Chandy,et al.  Proofs of Networks of Processes , 1981, IEEE Transactions on Software Engineering.

[24]  Chin-Laung Lei,et al.  Modalities for Model Checking: Branching Time Logic Strikes Back , 1987, Sci. Comput. Program..

[25]  E. Allen Emerson,et al.  The complexity of tree automata and logics of programs , 1988, [Proceedings 1988] 29th Annual Symposium on Foundations of Computer Science.

[26]  Matthew Hennessy,et al.  Algebraic theory of processes , 1988, MIT Press series in the foundations of computing.

[27]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[28]  Moshe Y. Vardi.  Sometimes and Not Never Re-revisited: On Branching Versus Linear Time , 1998, CONCUR.

[29]  E. Emerson,et al.  Modalities for model checking (extended abstract): branching time strikes back , 1985, ACM-SIGACT Symposium on Principles of Programming Languages.

[30]  Amir Pnueli,et al.  Checking that finite state concurrent programs satisfy their linear specification , 1985, POPL.

[31]  R. BurchJ.,et al.  Symbolic model checking , 1992 .

[32]  Orna Grumberg,et al.  Model checking and modular verification , 1994, TOPL.

[33]  Amir Pnueli.  The Temporal Semantics of Concurrent Programs , 1981, Theor. Comput. Sci..

[34]  Mordechai Ben-Ari,et al.  The temporal logic of branching time , 1981, POPL '81.

[35]  Amir Pnueli,et al.  Linear and Branching Structures in the Semantics and Logics of Reactive Systems , 1985, ICALP.

[36]  Larry J. Stockmeyer,et al.  Improved upper and lower bounds for modal logics of programs , 1985, STOC '85.

[37]  Bernhard Josko,et al.  Modular Verification of Petri Nets: The Temporal Logic Approach , 1989, REX Workshop.

[38]  Nancy A. Lynch,et al.  Hierarchical correctness proofs for distributed algorithms , 1987, PODC '87.

[39]  Philippe Schnoebelen,et al.  The Complexity of Propositional Linear Temporal Logics in Simple Cases (Extended Abstract) , 1998, STACS.

[40]  Edmund M. Clarke,et al.  Expressibility results for linear-time and branching-time logics , 1988, REX Workshop.

[41]  Michael Yoeli,et al.  Methodology and System for Practical Formal Verification of Reactive Hardware , 1994, CAV.

[42]  Zohar Manna,et al.  Temporal Verification of Reactive Systems , 1995, Springer New York.

[43]  Orna Kupferman,et al.  On the Complexity of Branching Modular Model Checking (Extended Abstract) , 1995, CONCUR.

[44]  Pierre Wolper,et al.  An Automata-Theoretic Approach to Automatic Program Verification (Preliminary Report) , 1986, LICS.

[45]  Joseph Y. Halpern,et al.  “Sometimes” and “not never” revisited: on branching versus linear time temporal logic , 1986, JACM.

[46]  Joseph Sifakis,et al.  Property Preserving Simulations , 1992, CAV.

[47]  Cliff B. Jones,et al.  Specification and Design of (Parallel) Programs , 1983, IFIP Congress.

[48]  Colin Stirling,et al.  Modal and temporal logics , 1993, LICS 1993.

[49]  Orna Kupferman,et al.  Module Checking , 1996, Inf. Comput..

[50]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[51]  E. Allen Emerson,et al.  Temporal and Modal Logic , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[52]  Robert P. Kurshan.  Formal verification in a commercial setting , 1997, DAC.

[53]  Jerzy Tiuryn,et al.  Logics of Programs , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[54]  Joseph Sifakis,et al.  Specification and verification of concurrent systems in CESAR , 1982, Symposium on Programming.

[55]  Kim G. LarsenBRICS.  Compositional Model Checking of Real Time Systems ? , 1995 .

[56]  Alberto Sangiovanni-Vincentelli,et al.  Equivalences for Fair Kripke Structures , 1994, ICALP.

[57]  Wolfgang Thomas,et al.  Automata on Infinite Objects , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.