• Corpus ID: 5302889

Principles of model checking

  title={Principles of model checking},
  author={Christel Baier and Joost-Pieter Katoen},
Our growing dependence on increasingly complex computer and software systems necessitates the development of formalisms, techniques, and tools for assessing functional properties of these systems. [] Key Method It introduces the temporal logics LTL and CTL, compares them, and covers algorithms for verifying these logics, discussing real-time systems as well as systems subject to random phenomena. Separate chapters treat such efficiency-improving techniques as abstraction and symbolic manipulation. The book…

Techniques and tools for the verification of concurrent systems

This thesis focuses on adapting and developing novel model-checking techniques for concurrent systems in the setting of the process algebra CSP and its primary model checker FDR, and proposes a static analysis framework for establishing livelock freedom of CSP processes, with lessons for other concurrent formalisms.

Verification of temporal properties of infinite state systems

This project aims to implement model checking algorithms that determine whether an LTL formula expressing a desired property is satisfied in a computing system.

Model checking: recent improvements and applications

  • D. BosnackiAnton Wijs
  • Computer Science
    International Journal on Software Tools for Technology Transfer
  • 2018
Several contributions in the model checking field are discussed that address both its scalability and its applicability to perform planning and quantitative analysis, and six papers selected from the 23rd International SPIN Symposium on Model Checking Software are introduced.

Directed diagnostics of system dependability models

This dissertation introduced the notion of counterexamples into stochastic model checking and devised the first methods for the generation and analysis of countrexamples, and gives a formal definition for countereXamples for common stochastics models.

CTL* model checking for data-aware dynamic systems with arithmetic

A model checking procedure for DDSAs that relies on a finite-state abstraction by means of a set of formulas that capture variable configurations, and is implemented in the SMT-based prototype ada, showing that many practical business process models can be effectively analyzed.

Abstract Graph Transformation - Theory and Practice

Two abstraction techniques are presented that yield a finite over-approximation of the behaviour of infinite-state GT systems, thus enabling verification on the abstract level and discussed under both a theoretical and a practical focus.

Automata-Theoretic Verification

The automata-theoretic approach to the satisfiability and model-checking problems for temporal logics reduces these problems to standard decision problems about automata, like nonemptiness, language containment, or membership (whether a given object is accepted by a given automaton).

Parallelizing model checking algorithms using multi-core and many-core architectures

This work states that model checking is not feasible for systems with infinite state space, since the data size would be unbounded or the number of processes would be infinite, and that Symbolic model checking approaches reduce the cost of storage to store the system.

Quantitative Analysis of Concurrent System Architectures

New translation rules are introduced into the QuantUM profile which are used to transform UML or SysML models into locally uniform Continuous-Time Markov Decision Processes and non-determinism is supported.

Towards Reliable Benchmarks of Timed Automata

This work has collected publicly available timed automaton models and industrial case studies and used them to compare the efficiency of the algorithms implemented in the Theta model checker, and presents a preliminary benchmark suite.



Limits for Automatic Verification of Finite-State Concurrent Systems

Model checking large software specifications

The results and experiences of using symbolic model checking to study the specification of an aircraft collision avoidance system and the approach to translating the specification to the SMV language and methods for achieving acceptable performance are reported.

Model checking for programming languages using VeriSoft

This paper discusses how model checking can be extended to deal directly with "actual" descriptions of concurrent systems, e.g., implementations of communication protocols written in programming languages such as C or C++, and introduces a new search technique that is suitable for exploring the state spaces of such systems.

Model-Checking in Dense Real-time

An algorithm for model-checking, for determining the truth of a TCTL-formula with respect to a timed graph, is developed and it is argued that choosing a dense domain instead of a discrete domain to model time does not significantly blow up the complexity of the model- checking problem.

Analysis of Timed Systems Using Time-Abstracting Bisimulations

The objective of this paper is to show how verification of dense-time systems modeled as timed automata can be effectively performed using untimed verification techniques, and to demonstrate the practical interest behind the approach, namely, Fischer's mutual exclusion protocol and the CSMA/CD communication protocol.

An improvement in formal verification

This paper proposes a new reduction method that solves some of the problems of redundancy caused by the many possible interleavings of inde- pendent actions in a concurrent system.

Systems and Software Verification, Model-Checking Techniques and Tools

The author provides a well written and basic introduction to the new technique model checking, which describes in simple terms the theoretical basis of model checking: transition systems as a formal model of systems, temporal logic asA formal language for behavioral properties, and model-checking algorithms.

Model Checking Timed Automata

  • S. Yovine
  • Computer Science
    European Educational Forum: School on Embedded Systems
  • 1996
This paper surveys the different algorithms, data-structures and tools that have been proposed in the literature to solve the so-called reachability problem.

A partial order approach to branching time logic model checking

The paper shows, for the first time, how this approach can be applied to languages that model the behavior of a program as a tree, e.g., the logics CTL and CTL* and process algebras such as CCS.

Bounded Model Checking Using Satisfiability Solving

This tutorial focuses on recent techniques that combine model checking with satisfiability solving, known as bounded model checking, which do a very fast exploration of the state space, and for some types of problems seem to offer large performance improvements over previous approaches.