Flexible Nets: a modeling formalism for dynamic systems with uncertain parameters

Abstract

The modeling of dynamic systems is frequently hampered by a limited knowledge of the system to be modeled and by the difficulty of acquiring accurate data. This often results in a number of uncertain system parameters that are hard to incorporate into a mathematical model. Thus, there is a need for modeling formalisms that can accommodate all available data, even if uncertain, in order to employ them and build useful models. This paper shows how the Flexible Nets (FNs) formalism can be exploited to handle uncertain parameters while offering attractive analysis possibilities. FNs are composed of two nets, an event net and an intensity net, that model the relation between the state and the processes of the system. While the event net captures how the state of the system is updated by the processes in the system, the intensity net models how the speed of such processes is determined by the state of the system. Uncertain parameters are accounted for by sets of inequalities associated with both the event net and the intensity net. FNs are not only demonstrated to be a valuable formalism to cope with system uncertainties, but also to be capable of modeling different system features, such as resource allocation and control actions, in a facile manner.

1 Introduction

The development of appropriate models is crucial for the design, analysis and control of dynamic systems. The usefulness of a model depends on both its capacity to capture the relevant features of the system, and its capacity for mathematical analysis. These capacities of the model largely rely on the adopted modeling formalism, i.e. on the set of modeling principles and rules that are used to build the model. The task of modeling is often hindered by the lack of detailed system information.

This paper exploits the particular features of Flexible Nets (FNs), a modeling formalism introduced in Júlvez et al. (2018) to study Wilson disease, to model and analyze dynamic systems with uncertain parameters, to account for partially observable systems and, to compute the control actions that optimize a given control objective. Roughly speaking, a dynamic system can be seen as a set of state variables that are modified by means of processes (by process, we mean any event, operation or activity whose occurrence has the potential to change the state of the system). These two basic entities, state and process, are mutually related: on the one hand, the execution of the processes determines how the state changes; on the other hand, the state determines the speed of the processes. These relationships between state and processes are clear, for instance, in a chemical system where the state is given by the amount of molecules and the processes are the reactions taking place in the system. On the one hand, the occurrence of reactions produces a change in the amount of molecules that satisfies the stoichiometry of these reactions. On the other hand, the rate of the reactions depends on the amount of molecules. FNs capture these relationships between state and processes by means of two different nets: the event net and the intensity net.

Let us introduce some of the basic features of FNs by means of a simple chemical reaction network. Assume that the reaction network is composed of the following two reactions:

$$R_{1}:\emptyset \rightarrow\ A\hspace{3cm} R_{2}: A\rightarrow\ nB+4nC$$

Reaction R₁ models the production of compound A (each occurrence of R₁ increases the concentration of A, which is denoted [A], one unit), and reaction R₂ models how A is decomposed into compounds B and C. The amounts which [B] and [C] are increased by the occurrence of R₂ depend on n. Let us assume that n is uncertain, but known to be in the interval [20,22]. That is, each occurrence of R₂ decreases [A] one unit, increases [B] n units, and increases [C] 4n units where n ∈ [20,22]. Let us further assume that the initial concentrations of [B] and [C] are 0, and the initial concentration of [A] is known to be in the interval [9.9,1.1].

The FN in Fig. 1 models the described reaction network. Namely, each chemical compound is a associated with a circle (which will be called a place), and each reaction is associated with a rectangle (which will be called a transition). The stoichiometry of the reactions is modeled by the equations associated with the dots labelled v₁ and v₂ (which will be called event handlers). The uncertain stoichiometry of R₂ is accounted for by the inequalities associated with v₂, i.e. a=v, 20v≤b≤ 22v and c= 4b; and the uncertain initial concentration [A] is captured by the inequalities associated with A, i.e. 9.9≤m₀[A]≤ 1.1.

Fig. 1

FN modeling a simple chemical reaction network

The event net of an FN is a graph with three different types of vertices: places, transitions and event handlers. While places and transitions are used to model the state and the processes of the system, respectively, event handlers are used to determine the quantities by which the state is changed when given processes occur. Each place is associated with a state variable, and the value of that variable at a given instant is called marking, or number of tokens, in that place. Similarly, each transition is associated with a process, and the number of times the process has taken place is the number of actions in the transition. Each event handler connects a set of transitions to a set of places, and is associated with a set of linear inequalities that relates actions to marking. Given a number of actions in the connected transitions, any solution of the set of linear inequalities can be used to update the number of tokens in the connected places. Thus, the amount by which the marking changes is allowed to be nondeterministic. This feature of event nets allows the model to account for the different system evolutions that can arise as a consequence of uncertainty in the system. In Fig. 1, the event net is composed of the places, transitions, event handlers and arcs and edges in green.

Let us further assume that the rate of reaction R₁ is uncertain, but constrained to the interval [4.5,5.5], i.e. the number of reactions that occur per time unit is in [4.5,5.5], and the rate R₂ satisfies 0.9[A] ≤ rate(R₂) ≤ 1.1[A], i.e. it is proportional to [A] with an uncertainty of 10%. These reaction rates are modeled in the FN by the inequality associated with R₁ and the inequality associated with the dot labelled s₁ (which will be denoted intensity handler).

Similarly to event nets, an intensity net is a graph with three different types of vertices: places, transitions and intensity handlers. Places and transitions have the same role as in event nets. Each intensity handler connects a set of places to a set of transitions, and is associated with a set of linear inequalities that relates the number of tokens with the speed of the transitions, i.e. of the processes modeled by the transitions. The intensity, or speed, of a transition determines the rate at which actions are created in the transition. As in event nets, any solution of the inequalities can be used to determine the speed of transition, thus, linear inequalities can be used to model uncertainties in the dynamics of the system. In Fig. 1, the intensity net is composed by the places, transitions, intensity handlers and arcs and edges in blue.

An FN is the result of combining an event net and an intensity net, i.e. an FN is a graph with four types of vertices: places, transitions, event handlers and intensity handlers. While the intensity net establishes the speeds at which actions are generated as a function of the marking, the event net specifies how the generated actions are executed and how a new marking is computed. Thus, although FNs are inspired by Petri nets (Murata 1989), their structure is different, since in addition to places and transitions, FNs have handlers which are connected to places and transitions by arcs and edges. FNs offer both high modeling power and appealing analysis possibilities that aim to make use of all the information provided by the available uncertain parameters. Namely, FNs can accommodate uncertainties in the initial marking, in the marking change produced by the firing of the transitions, in the default speeds of transitions, and in the speed of transitions produced by the marking.

A number of different formalisms can be found in the literature that can, to some extend, incorporate uncertain parameters in their models. Depending on the domain of their state variables, these formalisms can be roughly classified as those whose variables are integer numbers, and those whose variables are real numbers (hybrid approaches combine both types of variables).

In the discrete domain, extensions of the most popular modeling formalisms exist that can handle uncertain parameters. For instance, in the Petri nets arena, uncertain knowledge of the marking is particularly well handled by fuzzy (Looney 1988) and possibilistic Petri nets (Cardoso et al. 1999), uncertainty in the firing of transitions can be accounted for by labeled (Cabasino et al. 2010) and interpreted (Ramirez-Trevino et al. 2003) Petri nets, and uncertain firing times can be modeled by time Petri nets (Merlin and Faber 1976) and stochastic Petri nets (Ajmone Marsan et al. 1995). Other discrete formalisms that include extensions to account for uncertain parameters are probabilistic Boolean networks (Shmulevich et al. 2002), which are an extension of Boolean networks (Wang et al. 2012), and influence diagrams (Detwarasiti and Shachter 2005), which are generalizations of Bayesian networks (Needham et al. 2007) that can solve decision problems under uncertainty. Stochastic extensions of timed automata (Alur and Dill 1994) also exist in which delays and discrete choices are made randomly (Bertrand et al. 2014). In a similar vein, stochastic extensions of process algebras (Priami et al. 2001; Ciocchetta and Hillston 2008) have been proposed to describe components with uncertain behaviour (Clark et al. 2007).

A major difference of the above mentioned approaches with respect to FNs is that the state variables of FNs are real numbers. This implies that genuinely discrete systems cannot be modeled by FNs. Nevertheless, the use of real variables facilitates, in general, the use of more efficient analysis methods since the state explosion problem inherent to large discrete systems is avoided, and linear programming techniques can be applied. Moreover, large discrete populations can be approximated reasonably well in many cases by means of real variables (Bortolussi et al. 2013). With respect to the existing stochastic approaches and extensions, it should be said that they offer the possibility to perform useful statistical analyses, which usually require information about the probability distributions of the system, and often involve a significant computational cost. In contrast, FNs do not require information about probability distributions, just about the intervals in which the uncertain parameters lay. This results in efficient analysis techniques based on linear programming.

