The Complexity of Temporal Logic Model Checking

Temporal logic. Logical formalisms for reasoning about time and the timing of events appear in several fields: physics, philosophy, linguistics, etc. Not surprisingly, they also appear in computer science, a field where logic is ubiquitous. Here temporal logics are used in automated reasoning, in planning, in semantics of programming languages, in artificial intelligence, etc. There is one area of computer science where temporal logic has been unusually successful: the specification and verification of programs and systems, an area we shall just call “programming” for simplicity. In today’s curricula, thousands of programmers first learn about temporal logic in a course on model checking! Temporal logic and programming. Twenty five years ago, Pnueli identified temporal logic as a very convenient formal language in which to state, and reason about, the behavioral properties of parallel programs and more generally reactive systems [Pnu77, Pnu81]. Indeed, correctness for these systems typically involves reasoning upon related events at different moments of a system execution [OL82]. Furthermore, when it comes to liveness properties, the expected behavior of reactive systems cannot be stated as a static property, or as an invariant one. Finally, temporal logic is well suited to expressing the whole variety of fairness properties that play such a prominent role in distributed systems [Fra86]. For these applications, one usually restricts oneself to propositional temporal logic: on the one hand, this does not appear to be a severe limitation in practice, and on the other hand, this restriction allows decision procedures for validity and entailment, so that, at least in principle, the above-mentioned reasoning can be automated. Model checking. Generally speaking, model checking is the algorithmic verification that a given logic formula holds in a given structure (the model

[1]  Max J. Cresswell,et al.  A New Introduction to Modal Logic , 1998 .

[2]  Thomas Wilke,et al.  Classifying Discrete Temporal Properties , 1999, STACS.

[3]  Kousha Etessami,et al.  First-Order Logic with Two Variables and Unary Temporal Logic , 2002, Inf. Comput..

[4]  Martin Peschke,et al.  Design and Validation of Computer Protocols , 2003 .

[5]  A. Prasad Sistla,et al.  The complexity of propositional linear temporal logics , 1982, STOC '82.

[6]  François Laroussinie,et al.  Specification in CTL+Past for Verification in CTL , 1999, Inf. Comput..

[7]  Philippe Schnoebelen,et al.  The State Explosion Problem from Trace to Bisimulation Equivalence , 2000, FoSSaCS.

[8]  Leslie Lamport,et al.  Proving Liveness Properties of Concurrent Programs , 1982, TOPL.

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

[10]  Wolfgang Thomas,et al.  Computation Tree Logic CTL* and Path Quantifiers in the Monadic Theory of the Binary Tree , 1987, ICALP.

[11]  M. Rabin.  Decidability of second-order theories and automata on infinite trees , 1968 .

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

[13]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[14]  Nicolas Markey.  Past is for free: on the complexity of verifying linear temporal properties with past , 2003, Acta Informatica.

[15]  John P. Burgess,et al.  Basic Tense Logic , 1984 .

[16]  Colin Stirling,et al.  Modal Logics and mu-Calculi: An Introduction , 2001, Handbook of Process Algebra.

[17]  Dennis Dams.  Flat Fragments of CTL and CTL*: Separating the Expressive and Distinguishing Powers , 1999, Log. J. IGPL.

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

[19]  Joseph Y. Halpern.  The Effect of Bounding the Number of Primitive Propositions and the Depth of Nesting on the Complexity of Modal Logic , 1995, Artif. Intell..

[20]  Thomas Wilke,et al.  CTL+ is Exponentially more Succinct than CTL , 1999, FSTTCS.

[21]  Johan Anthory Willem Kamp,et al.  Tense logic and the theory of linear order , 1968 .

[22]  Amir Pnueli,et al.  The Glory of the Past , 1985, Logic of Programs.

[23]  H. James Hoover,et al.  Limits to Parallel Computation: P-Completeness Theory , 1995 .

[24]  Philippe Schnoebelen,et al.  Model Checking CTL+ and FCTL is Hard , 2001, FoSSaCS.

[25]  Saharon Shelah,et al.  On the temporal analysis of fairness , 1980, POPL '80.

[26]  David S. Johnson,et al.  A Catalog of Complexity Classes , 1991, Handbook of Theoretical Computer Science, Volume A: Algorithms and Complexity.

[27]  Alberto Zanardo,et al.  Ockhamist Computational Logic: Past-Sensitive Necessitation in CTL , 1993, J. Log. Comput..

[28]  D. Gabbay,et al.  Temporal Logic Mathematical Foundations and Computational Aspects , 1994 .

[29]  Moshe Y. Vardi.  Linear vs. branching time: a complexity-theoretic perspective , 1998, Proceedings. Thirteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.98CB36226).

[30]  E. Allen Emerson,et al.  Efficient Temporal Satisfiability , 1992, J. Log. Comput..

[31]  Moshe Y. Vardi.  An Automata-Theoretic Approach to Linear Temporal Logic , 1996, Banff Higher Order Workshop.

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

[33]  Zohar Manna,et al.  The anchored version of the temporal framework , 1988, REX Workshop.

[34]  Sérgio Vale Aguiar Campos,et al.  Symbolic Model Checking , 1993, CAV.

[35]  Dov M. Gabbay,et al.  The Declarative Past and Imperative Future: Executable Temporal Logic for Interactive Systems , 1987, Temporal Logic in Specification.

[36]  Paul Crubillé,et al.  A Linear Algorithm to Solve Fixed-Point Equations on Transition Systems , 1988, Inf. Process. Lett..

[37]  Larry J. Stockmeyer,et al.  The Polynomial-Time Hierarchy , 1976, Theor. Comput. Sci..

[38]  Mark W. Krentel.  The complexity of optimization problems , 1986, STOC '86.

