**2. Timed PN**

In the Petri net literature, three basic ways of representing time in Petri nets are used [2]: firing durations (FD), holding durations (HD) and enabling durations (ED). When using FD principle the transition firing has duration [23]. In contrast, when using HD principle, a firing has no duration but a created token is considered unavailable for the time assigned to transition that created the token, which has the same effect. With ED principle, the firing of the transitions has no duration while the time delays are represented by forcing transitions that are enabled to stay so for a specified period of time before they can fire. This is a more general concept since it allows for modelling of task interruption. Some authors use an even more general concept, which assigns delays to individual arcs, either inputs or outputs of a transition [10].

When modelling several performance optimisation problems, e.g. scheduling problems, such a general framework is not needed. It is natural to use HD when modelling most scheduling processes as operations are considered non-preemptive. The timed version of CPNs defined by [9] uses a HD equivalent principle, where the unavailability of the tokens is defined implicitly through the corresponding time stamps. While CPNs allow the assignment of delays both to transition and to output arcs, we further simplify this by allowing time delay inscriptions to transitions only. This is sufficient for the type of examples investigated here, and can be generalised if necessary.

To include a time attribute of the marking tokens, which determines their availability and unavailability, the notation of timed CPN will be adopted. Tokens are accompanied with a timestamp, which is written next to the token number and separated from the number by @. E.g., two tokens with time stamp 10 are denoted 2@10. A collection of tokens with different time stamps is defined as a multiset, and written as a sum (union) of sets of timestamped tokens. E.g., two tokens with time stamp 10 and three tokens with timestamp 12 are written as 2@10 + 3@12. The timestamp of a token defines the time from which the token is available.

Time stamps are elements of a time set *TS*, which is defined as a set of numeric values. In many software implementations the time values are integer, i.e., *TS* = **N**, but will be here admitted to take any positive real value including 0, i.e., *TS* = **R**<sup>+</sup> <sup>0</sup> . Timed markings are represented as collections of time stamps and are multisets over *TS* : *TSMS*. By using HD principle the formal representation of a P/T timed Petri net is defined as follows. *TPN* = (N , *M*0) is a timed Petri net system, where: N = (*P*, *T*, *Pre*, *Post*, *f*) is a Timed Petri net structure, *P* = {*p*1, *p*2, ..., *pk*}, *k* > 0 is a finite set of places, *T* = {*t*1, *t*2, ...,*tl*}, *l* > 0 is a finite set of transitions. *Pre* : (*P* × *T*) → **N** is the input arc function. If there exists an arc with weight *k* connecting *p* to *t*, then *Pre*(*p*, *t*) = *k*, otherwise *Pre*(*p*, *t*) = 0. *Post* : (*P* × *T*) → **N** is the output arc function. If there exists an arc with weight *k* connecting *t* to *p*, then *Post*(*p*, *t*) = *k*, otherwise *Post*(*p*, *t*) = 0. *f* : *T* → *TS* is the function that assigns a non-negative deterministic time delay to every *t* ∈ *T*. *M* : *P* → *TSMS* is the timed marking, *M*<sup>0</sup> is the initial marking of a timed Petri net.

To determine the availability and unavailability of tokens, two functions on the set of markings are defined. The set of markings is denoted by **M**. Given a marking and model time, *m* : *P* × **M** × *TS* → **N** defines the number of available tokens, and *n* : *P* × **M** × *TS* → **N** the number of unavailable tokens for each place of a TPN at a given time *τk*. Note that model time also belongs to time set *TS*, *τ<sup>k</sup>* ∈ *TS*.

Using the above definitions, addition and subtraction of timed markings, and the TPN firing rule can be defined. Given a marked *TPN* = (N , *M*), a transition *t* is time enabled at time *τk*, denoted *M*[*t*�*τ<sup>k</sup>* iff *m*(*p*, *M*, *τk*) ≥ *Pre*(*p*, *t*), ∀*p* ∈ •*t*. An enabled transition can fire, and as a result removes tokens from input places and creates tokens in output places. The newly created tokens are accompanied by timestamps depending on the model time and the delay of transition that created the tokens. If marking *M*<sup>2</sup> is reached from *M*<sup>1</sup> by firing *t* at time *τk*, this is denoted by *M*1[*t*�*τkM*2. The set of markings of TPN N reachable from *M* is denoted by *R*(N , *M*).