The most popular modeling approaches in the continuous domain are based on differential equations (Braun et al. 1983; Tyson et al. 2011; van den Berg et al. 2008). In particular, the relaxation of the integrality constraint in a discrete formalism usually leads to models that are governed by differential equations. For instance, the evolution of continuous Petri nets (Silva et al. 2011), which can be seen as a relaxation of Petri nets (Murata 1989), is determined by a set of ordinary differential equations. Another popular modeling formalism that can graphically represent systems in different domains and that can be easily converted to state space representation is bond graphs (Borutzky 2010). However, it should be emphasised that a potential difficulty in the design of models based on differential equations is that exhaustive and accurate information about the system dynamics is required, i.e. uncertain parameters cannot be easily handled. Note that the time trajectory of a system modeled by ordinary differential equations is continuous and deterministic. On the other hand, constraint-based models, which are popular in systems biology (Varma and Palsson 1994; Orth et al. 2011), can incorporate uncertain dynamic information but their analysis capabilities are limited to the steady state.

An important feature of FNs is that they can bridge the gap between deterministic models and constraint-based models by allowing the incorporation of uncertain parameters. Thus, on the one hand and similarly to continuous Petri nets which are deterministic (Jiménez et al. 2004), FNs can model positive linear systems; on the other hand and similarly to constraint-based models (Varma and Palsson 1994), FNs can model systems with uncertain initial state and uncertain process speeds. In contrast to Petri nets, the timing of transitions and the marking changes in places are explicitly separated in FNs: the timing is handled by the intensity handlers, and the marking changes by the event handlers. This can lead to a clearer and more concise graphical representation of the system. Moreover, efficient computational methods exist to analyse the transient state of FNs.

The rest of the paper is organized as follows: Section 2 introduces event nets and shows how a partially observable system can be modeled. Intensity nets are presented in Section 3. The combination of these nets leads to FNs, which are defined in Section 4. Section 5 shows how FNs can handle systems with uncertain parameters and analyze them. Section 6 concludes the paper.

2 Event nets

In the following, the reader is assumed to be familiar with Petri nets (see Murata1989 for a gentle introduction).

2.1 Definition and state equations

This section introduces event nets, which can be denoted as TVP nets, i.e. actions in transitions T produce and consume tokens in places P through event handlers V. Event handlers connect places and transitions, and determine the marking changes according to the actions in the transitions. In contrast to Petri nets, the net elements that produce changes in the marking are the event handlers, and such changes are allowed to be nondeterministic.

Definition 1 (Event net)

An event net is a tuple ${{\mathcal {N}}}_{V}=(P,T,V,E_{V},A,B)$ where (P, T, V, E_V) is a tripartite graph determining the net structure and (A, B) are matrices determining the potential evolutions of the marking.

The set of vertices of the net is partitioned into three sets:

• P = {p₁,…,p_i,…} is a set of |P| places.

• T = {t₁,…,t_j,…} is a set of |T| transitions.

• V = {v₁,…,v_k,…} is a set of |V | event handlers.

The places, depicted as circles, model the different types of components or elements in the system, e.g. resources, products, items, etc. The transitions, depicted as rectangles, model the different types of operations, activities or processes in the system. Such operations require time to be performed and have the potential to change, i.e. produce and consume, the amount of components, i.e. the marking. The event handlers, depicted as dots, model the different ways in which the transitions can change the marking.

The vertices of the net are connected by the edges in E_V. Each pair of vertices can be connected by at most one edge. The set E_V is partitioned into two sets ${E_{V}^{P}}$ and ${E_{V}^{T}}$, where ${E_{V}^{P}}$ is a set of directed edges connecting places to event handlers and vice versa, and ${E_{V}^{T}}$ is a set of undirected edges connecting transitions and event handlers. For simplicity, directed edges are referred as arcs, and undirected edges as edges. More formally:

• Every $e\in {E_{V}^{P}}$ is either an arc e = (p_i,v_k) from a place p_i to a handler v_k, or an arc e = (v_k,p_i) from a handler v_k to a place p_i.

• Every $e\in {E_{V}^{T}}$ is an edge e = {t_j,v_k} connecting a transition t_j and a handler v_k.

Notice that direct connections among places and transitions are not allowed. The following notation is used:

• ^pv_k denotes the input places of v_k, i.e. $^{p}v_{k}=\{p_{i}|(p_{i},v_{k})\in {E_{V}^{P}}\}$

• ${v_{k}^{p}}$ denotes the output places of v_k, i.e. ${v_{k}^{p}}=\{p_{i}|(v_{k},p_{i})\in {E_{V}^{P}}\}$

• ^vp_i denotes the input handlers of p_i, i.e. $^{v}p_{i}=\{v_{k}|(v_{k},p_{i})\in {E_{V}^{P}}\}$

• ${p_{i}^{v}}$ denotes the output handlers of p_i, i.e. ${p_{i}^{v}}=\{v_{k}|(p_{i},v_{k})\in {E_{V}^{P}}\}$

• ^tv_k denotes the transitions connected to v_k, i.e. $^{t}v_{k}=\{t_{j}|\{t_{j},v_{k}\}\in {E_{V}^{T}}\}$

• ${t_{j}^{v}}$ denotes the handlers connected to t_j, i.e. ${t_{j}^{v}}=\{v_{k}|\{t_{j},v_{k}\}\in {E_{V}^{T}}\}$

Example 1

The event net in Fig. 2a has three places, P = {p₁,p₂,p₃}, one transition, T = {t₁}, and two event handlers V = {v₁,v₂}. The set of arcs is ${E_{V}^{P}}=\{(p_{1},v_{1}), (v_{1},p_{2}), (p_{1}, v_{2}), (v_{2},p_{3})\}$, and the set of edges is ${E_{V}^{T}}=\{\{t_{1},v_{2}\}\}$. The set of all arcs and edges is $E_{V}={E_{V}^{P}}\cup {E_{V}^{T}}$. As examples for the introduced notation, the set of output handlers of p₁ is ${p_{1}^{v}}=\{v_{1},v_{2}\}$, the set of transitions connected to v₂ is ^tv₂ = {t₁}, and the set of input handlers of p₃ is ^vp₃ = {v₂}.

Fig. 2

a Event net. b Potential state evolutions with discrete firings of the event handlers (the components of the vectors correspond to the variables (m[p₁] m[p₂] m[p₃] a_T[t₁]))

In an event net, each place contains a number of tokens (or marking), and each transition contains a number of actions that represent the potential of the system to carry out the associated process. In contrast to tokens, actions require time to be produced (the production rate of actions is determined by the intensity net, see Section 3). The state of an event net accounts not only for the marking and the number of actions, but also for the marking changes and the execution of actions:

Definition 2 (State)

The state of an event net ${{\mathcal {N}}}_{V}$ is given by the tuple (σ, a_T,a_E,Δm, m), where:

• $\sigma \in \mathbb {R}^{|T|}_{\geq 0}$ is a vector indexed by T where σ[t_j] is the number of actions produced in t_j.

• $a_{T}\in \mathbb {R}^{|T|}_{\geq 0}$ is a vector indexed by T where a_T[t_j] is the number of actions available in t_j.

• $a_{E}\in \mathbb {R}^{|{E_{V}^{T}}|}_{\geq 0}$ is a vector indexed by ${E_{V}^{T}}$ where a_E[{t_j,v_k}] is the number of actions of t_j executed by v_k.

• ${\Delta }m\in \mathbb {R}^{|{E_{V}^{P}}|}_{\geq 0}$ is a vector indexed by ${E_{V}^{P}}$ where Δm[(p_i,v_k)] is the number of tokens in p_i consumed by v_k, and Δm[(v_k,p_i)] is the number of tokens in p_i produced by v_k.

• $m\in \mathbb {R}^{|P|}_{\geq 0}$ is the marking, i.e. a vector indexed by P where m[p_i] is the number of tokens in p_i.

Thus, every net element (except for the event handlers) is associated with at least one nonnegative real variable. Since actions need time to be produced, at the initial state it holds σ = 0, a_T = 0 and a_E = 0. Notice that dealing with real state variables instead of discrete ones allows the model to incorporate real quantities and to approximate large discrete quantities as in continuous Petri nets (Silva et al. 2011). In any case, the state variables can be constrained to the nonnegative integers if required, see Section 2.2.

Each event handler v_k ∈ V is associated with a set of linear inequalities that relate the number of actions executed in the connected transitions to the marking changes in the connected places. The coefficients of such a set of inequalities can be expressed by two matrices (A_k,B_k) of real numbers and the same number of rows that are associated with each handler v_k ∈ V. The number of actions executed by v_k, a_f, and the produced marking changes, Δm_f, is given by A_kΔm_f≤B_ka_f. The columns of A_k are indexed by the arcs connecting v_k to places. The columns of B_k are indexed by the edges connecting transitions to v_k. Matrix A(B) is obtained by arranging all the matrices A_k(B_k) diagonally.

Example 2