[39]  A. Pnueli.  The Temporal Semantics of Concurrent Programs , 1979, Theor. Comput. Sci..

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

[41]  Georg Gottlob,et al.  Propositional default logics made easier: computational complexity of model checking , 2002, Theor. Comput. Sci..

[42]  Nicolas Markey,et al.  On model checking durational Kripke structures (Extended abstract) , 2002 .

[43]  Moshe Y. Vardi.  The complexity of relational query languages (Extended Abstract) , 1982, STOC '82.

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

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

[46]  Moshe Y. Vardi.  Alternating Automata and Program Verification , 1995, Computer Science Today.

[47]  Alexander Moshe Rabinovich,et al.  Expressive Power of Temporal Logics , 2002, CONCUR.

[48]  Saharon Shelah,et al.  The Decision Problem for Branching Time Logic , 1985, J. Symb. Log..

[49]  Philippe Schnoebelen,et al.  A Hierarchy of Temporal Logics with Past , 1995, Theor. Comput. Sci..

[50]  Rob J. van Glabbeek,et al.  The Linear Time - Branching Time Spectrum I , 2001, Handbook of Process Algebra.

[51]  Grzegorz Rozenberg,et al.  Linear Time, Branching Time and Partial Order in Logics and Models for Concurrency , 1988, Lecture Notes in Computer Science.

[52]  Rance Cleaveland,et al.  A linear-time model-checking algorithm for the alternation-free modal mu-calculus , 1993, Formal Methods Syst. Des..

[53]  Kenneth L. McMillan,et al.  Symbolic model checking , 1992 .

[54]  R. J. vanGlabbeek.  The linear time - branching time spectrum , 1990 .

[55]  François Laroussinie,et al.  About the Expressive Power of CTL Combinators , 1995, Inf. Process. Lett..

[56]  Alexander Moshe Rabinovich,et al.  An Infinite Hierarchy of Temporal Logics over Branching Time , 2002, Inf. Comput..

[57]  Philippe Schnoebelen,et al.  Temporal logic with forgettable past , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

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

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

[60]  Pierre Wolper,et al.  The Complementation Problem for Büchi Automata with Appplications to Temporal Logic , 1987, Theor. Comput. Sci..

[61]  Klaus W. Wagner.  More Complicated Questions About Maxima and Minima, and Some Closures of NP , 1987, Theor. Comput. Sci..

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

[63]  Alexander Moshe Rabinovich,et al.  Symbolic model checking for µ-calculus requires exponential time , 2000, Theor. Comput. Sci..

[64]  Philippe Schnoebelen,et al.  Oracle Circuits for Branching-Time Model Checking , 2003, ICALP.

[65]  J. Castro,et al.  Complexity classes between θpk and Δpk , 1996 .

[66]  Wolfgang Reisig.  Towards a temporal logic of causality and choice in distributed systems , 1988, REX Workshop.

[67]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[68]  Pierre Wolper,et al.  Constructing Automata from Temporal Logic Formulas: A Tutorial , 2002, European Educational Forum: School on Formal Methods and Performance Analysis.

[69]  Johan van Benthem,et al.  Time, logic and computation , 1988, REX Workshop.

[70]  Robert P. Kurshan,et al.  Computer-Aided Verification of Coordinating Processes: The Automata-Theoretic Approach , 2014 .

[71]  Neil D. Jones,et al.  Space-Bounded Reducibility among Combinatorial Problems , 1975, J. Comput. Syst. Sci..

[72]  D. Harel.  Recurring dominoes: making the highly undecidable highly understandable , 1985 .

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

[74]  Stephan Merz,et al.  Model Checking , 2000 .

[75]  A. Nakamura,et al.  On the size of refutation Kripke models for some linear modal and tense logics , 1980 .

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

[77]  Pierre Wolper,et al.  On the Relation of Programs and Computations to Models of Temporal Logic , 1987, Temporal Logic in Specification.

[78]  Neil Immerman,et al.  An n! lower bound on formula size , 2003, TOCL.

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

[80]  Philippe Schnoebelen,et al.  The Complexity of Propositional Linear Temporal Logics in Simple Cases , 1998, Inf. Comput..

[81]  J.F.A.K. van Benthem,et al.  Modal logic and classical logic , 1983 .

[82]  Pierre Wolper,et al.  Temporal logic can be more expressive , 1981, 22nd Annual Symposium on Foundations of Computer Science (sfcs 1981).

[83]  Fred Kröger,et al.  Temporal Logic of Programs , 1987, EATCS Monographs on Theoretical Computer Science.

[84]  Antonín Kucera,et al.  The Stuttering Principle Revisited: On the Expressiveness of Nested X and U Operators in the Logic LTL , 2002, CSL.

[85]  Howard Barringer,et al.  Practical CTL* model checking: Should SPIN be extended? , 2000, International Journal on Software Tools for Technology Transfer.

[86]  Michael Kaminski.  A Branching Time Logic with Past Operators , 1994, J. Comput. Syst. Sci..

[87]  Larry J. Stockmeyer,et al.  Classifying the computational complexity of problems , 1987, The Journal of Symbolic Logic.

[88]  李幼升,et al.  Ph , 1989 .

[89]  Moshe Y. Vardi.  Branching vs. Linear Time: Final Showdown , 2001, TACAS.

[90]  Kousha Etessami,et al.  An Until Hierarchy and Other Applications of an Ehrenfeucht-Fraïssé Game for Temporal Logic , 2000, Inf. Comput..

[91]  Orna Grumberg,et al.  Research on Automatic Verification of Finite-State Concurrent Systems , 1987 .

[92]  Edmund M. Clarke,et al.  Formal Methods: State of the Art and Future Directions Working Group Members , 1996 .