{'fraction_non_alphanumeric': 0.04301145449205365, 'fraction_numerical': 0.008419541167640245, 'mean_word_length': 4.170237894381644, 'pattern_counts': {'":': 0, '<': 4, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 2, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A Forward Reachability Algorithm for Bounded Timed-Arc Petri Nets

Timed-arc Petri nets (TAPN) are a well-known time extension of the Petri net model and several translations to networks of timed automata have been proposed for this model. We present a direct, DBM-based algorithm for forward reachability analysis of bounded TAPNs extended with transport arcs, inhibitor arcs and age invariants. We also give a complete proof of its correctness, including reduction techniques based on symmetries and extrapolation. Finally, we augment the algorithm with a novel state-space reduction technique introducing a monotonic ordering on markings and prove its soundness even in the presence of monotonicity-breaking features like age invariants and inhibitor arcs. We implement the algorithm within the model-checker TAPAAL and the experimental results document an encouraging performance compared to verification approaches that translate TAPN models to UPPAAL timed automata.


Introduction
Time-dependent models and their formal analysis have attracted a considerable research activity. Notable formalisms include timed automata (TA) [3], time Petri nets (TPN) [18] and timed-arc Petri nets (TAPN) [7]. A comparison of the different modelling formalisms is provided in [23].
We shall focus on the TAPN model where tokens are assigned a nonnegative real number representing their age and input arcs of transitions contain time intervals restricting the usable ages of tokens for transition firing. The state-space of the model is in general infinite in two dimensions: the number of tokens in a marking can be unbounded, and the continuous time aspect induces infinitely many clock valuations. Indeed, the reachability problem for the model is undecidable [21], while coverability remains decidable [2]. Moreover, for modelling purposes additional features like inhibitor/transport arcs and age invariants are needed but they cause the undecidability also of the coverability problem [14].
We restrict our focus to bounded TAPNs where the maximum number of tokens in all reachable markings is fixed. This model is equally expressive to networks of timed automata [22] and efficient translations from TAPN into UPPAAL timed automata [16] have been implemented and employed in the model-checker TAPAAL [9]. The translation approach has though some drawbacks: experimentation with state-space reduction techniques is difficult and the engine does not return error traces when symmetry reduction is enabled.
We therefore design a novel reachability algorithm for extended TAPN that incorporates an efficient extrapolation, symmetry reduction and monotonic inclusion techniques to optimize its performance, while at the same time returning error traces with concrete time delays. We give a complete proof of the algorithm correctness, including all the optimization techniques. We provide an efficient (C++), open-source implementation of the algorithm and integrate the new engine into the tool TAPAAL. The experiments confirm a high efficiency of the new reachability algorithm and we document this by two larger case-studies.
Related work. Verification techniques for TAPNs include a backward coverability algorithm based on existential zones [2] (notably terminating also for unbounded nets) and a forward reachability algorithm based on region generators presented in [1]. Both algorithms rely on the monotonic behavior of the generated transition systems, however, inhibitor arcs and age invariants break this monotonicity [14] and hence the techniques are not applicable for extended TAPNs. Backward algorithms are generally rather inefficient for on-the-fly state-space exploration and for the employment of state-space reductions while the forward algorithm from [1] is based on a less efficient region construction instead of a zone-based one. The algorithms were implemented in prototype tools with no GUI and are not maintained any more.
There are efficient tools like TINA [6] or Romeo [12] for model-checking Time Petri nets (TPN). The tools are based on abstractions using state-class graphs but even though bounded TPN are essentially equally expressive as bounded TAPNs (see [23] for an overview), the translations are exponential and do not allow to perform a direct performance comparison because the modelling capabilities and the treatment of time in TPN and TAPN are very different.
The definition of our extrapolation (abstraction) operator is following [4] where a similar operator was suggested for timed automata; our extension (apart from its adaptation to the TAPN setting) is the handling of dynamic maximum constants depending on the current marking (see also [13] for a dynamic extrapolation on timed automata). The main novelty is our definition of an inclusion operator that incorporates symmetry reduction and works also for nets with monotonicity-breaking features.

Timed-Arc Petri Nets
Let N be the set of natural numbers and let N 0 = N ∪ {0}. By R ≥0 we denote the set of non-negative real numbers. The set of time intervals I is given by the abstract syntax (a ∈ N 0 , b ∈ N and a < b): . The set of invariant intervals, I Inv , consists of intervals that include 0.
Let C = {0, 1, 2, . . . , n} be a finite set of real-valued clocks whose elements (numbers) represent names of clocks. The clock 0 is a special pseudoclock that has always the value 0. A (clock) valuation over C is a function v : C → R ≥0 such that v(0) = 0. The set of all valuations over the clocks C is denoted by W C . Let v be a valuation and d a nonnegative real. We let v + d be the valuation such that ( 1 , 6 ] Let W ⊆ W C be a set of valuations and let R ⊆ C . We define the delay operation as W ↑ = {v + d | v ∈ W and d ∈ R ≥0 } and the reset operation as A timed labeled transition system (TLTS) is a tuple (S, Lab, −→) where S is a set of states (or processes), Lab = Act ∪ R ≥0 is a set of labels, consisting of discrete actions and time delays, and −→ ⊆ (S × Lab × S) is the transition relation. We often write s α −→ s instead of (s, α, s ) ∈−→ and if the label is not important, we simply write s −→ s .
We shall now define the Timed-Arc Petri Net (TAPN) model, restricting ourselves to k-bounded nets (where every reachable marking has at most k tokens). An example of a 4-bounded TAPN is given in Figure 1. It consists of six places (circles), one transition (rectangle) and two tokens of age 2.1 and 3.4 representing the current marking. Input arcs to the transition t contain time intervals and because both tokens belong to the corresponding interval, the transition can fire, consume the two tokens in p 1 and p 2 , and produce a new token of age 0 to each of the places p 3 , p 5 and p 6 . Because the place p 1 is connected to p 4 via a pair of transport arcs (denoted by a diamond tip), the token of age 2.1 is moved to p 4 while its age is preserved. Should there be more pairs of transport arcs connected to the transition t, we label them with numbers so that the routes on which tokens travel are clearly marked. Finally, note that the place p 4 has an associated age invariant, restricting the possible ages of tokens in the place to strictly less than 3. Should we in the current marking first delay 0.9 time units, both tokens in p 1 and p 2 would still fit into their intervals but the transition t is not enabled any more due to the age invariant in the place p 4 .
Definition A TAPN is a 7-tuple (P, T, IA, OA, c, Type, ι) where • P is a finite set of places, • T is a finite set of transitions such that P ∩ T = / 0, • IA ⊆ P × T is a finite set of input arcs, • OA ⊆ T × P is a finite set of output arcs, • c : IA → I assigns intervals to input arcs, • Type : IA ∪ OA −→ {Normal, Inhib} ∪ {Transport i | i ∈ N} is a function assigning a type to all arcs such that Type(t, p ) = Transport and -Type(t, p ) = Transport ⇒ ∃!(p,t) ∈ IA . Type(p,t) = Transport , and • ι : P → I inv assigns age invariants to places.
For notational convenience, we write Type(a) = Transport if Type(a) = Transport for some . For a transition t ∈ T , we define the preset of t as • t = {p ∈ P | (p,t) ∈ IA, Type(p,t) = Inhib} and the postset of t as t • = {p ∈ P | (t, p) ∈ OA}.
We denote by P ⊥ the set P ∪ {⊥} where ⊥ is a special symbol representing a pseudo-place that holds the currently unused tokens. The augmented preset and augmented postset of a transition t are defined as the multisets . This guarantees that | • t| = |t • | for any transition t, a convenient technical detail used in the algorithms. We also extend the definition of c and ι such that c(⊥,t) = [0, ∞) whenever ⊥ ∈ • t and ι(⊥) = [0, ∞).
A token in a k-bounded TAPN is an element from the set {1, 2, . . . , k}. A marking is a pair M = (pl, v) where pl : {1, 2, . . . , k} → P ⊥ is the placement function and v : {1, 2, . . . , k} → R ≥0 is the age function. The placement determines the current location of each token (it returns ⊥ if the token is unused) and the age function represents the age of each token. The placement function will be sometimes written as a vector where e.g. [p 1 , p 2 , p 1 ] represents the fact that tokens 1 and 3 are located in the place p 1 and token 2 is located in p 2 . The set of all markings on a k-bounded TAPN N is denoted by M (N). A marked k-bounded TAPN is a pair (N, (pl 0 , v 0 )) where N is a k-bounded TAPN and (pl 0 , v 0 ) is the initial marking where v 0 (i) = 0 for all i, 1 ≤ i ≤ k.
Since there are always k tokens in any marking (unused ones are in ⊥), it is for algorithmic purposes convenient to fix for each transition the paths from input to output places. This is formalized in the function Pairing : T → 2 P ⊥ ×P ⊥ such that for every transition t we have An example of a possible pairing function is given in Figure 1.

Transition Enabledness
A transition t is hence enabled if there is a token in each of its input places (i), the ages of these tokens fit into the intervals on the input arcs (ii), the age of the token that is moved along a pair of transport arcs does not break the age invariant of the place where is it moved to (iii), and there is no token in any place connected via inhibitor arc to the transition t (iv).
Transition Firing A transition t enabled in a marking (pl, v) by the set of tokens IN can fire, producing a marking (move(pl,

Symbolic Semantics
The concrete execution semantics is not suitable for the actual verification as there are infinitely (in fact uncountably) many reachable markings. Therefore we give a symbolic semantics of k-bounded TAPNs with respect to some given abstraction operator and show that the symbolic semantics preserves the answer to the reachability question.
A symbolic marking of a k-bounded TAPN is a pair (pl,W) where pl : {1, 2, . . . , k} → P ⊥ is a placement function and W ⊆ W C is a set of valuations.
In order to guarantee the finiteness of the state-space in the abstract semantics, we consider abstraction operators that can enlarge (extrapolate) the possible sets of valuations in symbolic markings. Instead of considering global abstraction operators like for example in the timed automata theory (see e.g. [4]), our abstraction operators depend also on the current placement.
Definition An abstraction operator is a function α : An example of an abstraction operator is the identity abstraction operator α id where α id (pl,W) = W for all symbolic markings (pl,W).
Our aim is of course to find an operator that for a given net abstracts as much as possible. To do so, we use the function mci : I → N 0 that returns, for an interval I, the maximum constant different from ∞ appearing in I. Let gc be the maximum constant different from ∞ that appears in intervals or invariants of the given TAPN. The function mc : P ⊥ → N 0 now returns, for each place p, the maximum constant appearing in the guards of outgoing arcs from p or in the invariant of p; if there are transport arcs connected to p, the constant is gc.
Following [4], we proceed to define an equivalence on valuations. The addition in our paper is that we take the placement function into account, thereby allowing for dynamic maximum constants. Let pl be a placement function and let v and v be valuations. We Hence two related valuations are indistinguishable from each other in the sense that they can be used to fire the same transitions. Now we can define an abstraction operator based on the relation above.
Definition Let α ≡ (pl,W) = {v | v ≡ pl v and v ∈ W} for a set of valuations W ⊆ W C and a placement function pl.
Clearly, W ⊆ α ≡ (pl,W) for any set of valuations W ⊆ W C and any placement function pl as the relation is reflexive. For two abstraction operators α and α we write α ⊆ α if α (pl,W) ⊆ α (pl,W) for all placement functions pl and all W ⊆ W C .
We are now ready to give the symbolic semantics of TAPNs. Let g be a function that takes a placement function pl, a set of tokens IN and a transition t as its arguments (assuming that and it returns the set of all valuations such that the tokens in IN satisfy all guards on the input arcs of t.
Similarly, we define a function I that takes a placement function as its argument and returns the set of all valuations satisfying the age invariants.

is a transition and there is a set of tokens IN such that
We can now state the main theorem of this section, which establishes soundness and completeness of the symbolic semantics for any abstraction operator between α id and α ≡ . In fact, we allow to dynamically change the abstraction operators during a computation in the symbolic semantics. Hence we consider a new transition relation α id ,α ≡ def = α id ⊆α⊆α ≡ α allowing us to apply in any step an arbitrary abstraction operator between the identity and α ≡ .
Note that the completeness part of the theorem imposes that the symbolic semantics can reach the given placement via a strictly alternating sequence of time elapsing and transition firing steps where the transition firing steps are not extrapolated (using the identity abstraction operator); this reflects how the successors are computed in the reachability algorithm discussed in Section 6.

Extrapolation via DBMs
For the use in our reachability algorithm, we need to represent infinite sets of valuations W in a finite way. However, it is not known how to effectively deal directly with the α ≡ abstraction operator. Instead, we suggest a slightly less general abstraction (extrapolation) operator and a way to finitely represent infinite sets of valuations in order to guarantee a finite and effectively searchable state-space of symbolic markings.
For this purpose we use Difference Bound Matrices (DBM), a well-known technique for verification of real-time systems (see e.g. [5,10]) that allows us to store constraints on single clocks and on differences of two clocks in a compact matrix-based data structure. For notational convenience, we introduce an alternative notation lb and ub for the lower and upper bound of a clock i. Intuitively, the extrapolation works by removing all upper bounds greater than the maximum constant of a given place and by replacing any lower bound greater than the maximum constant with the value (mc(pl(i)), <). Additionally, whenever the lower bound is above the maximum constant of a given place, any diagonal constraint involving that clock are also removed. An example of a DBM D and its extrapolation ext pl (D) together with their graphical representations (clock 1 is on the x-axis and clock 2 on the y-axis) is given in Figure 2. We can see that the extrapolation operator enlarges the set of valuations represented by D such that there are only finitely many extrapolated DBMs.

Lemma 4.1 The set {ext pl (D) | D is a canonical DBM} is finite.
We can now conclude with the main result stating that the extrapolation provides an abstraction which is between identity and α ≡ ; a crucial and nontrivial fact needed for proving correctness of the reachability algorithm.

Monotonicity of Bounded TAPNs
It is a well-known fact that the behaviour of the basic TAPN model is monotonic [11] with respect to the standard marking inclusion, intuitively meaning that adding more tokens to the net does not restrict its behaviour. However, the use of age invariants and inhibitor arcs breaks the monotonicity property [14].
In this section, we introduce a more refined inclusion relation on symbolic markings that preserves monotonicity even in the presence of age invariants and inhibitor arcs. Moreover, the inclusion relation allows for reordering of tokens in the net and hence it implements the symmetry reduction. The inclusion relation is then exploited in the reachability algorithm presented in Section 6. Let us fix a marked k-bounded TAPN (N, (pl 0 , v 0 )). For a place p ∈ P, we define a boolean predicate untimed(p) ≡ (ι(p) = [0, ∞)) ∧ ∀t ∈ p • . (Type(p,t) = Transport ∧ c(p,t) = [0, ∞)). If the predicate is true, we do not need to keep track of the ages of tokens in this place. For a symbolic marking M we now define the set INC M representing the set of tokens eligible for the inclusion checking. 3. pl(i) has no outgoing inhibitor arcs, and 4. either untimed(pl(i)) or Let us briefly comment on Condition 4. If a place is untimed then the ages of tokens in that place are irrelevant and we can consider them for inclusion checking. Otherwise, the lower bound of clock i in W is calculated by inf(V i ) and the two subconditions distinguish whether this bound is included or not 1 . The point is that if the lower-bound for the token i is above the maximum constant for the place where i is placed, then its concrete age is irrelevant for the firing of transitions. Let P inc ⊆ P be a set of places that we want to consider for the inclusion checking (typically we set P inc = P but the user can restrict some places from the application of the inclusion operator by excluding them from P inc ). We can now partition all tokens in the marking M = (pl,W) into three categories where inc(M) contains all tokens eligible for inclusion checking, bot(M) contains all unused tokens and eq(M) is the set of all tokens that have to be checked for equality. Let us now introduce some notation. Let pl be a placement function, p a place and let X ⊆ {1, 2, . . . , k} be a set of tokens. We define count X pl (p) = |{i ∈ X | pl(i) = p}|. Intuitively, count X pl (p) tells us how many tokens from X are in the place p. We are now ready to introduce the refined ordering relation.  Hence two symbolic markings M and M are related by , if they agree on the sets eq(M) and eq(M ) via the bijection h (this gives us the possibility to employ symmetry reduction), and moreover, the number of tokens in any place p from the set inc(M ) in the marking M must be larger than or equal to the number of tokens in the place p in the marking M. We finish this section by a theorem proving monotonicity with respect to the ordering relation for any abstraction operator below α ≡ .

Implementation of the Reachability Algorithm
Before we present the reachability algorithm, let us first introduce a reachability fragment of CTL that is used in the algorithm. A formula of the logic is given by the abstract syntax: where p ∈ P, n ∈ N 0 and ∈{<, ≤, =, =, ≥, >}.
The semantics of formulae is given in terms of a TLTS (S, Lab, −→) and a labeling function µ : S → 2 AP assigning sets of true atomic propositions to states. We define the set of atomic propositions AP Since atomic propositions only depend on the discrete part of a marking, we adopt the same definition of µ for symbolic markings. For a state s ∈ S and a formula φ , we define the satisfaction relation s |= φ inductively as follows: As the AG and EF temporal operators are dual, it is enough to design an algorithm for deciding the validity of EF ψ. Note that because the predicates do not allow us to query the ages of tokens in the net, the presence of age invariants in the TAPN model adds an expressive power (otherwise we could conjunct the age invariants with the intervals on input arcs and add to the formulae the requirement that no place contains any token exceeding the invariant bound).
We say that a place p in a boolean predicate ψ defined according to Equation (1) is monotonicitybreaking if ψ contains an atomic proposition of the form p < n, p ≤ n, p = n or p = n. In other words, the inequality imposes some upper bound or an exact comparison to a concrete number in the place p. Proof By structural induction on ψ. The induction step is trivial; we discuss here only the base case for a proposition of the formi ψ = p n. Let (pl 1 ,W 1 ) and (pl 2 ,W 2 ) be symbolic markings such that (pl 1 ,W 1 ) (pl 2 ,W 2 ). Let (pl 1 ,W 1 ) |= ψ.
If p is a monotonicity-breaking place than p ∈ P inc and all tokens in the place p belong to the set eq((pl 1 ,W 1 )). By Condition 1 of the inclusion ordering there exists a bijection h such that for all i ∈ eq((pl 1 ,W 1 )) we have pl 1 (i) = pl 2 (h(i)) and hence in the marking (pl 2 ,W 2 ) the number of tokens in the place p is equal to the number of tokens in the place p in the marking (pl 1 ,W 1 ) and we get (pl 2 ,W 2 ) |= ψ.
If p is not a monotonicity-breaking place, the constraint on p has the form p ≥ n or p > n. If the tokens in the place p belong to eq((pl 1 ,W 1 )) we are done by the arguments as above. If the tokens in the place p belong to inc((pl 1 ,W 1 )) then by Condition 2 of the inclusion ordering the number of tokens placed in p in the marking (pl 2 ,W 2 ) is at least the number of tokens in the marking (pl 1 ,W 1 ) and because the proposition on p states only a lower-bound, we can again conclude that (pl 2 ,W 2 ) |= ψ.
In order to present an efficient reachability algorithm, we need a finite representation for the potentially infinite sets of valuations discussed in Section 5. We will thus use DBMs. However, we have to implement the operations used on the sets of valuations, such as delay, clock reset and intersection, on DBMs. Similarly, we need to define a DBM which represents a guard or invariant of the form i ∈ [ (a, b)] where i is a clock and [ (a, b)] is a well-formed interval-here [ ( is either closed or open left parenthesis and similarly for )]. Proposition 6.2 Let D 1 and D 2 be canonical DBMs over the clocks C . Then the following operations and DBMs can be computed efficiently can be computed efficiently.
All these operations can be efficiently implemented for DBMs (see e.g. [5,20]) for details on operations 1-4; the fifth operator can be implemented using DBMs, as showed in the full version of the paper.
We can now perform a standard search through the state-space of symbolic markings using the passed/waiting list approach. We start by adding the initial marking to the waiting list. As long as the waiting list is nonempty, a symbolic marking M is removed from the waiting list, added to the passed list, and all symbolic extrapolated successors of M are explored. If a successor M of M is below (w.r.t. the ordering ) some marking on the passed or waiting list, we ignore it. Otherwise we add M to the waiting list and remove from the waiting and passed lists all markings that are below M . We stop with a positive answer once we find a marking satisfying a property we are searching for. If the whole statespace is searched without finding such a marking, we return a negative answer. The search is performed only upto k tokens in the net where this number is supplied by the user (it is undecidable whether there is some k such that the net is k-bounded [14]). If the net is k-bounded for the given k (this can be automatically verified) then this gives a conclusive answer, otherwise the search can give a conclusive answer only if it finds a marking satisfying the given property.
The successor generation algorithm is presented in Algorithm 1 and the reachability algorithm is given in Algorithm 2. Observe, as remarked above, that the algorithm will discard any generated successor marking if a larger marking is already present in the PASSED or WAITING list (line 11). Similarly, if a generated successor marking is larger than some marking in the PASSED or WAITING list, then it will remove all such smaller markings from the PASSED and WAITING list (lines 12 to 13).

Lemma 6.3 Algorithm 2 terminates.
Proof Let N be a k-bounded TAPN. We must argue that the state-space of the symbolic semantics is finite. Since N is a k-bounded TAPN, it follows that there are only finitely many placement functions. Further, from Theorem 4.1 we know that there are only finitely many extrapolated DBMs for a given placement function. Thus, we may conclude that there are only finitely many symbolic markings in the symbolic semantics using the extrapolation operator. Observe that Algorithm 2 will add each symbolic marking to the WAITING list at most once. Thus, it follows that the algorithm terminates.  Since the algorithm returned "YES", it must have found some symbolic marking (pl, D) such that (pl, D) |= ψ. Observe that Algorithm 2 (and Algorithm 1) will alternate between using the identity abstraction for discrete transition firings and α ext for time delays. Thus, from the way the algorithm searches through the state-space, we may conclude that there must exist symbolic markings (pl 1 , D 1 ), (pl 2 , D 2 ), . . . , (pl, D) such that where [D 0 ] = {v 0 }. By Theorem 4.2 and Theorem 3.1, we have that α ext is sound. Thus, there exists a concrete marking (pl, v) such that (pl 0 , v 0 ) −→ * (pl, v) and v ∈ [D]. Since atomic propositions depend only on the discrete part of a marking (placement function), it follows that (pl, v) |= ψ. Lemma 6.5 If (pl 0 , v 0 ) |= EF ψ then Algorithm 2 returns "YES".
Proof Assume that (pl 0 , v 0 ) |= EF ψ. This means that (pl 0 , v 0 ) −→ * (pl, v) and (pl, v) |= ψ. We must show that Algorithm 2 returns "YES". We define α ext (pl, [D]) def = [ext pl (D)] as before. By Theorem 4.2 and Theorem 3.1, we get that α ext is complete. Thus, there exists a symbolic marking (pl, We will now argue that Algorithm 2 will find a symbolic marking (pl , D ) such that (pl, However, by Theorem 5.1 it is safe to skip these symbolic markings since the future behaviour of the smaller symbolic markings is included in the larger symbolic marking. Thus, it follows that Algorithm 2 will find a symbolic marking (pl , D ) such that (pl, [D]) (pl , [D ]). By Theorem 6.1, we have that if the smaller marking satisfies ψ then the larger marking (pl , [D ]) also satisfies ψ. Thus, Algorithm 2 returns "YES".
The correctness of the reachability algorithm is hence established.

Experiments
We implemented the reachability algorithm in C++ and fully integrated it into the tool TAPAAL [9] (www.tapaal.net), an open-source and platform-independent editor, simulator and verifier of extended timed-arc Petri nets. In order to document the performance of our proposed algorithm, we present two larger case studies of Patient Monitoring System (PMS) and a communication protocol from the WS-Business Activity standard [19]. Both models can be downloaded from the tool's homepage. The patient monitoring system (PMS) is a case study taken from [8]. The system monitors the pulse rate and the level of oxygen saturation via sensors applied on the skin of a patient. It consists of three components: sampling subsystem, signal analyzer and alarm. The purpose of the PMS model is to verify that abnormal situations dangerous for the patient's health are detected within given deadlines. We have verified the model for deadline violation both in the sampling component and the signal analyzer. The sampling delay has been varied from 28 down to 16 seconds. This increased the complexity of the verification, as the queries were still satisfied and the whole state-space had to be searched.
In the second case study we verify the correctness of one of the web services coordination protocols called Business Activity with Participant Completion (BAwPC) [19]. Our model is based on the work presented in [17] where an enhanced protocol that avoids reaching any invalid states is given. We modelled the protocol in TAPAAL and considered asynchronous communication where messages can be lost; the model is scaled by the number of extra messages that can be used for retransmissions. The protocol is correct and hence the whole state-space is searched.
We compare the performance of our implementation with the UPPAAL engine where the timed automata models were obtained by automatic translations (called broadcast and degree 2 broadcast; see [15,16] for the details) from the TAPN models. We remark that the verification times of the translated TAPN models are in general comparable with native UPPAAL models and in some examples the translated models verify even faster than the native ones [16]. A direct comparison with other Petri net tools extended with time like Romeo [12] and TINA [6] is not possible due to the radically different semantics of the Petri net models used in these tools.
All experiments were run on Macbook Pro with 2.7 GHz Intel Core i7 with 8 GB RAM using BFS search strategy and the results are presented in Tables 1 and 2. The column TAPAAL refers to our algorithm where the set of inclusion places has been set to empty and TAPAAL incl. is our algorithm with the largest possible inclusion set. The user has the possibility to choose between these algorithms (or even manually select the concrete inclusion places) because for example in the case of 1-safe Petri nets where the inclusion is only rarely applied, the algorithm with the maximum inclusion can be slower due to the implementation overhead connected with inclusion checking of markings on the passed and waiting list. Indeed, in situations like in Table 1 the full inclusion checking is not that beneficial opposite to nets like in Table 2 where we have many tokens (messages) in the same place.

Conclusion
We presented a reachability algorithm for extended timed-arc Petri nets and implemented it within the tool TAPAAL. The algorithm includes efficient extrapolation and symmetry reduction techniques that show a very encouraging performance even on larger case-studies. We would like to emphasize the fact that all features that are implemented in the tool are formally defined and proved correct. We believe that our tool, available at www.tapaal.net, is one of a rather few reasonably-sized model checkers with a complete correctness proof taking into account all implemented optimizations and reduction techniques. In the future work we shall look at extending the technique to liveness properties and at further performance improvements by using for example the LU-extrapolation [4].