The inequalities associated with the event handlers of the net in Fig. 2a are: v₁:a=b and $v_{2}{:}\left \{\begin {array}{cc}a{=}x\\ x{\leq } b{\leq } 2x \end {array}\right .$, where ’a’, ’b’ and ’x’ are used to label arcs and edges. More precisely, in v₁:a=b, ’a’ denotes the number of tokens in p₁ consumed by v₁, and ’b’ denotes the number of tokens in p₂ produced by v₁. In the inequalities associated with v₂, ’a’ and ’b’ denote the number of tokens in p₁ consumed by v₂ and the number of tokens in p₃ in produced by v₂ respectively, and ’x’ denotes the number of actions in t₁ executed by v₂. The equality v₁:a=b means that the number of tokens in p₁ consumed by v₁ is equal to the number of tokens in p₂ produced by v₁. In other words, for every token in p₁ consumed by v₁, a token is produced in p₂ by v₁, this can be interpreted as tokens moving from p₁ to p₂ through v₁.

The equation a=x associated with v₂ means that the number of tokens in p₁ consumed by v₂ is equal to the number of actions in t₁ executed by v₂, e.g. if one action is executed then one token is consumed. Moreover, the inequality x≤b≤ 2x means that the execution of one action in t₁ by v₂, i.e. x = 1, produces a nondeterministic quantity b ∈ [1,2] of tokens in p₃ (each execution of an action can produce a different amount b ∈ [1,2] of tokens in p₃).

Notice that v₁ is not connected to any transition. This means that no process is required to move a token from p₁ to p₂. For the sake of mathematical notation, it can be assumed that v₁ is connected to a fake transition, t_fake, that has no effect on the model. The matrices A₁, B₁, A₂ and B₂ that capture the inequalities associated with the event handlers are:

$$ A_{1}{=} \left( \begin{array}{cc} 1 & -1\\ -1 & 1 \end{array}\right) ; B_{1}{=} \left( \begin{array}{l} 0\\ 0 \end{array}\right) ; A_{2}{=} \left( \begin{array}{cccc} 1 & 0\\ -1 & 0\\ 0 & -1\\ 0 & 1 \end{array}\right) ; B_{2}{=} \left( \begin{array}{ll} 1\\ -1\\ -1\\ 2 \end{array}\right) $$

where the indices of the columns of A₁ are ordered as (p₁,v₁), (v₁,p₂); the index of the column of B₁ is {t_fake,v₁}; the indices of the columns of A₂ are ordered as (p₁,v₂), (v₂,p₃); and the index of B₂ is {t₁,v₂}. Thus, the number of actions executed and marking changes produced by v₂ are related by:

$$ \left( \begin{array}{cc} 1 & 0\\ -1 & 0\\ 0 & -1\\ 0 & 1 \end{array}\right) \left( \begin{array}{cc} {\Delta}m[(p_{1},v_{2})]\\ {\Delta}m[(v_{2},p_{3})] \end{array}\right) {\leq} \left( \begin{array}{cc} 1\\ -1\\ -1\\ 2 \end{array}\right) \left( \begin{array}{cc} a_{E}[\{t_{1},v_{2}\}] \end{array}\right) $$

Matrices A₁ and A₂(B₁ and B₂) can be arranged diagonally to obtain A(B):

$$ A= \left( \begin{array}{cccc} 1 & -1 & 0 & 0\\ -1 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & -1 & 0\\ 0 & 0 & 0 & -1\\ 0 & 0 & 0 & 1 \end{array}\right) ;\ \ B= \left( \begin{array}{cc} 0 & 0 \\ 0 & 0 \\ 0 & 1 \\ 0 & -1 \\ 0 & -1 \\ 0 & 2 \end{array}\right) $$

where the indices of the columns of A are (p₁,v₁), (v₁,p₂), (p₁,v₂), (v₂,p₃); and the indices of the columns of B are {t_fake,v₁}, {t₁,v₂}.

Notice that the number of actions produced in a transition (by the intensity net), σ, is equal to the number of actions that have been executed by the connected event handlers, a_E, plus the number of actions still available, a_T, hence, it holds:

$$ \sigma[t_{j}]=a_{T}[t_{j}]+\sum\limits_{v_{k}\in {t_{j}^{v}}} a_{E}[\{t_{j},v_{k}\}]\ \ \forall\ t_{j}\in T $$

(1)

Similarly, the number of tokens in a place p_i is equal to the initial number of tokens, which is denoted m₀[p_i], minus the number of tokens consumed plus the number of tokens produced by the connected event handlers:

$$ m[p_{i}]{=}m_0[p_{i}] {-} \sum\limits_{v_{k}\in {p_{i}^{v}}} {\Delta}m[(p_{i},v_{k})] {+}{\sum}_{v_{k}\in^{v}p_{i}} {\Delta}m[(v_{k},p_{i})]\ \ \forall\ p_{i}\in P $$

(2)

The event net establishes how the state evolves as event handlers are enabled and fire.

Definition 3 (Enabling)

Event handler v_k is enabled at (σ, a_T,a_E,Δm, m) if a vector $a_{f}\in \mathbb {R}_{\geq 0}^{|^{t}v_{k}|}$ indexed by the edges of v_k, and a vector ${\Delta }m_{f}\in \mathbb {R}_{\geq 0}^{|^{p}v_{k}|+|{v_{k}^{p}}|}$ indexed by the arcs of v_k exist such that:

$$ \begin{array}{@{}rcl@{}} a_{f}[\{t_{j},v_{k}\}] &\leq& a_{T}[t_{j}]\ \ \ \forall\ t_{j}\in ^{t}v_{k} \end{array} $$

(3)

$$ \begin{array}{@{}rcl@{}} A_{k} {\Delta}m_{f} &\leq& B_{k} a_{f} \end{array} $$

(4)

$$ \begin{array}{@{}rcl@{}} {\Delta}m_{f}[(p_{i},v_{k})] &\leq& m[p_{i}]\ \ \ \forall\ p_{i}\in ^{p}v_{k} \end{array} $$

(5)

$$ \begin{array}{@{}rcl@{}} \mathbf{1}a_{f} + \mathbf{1}{\Delta}m_{f} & >& 0 \end{array} $$

(6)

Inequality (3) guarantees that enough actions are available, (4) makes use of the matrices A_k and B_k to relate the number of executed actions to the marking changes, (5) guarantees that enough tokens are available in the input places to be consumed, (6) guarantees that the overall state change is not null. Notice that the inequalities (4) allow the modeling of uncertainty in the marking changes produced by the execution of actions.

Definition 4 (Firing)

An event handler v_k enabled at (σ, a_T,a_E,Δm, m) can fire. The firing of v_k leads instantaneously to a new state $(\sigma ,a_{T}^{\prime },a_{E}^{\prime },{\Delta }m^{\prime },m^{\prime })$ where only the variables associated with edges, arcs, places and transitions connected to v_k are updated as follows:

$$ \begin{array}{@{}rcl@{}} a_{T}^{\prime}[t_{j}] & =& a_{T}[t_{j}] - a_{f}[\{t_{j},v_{k}\}]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \forall \ t_{j}{\in} ^{t}v_{k}\\ a_{E}^{\prime}[\{t_{j},v_{k}\}] &=& a_{E}[\{t_{j},v_{k}\}] + a_{f}[\{t_{j},v_{k}\}]~~~~~~~~~~~~~~~~~~~~~~~~~ \forall \ t_{j}{\in} ^{t}v_{k}\\ {\Delta}m^{\prime}[(p_{i}, v_{k})] & =& {\Delta}m[(p_{i}, v_{k})] + {\Delta}m_{f}[(p_{i}, v_{k})]~~~~~~~~~~~~~~~~~ \forall \ p_{i}{\in} ^{p}v_{k}\\ {\Delta}m^{\prime}[(v_{k}, p_{i})] & =& {\Delta}m[(v_{k}, p_{i})] + {\Delta}m_{f}[(v_{k}, p_{i})]~~~~~~~~~~~~~~~~~ \forall \ p_{i}{\in} {v_{k}^{p}}\\ m^{\prime}[p_{i}]&=&m[p_{i}]{-}{\Delta}m_{f}[(p_{i}, v_{k})]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \forall \ p_{i}{\in} ^{p}v_{k}\\ m^{\prime}[p_{i}]&=&m[p_{i}]{+} {\Delta}m_{f}[(v_{k}, p_{i})]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \forall \ p_{i}{\in} {v_{k}^{p}} \end{array} $$

where a_f and Δm_f satisfy (3), (4), (5) and (6).

Notice that an enabled handler is not forced to fire, and that the state reached by the firing of an event handler is allowed to be nondeterministic (see inequality (4)). Moreover, the firing does not force the execution of a minimum number of actions nor the consumption or production of a minimum number of tokens. In fact, the equations in Definition 4 are trivially satisfied with a_f = 0 and Δm_f = 0. Thus, such equations also hold for every non-enabled handler with a_f = 0 and Δm_f = 0.

The overall change in the state produced by several firings is the result of adding the changes produced by each firing. This leads to a set of equations that are satisfied by the states that can be reached from the initial state.

Proposition 1 (State equations)

Let the state of an event net ${{\mathcal {N}}}_{V}$ be (σ, σ,0,0,m₀), i.e. σ actions are available and no event handler has fired. Every state (σ, a_T,a_E,Δm, m) reachable from (σ, σ,0,0,m₀) belongs to $SE_{{{\mathcal {N}}}_{V}}(\sigma ,m_0)$ where:

$$ \begin{array}{ll} SE_{{{\mathcal{N}}}_{V}}(\sigma,m_0) = \{(&\sigma,a_{T},a_{E},{\Delta}m,m)| \\ & \sigma = a_{T} + Y_{\sigma} a_{E}\\ & A {\Delta}m \leq B a_{E}\\ & m = m_0 + Z_{m} {\Delta}m\} \end{array} $$

(7)

where Y_σ and Z_m are determined by the net structure:

• Y_σ is a matrix with rows indexed by T, columns indexed by ${E_{V}^{T}}$, and such that $Y_{\sigma }[t_{j},\{t_{j},v_{k}\}]=1\ \forall \ \{t_{j},v_{k}\}\in {E_{V}^{T}}$ and the rest of the elements in Y_σ are 0,

• Z_m is a matrix with rows indexed by P, columns indexed by ${E_{V}^{P}}$, and such that $Z_{m}[p_{i},(p_{i},v_{k})]=-1\ \forall \ (p_{i},v_{k}) \in {E_{V}^{P}}$, $Z_{m}[p_{i},(v_{k},p_{i})]=1\ \forall \ (v_{k},p_{i}) \in {E_{V}^{P}}$ and the rest of the elements in Z_m are 0,

and a_T, a_E, Δm and m are nonnegative variables.

Proof

Let us show that equations (7) necessarily hold for every state (σ, a_T,a_E,Δm, m) reachable from (σ, σ,0,0,m₀). Equation σ = a_T + Y_σa_E in (7) states that the number of actions produced, σ, is equal to the number of actions executed, a_E, plus the number of actions available, a_T. This is equivalent to (1) expressed in matrix form, and thus necessarily holds. Equation AΔm ≤ Ba_E in (7) is the matrix form of (4) and accounts for all the actions executed and all the marking changes produced by the firing of all the event handlers. That is, it captures all the cumulative marking changes, Δm, produced by all the executed actions, a_E, and, hence, must necessarily hold. Finally, equation m = m₀ + Z_mΔm in (7) which updates the number of tokens, m, in all the places according to the cumulative marking changes, Δm, is the matrix form of (2) and, hence, must also hold. □

Roughly speaking, the role of matrix Y_σ is to distribute the actions in transitions among the handlers connected to them, see (1). The role of Z_m is to collect and add the marking changes produced by the firings, see (2).

Example 3

Equation σ = a_T + Y_σa_E for the event net in Fig. 2a assuming again that v₁ is connected to a fake transition is:

$$ \left( \begin{array}{cc} \sigma[t_{1}]\\ \sigma[t_{fake}] \end{array}\right) = \left( \begin{array}{cc} a_{T}[t_{1}]\\ a_{T}[t_{fake}] \end{array}\right) + \left( \begin{array}{cc} 1 & 0\\ 0 & 1 \end{array}\right) \left( \begin{array}{cc} a_{E}[\{t_{1},v_{2}\}]\\ a_{E}[\{t_{fake},v_{1}\}] \end{array}\right) $$

and equation m = m₀ + Z_mΔm is:

$$ \left( \begin{array}{cc} m[p_{1}]\\ m[p_{2}]\\ m[p_{3}] \end{array}\right) = \left( \begin{array}{cc} m_0[p_{1}]\\ m_0[p_{2}]\\ m_0[p_{3}] \end{array}\right) + \left( \begin{array}{cccc} -1 & 0 & -1 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0& 1 \end{array}\right) \left( \begin{array}{cc} {\Delta}m[(p_{1},v_{1})]\\ {\Delta}m[(v_{1},p_{2})]\\ {\Delta}m[(p_{1},v_{2})]\\ {\Delta}m[(v_{2},p_{3})] \end{array}\right) $$

Let us assume that the marking of the net in Fig. 2a is m[p₁]= 2, m[p₂]= 0, m[p₃]= 0, that one action was produced in t₁, i.e. σ[t₁]= 1, and it is available, i.e, a_T[t₁]= 1, and no event handler has fired. This corresponds to the state (σ[t₁]= 1, a_T[t₁]= 1, a_E[{t₁,v₂}]= 0, (Δm[(p₁,v₁)]= 0,Δm[(v₁,p₂)]= 0,Δm[(p₁,v₂)]= 0, Δm[(v₂,p₃)]= 0), (m[p₁]= 2,m[p₂]= 0,m[p₃]= 0)). At this state, both event handlers, v₁ and v₂, are enabled and can fire. If v₂ fires in an amount of 1, i.e. x= 1, then: a_T[t₁] and m[p₁] are decreased by 1; a_E[{t₁,v₂}] and Δm[(p₁,v₂)] are increased by one; and Δm[(v₂,p₃)] and m[p₃] are increased by a nondeterministic quantity in the interval [1,2] (the value of σ[t₁] remains unaltered as no actions are produced).

The graph in Fig. 2b shows the potential evolutions of the net under the assumption that event handlers fire in discrete amounts, i.e. all markings and actions are integers. The components of the vectors of states in the graph correspond to the variables (m[p₁] m[p₂] m[p₃] a_T[t₁]). The arcs are labeled with the event handler that is fired. Remark that while the firing of v₁ produces a deterministic change (one token consumed from p₁ and one token produced in p₂), the state change produced by the firing of v₂ is nondeterministic (either one or two tokens can be produced in p₃).

Notice that equations (7) account for the cumulative effect, and not the sequence, of the firings. In particular, the availability of tokens and actions consumed by the sequence of firings is not checked. This can lead to spurious solutions (Silva et al. 1998) in the state equations. Hence, equations (7) represent a necessary condition for the reachability of (σ, a_T,a_E,Δm, m).

In order to account for linear relationships among the values of the initial marking, m₀ is assumed to be a vector constrained as:

$$ J_{m}m_0\leq K_{m} $$

(8)

where J_m and K_m are real matrices of appropriate size. Note that the inequalities (8) can be used to account for the uncertain initial marking of a place, e.g. 10 ≤ m₀[p₁] ≤ 12, or to express linear constraints among markings, e.g. m₀[p₁] + m₀[p₂] = 5 and m₀[p₄] = 2m₀[p₃]. Equations (7) can be easily modified to take into account the relationships expressed by (8):

$$ \begin{array}{ll} SE_{{{\mathcal{N}}}_{V}}(\sigma,J_{m},K_{m}) = \{(&\sigma,a_{T},a_{E},{\Delta}m,m)| \\ & \sigma = a_{T} + Y_{\sigma} a_{E}\\ & A {\Delta}m \leq B a_{E}\\ & m = m_0 + Z_{m} {\Delta}m\\ & J_{m}m_0\leq K_{m}\} \end{array} $$

(9)

Although event handlers are not forced to fire, it is useful in some cases to consider only those states in which all the actions of given transitions have been executed. Let $T_{F}\subseteq T$ be the set of transitions whose actions must have been executed, i.e. the number of available actions of t_j ∈ T_F must be 0. In order to constrain (9) to such a set of states, the following equation can be added:

$$ a_{T}[t_{j}] = 0\ \ \forall\ t_{j}\in T_{F} $$

(10)

2.2 Partial observability

In an event net, the marking change produced by the execution of an action is allowed to be nondeterministic. This is the case when there are several event handlers connected to a transition, or if the connected event handler has appropriate inequalities associated with it. The nondeterministic effect of the execution of actions can be used to develop nondeterministic models and, in particular, to model partially observable systems. The state equations (9) account for all the states that can be reached after the firing of event handlers. In the context of partial observability, these equations characterize the set of states that are consistent with a given observation of a partially observable system. The following example shows how a partially observable system can be modeled by an event net.

For the sake of this example, let us assume that the event handlers of the net in Fig. 3a only fire in discrete amounts and that only the sequence of transitions whose actions are executed is observable. For clarity, the equations of event handlers that make all their labels equal are omitted, e.g. the equations of v₁ are a=b and a=x, and they are therefore omitted (this same omission is made in the nets of the rest of the paper).

Fig. 3

a Event net modeling a partially observable system. b Potential evolutions of the marking with discrete firings

Thus, the observation of t₁ corresponds to the firing of v₁; the firing of v₂ is unobservable (silent event) because it is not connected to a transition; the observation of t₂ corresponds either to the firing of v₃ or v₄ because both handlers use the actions in t₂ (in other words, t₂ models events that cannot be distinguished by an observer); the observation of t₃ corresponds to the firing of v₅.

The graph in Fig. 3b shows the potential evolutions of the net with m₀ = (1 0 0 0 0 0) and σ = (2 1 1), the components of the vectors in the graph correspond to the marking of places (p₁p₂p₃p₄p₅p₆). Initially, only v₁ can fire and, hence, the execution of actions in t₁ is the only event that can be observed. The observation of t₁ means that a token was consumed from p₁ and a token was produced in p₂. Since p₂ is the input place of v₂ whose firing cannot be observed, a token in p₂ can remain in p₂ or move silently to p₃. Thus, the set of markings consistent with the observation of t₁ is {(0 1 0 0 0 0),(0 0 1 0 0 0)}, see second row of the graph. Assume that t₂ is now observed, i.e. either v₃ or v₄ has fired. If the marking was (0 0 1 0 0 0), then v₃ (the only enabled handler) has fired and that leads to marking (0 0 0 1 0 0). Otherwise, v₄ has fired and that leads either to (0 0 0 0 1 0) or (0 0 0 0 2 0) because one firing of v₄ can produce one or two tokens in p₅. Thus, the set of markings consistent with the observation of the sequence of events t₁ and t₂ is {(0 0 0 0 1 0),(0 0 0 0 2 0),(0 0 0 1 0 0)}, see third row of the graph. Assume that t₃ is now observed, i.e. v₅ has fired. Notice that the firing of v₅ requires two tokens in p₅, thus, after the observation of t₁ and t₂, (0 0 0 0 2 0) is the only consistent marking at which v₅ can fire. Consequently, the only sequence of markings consistent with the observation of t₁, t₂ and t₃ is (1 0 0 0 0 0), (0 1 0 0 0 0), (0 0 0 0 2 0) and (0 0 0 0 0 1).

Notice that the state equations (7) can be used straightforwardly to compute the set of consistent markings with a given observation. For instance, for the observation of t₁, t₂ and t₃ discussed above, the marking m = (0 0 0 0 0 1) is the only solution of:

$$ \sigma = a_{T} + Y_{\sigma} a_{E};\ A {\Delta}m \leq B a_{E};\ m = m_0 + Z_{m} {\Delta}m;\ \sigma=(2\ 1\ 1);\ a_{T}=(1\ 0\ 0) $$

where σ = (2 1 1) and a_T = (1 0 0) are the number of actions available at the beginning and at the end respectively. That is, each transition was observed once, i.e. σ − a_T = (1 1 1).

3 Intensity nets

3.1 Definition and state equations

This section introduces intensity nets, which can be denoted as PST nets, i.e. tokens in places P produce and consume intensities in transitions T through intensity handlers S. The intensity of a transition t_j is the speed at which actions are produced in t_j. In other words, the number of actions produced at t is given by the integral over time of the intensity of t_j. Intensity nets and event nets operate in a similar fashion. In fact, the changes in the intensities are produced by tokens in the intensity net in the same way that changes in the marking are produced by actions in the event net.

Definition 5 (Intensity net)

An intensity net is a tuple ${{\mathcal {N}}}_{S}=(P,T,S,E_{S},C,D)$ where (P, T, S, E_S) is a tripartite graph determining the net structure and (C, D) are matrices determining the potential intensity changes produced by the marking.

The set of vertices of the net is partitioned into three sets, P is the set of places, T is the set of transitions, and:

• S = {s₁,…,s_l,…} is a set of |S| intensity handlers.

Places and transitions model the same system features as in the event net. The intensity handlers are depicted as dots and model the different ways in which the tokens can generate intensities in the transitions.

The vertices of the net are connected by the edges in E_S. Each pair of vertices can be connected by at most one edge. The set E_S is partitioned into two sets ${E_{S}^{T}}$ and ${E_{S}^{P}}$, where ${E_{S}^{T}}$ is a set of directed edges (or simply arcs) connecting transitions to intensity handlers and vice versa, and ${E_{S}^{P}}$ is a set of undirected edges (or simply edges) connecting places and intensity handlers. Thus, although both event handlers and intensity handlers are represented as dots, they can be easily distinguished by the arcs and edges that connect them to transitions and places. More formally:

• Every $e\in {E_{S}^{T}}$ is either an arc e = (t_j,s_l) from a transition t_j to a handler s_l, or an arc e = (s_l,t_j) from a handler s_l to a transition t_j.

• Every $e\in {E_{S}^{P}}$ is an edge e = {p_i,s_l} connecting a place p_i and a handler s_l.

As in the event net, connections among places and transitions are not allowed. The following notation is used:

• ^ts_l denotes the input transitions of s_l, i.e. $^{t}s_{l}=\{t_{j}|(t_{j},s_{l})\in {E_{S}^{T}}\}$

• ${s_{l}^{t}}$ denotes the output transitions of s_l, i.e. ${s_{l}^{t}}=\{t_{j}|(s_{l},t_{j})\in {E_{S}^{T}}\}$

• ^st_j denotes the input handlers of t_j, i.e. $^{s}t_{j}=\{s_{l}|(s_{l},t_{j})\in {E_{S}^{T}}\}$

• ${t_{j}^{s}}$ denotes the output handlers of t_j, i.e. ${t_{j}^{s}}=\{s_{l}|(t_{j},s_{l})\in {E_{S}^{T}}\}$

• ^ps_l denotes the places connected to s_l, i.e. $^{p}s_{l}=\{p_{i}|\{p_{i},s_{l}\}\in {E_{S}^{P}}\}$

• ${p_{i}^{s}}$ denotes the handlers connected to p_i, i.e. ${p_{i}^{s}}=\{s_{l}|\{p_{i},s_{l}\}\in {E_{S}^{P}}\}$

As in the event net, the places in the intensity net contain tokens. These tokens can be used by the intensity handlers to produce intensities. A token is active if it is being used by an intensity handler, otherwise it is idle. While idle tokens are associated with places, active tokens are associated with edges. An intensity handler determines how much intensity is produced in its arcs as a function of the number of active tokens in its edges.

The state of the net is given by the variables associated with the net elements. Formally:

Definition 6 (State)

The state of an intensity net ${{\mathcal {N}}}_{S}$ is given by the tuple (m, μ_P,μ_E,Δλ, λ), where:

• $m\in \mathbb {R}^{|P|}_{\geq 0}$ is the marking, i.e. a vector indexed by P where m[p_i] is the number of tokens in p_i,

• $\mu _{P}\in \mathbb {R}^{|P|}_{\geq 0}$ is a vector indexed by P where μ_P[p_i] is the number of idle tokens in p_i,

• $\mu _{E}\in \mathbb {R}^{|{E_{S}^{P}}|}_{\geq 0}$ is a vector indexed by ${E_{S}^{P}}$ where μ_E[{p_i,s_l}] is the number of active tokens of p_i being used by s_l,

• ${\Delta }\lambda \in \mathbb {R}^{|{E_{S}^{T}}|}_{\geq 0}$ is a vector indexed by ${E_{S}^{T}}$ where Δλ[(t_j,s_l)] is a decrease of intensity in t_j produced by s_l, and Δλ[(s_l,t_j)] is an increase of intensity in t_j produced by s_l,

• $\lambda \in \mathbb {R}^{|T|}_{\geq 0}$ is a vector indexed by T where λ[t_j] is the intensity in t_j.

The number of tokens in a place p_i is equal to the number of its idle tokens plus the number of its active tokens:

$$ m[p_{i}]=\mu_{P}[p_{i}]+\sum\limits_{s_{l} \in {p_{i}^{s}}} \mu_{E}[\{p_{i},s_{l}\}]\ \ \forall\ p_{i}\in P $$

(11)

An intensity handler is said to be working when it is producing intensities. When an intensity handler s_l ∈ S starts working, the number of idle tokens in ^ps_l decreases, the number of active tokens in its edges increases (such tokens start being used by the handler), and intensities are produced in its arcs. Conversely, when an intensity handler s_l stops working, the number of idle tokens in ^ps_l increases (i.e. they are released by the handler), the number of active tokens becomes 0, and no intensities are produced in its arcs. Thus (in contrast to the firing of event handlers whose firing cannot be reversed once it has occurred) intensity handlers are allowed to start and stop working (or to increase and decrease their working rates), thus allocating tokens as active tokens and releasing them as idle tokens over time.

The relation between the number of active tokens and the intensities produced are given by a set of inequalities associated with each intensity handler s_l ∈ S. The coefficients of these inequalities can be captured by two matrices (C_l,D_l) of real numbers and same number of rows. The columns of C_l are indexed by the arcs connecting s_l to transitions. The columns of D_l are indexed by the edges connecting places to s_l. Matrix C(D) is obtained by arranging all the matrices C_l(D_l) diagonally.

Each transition t_j is assigned a default (or nominal) intensity λ₀[t_j]. Thus, the intensity λ[t_j] in a transition t_j is equal to λ₀[t_j] plus the positive changes in intensity minus the negative changes in intensity:

$$ \lambda[t_{j}]=\lambda_{0}[t_{j}] {-} \sum\limits_{s_{l}\in {t_{j}^{s}}} {\Delta}\lambda[(t_{j},s_{l})] {+}\sum\limits_{s_{l}\in ^{s}t_{j}} {\Delta}\lambda[(s_{l},t_{j})]\ \ \forall\ t_{j}\in T $$

(12)

The number of active tokens, $\mu _{w}\in \mathbb {R}_{\geq 0}^{|^{p}s_{l}|}$ indexed by the edges of s_l, being used by an intensity handler s_l, and the intensities, ${\Delta }\lambda _{w}\in \mathbb {R}_{\geq 0}^{|^{t}s_{l}|+|{s_{l}^{t}}|}$ indexed by the arcs of s_l, produced by s_l are related by the matrices C_l and D_l as follows:

$$ C_{l} {\Delta}\lambda_{w} \leq D_{l} \mu_{w} $$

(13)

If 1μ_w + 1Δλ_w > 0, then s_l is said to be working. Similarly to event handlers, intensity handlers are not forced to work. When a number of intensity handlers work simultaneously, they share the tokens in places and collaborate in the production of intensities. In a similar way to (4), the inequalities (13) allow the modeling of uncertainty in the intensity changes produced by the active tokens.

Similarly to (7), the state equations of the intensity net determine the potential states of the net for a given marking m and default intensities λ₀:

Proposition 2 (State equations)

Let the state of an intensity net ${{\mathcal {N}}}_{S}$ be (m, m,0,0,λ₀), i.e. m idle tokens are available and no intensity handler is working. Every state (m, μ_P,μ_E,Δλ, λ) reachable from (m, m,0,0,λ₀) belongs to $SE_{{{\mathcal {N}}}_{S}}(m,\lambda _{0})$ where:

$$ \begin{array}{ll} SE_{{{\mathcal{N}}}_{S}}(m,\lambda_{0}) = \{(&m,\mu_{P},\mu_{E},{\Delta}\lambda,\lambda)| \\ & m = \mu_{P} + Y_{m} \mu_{E}\\ & C {\Delta}\lambda \leq D \mu_{E}\\ & \lambda = \lambda_{0} + Z_{\lambda} {\Delta}\lambda\} \end{array} $$

(14)

where Y_m and Z_λ are matrices determined by the net structure:

• Y_m is a matrix with rows indexed by P, columns indexed by ${E_{S}^{P}}$, and such that $Y_{m}[p_{i},\{p_{i},s_{l}\}]=1\ \forall \{p_{i},s_{l}\}\in {E_{S}^{P}}$ and the rest of the elements in Y_m are 0,

• Z_λ is a matrix with rows indexed by T, columns indexed by ${E_{S}^{T}}$, and such that $Z_{\lambda }[t_{j},(t_{j},s_{l})]=-1\ \forall (t_{j},s_{l}) \in {E_{S}^{T}}$, $Z_{\lambda }[t_{j},(s_{l},t_{j})]=1\ \forall (s_{l},t_{j}) \in {E_{S}^{T}}$ and the rest of the elements in Z_λ are 0,

and μ_P, μ_E, Δλ and λ are nonnegative variables.

Similarly to (7), the equations m=μ_P + Y_mμ_E, CΔλ≤Dμ_E, λ=λ₀ + Z_λΔλ in (14) are the matrix forms of (11), (13) and (12) respectively, and thus, must hold at every state (m, μ_P,μ_E,Δλ, λ) reachable from (m, m,0,0,λ₀). As in (7), equations (14) account for the cumulative intensities produced by the handlers, and hence, $SE_{{{\mathcal {N}}}_{S}}(m,\lambda _{0})$ can contain spurious solutions.

As in (8), inequalities can be considered to model linear relationships among the values of the default intensities, λ₀. Let us assume that λ₀ is a vector constrained as:

$$ J_{\lambda}\lambda_{0}\leq K_{\lambda} $$

(15)

where J_λ and K_λ are real matrices of appropriate size. Similarly to (8), the inequalities (15) can be used to model the uncertain default intensity of a transition, or to establish linear constraints among default intensities of transitions. Equations (14) can be easily modified to take into account the relationships expressed by (15):

$$ \begin{array}{ll} SE_{{{\mathcal{N}}}_{S}}(m,J_{\lambda},K_{\lambda}) = \{(&m,\mu_{P},\mu_{E},{\Delta}\lambda,\lambda)| \\ & m = \mu_{P} + Y_{m} \mu_{E}\\ & C {\Delta}\lambda \leq D \mu_{E}\\ & \lambda = \lambda_{0} + Z_{\lambda} {\Delta}\lambda\\ & J_{\lambda}\lambda_{0}\leq K_{\lambda}\} \end{array} $$

(16)

Although intensity handlers are not forced to work, it is useful in some cases to consider only those states in which all the tokens of given places are active. Let $P_{F}\subseteq P$ be the set of places whose tokens must be active, i.e. the number of idle tokens of p_i ∈ P_F must be 0. In order to constrain (16) to such a set of states, the following equation can be added:

$$ \mu_{P}[p_{i}] = 0\ \ \forall\ p_{i}\in P_{F} $$

(17)

3.2 Modeling capabilities

Figure 4 shows some of the modeling capabilities of intensity nets. The default intensity, λ₀[t], of a transition, t, can be written next to the transition, see Fig. 4b (default intensities equal to 0 are omitted in the figures). As in the event nets, labels are associated with arcs and edges to represent amounts of produced/consumed intensities and number of active tokens.

Fig. 4

Modeling capabilities of intensity nets

The intensity net in Fig. 4a has one place p₁, one transition t₁ and one intensity handler s₁. The inequality associated with s₁ establishes that the intensity Δλ[(s₁,t₁)] produced in the arc (s₁,t₁) by s₁ must satisfy 2μ_E[{p₁,s₁}]≤Δλ[(s₁,t₁)]≤ 3μ_E[{p₁,s₁}] where μ_E[{p₁,s₁}] is the number of active tokens in {p₁,s₁} (notice that given that m[p₁]= 2, the number of active tokens is upper bounded by 2). The actual value of Δλ[(s₁,t₁)] is selected nondeterministically in this interval. Since the default intensity of t₁ is 0 and (s₁,t₁) is the only arc connected to t₁, it holds λ[t₁]=Δλ[(s₁,t₁)] what establishes the rate at which actions will be produced in t₁.

The intensity handler s₁ in Fig. 4b makes use of the active tokens in p₁ to decrease the intensity in t₁ and increase the intensity in t₂. This can be seen as an intensity transfer from one transition to the other. According to the equations associated with s₁, which can be rewritten as μ_E[{p₁,s₁}] = Δλ[(t₁,s₁)] = Δλ[(s₁,t₂)], the amount of this transfer is equal to the number of active tokens, μ_E[{p₁,s₁}], which in this case is at most 2 given that m[p₁] = 2. Thus, if there is one active token, i.e. μ_E[{p₁,s₁}] = 1, according to the state equations (14) the resulting intensities will be λ[t₁] = λ₀[t₁] −Δλ[(t₁,s₁)] = λ₀[t₁] − μ_E[{p₁,s₁}] = 5 − 1 = 4 and λ[t₂] = λ₀[t₂] + Δλ[(s₁,t₂)] = λ₀[t₂] + μ_E[{p₁,s₁}] = 0 + 1 = 1.

The net in Fig. 4c shows how the intensity of one transition, t₁, can be used to produce intensity in other transitions, t₂ and t₃. For this net, the state equations (14) become λ[t₁] = λ₀[t₁]−Δλ[(t₁,s₁)]−Δλ[(t₁,s₂)], λ[t₂] = λ₀[t₂]+Δλ[(s₁,t₂)], λ[t₃] = λ₀[t₃]+Δλ[(s₂,t₃)], Δλ[(t₁,s₁)] = Δλ[(s₁,t₂)], Δλ[(t₁,s₂)] = Δλ[(s₂,t₃)]. Given that λ₀[t₁] = 6 and λ₀[t₂] = λ₀[t₃] = 0, these state equations reduce to λ[t₁]+λ[t₂]+λ[t₃] = 6 what summarizes the potential intensities of the net.

The net in Fig. 4d models a choice in place p₁, i.e. each token in p₁ can be used either to produce an intensity within the interval [1,2] in t₁, or synchronize with a token in p₂ to produce an intensity within the interval [3,5] in t₂.

4 Flexible nets

This section introduces Flexible Nets (FNs), which can be denoted as PHT nets, i.e. places P and transitions T are connected by event and intensity handlers. Roughly, an FN consists of an event net and an intensity net that have the same set of places and the same set of transitions.

Definition 7 (Flexible net)

A Flexible Net (FN) is a tuple $\mathcal {N}$ = (P, T, V, E_V,A, B, S, E_S,C, D) where (P, T, V, E_V,A, B) is an event net and (P, T, S, E_S,C, D) is an intensity net.

In an FN, the event net determines the way actions produce marking changes, and the intensity net determines the way tokens produce intensity changes. The inequalities associated with handlers allow the modeler to cover a range of relationships between “actions and tokens” and “tokens and intensities”. Thus, handlers can be seen as a flexible layer between places and transitions that offers the possibility to model uncertainties in both the way actions produce marking changes, and the way tokens produce intensity changes.

The FN in Fig. 5 is composed of the event net in Fig. 2a and the intensity net in Fig. 4a. While the event net determines the marking changes produced by the firing of event handlers, the intensity net establishes the rate at which actions are created in t₁. Notice that the firing of v₂ implies the execution of actions in t₁, i.e. actions need to be produced in t₁ so that v₂ can fire. On the other hand, v₁ is not connected to any transitions and, thus, it can fire when there is a positive marking in p₁. It should be noted that this is not equivalent to an immediate transition in Petri nets, since the firing of t₂ is not forced to happen as soon as the marking of p₁ is positive, its firing can occur at any time at which the marking of p₁ is positive.

Fig. 5

FN resulting of combining the event net in Fig. 2a and the intensity net in Fig. 4a

In order to compute the number of actions produced in transitions, the number of actions produced in the intensity arcs will be computed first. Let Δσ(τ) denote the number of actions produced in the intensity arcs until time τ (Δσ[e](τ) with $e\in {E_{S}^{T}}$ denotes the number of actions produced in e). The value of Δσ(τ) is defined as the integral of Δλ over time:

$$ {\Delta}\sigma(\tau)={\int}_{0}^{\tau} \! {\Delta}\lambda(s) \mathrm{d}s $$

(18)

The overall number of actions, σ[t_j](τ), produced in a transition t_j can be computed by integrating λ[t_j], or equivalently, by making use of Z_λ, see (14), and Δσ(τ):

$$ \sigma(\tau) = \lambda_{0}\tau + Z_{\lambda} {\Delta}\sigma(\tau)\\ $$

(19)

In addition to the state variables of the event and intensity net, Δσ is included in the tuple of variables defining the state of the FN.

Definition 8 (State)

The state x of an FN is given by the tuple x = (m, μ_P,μ_E,Δλ, λ, Δσ, σ, a_T,a_E,Δm).

All the state variables are time dependent. For the sake of clarity, the time dependency will be omitted when it is clear from the context, e.g. m(τ) is shortened to m. At time 0 it holds Δσ = 0, σ = 0, a_T = 0, a_E = 0, Δm = 0, i.e. the initial state can be written as: (m, μ_P,μ_E,Δλ, λ,0,0,0,0,0).

By making use of $SE_{{{\mathcal {N}}}_{V}}(\sigma ,J_{m},K_{m})$ in (9), $SE_{{{\mathcal {N}}}_{S}}(m,J_{\lambda },K_{\lambda })$ in (16), (18) and (19), it is possible to write a set of equations that any potential state at time τ must satisfy.

Proposition 3 (State equations)

Let ${{\mathcal {N}}}$ be an FN with initial marking m₀ satisfying J_mm₀ ≤ K_m, and default intensities λ₀ satisfying J_λλ₀ ≤ K_λ. Every state (m, μ_P, μ_E,Δλ, λ,Δσ, σ, a_T,a_E,Δm) reachable at time τ belongs to $SE_{{{\mathcal {N}}}}(\tau ,J_{m},K_{m},J_{\lambda },K_{\lambda })$ where:

$$ \begin{array}{ll} SE_{{{\mathcal{N}}}}&(\tau,J_{m},K_{m},J_{\lambda},K_{\lambda}) = \{(m,\mu_{P},\mu_{E},{\Delta}\lambda,\lambda,{\Delta}\sigma,\sigma,a_{T},a_{E},{\Delta}m)| \\ & m = \mu_{P} + Y_{m} \mu_{E};\ C {\Delta}\lambda \leq D \mu_{E};\ \lambda = \lambda_{0} + Z_{\lambda} {\Delta}\lambda; J_{\lambda}\lambda_{0}\leq K_{\lambda}\\ & {\Delta}\sigma=\displaystyle{\int}_{0}^{\tau} \! {\Delta}\lambda(s) \mathrm{d}s;\ \sigma = \lambda_{0}\tau + Z_{\lambda} {\Delta}\sigma\\ & \sigma = a_{T} + Y_{\sigma} a_{E};\ A {\Delta}m \leq B a_{E};\ m = m_0 + Z_{m} {\Delta}m;\ J_{m}m_0\leq K_{m} \} \end{array} $$

(20)

where every variable is nonnegative.

This way, an FN is a continuous time model where time, denoted as τ, is the independent variable and all the state variables are nonnegative reals.

Equations (20) can be interpreted as follows: at a given time τ, some of the produced actions (σ) are available (a_T), and the rest (a_E) were executed before τ. The executed actions produced marking changes (Δm) which resulted in the marking m in places at τ. Some of the tokens in m are active (μ_E) and the rest are idle (μ_P). Active tokens produce intensity changes (Δλ) which result in overall intensities (λ) in transitions at τ. The integral of the intensity changes and overall intensities over time after τ will produce more actions (σ), i.e. σ is produced as time elapses. This behavior repeats over time: when a new marking is reached, intensities are updated, which can lead to the production and execution of new actions, which consequently results in a new marking.

As in the event and intensity nets, constraints (10) and (17) can be added to (20) to force the execution of actions and the activity of places.

5 Exploiting uncertainty

The state equations (20) account for all the potential states of the net at time τ. In order to facilitate the analysis of FNs, a set of necessary reachability conditions was developed (Júlvez et al. 2018). These conditions consist of linear and quadratic inequalities that all the solutions of (20) must satisfy during the interval [0,τ]. In order to obtain a time trajectory of the state, i.e. values of the state at different time instants τ₁, τ₂, τ₃, …, two methods are considered:

• 1. The first method consists of developing a unique set of necessary reachability conditions that combines the reachability conditions of each interval [0,τ₁], [τ₁,τ₂],[τ₂,τ₃],…, in such a way that all the states that satisfy the constraints at the end of a given interval are taken as potential initial states for the next interval (see Júlvez et al. 2018 for details). Once this set of constraints is obtained, a particular trajectory of the FN can be computed by adding an objective function to such a set of constraints, and by solving the resulting programming problem.

• 2. The second method follows a model predictive control (MPC) (Kouvaritakis and Cannon 2016) approach. According to this approach, the programming problem described in the first method is solved over the intervals [0,τ₁],[τ₁,τ₂],…,[τ_n− 1,τ_n] where τ_n is the prediction horizon. Then, the state obtained at τ₁ is taken as the initial state and a programming problem over the intervals [τ₁,τ₂],[τ₂,τ₃],…,[τ_n,τ_n+ 1] is defined and solved. This procedure can be repeated with the subsequent intervals.

It should be noted that solving convex quadratic programming problems is required by both methods above. Given that the computational complexity required to solve such problems is polynomial, the proposed computational methods can be applied to large FNs. The following subsections present some of the modeling, analysis and control capabilities of FNs by modeling a linear system with uncertain parameters, a resource allocation system and a system with control actions.

5.1 Linear system with uncertain parameters

The FN in Fig. 6 models a linear system with uncertain dynamics. More precisely, if we assume that all the tokens are forced to be active and all the actions to be executed, the rate at which the marking changes can be expressed as:

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{1}] & =& -q - hm[p_{1}] + m[p_{2}] + 2 \end{array} $$

