# Model checking

### From Wikipedia, the free encyclopedia

In the field of logic in computer science, **model checking** refers to the following problem: Given a simplified model of a system, test automatically whether this model meets a given specification. Typically, the systems one has in mind are hardware or software systems, and the specification contains safety requirements such as the absence of deadlocks and similar critical states that can cause the system to crash.

In order to solve such a problem algorithmically, both the model of the system and the specification are formulated in some precise mathematical language: To this end, it is formulated as a task in Logic, namely to check whether a given structure satisfies a given logical formula. The concept is general and applies to all kinds of logics and suitable structures. A simple model-checking problem is verifying whether a given formula in the propositional logic is satisfied by a given structure.

## Contents |

## [edit] Overview

An important class of model checking methods have been developed for checking models of hardware and software designs where the specification is given by a temporal logic formula. Pioneering work in the model checking of temporal logic formulae was done by E. M. Clarke and E. A. Emerson^{[1]}^{[2]}^{[3]} and by J. P. Queille and J. Sifakis^{[4]}. Clarke, Emerson, and Sifakis shared the 2007 Turing Award for their work on model checking.^{[5]}^{[6]}

Model checking is most often applied to hardware designs. For software, because of undecidability (see computability theory) the approach cannot be fully algorithmic; typically it may fail to prove or disprove a given property.

The structure is usually given as a source code description in an industrial hardware description language or a special-purpose language. Such a program corresponds to a finite state machine (FSM), i.e., a directed graph consisting of nodes (or vertices) and edges. A set of atomic propositions is associated with each node, typically stating which memory elements are one. The nodes represent states of a system, the edges represent possible transitions which may alter the state, while the atomic propositions represent the basic properties that hold at a point of execution.

Formally, the problem can be stated as follows: given a desired property, expressed as a temporal logic formula *p*, and a structure *M* with initial state *s*, decide if . If M is finite, as it is in hardware, model checking reduces to a graph search.

## [edit] Model checking tools

Model checking tools face a combinatorial blow up of the state-space, commonly known as the state explosion problem, that must be addressed to solve most real-world problems. There are several approaches to combat this problem.

- Symbolic algorithms avoid ever building the graph for the FSM; instead, they represent the graph implicitly using a formula in propositional logic. The use of binary decision diagrams (BDDs) was made popular by the work of Ken McMillan.
^{[7]} - Bounded model checking algorithms unroll the FSM for a fixed number of steps
*k*and check whether a property violation can occur in*k*or fewer steps. This typically involves encoding the restricted model as an instance of SAT. The process can be repeated with larger and larger values of*k*until all possible violations have been ruled out (cf. Iterative deepening depth-first search). - Partial order reduction can be used (on explicitly represented graphs) to reduce the number of independent interleavings of concurrent processes that need to be considered. The basic idea is that if it does not matter, for the kind of things one intends to prove, whether A or B is executed first, then it is a waste of time to consider both the AB and the BA interleavings.
- Abstraction attempts to prove properties on a system by first simplifying it. The simplified system usually does not satisfy exactly the same properties as the original one so that a process of refinement may be necessary. Generally, one requires the abstraction to be
*sound*(the properties proved on the abstraction are true of the original system); however, most often, the abstraction is not*complete*(not all true properties of the original system are true of the abstraction). An example of abstraction is, on a program, to ignore the values of non boolean variables and to only consider boolean variables and the control flow of the program; such an abstraction, though it may appear coarse, may be in fact be sufficient to prove e.g. properties of mutual exclusion. - Counter-example guided abstraction refinement (CEGAR) begins checking with a coarse (imprecise) abstraction and iteratively refines it. When a violation (counter-example) is found, the tool analyzes it for feasibility (i.e., is the violation genuine or the result of an incomplete abstraction?). If the violation is feasible, it is reported to the user; if it is not, the proof of infeasibility is used to refine the abstraction and checking begins again.
^{[8]}

Model checking tools were initially developed to reason about the logical correctness of discrete state systems, but have since been extended to deal with real-time and limited forms of hybrid systems.

## [edit] See also

- Tools

- BLAST model checker
- CHIC
- CHESS model checker
- ISP code level verifier for MPI programs
- Java Pathfinder - open source model checker for Java programs
- MoonWalker - open source model checker for .NET programs
- Markov Reward Model Checker (MRMC)
- NuSMV, a new symbolic model checker
- SPIN model checker
- Vereofy: [1]
- μCRL, GPL, Based on ACP
- mCRL2 Toolset, Boost Software License, Based on ACP

- Related techniques

- Abstract interpretation
- Automated theorem proving
- Program analysis (computer science)
- Rabbit
- Static code analysis

- History

- E.M. Clarke:
*The birth of model checking* - E. Allen Emerson:
*The Beginning of Model Checking: A Personal Perspective*(this is also a very good introduction and overview of model checking)

## [edit] References

This article needs additional citations for verification. Please help improve this article by adding reliable references (ideally, using inline citations). Unsourced material may be challenged and removed. (November 2008) |

**^**Allen Emerson, E.; Clarke, Edmund M. (1980), "Characterizing correctness properties of parallel programs using fixpoints",*Automata, Languages and Programming*, doi:**^**Edmund M. Clarke, E. Allen Emerson: "Design and Synthesis of Synchronization Skeletons Using Branching-Time Temporal Logic". Logic of Programs 1981: 52-71.**^**Clarke, E. M.; Emerson, E. A.; Sistla, A. P. (1986), "Automatic verification of finite-state concurrent systems using temporal logic specifications",*ACM Transactions on Programming Languages and Systems***8**: 244, doi:**^**Queille, J. P.; Sifakis, J. (1982), "Specification and verification of concurrent systems in CESAR",*International Symposium on Programming*, doi:**^**Press Release: ACM Turing Award Honors Founders of Automatic Verification Technology**^***USACM*: 2007 Turing Award Winners Announced**^****Symbolic Model Checking*, Kenneth L. McMillan, Kluwer, ISBN 0-7923-9380-5, also online.**^**Clarke, Edmund; Grumberg, Orna; Jha, Somesh; Lu, Yuan; Veith, Helmut (2000), "Counterexample-Guided Abstraction Refinement",*Computer Aided Verification***1855**: 154, doi:

## [edit] External links

## [edit] Further reading

*Model Checking*, Edmund M. Clarke, Jr., Orna Grumberg and Doron A. Peled, MIT Press, 1999, ISBN 0-262-03270-8.*Systems and Software Verification: Model-Checking Techniques and Tools*, B. Berard, M. Bidoit, A. Finkel, F. Laroussinie, A. Petit, L. Petrucci, P. Schnoebelen, ISBN 3540415238*Logic in Computer Science: Modelling and Reasoning About Systems*, Michael Huth and Mark Ryan, Cambridge University Press, 2004. DOI.*The Spin Model Checker: Primer and Reference Manual*, Gerard J. Holzmann, Addison-Wesley, ISBN 0-321-22862-6.- Julian Bradfield and Colin Stirling, Modal logics and mu-calculi, [2]
- Specification Patterns [3]
- Property Pattern Mappings for RAFMC [4]
- more patterns: page 6 of [5]
- Müller-Olm, M., Schmidt, D.A. and Steffen, B.
*Model checking: a tutorial introduction.*Proc. 6th Static Analysis Symposium, G. File and A. Cortesi, eds., Springer LNCS 1694, 1999, pp. 330-354.

*This article was originally based on material from the Free On-line Dictionary of Computing, which is licensed under the GFDL.*