Linear-Time Model Checking: Automata Theory in Practice

  title={Linear-Time Model Checking: Automata Theory in Practice},
  author={Moshe Y. Vardi},
In automata-theoretic model checking we compose the design under verification with a Buchi automaton that accepts traces violating the specification. We then use graph algorithms to search for a counterexample trace. The basic theory of this approach was worked out in the 1980s, and the basic algorithms were developed during the 1990s. Both explicit and symbolic implementations, such as SPIN and and SMV, are widely used. It turns out, however, that there are still many gaps in our understanding… 
1 Citations
Symbolic automata better balances how automata are implemented in practice
  • 2021


An Automata-Theoretic Approach to Linear Temporal Logic
The automata-theoretic approach to linear temporal logic uses the theory of automata as a unifying paradigm for program specification, verification, and synthesis and considers the relationships between programs and their specifications as relationships between languages.
Memory-efficient algorithms for the verification of temporal properties
Algorithms are presented that solve the emptiness problem without explicitly constructing the strongly connected components of the graph representing the product automaton by allowing the algorithms to err with some probability.
Symbolic Model Checking without BDDs
This paper shows how boolean decision procedures, like Stalmarck's Method or the Davis & Putnam Procedure, can replace BDDs, and introduces a bounded model checking procedure for LTL which reduces model checking to propositional satisfiability.
Theories of Automata on omega-Tapes: A Simplified Approach
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.
Model Checking
Model checking is applied concurrently with system design, and particularly in its early stages when systems are modelled at a high level of abstraction, because the payoff of finding bugs at that stage is highest whereas the costs are low.
Reasoning About Infinite Computations
This work investigates extensions of temporal logic by connectives defined by finite automata on infinite words and shows that they do not increase the expressive power of the logic or the complexity of the decision problem.
Computer Aided Verification
Theorem proving and model checking are powerful tools that can verify the logical correctness of today's ICs or find their hidden bugs, and symbolic model-checking and homomorphic reduction are among the most powerful of these methods.
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.