(21)

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{2}] & =& q - m[p_{2}] \end{array} $$

(22)

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{3}] & =& hm[p_{1}] - 2 \end{array} $$

(23)

where q and h are uncertain parameters but known to be in the intervals: q ∈ [1.0,1.5], h ∈ [0.9,1.1]. Thus, any potential time trajectory of the system will satisfy (21) with values of q and h within the given intervals. The uncertain parameter q is modeled by the default intensity of t₁, and h is modeled by the inequalities of s₃. Notice that the FN in Fig. 6 combines transitions with constant speed, e.g. t₄, transitions whose speed is proportional to the marking of a place, e.g. t₂, and uncertain parameters.

Fig. 6

FN with uncertain dynamics modeled by the default intensity of t₁ and the inequalities of s₃

Let the initial marking be m₀[p₁]= 4, m₀[p₂]= 0, and m₀[p₃]= 0. Figure 7 shows the time trajectories of the marking and the intensities of t₁ and t₃ under different objective functions (notice that the intensity of t₂ is equal to m[p₂], and the intensity of t₄ is constant and equal to 2). The trajectories have been obtained by an MPC approach with a sample time (or interval) of 0.1 time units and a prediction horizon of one sample time. This means that initially, i.e. at time 0.0, the programming problem (Júlvez et al. 2018) is defined and solved over the time interval [0.0, 0.1]. The solution of the problem is taken as the state of the system at time 0.1. Then, the programming problem is defined and solved over the interval [0.1, 0.2], and the procedure is repeated.

