1,983 research outputs found
Reachability Analysis on Timed Graph Transformation Systems
In recent years, software increasingly exhibits self-* properties like selfoptimization
or self-healing. Such properties require reconfiguration at runtime in
order to react to changing environments or detected defects. A reconfiguration might
add or delete components as well as it might change the communication topology of
the system. Considering communication protocols between an arbitrary number of
participants, reconfiguration and state-based protocol behavior are no longer independent
from each other and need to be verified based on a common formalism. Additionally,
such protocols often contain timing constraints to model real-time properties.
These are of integral importance for the safety of the modeled system and thus
need to be considered during the verification of the protocol. In current approaches
either reconfigurations or timing constraints are not considered. Existing approaches
for the verification of timed graph transformation systems lack important constructs
needed for the verification of state-based real-time protocol behaviors. As a first
step towards a solution to this problem, we introduced Timed Story Driven Modeling
[HHH10] as a common formalism integrating state-based real-time protocol
behaviors and system reconfigurations based on graph transformations.
In this paper, we introduce a framework allowing to perform reachability analysis
based on Timed Story Driven Modeling. The framework allows to compute the
reachable timed graph transition system based on an initial graph and a set of timed
transformation and invariant rules
Automating the transformation-based analysis of visual languages
The final publication is available at Springer via http://dx.doi.org/10.1007/s00165-009-0114-yWe present a novel approach for the automatic generation of model-to-model transformations given a description of the operational semantics of the source language in the form of graph transformation rules. The approach is geared to the generation of transformations from Domain-Specific Visual Languages (DSVLs) into semantic domains with an explicit notion of transition, like for example Petri nets. The generated transformation is expressed in the form of operational triple graph grammar rules that transform the static information (initial model) and the dynamics (source rules and their execution control structure). We illustrate these techniques with a DSVL in the domain of production systems, for which we generate a transformation into Petri nets. We also tackle the description of timing aspects in graph transformation rules, and its analysis through their automatic translation into Time Petri netsWork sponsored by the Spanish Ministry of Science and Innovation, project METEORIC (TIN2008-02081/TIN) and by the Canadian Natural Sciences and Engineering Research Council (NSERC)
Better abstractions for timed automata
We consider the reachability problem for timed automata. A standard solution
to this problem involves computing a search tree whose nodes are abstractions
of zones. These abstractions preserve underlying simulation relations on the
state space of the automaton. For both effectiveness and efficiency reasons,
they are parametrized by the maximal lower and upper bounds (LU-bounds)
occurring in the guards of the automaton. We consider the aLU abstraction
defined by Behrmann et al. Since this abstraction can potentially yield
non-convex sets, it has not been used in implementations. We prove that aLU
abstraction is the biggest abstraction with respect to LU-bounds that is sound
and complete for reachability. We also provide an efficient technique to use
the aLU abstraction to solve the reachability problem.Comment: Extended version of LICS 2012 paper (conference paper till v6). in
Information and Computation, available online 27 July 201
Efficient Emptiness Check for Timed B\"uchi Automata (Extended version)
The B\"uchi non-emptiness problem for timed automata refers to deciding if a
given automaton has an infinite non-Zeno run satisfying the B\"uchi accepting
condition. The standard solution to this problem involves adding an auxiliary
clock to take care of the non-Zenoness. In this paper, it is shown that this
simple transformation may sometimes result in an exponential blowup. A
construction avoiding this blowup is proposed. It is also shown that in many
cases, non-Zenoness can be ascertained without extra construction. An
on-the-fly algorithm for the non-emptiness problem, using non-Zenoness
construction only when required, is proposed. Experiments carried out with a
prototype implementation of the algorithm are reported.Comment: Published in the Special Issue on Computer Aided Verification - CAV
2010; Formal Methods in System Design, 201
Interrupt Timed Automata: verification and expressiveness
We introduce the class of Interrupt Timed Automata (ITA), a subclass of
hybrid automata well suited to the description of timed multi-task systems with
interruptions in a single processor environment. While the reachability problem
is undecidable for hybrid automata we show that it is decidable for ITA. More
precisely we prove that the untimed language of an ITA is regular, by building
a finite automaton as a generalized class graph. We then establish that the
reachability problem for ITA is in NEXPTIME and in PTIME when the number of
clocks is fixed. To prove the first result, we define a subclass ITA- of ITA,
and show that (1) any ITA can be reduced to a language-equivalent automaton in
ITA- and (2) the reachability problem in this subclass is in NEXPTIME (without
any class graph). In the next step, we investigate the verification of real
time properties over ITA. We prove that model checking SCL, a fragment of a
timed linear time logic, is undecidable. On the other hand, we give model
checking procedures for two fragments of timed branching time logic. We also
compare the expressive power of classical timed automata and ITA and prove that
the corresponding families of accepted languages are incomparable. The result
also holds for languages accepted by controlled real-time automata (CRTA), that
extend timed automata. We finally combine ITA with CRTA, in a model which
encompasses both classes and show that the reachability problem is still
decidable. Additionally we show that the languages of ITA are neither closed
under complementation nor under intersection
Model Checking One-clock Priced Timed Automata
We consider the model of priced (a.k.a. weighted) timed automata, an
extension of timed automata with cost information on both locations and
transitions, and we study various model-checking problems for that model based
on extensions of classical temporal logics with cost constraints on modalities.
We prove that, under the assumption that the model has only one clock,
model-checking this class of models against the logic WCTL, CTL with
cost-constrained modalities, is PSPACE-complete (while it has been shown
undecidable as soon as the model has three clocks). We also prove that
model-checking WMTL, LTL with cost-constrained modalities, is decidable only if
there is a single clock in the model and a single stopwatch cost variable
(i.e., whose slopes lie in {0,1}).Comment: 28 page
Formal and efficient verification techniques for Real-Time UML models
The real-time UML profile TURTLE has a formal semantics expressed by translation into a timed process algebra: RT-LOTOS. RTL, the formal verification tool developed for RT-LOTOS, was first used to check TURTLE models against design errors. This paper opens new avenues for TURTLE
model verification. It shows how recent work on translating RT-LOTOS specifications into Time Petri net model may be applied to TURTLE. RT-LOTOS to TPN translation patterns are presented. Their formal proof is the subject of another paper. These patterns have been implemented in a RT-LOTOS to TPN translator which has been interfaced with TINA, a Time Petri Net Analyzer which implements several reachability analysis procedures depending on the class of property to be verified. The paper illustrates the benefits of the TURTLE->RT-LOTOS->TPN transformation chain on an avionic case study
Test Derivation from Timed Automata
A real-time system is a discrete system whose state changes occur in real-numbered time [AH97]. For testing real-time systems, specification languages must be extended with constructs for expressing real-time constraints, the implementation relation must be generalized to consider the temporal dimension, and the data structures and algorithms used to generate tests must be revised to operate on a potentially infinite set of states
- …