Modelling modern systems presents a lot of challenges some of which can be eased by the use of appropriate models. A well known technique for system modelling are Petri nets. Petri nets provide a graphical language for constructing system models as well as a precise, mathematical semantics. These models can be used for simulations and to analyse the model's properties. This allows locating possible faults in the system at earlier stages which also can decrease overall development costs. The increasing sizes of modern systems results in models becoming rather large and possibly hard to comprehend. Additional abstraction layers as for example hierarchies present one solution for the increasing size. Hierarchical Petri nets use hierarchy to break down the complexity of a large model, by dividing it into a number of submodels. This helps to concentrate on a specific system part without the need to take the whole system into account. Also submodels can be reused with less effort at multiple locations in the same system or even in a different system where similar components are used.
Advanced systems that need dynamic structural adaptation can be modelled using reconfigurable Petri nets, an approach for dynamic changes in Petri nets. A reconfigurable Petri net consist of a Petri net and set of rules that modify the Petri net's structure at runtime. Hence they increase flexibility enabling the modification of a net while allowing the transitions to fire. The characteristic feature of reconfigurable Petri nets is the possibility to discriminate between different levels of change as they consist of a Petri net and a set of rules that can modify the Petri net. They provide powerful and intuitive formalisms to model dynamic software or hardware systems that are increasingly executed in dynamic infrastructures.
Such infrastructures are dynamic as they are themselves subject to change and support various applications that may or may not share some of the resources. Reconfigurable Petri nets have been used in many different application areas, that require both the representation of their processes and of the system changes within one model. Examples are concurrent systems [LO04], mobile ad-hoc networks [Pa07], workflows in dynamic infrastructures [HEP08], communication spaces [MGH10,GE12], ubiquitous computing [GNH12,Bo06], flexible manufacturing systems [Tâ12], reconfigurable manufacturing systems [KBD16]). In [PK18] a comprehensive overview of reconfigurable Petri nets is given, including theoretical foundations and application areas. The term reconfigurable Petri nets is used since the underlying type of Petri net may vary (for example being place/transition nets, object nets, timed and/or stochastic nets, or high-level nets). Hence, this approach can be considered a family of formal modelling techniques (see [PK18] for details). Reconfigurable Petri nets are an instantiation of abstract transformation systems, called M-adhesive transformations systems, that are formulated in category theory. The fundamental idea is to characterize those categories that allow double-pushout transformations: therefore only the diagrammatic descriptions are needed. This has the advantage of a thorough theory that yields a vast amount of results concerning the transformation part. Nevertheless, in this contribution we omit the categorical foundation.
Hierarchical, reconfigurable Petri nets combine the hierarchical Petri net types and reconfigurable Petri net types into one, allowing a focused design of submodels and their reusability and the ability for dynamic changes at runtime. The main idea is to use the hierarchies purely at the surface, so the semantics is defined in terms of the underlying flattened reconfigurable net.
The hierarchy based on transitions being replaced by subnets is given as a syntactic abbreviation. The hierarchical reconfigurable net is defined purely by it's flattening into a reconfigurable net. This fundamental design decision has the following advantages: First, only the consistency of the flattening construction can be guaranteed using well-known results, but no further semantic correctness needs to be proven. Second, this corresponds directly to the intended implementation of hierarchies in ReConNet [Re17,Pa12] (ReConfigurable Net). Moreover, the transformation systems needs not to be shown for another category of hierarchical nets. And, apart from the flattening construction, which needs to be done once, the analysis and verification of a hierarchical Petri net requires no more effort than it's counter part with no hierarchy, since the whole behaviour is defined in terms of the flattened net.
The software tool ReConNet has been developed so that the modelling and simulation capabilities of reconfigurable nets are supported adequately. The most important feature of the tool is the ability to create, modify and simulate reconfigurable nets in a single tool through an intuitive graphic-based user interface. It allows the design and verification of 168 Jan-Uriel Lorbeer, Julia Padberg Hierarchical, Reconfigurable Petri Nets 3 reconfigurable place/transition nets. In this paper we discuss the basis for the integration of hierarchical reconfigurable Petri nets in ReConNet. This paper is organised as follows: We start by given a very simple introductory example of hierarchical reconfigurable Petri nets in Sect. 2. In Sect. 3 related work, namely approaches to hierarchical Petri nets and hierarchical graph transformations are discussed. The subsequent section introduces reconfigurable place/transition nets with labels. Sect. 5 elaborates the formal definition of hierarchical reconfigurable Petri nets and their flattening, the definition of transformation rules and proves the correctness of the flattening construction. The integration of reconfigurable hierarchical Petri nets into the simulation tool for reconfigurable Petri nets ReConNetis discussed in Sect. 6. The conclusion in Sect. 7 completes this paper.
Reconfigurable Petri nets extend classical Petri nets to include the possibility of dynamic changes. This is achieved through the use of a rewriting system and allows the modification of the net's structure at run time. Such a system provides two kinds of changes:
• a change of state accomplished through the firing of the net's transitions
• a change of the process itself induced by the rules.
A reconfigurable Petri net N can either fire an activated transition or execute a transformation step N r = ⇒ M. An example for this process is displayed in Fig. 1. In Fig. 1a a reconfigurable Petri net N is shown and in Fig. 1b it's rule r with r's nets L, K and R is given. N consists of two places, two tokens and one transition which is black when activated. When rule r is executed the net's arcs are inverted. In it's initial state (1) the rule r is not executable because there is no match to the rule's left-hand net L. The net L specifies that at least two tokens are required at the place P at the figure's bottom where the edges lead to. So only the transition T can fire. Firing transition T twice state (3) is reached. In this state two tokens are located on the bottom place P and r can be executed inverting the arc directions resulting in state (4). If in state (3) there would have been an additional token on the upper place P either the transition T could have fired or r could have been executed. In state (4) r is no longer executable because the edges now lead to the upper place P, so only the transition T can fire. State (4) is very similar to state (1) and after T firing twice r would be executable once again.
Hierarchical, Reconfigurable Petri Nets 169 To give an intuition of hierarchical reconfigurable Petri nets we subsequently give an example that comprises the ideas presented in the following sections. Imagine some simple but adaptive process that can alternatively execute three different tasks task1, task2, and
task3. An abstract view of this process is given in Fig. 2. The tasks task2 and task3 are more complex and are given by subnets, where task2 is a sequence of steps and task3 includes some forking. The hierarchy concept in Sect. 5 allows the substitution of the transitions with the subnets. The substitution of the transition task2 replaces the transition and its adjacent places, that is Net(task2), by the subnet SN1 and Net(task3) is replaced by SN2, both in Fig. 4. Applying these substitutions to the abstract nets in Fig. 2 yields the flatted net in Fig. 3. Now we add rules for the subnets for the adaptation of the tasks: task1 is so simple, it requires no adaptation. In task2 the sequence of steps can be changed (rules SN1:r1 and SN1:r2) or an intermediate steps is introduced or removed ( rules SN1:r3 and SN1:r4). So we have the four rules that belong to subnet SN1 and are given in light grey in Fig. 5. In task3 the intermediate step can be adapted by rule SN2:r5 so that parallel step may require something from the intermediate result. And this adaptation can be reversed by rule SN2:r6.
Both rules belong to subnet SN2 and are given in dark grey in Fig. 5. These six rules are local rules, that should be only applied in the corresponding subnet. The transitions have the name space A T = {initialise, task1, task2, task3, fork, join, step, step1, step2, intermediate step, parallel step} that ensures the locality of the rules by the labels. Additionally, we want a global rule that adds to all steps a counting place. This rule is given below in Fig. 6. This rule can be applied at each transition with a lesser label. The name space A T for the transition is ordered in the following way:
g T ≥ l for all l ∈ A T and step ≥ l for all l ∈ {step1, step2, intermediate step, parallel step} which are the other local steps.
The main related research areas for hierarchical reconfigurable Petri nets are obviously hierarchical Petri nets and hierarchical graph transformations.
From 1991 on, hierarchies in Petri nets [HJS91] have been used in numerous papers and contributions and are still prominent, e.g. [HW18,Ak17]. In [HW18] the HiPS tool provides a common operating method, graphical user interface, the ability to describe hierarchical Petri nets and an on-the-fly linear temporal logic model checker. [Ak17] defines a hierarchy of places, and with various arcs as inhibitor arcs, reset arcs and transfer arcs that respect this hierarchy. A total ordering over the places encodes the hierarchy depending on the arc types various extensions are given. The decidability for almost all these extensions has been shown using different reductions and proof techniques. Besides hierarchical Petri nets based on transition substitution as e.g. in [JR91] nets based on place substitution and Object-Oriented Petri nets [La01, MK05] have been considered. CPN [CP17] also supports fusion places by defining sets of places that are functionally identical. The net-in-nets approach [Va98,Va04] as well as object nets [KH10, KH11] yield hierarchical composition as well.
There are a number of tools similar to ReConNet. CPN tools [Ra03,CP17] is the main tool for the modelling and simulation of coloured Petri nets. Using a graphic user interface CPN tools features syntax checking, code generation and state space analysis. Snoopy [He12] is a unifying Petri net framework with a graphical user interface. It allows the modelling and simulation of coloured and uncoloured Petri nets of different classes, supports analytic tools and the hierarchical structuring of models. The HiPS tool [Hi17] developed at the Department of Computer Science and Engineering, Shinshu University is a tool written in C# and also employs a graphical user interface. HiPS is a platform for design and simulation of hierarchical Petri nets. It also provides functions of static and dynamic net analysis. While all of these tools support the design of hierarchical Petri nets it is evident that they lack reconfiguration, ReConNet's core feature.
Hierarchical graphs (and graph transformations) add some hierarchy to the nodes or to the edges. Various approaches to graphs with hierarchy have been proposed, e.g. [BH01, DHP02, BKK05, Br14]. The resulting techniques were used for modelling hierarchical hypermedia, distributed project management, mobile and ubiquitous systems among others.
Hypergraphs in [DHP02] consist of two finite sets of nodes and hyperedges. The hierarchy is given in layers, in the sense that subsets in the same layer have the same nesting depth. In [BKK05] hierarchical graph is a system of graphs of various types that are grouped into packages. Hierarchical graphs in [Pa04] are obtained from hypergraphs by adding a parent assigning function to them. Nodes and edges can be assigned as a child of any other node or edge. But in contrast to our approach only the graph is structured, whereas the rules only are given at the topmost level.
In this section we give the basic notions. Note that in ReConNet the underlying type of nets are decorated place/transition nets. To concentrate on the essential notions, in this paper we use place/transition nets, but the corresponding technical report [Pa18] deals explicitly with decorated place/transition nets. Moreover, in [Pa18] the underlying categorical requirements are proven for place/transition nets, decorated place/transition nets, as well as for algebraic high-level nets.
We use the algebraic approach to Petri nets, where the pre-and post-domain functions pre, post : T → P ⊕ map the transitions T to a multiset of places P ⊕ given by the set of all linear sums over the set P. A marking is given by m ∈ P ⊕ with m = p ∈P k p • p. The ≤ operator can be extended to linear sums: For m 1 , m 2 ∈ P ⊕ with m 1 = p ∈P k p • p and m 2 = p ∈P l p • p we have m 1 ≤ m 2 if and only if k p ≤ l p for all p ∈ P. The operations "+ " and "-" can be extended accordingly.
Here, we introduce reconfigurable place/transition nets with labels and subtyping of labels for the rules. These labels need a name space that is given by a partial order (A, ≤, g A ) with a greatest element, a ≤ g A for all a ∈ A. g A is similar to the common supertype in a type hierarchy. The labelling function is provided with an order for subtyping, this allows more abstract rules that can be applied for occurrences with lesser labels, for an example see Sect.2.
Definition 4.1 (Labelled place/transition nets) A (marked labelled place/transition) net is given by N = (P, T, pre, post, pl, tl, M) over the name space A = (A P , A T ) with partial orders (A P , ≤ A , g p ) and (A T , ≤ T , g T ). P is a set of places and T is a set of transitions. pre : T → P ⊕ maps a transition to its pre-domain and post : T → P ⊕ maps it to its post-domain. Moreover, pl : P → (A P , ≤ A , g p ) is a label function mapping places to a name space, tl : T → (A T , ≤ T , g T ) is a label function mapping transitions to a name space and M ∈ P ⊕ is the marking denoted by a multiset of places.
A transition t ∈ T is M-enabled for a marking M ∈ P ⊕ if we have pre(t) ≤ M. The successor marking m is computed by M = M − pre(t) + post(t) and represents the result of a firing step M[t > M .
Note, we do not require P ∩ T = ∅ since this is not necessary. This condition would require constructing the transformation step explicitly to ensure that the target net M in Fig. 7 satisfies this construction as well.
A reconfigurable Petri net RN = (N, R) consists of a Petri net N and a set of rules R. This allows reconfigurable Petri nets to modify themselves. Rules and occurrences are defined by net morphisms. Net morphisms are given as a pair of mappings for the places and the transitions preserving the structure, the labels and the marking. Given two nets N 1 and N 2 as in Def. 4.1 a net morphism f : N 1 → N 2 is given by f = ( f P :
for all p ∈ P 1 . The labels are mapped so that tl 2 • f T (t) ≤ tl 1 (t) for all t ∈ T 1 and pl 2 • f p (p) ≤ pl 1 (p) for all p ∈ P 1 .
Moreover, the morphism f is called strict if both f P and f T are injective, if = == ⇒ M is constructed in two steps by the commutative squares via a gluing construction, that is a pushout. Fig. 7 illustrates the transformation of a net using two pushouts (PO1) and (PO2). An intuitive explanation for a pushout is to take two nets N 1 , N 2 that overlap in some I. Now we glue N 1 and N 2 together over this common interface I, obtaining a new net N 1 + I N 2 that is the union of both nets factorized by an equivalence relation induced by the inclusion of I into N 1 and N 2 . Given a rule with an occurrence o : L → N the gluing condition has to be satisfied in order to apply a rule at a given occurrence. Its satisfaction requires that the deletion of a place implies the deletion of the adjacent transitions, and that the deleted place's marking does not contain more tokens than the corresponding place in L. After finding an occurrence of a left-hand side L in a net, the effect of applying a rule is to remove all obsolete elements and add all fresh elements. The elements of K are preserved, providing us with well-defined attachment points for R.
This transformation concepts is based on M-adhesive transformation systems [Eh06] and is given in terms of category theory, so that is allows the application of the concepts and results
174 Jan-Uriel Lorbeer, Julia Padberg Hierarchical, Reconfigurable Petri Nets 9
to high-level structures such as graphs, typed attributed graph, hyper-graphs, various types of Petri nets, algebraic signatures and specifications. This is possible because place/transition nets can be proven to be an M-adhesive transformation category [Eh06,Pa15] and nets with labels and subtyping in [Pa18]. Hence these results hold for the corresponding type of Petri net:
A hierarchical reconfigurable Petri net uses substitution transitions to implement the hierarchy. A substitution transition is a special kind of transition that itself does not fire, instead it contains a subnet that defines the behaviour that takes place in its stead. Following this basic definition of substitution transitions, different implementations suited for specific purposes are possible, this work focuses on the variant of the substitution transition based hierarchical Petri net that have been presented in [JK09].
Each substitution transition has its own subnet with its own local rules. All places that share an edge with a substitution transition are called the transition's connecting places. For each connecting place of the substitution transition there exists a corresponding connecting place in the transition's subnet with the same marking. Via these places tokens enter and leave the subnet. Any transition that may fire belongs either to the main net or to some subnet, but it cannot be a substitution transition. Any net may contain multiple substitution transitions, each instantiating exactly its own subnet. Although multiple substitution transitions may instantiate the same subnet layout, each substitution transition has it's own permanent instance. This leads to a behaviour of the main nets that relies solely on the firing of the subnets, i.e the firing of the flattened net.
Hierarchical, Reconfigurable Petri Nets 175 Figure 8 shows in the top half a hierarchical net with it's main net M N and a subnet SN.
In the main net the substitution transition st1 has two connecting places: p0 has an edge connecting it to st1 and st1 has an edge connecting it to the place p1. These places can also be found in the subnet as connecting places with edges to and from different transitions. If tokens are added to the place p0 via the transition t1 these also appear in the subnet. There SNs transition sub_t1 can fire and remove tokens from p0 resulting in the removal of the same tokens from p0 in M N.
Subnets may contain substitution transitions containing further subnets resulting in a nested hierarchy. Reconfigurable Petri nets use transformation rules to reconfigure themselves. The chosen hierarchical model allows two different rule concepts: global rules and local rules. A global rule is a general rule that may be applied in any net on any level of the whole hierarchical net. So occurrences can be in the main net, its subnets, all their subnets and so forth. A local rule that is applied to a (sub-)net allows occurrences to be found in that specific net only. Local rules enable the dynamic modification of a specific part of a hierarchical net. The advantage is that rules can be created without knowledge of other parts of the hierarchical net. Local rules are given for one subnet only, whereas global rules belong to the hierarchical net. They can be applied in all subnets since their labels are greater than the labels in the subnet. For details see Subsection 2.2 in [Pa18]. The name space is given by the disjoint union of all local name spaces, so that local rules can be applied only with in the given subnet. Local rules respect the hierarchical net borders so that no transformation may effect more than one (sub-)net. Hence, one restriction is imposed on the rules: Substitution transitions may not be part of a rule. As a consequence connecting places may not be deleted or added by a rule, but they can be part of one. This is due to the gluing condition which requires that places may only be deleted if the adjacent transition is deleted as well and no tokens are left over. Since connection places are neighbours of substitution transitions that cannot occur in a rule, they remain unchanged.
Subsequently, we define substitution os transition by subnets formally. Figure 11 shows an example for a very basic substitution rule. Substitution transition are mapped to such rules given by the mapping subst : sT → SR N where SR N is a set of substitution rules.
The definition of the reconfigurable hierarchical Petri net requires the substitution transition together with its adjacent places, called net Net(t) of a transition t.
Given N = (P, T, pre, post, pl, tl) then for a transition t ∈ T the net of t is the net
With this, reconfigurable hierarchical Petri nets can be formally defined. A reconfigurable hierarchical Petri net consists of a reconfigurable net with substitutions and a set of global rules. They both are defined over a common name spaceA = (A P , A T )The reconfigurable net with substitutions consist of a place/transition net N, a set of local rules R N and a set of substitution rules SR N together with the mapping of substitution transitions to substitution rules subst : sT → SR N .
Petri net HN = (RN, A, GR) is given by its name space A = (A P , A T ), a set of global rules GR over A = (A P , A T ), and a reconfigurable net with substitutions RN = (N, R N , SR N ):
1. N = (P, T, pre, post, pl, tl, M) is a place/transition net over (A N P , A N T ) so that, • P is a set of places.
T is a set of transitions.
• T contains substitution transitions sT ⊆ T.
• pre : T → P ⊕ is a function used for the pre-domain of each transition.
• post : T → P ⊕ is a function used for the post-domains of each transition.
T is a naming function for transitions, where substitution transitions have their own name space A sT ⊆ A N T so that tl(sT) ⊆ A sT and injective tl |sT . Moreover, regular transitions are not allowed to use that name space. tl(T\sT) ⊆ A N T \A sT . • pl : P − → A N P is a naming function for places, where the set of connecting places cP = {•t ∪ t• | t ∈ sT } ⊆ Pis given by the neighbourhood of the substitution transitions and the name space of the connecting places A cP ⊆ A N P satisfies pl(cP) ⊆ A N P . Moreover, regular places are not allowed to use that name space. tl(P\cP) ⊆ A N P \A c P .
M is a set of tokens withM ∈ P ⊕ .
SR N is a set of substitution rules together with a mapping of substitution transitions to substitution rules subst : sT → SR N so that subst
Chapter 5 in [JK09] states that the flattening of a hierarchical net that uses substitution transitions must remove each substitution transition and insert its subnet into the supernet by fusing the connecting places. This process corresponds to applying the substitution rules from Def. 5.2. Only one substitution for each substitution transition is applicable to RN. Due to the global and local rules, flattening construction is more complex than for a normal hierarchical Petri net. Flattening of a normal hierarchical Petri net looses all information of the hierarchical borders, but this information is needed for the correct application of local and global rules in the flattened net. Hence, we use the disjoint union of the subnet's name spaces.
First we investigate the parallel independence [Eh06] of the substitution rules. If any two s 1 , s 2 ∈ S with s 1 s 2 are pairwise parallel independent the Parallelism Theorem states that they are also sequentially independent [Eh06]. All substitution rules sr together with their occurrences are independent from each other if any two sr 1 , sr 2 with sr 1 sr 2 are pairwise independent. So the proof of parallel independence of two arbitrary substitutions s 1 , s 2 ∈ S is sufficient to prove Lemma 5.4.
Lemma 5.4 (Pairwise Independence of Substitutions) Given a reconfigurable net with substitutions RN = (N, R N , SR N ). Any two substitutions s 1 , s 2 ∈ S N with s 1 s 2 are pair-wise independent.
We show for two arbitrary substitutions s 1 s 2 the set theoretic representation of parallel independence o 1 (ST 1 ) ∩ o 2 (ST 2 ) ⊆ o 1 (l 1 (CP 1 )) ∩ o 2 (l 2 (CP 2 )) holds.
) )
The left-hand side of any rule r s of (r s, o) ∈ S N contains by Def. 5.2 only a net Net(t).
As specified in Def. 5.1 Net(t) contains only a substitution transition t and t's pre-and post-domains. The interface CP(t) contains only t's pre-and post-domains. Considering two substitutions s 1 , s 2 ∈ S N with s 1 s 2 , the intersection between their occurrences only considering transitions must be empty because otherwise t 1 = t 2 and thus s1 = s2. Since CP(t 1 ) only contains places and since Net(t 1 ) contains one distinct transition t 1 and Net(t 2 ) the another one t 2 , it follows:
) by definition of CP. Since l 1 , l 2 , o 1P and o 2P are functions we conclude that p ∈ (l 1 (CP(t 1 ))) ∩ (l 2 (CP(t 2 ))) and p ∈ o 1P (l 1 (CP(t 1 ))) ∩ o 2P (l 2 (CP(t 2 ))). Thus: o 1P (Net(t 1 )) ∩ o 2P (Net(t 2 )) ⊆ o 1P (l 1 (CP(t 1 ))) ∩ o 2P (l 2 (CP(t 2 ))) which proves any two s 1 , s 2 ∈ S with s 1 s 2 are pairwise parallel independent.
where the name space A is the union of the name spaces, so that the global labels are greater than the corresponding local labels (see [Pa18]).
During the simulation ReConNet's simulation engine uses the flat representation of a hierarchical reconfigurable Petri net for transition firing and rule application, because this allows using ReConNet's simulation engine to handle the hierarchical net, i.e its flattened net. However, for the user this remains transparent and the visual interface continues presenting the hierarchical view. While transitions are fired and transformations are made on the flat net the hierarchical view visualizes the changes accordingly. While developing the nets and transformation rules, the hierarchy is established and the simulation requires the flattened net that is the result of the flattening construction.
The application of local rules in the flat net needs one single name space for places and transitions A = (A N P , A N T ). This name space needs to include all of the disjoint name spaces of the (sub-)nets. This single name space is created during the flattening. Whenever a subnet is inserted into its supernet all places and transitions that are not connecting places get a prefix to their names that is unique to the substitution transition that was replaced. This way the naming preserves hierarchy borders and (sub-)net identities and so the names of places and transitions are specific enough that a rule meant for only a specific (sub-)net can be limited to the correct part of the flat net. For persistence of a hierarchical reconfigurable Petri net from ReConNet the hierarchical reconfigurable Petri net's flat net and the substitution rules. The hierarchical reconfigurable Petri net is saved as a tuple of the main net, as a reconfigurable Petri net, its substitution rules and the flat net, so that HN = RN, SR, Flat(RN, SR) . So, the flat net can be loaded directly and needs not to be computed each time again. [KKR08] the as-long-as-possible operator ! forces the rule set R to be applied as long as possible. Since ReConNet is provided with transformation units [Ho16] the flattening construction can be realized using this as-longas-possible operator !. In the transformation unit RN S N ! = == ⇒ F an applicable substitution rule s with an injective occurrence is randomly picked and applied. This step is repeated until all s ∈ S N have been applied, since each s has by construction only one occurrence. = = ⇒ F both substitutions s i and s j have to be applied. All s ∈ S are pairwise sequential independent, so any sequence can be applied in arbitrary order yielding the same well-defined resulting net [Eh06]. Hence, we obtain diagram (2). Any two s ∈ S are pairwise parallel independent, so are s i and s j , thus their sequence is interchangeable s i is always applicable to M j and s j is always applicable to M i both always leading to the same net M i j . So F F for HN
For any s ∈ S to be able to be applied more than once it would have to be independent from itself. s 1 = s 2 implies they contain the same substitution transition t 1 = t 2 , it follows: (o 1T (net(t 1 )) ∩ o 2T (net(t 2 )) ∅) ∅ = o 1T (l 1 (CP 1 )) ∩ o 2T (l 2 (CP 2 )). Thus s 1 and s 2 are not independent. Hence any s is not independent from itself and thus can only be applied once.
This paper introduces substitution transitions for hierarchical reconfigurable Petri nets. The main contribution is a formal definition of hierarchical reconfigurable Petri nets and its flattening construction.
Hierarchical, Reconfigurable Petri Nets 183 18 Lorbeer,Padberg This work presents a first step to the integration of reconfigurable hierarchical Petri nets into the ReConNet tool [Pa12,Re17]. Ongoing work will accomplish support of hierarchical Petri nets in ReConNet. First a hierarchy needs to be introduced into ReConNet to allow transformation simulation, including an appropriate update to ReConNet's persistence module to allow proper storing and restoring of hierarchical nets. Then individual rules will be added to allow the functionality of a reconfigurable net. For net verification and validation purposes the flat representation of the hierarchical reconfigurable Petri net will be used.