The trajectory in Fig. 7a is obtained by the objective function “minm[p₃]”, i.e. the goal is to minimize the marking of p₃ at the end of each interval. In the plots, $\bar {\lambda }[t_{j}]$ denotes the average intensity of t_j during each interval. For such an objective, the solution of the programming problem sets the uncertain parameters to λ₀[t₁]= 1.5 and 0.9a=r (which results in λ[t₃]= 0.9m[p₁]). This setting minimizes the flow directed from p₁ to the branch composed of v₃ and v₄. As expected, the intensity of t₁ and t₂ (t₃ and t₄) is the same at steady state.

Fig. 7

Time evolution of the FN in Fig. 6 when m[p₃] is minimized (a) and maximized (b)

The trajectory in Fig. 7b is obtained by the objective function “maxm[p₃]”. For such an objective, the solution of the programming problem sets λ₀[t₁]= 1.0 and r= 1.1a (which results in λ[t₃] = 1.1m[p₁]). This setting maximizes the flow directed from p₁ to the branch composed of v₃ and v₄.

5.2 Resource allocation

The FNs in Fig. 8 models a dynamic system in which shared resources can be allocated to different production lines. Such a net shows how the tokens of a given place can activate different processes (those places have several intensity edges) and can cooperate with active tokens of other places. Namely, there are two types of resources, p_a and p_b, and three production lines, t₁, t₂ and t₃. The production line associated with t₁(t₂) uses the raw material modeled by the tokens in p₁(p₃) and produces items modeled by the tokens in p₂(p₄). The production line associated with t₃ produces tokens in p₅ and it is assumed that it requires no raw material (or equivalently, this raw material is inexhaustible). In order to operate, the production line associated with t₁(t₃) requires the allocation of resources of type p_a(p_b). The speed of these production lines, t₁ and t₃, is proportional to the number of tokens allocated to them. The operation of production line t₂ requires the cooperation of both resources, p_a and p_b, i.e. tokens of both resources must synchronize in equal amounts to make t₂ work. The speed of t₂ is equal to the number of tokens of p_a (or p_b) allocated to this production line.

