scispace - formally typeset
Proceedings ArticleDOI

Model-checking for real-time systems

Reads0
Chats0
TLDR
An algorithm is developed for model checking, that is, for determining the truth of a TCTL formula with respect to a timed graph, and it is argued that choosing a dense domain, instead of a discrete domain, to model time does not blow up the complexity of the model-checking problem.
Abstract
This research extends CTL model-checking to the analysis of real-time systems, whose correctness depends on the magnitudes of the timing delays. For specifications, the syntax of CTL is extended to allow quantitative temporal operators. The formulas of the resulting logic, TCTL, are interpretation over continuous computation trees, trees in which paths are maps from the set of nonnegative reals to system states. To model finite-state systems the notion of timed graphs is introduced-state-transition graphs extended with a mechanism that allows the expression of constant bounds on the delays between the state transition. As the main result, an algorithm is developed for model checking, that is, for determining the truth of a TCTL formula with respect to a timed graph. It is argued that choosing a dense domain, instead of a discrete domain, to model time does not blow up the complexity of the model-checking problem. On the negative side, it is shown that the denseness of the underlying time domain makes TCTL II/sub 1//sup 1/-hard. The question of deciding whether a given TCTL formula is implementable by a timed graph is also undecidable. >

read more

Citations
More filters
Journal ArticleDOI

A theory of timed automata

TL;DR: Alur et al. as discussed by the authors proposed timed automata to model the behavior of real-time systems over time, and showed that the universality problem and the language inclusion problem are solvable only for the deterministic automata: both problems are undecidable (II i-hard) in the non-deterministic case and PSPACE-complete in deterministic case.
Journal ArticleDOI

The algorithmic analysis of hybrid systems

TL;DR: A general framework for the formal specification and algorithmic analysis of hybrid systems is presented, which considers symbolic model-checking and minimization procedures that are based on the reachability analysis of an infinite state space.
Journal ArticleDOI

The synchronous data flow programming language LUSTRE

TL;DR: The authors describe LUSTRE, a data flow synchronous language designed for programming reactive systems-such as automatic control and monitoring systems-as well as for describing hardware.
Book ChapterDOI

A Tutorial on UPPAAL

TL;DR: This is a tutorial paper on the tool Uppaal to be a short introduction on the flavor of timed automata implemented in the tool, to present its interface, and to explain how to use the tool.
References
More filters
Proceedings ArticleDOI

The temporal logic of programs

Amir Pnueli
TL;DR: A unified approach to program verification is suggested, which applies to both sequential and parallel programs, and the main proof method is that of temporal reasoning in which the time dependence of events is the basic concept.
Journal ArticleDOI

Automatic verification of finite-state concurrent systems using temporal logic specifications

TL;DR: It is argued that this technique can provide a practical alternative to manual proof construction or use of a mechanical theorem prover for verifying many finite-state concurrent systems.
Book ChapterDOI

Automata for modeling real-time systems

TL;DR: To model the behavior of finite-state asynchronous real-time systems, the notion of timed Buchi automata (TBA) is proposed, coupled with a mechanism to express constant bounds on the timing delays between system events.
Book ChapterDOI

Timing assumptions and verification of finite-state concurrent systems

TL;DR: A scheme that allows timing assumptions to be incorporated into automatic proofs of arbitrary finite-state temporal properties is described, and it is conjecture that the method presented can be extended in this way.
Journal ArticleDOI

Using branching time temporal logic to synthesize synchronization skeletons

TL;DR: A method of constructing concurrent programs in which the synchronization skeleton of the program is automatically synthesized from a (branching time) temporal logic specification by using a decision procedure based on the finite model property of the logic.
Related Papers (5)