Modalities for Model Checking: Branching Time Logic Strikes Back

  title={Modalities for Model Checking: Branching Time Logic Strikes Back},
  author={E. Allen Emerson and C. L. Lei},
  journal={Sci. Comput. Program.},

Figures from this paper

Temporal Logics for Trace Systems: On Automated Verification
  • W. Penczek
  • Computer Science
    Int. J. Found. Comput. Sci.
  • 1993
This work investigates an extension of CTL by past modalities, called CTLP, interpreted over Mazurkiewicz's trace systems, and shows that all the interesting partial order properties can be model checked using the model checking algorithm.
The existence of finite abstractions for branching time model checking
  • D. Dams, K. Namjoshi
  • Computer Science
    Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science, 2004.
  • 2004
This paper begins by showing that existing abstraction frameworks are inherently incomplete for verifying purely existential or mixed universal-existential properties, and proposes a new, complete abstraction framework which is based on a class of focused transition systems (FTS's).
Model Checking with Strong Fairness
This paper uses the computational model of a fair discrete system (fds) which takes into account both justice and compassion, and extends previous methods by dealing with compassion at the algorithmic level instead of either adding it to the specification, or transforming compassion to justice.
Temporal Logics and Model Checking for Fairly Correct Systems
This work motivates and study a generic relaxation of correctness of reactive and concurrent systems with respect to a temporal specification, and shows that topological and probabilistic largeness of omega-regular specifications coincide for bounded Borel measures on finite-state systems.
Sometimes and Not Never Re-revisited: On Branching Versus Linear Time
Two approaches that relate branching and linear model checking are described, one motivated by the fact that the alternation-free Μ-calculus, which is more expressive than CTL, has the same computational advantage as CTL when it comes to model checking.
Branching vs. Linear Time: Final Showdown
It is argued that in spite of the phenomenal success of CTL-based model checking, CTL suffers from several fundamental limitations as a specification language, all stemming from the fact that CTL is a branching-time formalism: the language is unintuitive and hard to use, it does not lend itself to compositional reasoning, and it is fundamentally incompatible with semiformal verification.
Augmenting Branching Temporal Logics with Existential Quantification over Atomic Propositions
This paper examines the complexity of the model-checking problem in the two semantics for the logics CTL and CTL* augmented with existential quantification over atomic propositions, and shows that while fixing the formula dramatically reduces model- checking complexity in the tree semantics, its influence on the structure semantics is poor.
A Unified Approach to Language Containment and Fair CTL Model Checking
This paper argues that MC and LC are to some extent complementary, and presents an MC algorithm for Fair CTL, an extension of CTL capable of handling fairness constraints, which uses algorithms for LC as a subroutine.
Efficient temporal reasoning (extended abstract)
This work shows that there exist Temporal Logics that are decidable in polynomial time, and still useful in applications, and demonstrates that many useful correctness properties can be expressed with a rather restricted syntax.
A Tableau Calculus for First-Order Branching Time Logic
This paper proposes a sound tableau calculus for temporal logics of the first-order CTL-family and shows that by using prefixed formulas and explicit representation of paths it becomes possible to express and process fairness properties without having to resort to full CTL.


Decision Procedures and Expressiveness in the Temporal Logic of Branching Time
It is established that CTL has the small property by showing that any satisfiable CTL formulae is satisfiable in a small finite model obtained from a small -&-ldquo;pseudo-model-&-rdquo%; resulting from the Fischer Ladner quotient construction.
Deciding Full Branching Time Logic
Decidability and expressiveness of logics of processes
It is shown that PDL is decidable only when processes are tree-like, in Parikh's sense, and that extending PDL by a concurrency operator, a global invariance operator and flowgraph programs, among others, adds no expressive power to PDL.
Characterizing Correctness Properties of Parallel Programs Using Fixpoints
We have shown that correctness properties of parallel programs can be described using computation trees and that from these descriptions fixpoint characterizations can be generated. We have also
  • V. Pratt
  • Computer Science, Philosophy
    FOCS 1976
  • 1976
An appropriate axiom system is given which is complete for loop-free programs and also puts conventional predicate calculus in a different light by lumping quantifiers with non-logical assignments rather than treating them as logical concepts.
Proving Liveness Properties of Concurrent Programs
A formal proof method, based on temporal logic, for deriving liveness properties is presented, which allows a rigorous formulation of simple informal arguments and how to reason with temporal logic and use safety (invariance) properties in proving liveness is shown.
“Sometimes” and “not never” revisited: on branching versus linear time temporal logic
A language, CTL*, in which a universal or existential path quantifier can prefix an arbitrary linear time assertion, is defined and the expressive power of a number of sublanguages is compared.
"Sometime" is sometimes "not never": on the temporal logic of programs
  • L. Lamport
  • Philosophy, Computer Science
    POPL '80
  • 1980
The logical foundations of the application of temporal logic to concurrent programs are clarified, and the relation between concurrency and nondeterminism is clarified, as well as some problems for further research.
Checking that finite state concurrent programs satisfy their linear specification
An algorithm for checking satisfiability of a linear time temporal logic formula over a finite state concurrent program and a formal proof in case the formula is valid over the program is presented.