Fig. 8

FN modeling a resource allocation system with three production lines and two shared resources

While the event handlers, v₁, v₂ and v₃ determine the relationship between the input and output material of the production lines, the intensity handlers specify the speed of these lines according to the number of active tokens assigned to each line. In particular, the intensity edges {p_a,s₁} and {p_a,s₂} model the fact that the active tokens of p_a can be used either by s₁ or s₂. In a similar way, the fact that the active tokens of p_b can be used either by s₂ or s₃ is modeled by the intensity edges {p_b,s₂} and {p_b,s₃}. This way, s₂ is the intensity handler responsible for the synchronization of resources for t₂. The actions of all transitions are forced to be executed in order to model the active tokens to make the production lines work. Note that the graphical representation of the system by an FN is reasonably clear and compact. If the system were modeled by a classical Petri net, each transition would have to be split into several transitions that would each model the acquisition and release of the resources and the speed of the production lines. This would lead to a more complex graphical notation and, potentially, to more involved analysis methods.

Let the initial marking of the net be m₀[p₁]= 3, m₀[p₂]= 0, m₀[p₃]= 2, m₀[p₄]= 0, m₀[p₅]= 0, m₀[p_a]= 2 and m₀[p_b]= 1, i.e. there are two copies of resource type p_a and one copy of resource type p_b. Assume that the goal is to compute how the resources must be allocated over time so that the objective function $\bar {m}[p_{2}]{+}0.5\bar {m}[p_{4}]{+}0.25\bar {m}[p_{5}]$, where $\bar {m}[p_{i}]$ denotes the average marking of p_i, is maximized. In words, this objective function implies that the goal is to maximize the production of all items giving priority to the products of type p₂, then p₄ and finally p₅.

This resource allocation problem can be solved by a single programming problem (see first method in Section 5) that makes use of the reachability constraints in Júlvez et al. (2018) and the mentioned objective function. More precisely, in order to obtain time trajectories, 90 intervals, each of 0.05 time units, will be considered.

The time trajectories of the marking and the allocated resources are shown in Fig. 9a and b respectively. Four time periods with different resource allocations (or operation modes) can be distinguished in these figures. The first period, from time 0 to 1.25, allocates the two tokens of p_a to s₁. This gives a high yield in the production of the items in p₂ which has the highest priority. Given that the two tokens of p_a are used by s₁ during this first period, the token in p_b cannot be used by s₂, and hence it is used by s₃ to produce the items in p₅, which has the lowest priority. During the second time period, from time 1.25 to 1.75, one token of p_a is used by s₁, and the other token of p_a is synchronized by s₂ with the token of p_b to operate t₂ and produce the items in p₄, which has medium priority. As a result, the speed of t₁(t₂)(t₃) is 1(1)(0) during the second time period. At time 1.75, the marking of p₁ becomes 0, and hence, the active token of p_a allocated to s₁ is released and becomes idle. Thus, during the third period, from time 1.75 to 3.25, only t₂ is working. At time 3.25, the marking of p₃ becomes 0, and hence the two tokens of p_a become idle. During the fourth period, from time 3.25 onward, only the token of p_b is active, and is employed by s₃ to operate t₃.

Fig. 9

Time trajectories of the marking (a) of the net in Fig. 8, and of the number of resources allocated to the transitions (b)

5.3 Control actions

Control actions can be modeled in FNs by means of default intensities. This section demonstrates the ability of FNs to model and solve a control problem in which the control action is dynamically constrained.

Figure 10a depicts a net with three places and four transitions. All the tokens are forced to be active, and all the actions are forced to be executed. The initial marking is m₀[p₁]=m₀[p₂]= 0 and m₀[p₃]= 9. The default intensities of t₁, t₂ and t₃ are 0. The default intensity of t₄, λ₀[t₄], models the only control action that can be applied to the system, and is constrained to the interval [0,1.5]. Given that the equations associated with s₄ are s₄:y=x;z= 2x, each intensity unit in t₄ increases the intensity in t₁, λ[t₁], by one unit and decreases the intensity in t₂, λ[t₂], by two units. This way, the same control action is used for the intensities of t₁ and t₂. Thus, the intensities in transitions satisfy λ[t₁]=m[p₁] + λ₀[t₄], λ[t₂]=m[p₂] − 2λ₀[t₄], λ[t₃]=m[p₃]. Notice that the input action λ₀[t₄] is not only statically constrained by λ₀[t₄]≤ 1.5, but also dynamically constrained by λ₀[t₄]≤ 0.5m[p₂] (if this constraint is violated then λ[t₂] becomes negative).

Fig. 10

a FN with control action modeled by λ₀[t₄]. b Time evolution of the marking. c Time evolution of the average intensities during each interval, $\bar {\lambda }[t_{1}]$, $\bar {\lambda }[t_{2}]$, $\bar {\lambda }[t_{3}]$, and control action λ₀[t₄]

The evolution of the system can be described by the following differential equations:

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{1}] & =& \lambda[t_{3}]-\lambda[t_{1}] = m[p_{3}] - m[p_{1}] - \lambda_{0}[t_{4}] \end{array} $$

(24)

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{2}] & =& \lambda[t_{1}]-\lambda[t_{2}] = m[p_{1}] - m[p_{2}] + 3\lambda_{0}[t_{4}] \end{array} $$

(25)

$$ \begin{array}{@{}rcl@{}} \dot{m}[p_{3}] & =& \lambda[t_{2}]-\lambda[t_{3}] = m[p_{2}] - 2\lambda_{0}[t_{4}] - m[p_{3}] \end{array} $$

(26)

where all the variables are nonnegative and λ₀[t₄]≤ 1.5.

Consider the objective function min (m[p₁] − 1)² + (m[p₂] − 4)². Notice that in this system the invariant m[p₁] + m[p₂] + m[p₃] = 9 holds, then, the control objective is to drive the system to a marking that is as close as possible to the target marking (1,4,4). Figure 10b and c show the trajectories obtained by MPC with a sample time of 0.1 time units and a prediction horizon of one step. Initially, the value of λ₀[t₄] is low as it is constrained by m[p₂], which initially is 0. Then, λ₀[t₄] increases so that m[p₂] increases and m[p₁] decreases. At time 1.0, λ₀[t₄] hits the constraint 1.5 where it is kept constant for 0.4 time units. Then, λ₀[t₄] decreases in order to approach further the target marking. At steady state, the average intensities of t₁, t₂ and t₃ are the same and equal to 2.73, and the value of the control action is λ₀[t₄] = 0.81. The steady state marking reached is (1.93,4.35,2.73). It is important to note that the target marking (1,4,4) cannot be an achievable steady state marking with the proposed single control action.

All the trajectories in this paper have been obtained by the tool fnyzer (https://bitbucket.org/Julvez/fnyzer.git). This tool makes use of the modeling language Pyomo (Hart et al. 2017; Hart et al. 2011) and solvers, such as Gurobi (Gurobi Optimization 2015) and CPLEX (IBM ILOG CPLEX Optimizer 2010), to solve the programming problems associated with the FNs. The CPU time (Intel i7, 2.00 GHz, 8 GiB, Ubuntu 14.04 LTS) to solve one step of the MPC approach for the FNs in Figs. 6 and 10 was 1.81s and 5.93s respectively. The CPU time to solve the only programming problem associated with Fig. 8 was 1.27s.

6 Conclusions

FNs consist of two nets, an event net and an intensity net, that make an explicit distinction between the parts of the system involved in updating the marking in places, i.e. the event net, and the parts of the system involved in the determination of the speeds of transitions, i.e. the intensity net. Both the event and the intensity net are tripartite graphs in which places and transitions are connected by event and intensity handlers, respectively. This way, handlers act as an intermediate layer between places and transitions, which results in a significant modeling power. For instance, a transition in an event net can consume tokens from different sets of places, and a place in an intensity net can regulate the speed of different transitions. The tripartite net structure of event and intensity nets has demonstrated to be useful to model partial observability and resource allocation.

Different types of system uncertainties can be accommodated by FNs through sets of linear inequalities associated with places, transitions, event handlers and intensity handlers. Namely, these inequalities allow the modeling of uncertainty in: a) the initial marking (8); b) the default intensities (15); c) the marking change produced by the execution of actions (4); and d) the intensity change produced by the active tokens (13). FNs account for the potential system trajectories arising as a result of uncertainties by means of a set of constraints that represent necessary reachability conditions. The combination of these constraints with an objective function can be used to obtain a system trajectory that optimizes a given criterion. This approach was successfully used to compute trajectory bounds, for instance, in the presented linear system with uncertain parameters, or to obtain a control law in a system whose control action is modeled by a transition with uncertain default intensity.