Description of membrane systems with time Petri nets: promoters/inhibitors, membrane dissolution, and priorities

We continue the investigations of the connection between membrane systems and time Petri nets by extending the examined class of systems from simple symbol-object membrane systems to more complex cases: rules with promoters/inhibitors, membrane dissolution, and priority relation on the rules. By constructing the simulating time Petri net, we retain one of the main characteristics of the Petri net model; namely, the firings of the transitions can take place in any order, and there is no need to introduce maximal parallelism in the Petri net semantics. Instead, we substantially exploit the gain in computational strength obtained by the introduction of the timing feature for Petri nets.


Introduction
Several models have emerged in the past decades to model distributed systems with interactive, parallel components. One of them was developed by Petri [16], and since then, the Petri nets have become the underlying system of a vast field of research with a considerable practical interest, see [3,15,19] for more information. The theory of membrane systems was established by Păun [12], and it has proved to be a very convenient and many-sided model of distributed systems with concurrent processes, see [13,14]. Here, we continue the investigations concerning the relationship of these two computational models.
Place/transition Petri nets are bipartite graphs, the conditions of the events of a distributed system are represented by places, and directed arcs connect the places to the transitions which model the events. The conditions for the events are expressed by tokens: an event can take place, i.e., a transition can fire, if there are enough tokens in the places at the source ends of the incoming arcs of a transition. These places are called preconditions. The outgoing edges of a transition represent the post-condition of the events. Firing of a transition means removing tokens from the preconditions and adding them to the post-conditions. The number of tokens moved in this way is prescribed by the multiplicities of the incoming and outgoing arcs.
Membrane systems are models of distributed, synchronized computational systems ordered in a tree-like structure. The building blocks are compartments which contain multisets of objects. The multisets evolve in each compartment in a parallel manner, and the compartments, in each computational step, wait for the others to finish their computation; hence, the system acts in a synchronized manner. In every computational step, the multisets in the compartments evolve in a maximal parallel manner. This means that as many evolution rules of the compartment are applied simultaneously in each step as possible. For more on the ways of synchronizing P systems, see the handbook [14] and the recent papers [2,4].
By looking at the basic functioning of membrane systems and place/transition nets, we might notice some similar features. Petri net transitions consume tokens from their input places and produce new tokens at their output places, so in some sense they behave similarly to membrane systems which consume, produce, and move objects around in the 1 3 regions of their membrane structure. And not only do they behave similarly, but the functioning of place/transition nets can naturally be described by transformations of the multisets corresponding to possible token distributions on the places of the net. See [5,9,10] for more on these and similar ideas. As we will describe later in more detail, each kind of object in a compartment of a membrane system can be represented by a different place, and each evolution rule by a different transition having its input and output places. The building of such a structural link between the two models motivates the study of membrane systems from the point of view of the concurrent nature of their behavior, and as a consequence, the techniques and tools developed for Petri nets might become applicable in the area of membrane computing.
Besides this basic connection described above, Petri net variants were also introduced with the aim of capturing some of the advance features of more sophisticated membrane system models. For example, in order to describe the maximal parallel application of rules in membrane systems, the usual semantics of place/transition nets can be extended. So-called maximally concurrent steps in Petri nets were already considered in [6] (independently of any motivation from membrane computing) to describe the concurrent evolution of non-sequential systems. In order to capture the compartmental structure and the locally maximal parallel behavior of membrane systems, localities and a locally maximal concurrent semantics were introduced and investigated for Petri nets in [9]. Furthermore, Petri nets with localities were also used to describe membrane creation and membrane dissolution in [8] and extended in [7] to model the use of promoters and inhibitors. For more details on the specific membrane system models and their computational power, see the handbook [14,20,21] for more recent developments. On the connections of these models to variants of Petri nets with localities, the reader is also referred to [14].
In the present paper, we follow a different approach by considering the possibilities provided by a model called time Petri net developed by Merlin [11] in order to deal with the difficulty that ordinary place/transition nets are not able to model systems where a certain order of events must be taken into account, see also [17,18]. In this model, time intervals are associated with transitions. The local time observed from a transition can be modified by the Petri net state transition rules, and a transition can fire only if its observed time lies in the interval assigned to the transition by the definition of the net. In this way, the computational power of Petri nets is increased: the time Petri net model is Turing complete in contrast with the original state/transition Petri net.
Besides the increase of the computational power, the feature of timing also provides a more or less natural framework to describe the computations of membrane systems more conveniently. In the following, we continue the research on the connection between time Petri nets and membrane systems initiated in [1]. One of the main features of our construction is that the usual semantic characteristics of Petri nets is retained when a Petri net equivalent of a membrane system is presented. That is, unlike the construction in [9] (and unlike the constructions in many other Petri net descriptions of membrane systems), we do not stipulate that the Petri nets should perform their computational steps in some variant of a maximal concurrent manner. Instead of a modified membrane system-like semantics, the attached time intervals provide the synchronization in the corresponding Petri nets.
The structure of the paper is the following. After providing the necessary preliminaries and definitions in Sect. 2, we describe in Sect. 3 a variant of the basic construction of the time Petri net simulation of symbol object membrane systems developed in [1]. Then, in Sect. 4, this construction is extended in order to represent some more advanced membrane computational tools. Similarly to [1], there will be no need to introduce any other "special features" (beside the feature of time) to be able to capture the effect of priorities, the use of promoters/inhibitors, or membrane dissolution. Finally, the paper ends with a short section of conclusions. ; the empty multiset is denoted by ∅.

Preliminaries and definitions
The notation ℕ >0 stands for the set of positive integers, while ℚ and ℚ ≥0 denote the set of rational numbers and nonnegative rational numbers and ℝ and ℝ ≥0 the set of real numbers and nonnegative real numbers, respectively.

Membrane systems
Membrane systems are computational models operating on multisets. We define the notion of the basic symbolobject membrane system [14] and shortly introduce the additional features which will be discussed in more detail in Sect. 5. A membrane system (or P system) is a tree-like structure of hierarchically arranged membranes. The outermost membrane is usually called the skin membrane. The membranes are labeled by natural numbers {1, … , n} , and each membrane, except the skin membrane, has its parent membrane. We use for representing the structure of the membrane system itself, which can also be given as a balanced string of left and right brackets indexed by their labels. 1 , then the skin membrane has two submembranes, while region also contains two embedded regions. Abusing the notation, (i) = k can also mean that the parent of the i-th region is region k.
The regions of a P system contain multisets over a finite alphabet O of objects. The contents of the regions evolve through rules associated with the regions. The rules describe how certain multisets can be transformed to other multisets. They are applied in a maximal parallel manner, which constitute the "micro-steps" of the computations. A computational step is the "macro-step" of the process: it ends when each of the regions has finished the parallel applications of their rules. A computational sequence is a sequence of computational steps.
Here, we think of the computational steps in the regions as consisting of two phases: first the rule application phase produces from the objects on the left-hand sides of the rules the labeled objects on the right-hand sides. (The labels of the labeled objects describe the way they should be moved between the regions: stay where they are, move to the parent region, or move into one of the child regions.) Then, we have the communication phase when the labels (also called target indicators) are removed and all the objects are transported to the regions indicated by their labels. The P system gives a result when it halts, i.e., when no more rules can be applied in any of the regions. The result is a natural number or a tuple of natural numbers counting certain objects in the membrane(s) designated as the output membrane(s).
A P s y s t e m o f d e g r e e n ≥ 1 i s = (O, , w 1 , … , w n , R 1 , … , R n ) where O is an alphabet of objects, is a membrane structure of n membranes, w i ∈ M(O) with 1 ≤ i ≤ n are the initial contents of the n regions, R i with 1 ≤ i ≤ n are the sets of evolution rules associated with the regions. They are of the We assume that one or more membranes are designated as output membranes. A configuration is a sequence W = (u 1 , … , u n ) , where u i is the multiset contained by membrane i, 1 ≤ i ≤ n . For a rule r ∶ u → v ∈ R i , we denote by lhs(r) ∈ M(O) and rhs(r) ∈ M(O × tar) the left-hand side and the right-hand side of r, respectively (u and v, for the rule u → v ). By the application of a rule u → v ∈ R i , we mean the process of removing the elements of u from the multiset u i and extending u i with the labeled elements, which are called messages. As a result, during a computational step, a region can contain both elements of O and messages from O × tar . We say that W is a proper configuration if u i ∈ M(O) for each 1 ≤ i ≤ n , while W is an intermediate configuration if there is at least one region containing The communication phase after the rule applications produces proper configurations from intermediate ones: the elements coming from the right-hand sides of the rules are added to the regions specified by the target indicators associated with them. If the right-hand side of a rule contains a pair (a, here) ∈ O × tar , then a is added to the region where the rule is applied. If it contains (a, out) , then a is added to the parent region; if it contains (a, in j ) , then a is added to the contents of region j. In this case, i must be the parent region of j, (j) = i must hold.
Given a (proper) configuration W, we obtain a new (proper) configuration W ′ by executing the two phases of the transformations determined by the parallel application of maximal multisets of rules chosen for each compartment of the membrane system. A rule multiset is maximal, if it is applicable in a region, but if any other rule occurrence is added to it, then the sum of the left-hand sides is not contained in the region; that is, the extended rule multiset is not applicable any more. We call this a computational step and denote it by W ⇒ W ′ . A computation is a sequence of such computational steps, and it halts when a configuration is reached where there are no rules which can be applied. In such a halting configuration, the result of the computation appears as the contents of the output membranes.
We might consider additional features being present in the membrane system. First, we can add promoters and inhibitors to the rules. These are multisets of objects that regulate the rule applications in a way that the promoter z ∈ M(O) assigned to the rule r prescribes that z must be present in the region where the rule is applied, while the inhibitor ¬z with z ∈ M(O) prevents the rule from being applied if z is present in the region.
Second, we can consider membrane dissolution. The set of objects is extended with an additional element that can appear on the right-hand sides of the rules. If appears in a rule r which is applied in the i-th region for some i, 1 ≤ i ≤ n , then the communication phase is executed as above, but after that, as the result of the presence of in region i, the region together with its set of rules R i disappears from the P system. This means that the elements of region i are passed over to the parent region (except , which disappears), and the rules in R i are not applied anymore. Note that the outermost region (the skin region) cannot dissolve.
Finally, we can consider a priority relation on rules, that is, a partial ordering (an antisymmetric and transitive relation) i on the set R i , 1 ≤ i ≤ n . We say that r ′ has priority over r, or r ′ has higher priority than r (denoted as r ′ > r ), if (r � , r) ∈ i . In this case, if both r ′ and r were applicable in a configuration, then r is suppressed, that is, not allowed to be applied.
In Sect. 5, we show that all these features can be modeled by time Petri nets. The advantage of using time Petri nets is that the usual semantics, the usual unsynchronized way of firing of the transitions can be preserved: we do not inflict any additional condition on the transitions (like the requirement that the transitions fired in a computational step should constitute a maximal multiset).

Time Petri nets
In this section, following the definitions in [17] we define time Petri nets, a model rendering time intervals to transitions along the concept of [11]. First of all, we introduce the underlying place/transition Petri nets and then extend this model to the timed version.
A Petri net is a 5-tuple U = (P, T, F, V, m 0 ) such that The elements of P and T are called places and transitions, respectively, the elements of F are the arcs, and F is also called the flow relation of U. The function V is the multiplicity (weight) of the arcs, and m 0 is the initial marking. In general, a marking is a function m ∶ P → ℕ , it can be thought of as representing a state of the net U. We stipulate that for every transition t ∈ T , there is a place p ∈ P such that f = (p, t) ∈ F. Let x ∈ P ∪ T . The pre-and post-sets of x, denoted by • x and x • , respectively, are defined as For each transition t ∈ T , we define two markings, t − , t + ∶ P → ℕ as follows: for p ∈ P , we define the firing of the transitions of a Petri net. A transition t ∈ T can fire in m (notation: m ⟶ t ) if t is enabled in m. After the firing of t, the Petri net obtains the new marking We obtain time Petri nets if we add time assigned to transitions of the Petri net. Intuitively, the time associated with a transition denote the last time when the transition was fired. We are considering only bounded time intervals.
We present the definitions from [17], see also [18] for more information.
A time Petri net is a 6-tuple N = (P, T, F, V, m 0 , I) such that 1. the skeleton of N given by S(N) = (P, T, F, V, m 0 ) is a Petri net, and 2. I ∶ T → ℚ × ℚ is a function assigning a rational interval to each transition, that is, for t ∈ T and We call eft (t) and lft (t) the earliest and the latest firing times belonging to transition t, respectively. Given a time Petri net N = (P, T, F, V, m 0 , I) , a function m ∶ P → ℕ is called a p-marking of N. Note that talking about a p-marking of N is the same as talking about a marking of S(N) The two markings m and h satisfy the following properties.
For all t ∈ T , The initial state is the pair u 0 = (m 0 , h 0 ) , where m 0 is the initial marking and for all t ∈ T, Now we define the result of the firing for a transition that is ready to fire. Let t ∈ T be a transition and u = (m, h) be a state such that u ⟶ t . Then the state u ′ resulting after the firing of t denoted by u ⟶ t u ′ is a new state and for all transitions s ∈ T , we have Hence, the firing of a transition changes not only the p-marking of the Petri net, but also the time values corresponding to the transitions. If a transition s ∈ T which was enabled before the firing of t remains enabled after the firing, then the value h(s) remains the same, even if s is t itself. If an s ∈ T is newly enabled with the firing of transition t, then we set h(s) = 0 . Finally, if s is not enabled after firing of transition t, then h(s) = #.
Observe that we allow transitions to be fired several times in a row: if t is fired resulting in the new p-marking m ′ , and t remains enabled in m ′ , that is, t − (p) ≤ m � (p) holds for all p ∈ • t , then the time associated with t does not change, h � (t) = h(t).
Besides the firing of a transition, there is another possibility for a state to alter, and this is the time delay step. Let u = (m, h) be a state of a time Petri net, and ∈ ℝ ≥0 . Then, the elapsing of time is possible for the state u (denoted u ⟶ ) if for all t ∈ T which are enabled in the current marking, the new time value assigned to t is less than the latest firing time of t. The state u ′ , namely the result of the elapsing of time by denoted by u ⟶ u ′ , is defined as Note that the definitions ensure that we are not able to skip a transition when it is enabled: a transition cannot be disabled by a time delay step. This kind of semantics is called the strong semantics in [18]. Note also that classic Petri nets can be obtained as time Petri nets having h(t) = [0, 0] , as in such systems there are no time delay steps possible at all.

Connecting Petri nets and membrane systems
We start by discussing the time Petri net simulation of the basic variant of membrane systems we constructed in [1] and describe a simplification in the construction that we are going to use here. The model is based on the correspondence between Petri nets and membrane systems described in [9]. Membrane system configurations are represented by places (a, i) for each object a and membrane i, the number of tokens associated with such places correspond to the multiplicity of object a in membrane i. The rules of the membrane system are represented by transitions which move the tokens between the places according to the way that the rule application changes the corresponding object multiplicities in the membrane regions. A membrane system computation can be simulated by such a Petri net: if the membrane system halts, the Petri net reaches a configuration where no transitions can fire, and the marking of the Petri net corresponds to the halting configuration of the membrane system. The new feature of the construction in [1] is the property that it does not change the usual Petri net semantics, and it simulates the maximal parallel rule application of membrane systems without requiring that the Petri net model fires its transitions in a maximal parallel manner. In general, both by membrane systems and by Petri nets, a computational step can be considered as a multiset of rules or as a multiset of transitions, respectively. In the case of Petri nets, an application of a multiset of transitions is maximal parallel, if augmenting the multiset by any other transition results in a multiset of transitions that cannot be fired simultaneously in the configuration represented by the current marking. In the case of membrane systems, maximal parallel execution means that no rule can be added to the multiset of rules such that the resulting multiset still forms a multiset of applicable rules. In our construction, the fireable transitions of the simulating Petri net can be executed in any order, and we do not impose any restrictions on the computational sequence of the Petri nets. This is possible, because we make an essential use of the time feature. (Note that the original place/transition Petri net model is not Turing complete, unlike the majority of the variants of symbol object membrane systems.) In short, in [1] we have shown that given a membrane system (without priorities, membrane dissolution and promoters/inhibitors), there is a time Petri net N, such that N halts if and only if halts, and if they halt, then they provide the same result.
In the following, we will present analogous results also for membrane systems with extended features; that is, we show how time Petri nets can simulate membrane systems using rules with promoters/inhibitors, membrane systems with priorities assigned to the rules, and systems with the possibility of membrane dissolution.
In order to simplify the constructions, we modify the correspondence between membrane system computations and Petri nets, since we do not require that the simulating time Petri nets halt. For each halting configuration of the membrane system, the corresponding Petri net reaches a state where the computation continues in a cycle and the markings of places representing the membrane system configuration do not change any more.
In order to present this idea more formally, we say that a time Petri net N = (P, T, F, V, m 0 , I) simulates the computations of a membrane system by stabilizing in a configuration corresponding to a halting configuration of , if there is a subset of places P R ⊆ P and a subset transitions T R ⊆ T , such that if and only if halts, N enters into a cyclic computation where 1. no transition of T R is enabled, 2. the markings on the places of P R do not change, and 3. the numbers of tokens associated with the places of P R correspond to the halting configuration of .

Remark 1
In the following, we will show how to simulate halting computations of different membrane system variants with Petri net computations stabilizing in configurations corresponding to halting membrane system configurations. However, the simulations also work if we apply our constructions to membrane systems which do not halt. In such cases, the Petri net simulation of the membrane system proceeds by a non-halting Petri net computation passing through an infinite sequence of configurations which corresponds to the infinite sequence of configurations of the membrane system. For more about the influence of different ways of halting on the computational power of P systems, also see the recent paper [4].
In the following, we first present a variant of the main theorem from [1] to introduce the basic ideas of the construction, and then we show how to modify this to be able to represent promoters/inhibitors, membrane dissolution, and the role of priorities on the rules.

Theorem 1 For any membrane system
(without priorities, membrane dissolution and promoters/inhibitors), there is a time Petri net N simulating the computations of by stabilizing in configurations corresponding to the halting configurations in .
Proof Let = (O, , w 1 , … , w n , R 1 , … , R n ) be a membrane system and let N = (P, T, F, V, m 0 , I) be the corresponding Petri net. We define N so that a computational step of is simulated by two subnets of N. The two subnets correspond to the two computational phases of a computational step of a membrane system, namely the rule application and the communication phases. Let us see the construction in detail.
A marking m ∶ P → ℕ corresponds to a configuration (u 1 , … , u n ) ∈ M(O) n of as follows. If m(p) = k for some p = (a, i) ∈ P 0 , then there are k objects a ∈ O in compartment i, that is, u i (a) = k . If m(p) = l for some p = (b, j) ∈P , then there are l copies of object b which will enter into membrane j at the end of the computational step.
The presence of a token at the places p app or p com is enabling the rule application or the communication phases of the Petri net computation, respectively.
The initial marking corresponds to the initial configuration of , m 0 (p) = w i (a) for every p = (a, i) ∈ P 0 , 1 ≤ i ≤ n , and m 0 (p) = 0 for all p ∈P 0 . In addition, m 0 (p app ) = 1 and m 0 (p com ) = 0.
Let also where the transitions are defined as follows.
• For any rule r ∈ R i for some i, 1 ≤ i ≤ n , there is a transition t r ∈ T 0 corresponding to r, and • for any place p ∈P 0 , there is a transition s̄p ∈T 0 . • The transitions t com and t app transform the net from the rule application phase to the communication phase, and from the communication phase back to the rule application phase, respectively.
The input and output arcs and the time intervals associated with these transitions are as follows (see Fig. 1 for the graphical representation and an example).
-For each t r ∈ T 0 , r ∈ R i , 1 ≤ i ≤ n , we have (a, i) ∈ • t r if and only if a ∈ lhs(r) , we have (b, j) ∈ t • r if and only if either (b, in j ) ∈ rhs(r) (where i is the parent region of j) or (b, out) ∈ rhs(r) and region j is the parent region of i, or we have (b, here) ∈ rhs(r) and j = i.
-Regarding the weights of the arcs, the weight of f = (p, t r ) ∈ F for some p = (a, i) ∈ P 0 and r ∈ R 0 is the multiplicity of a ∈ O on the left-hand side of r, In addition, -we have p app ∈ • t ∩ t • for all t ∈ T 0 and p com ∈ • t ∩ t • for all t ∈T 0 , all of these arcs having a weight of one, and -we also have p app ∈ • t com , p com ∈ t • com , p com ∈ • t app , and p app ∈ t • app with all of these arcs also having weight one. To see how the above construction works, consider the following. A computational step of a membrane system is split into a rule application and a communication phase, and those two phases are simulated separately and in an alternating order. The simulation of the rule application phase is enabled by the presence of a token at p app , and it finishes only when no more rule applications are possible, ensuring that the rule application happens in the maximal parallel way. Any transition t r corresponding to a rule r from some rule set of the membrane system can fire only if a token is found in p app , but if no transition t r can fire (that is, no rule r of the membrane system is applicable), then the transition t com is enabled at time 1, so after performing a time delay step, a token is passed to p com . The place p com is connected to each transition s̄p ∈T 0 in both directions with an arc of multiplicity 1, which means that after the tokens have finished wandering back to their respective places (when no s̄p is enabled any more), then there is still a token left in p com . This token moves to p app (after a time delay step) at time 1 via t app , and the net is ready for simulating the next membrane computational step by performing a rule application phase of the simulation again. When the Petri net arrives to a marking which corresponds to a halting configuration of the membrane system, no transitions in T 0 (and hence, no transitions in T 0 ) are enabled, so it can only continue the cyclic computation consisting of passing a token back and forth between p app and p com without being able to change anything else in the distribution of the tokens, so in some sense, the representative of the halting membrane system configuration is "stabilized." ◻

Extending the correspondence to membrane systems with more features
In this section, we examine the possibility of extending our core model to Petri nets that are able to represent various properties of membrane systems, such as the presence of promoters/inhibitors, membrane dissolution and a priority relation on the rules. The obtained Petri nets each build upon the basic model defined in the previous section, so, in most of the cases, we restrict ourselves to emphasize only the new elements of the constructions by which the basic Petri net model is extended. We begin with discussing the case of promoters and inhibitors. We say that = (O, , w 1 , … , w n , R 1 , … , R n , P) is a membrane system with promoters/inhibitors, if P is mapping which maps the rules to M(O) 2 . Then P(r) is a promoter/inhibitor pair associated with r ∈ R i for some i, 1 ≤ i ≤ n , denoted as (prom r , inhib r ).
We say that a multiset R of rule occurrences is applicable in a configuration (u 1 , … , u n ) , if each of the following conditions is fulfilled. For all 1 ≤ i ≤ n , 1. lhs(r)(a) ⋅ R(r) ≤ u i (a) for each r ∈ R i and a ∈ O, 2. prom r (a) ≤ u i (a) for each r ∈ R, r ∈ R i , a ∈ O , and 3. inhib r ⊈ u i , or in other words, there exists an a ∈ O , such that u i (a) < inhib r (a) for all r ∈ R, r ∈ R i . . This is in accordance with the fact that three objects c should be added to region 1, and one copy of d should be added to region 2 in the following communication phase. The subnet on the right simulates the communication phase of the membrane computational step. When the simulation of a maximal parallel rule application is finished, that is, when no transition associated with any rule is enabled any more, a time delay step can be performed, and then a token is passed over to p com at time instance 1. Then, the transitions s (c,1) , s (d,2) ∈T 0 become enabled and ensure the correct placement of the tokens corresponding to the messages. When the updating of the marking is finished, a time delay step can follow, and then the token from p com is passed back to p app enabling the rule application phase once more

Theorem 2 For any membrane system with promoters/ inhibitors, there is a time Petri net N simulating by stabilizing in configurations corresponding to the halting configurations of .
Proof Let = (O, , w 1 , … , w n , R 1 , … , R n , P) be a membrane system with promoters/inhibitors. We construct N by extending the construction in the proof of Theorem 1, that is, the Petri net simulates the rule application and the communication phase separately in a similar manner. Here we concentrate on the differences concerning the rule application phase, the other elements of the construction can be adapted from Theorem 1.
Let N = (P, T, F, V, m 0 , I) be a time Petri net with places where P 0 ∪P 0 ∪ {p app , p com } are as in the proof of Theorem 1, and The initial marking corresponds to the initial configuration of the membrane system as before. In addition, m 0 (p ini ) = m 0 (p ¬inh(r) ) = m 0 (p ¬pro(r)(a) ) = m 0 (p ¬inh(r)(a) ) = 1 for all rules r, objects a ∈ O , while the rest of the places are marked with zero. Let also where T = T 0 ∪T 0 ∪ {t com , t app } are as int the proof of Theorem 1, and P pro ={p pro(r) , p pro(r)(a) , p ¬pro(r)(a) | r is a rule occurrence in , a ∈ O}, P inh ={p inh(r) , p ¬inh(r) , p inh(r)(a) , p ¬inh(r)(a) | r is a rule occurrence in , a ∈ O}.
t 1 col(r) , t 2 col(r) , t 3 col(r) , t col(r)(a) , t 1 col(r)(a) , t 2 col(r)(a) , t 3 col(r)(a) | r is a rule occurrence in , a ∈ O}. Fig. 2 The subnet simulating the rule application phase of a membrane system with promoters and inhibitors. The contents of the first region is a 2 , and r = a → c(d, in 2 ) 3 with prom r (a) = 2 , inhib r (a) = 3 is applied. The rule application phase starts when t ini(r) sends a token to all places where one token is seen. First the inhibitor multiset is checked: if all a ∈ inhib r is present in the necessary number of occurrences (if the rule r should be inhibited), tokens are sent to each p inh(r)(a) , and then to p inh(r) . (The dashed arrows represent a collection of arcs and transitions described in the text: if the places p inh(r)(a) and p pro(r)(a) contain tokens for all a ∈ inhib r or a ∈ prom r , then a token appears at p inh(r) or p pro(r) , respectively.) Thus, if the rule should be inhibited, the token from p ¬inh(r) is removed, and t r will not be able to fire. After the inhibitor, the promoter is checked: if all necessary objects are present, a token is sent to each p pro(r)(a) , and then to p pro(r) , which enables the firing of transition t r corresponding to the execution of rule r. Since we have also made a time delay step before, the result of the promoter and inhibitor checks are kept the same until the repeated application of the allowed rules (simulating the maximal parallel application of the membrane system) is finished, and the communication phase begins. The subnet for the communication phase is not depicted here; it is similar to the subnet in Fig. 1, except for the transition t ini which returns a token to p ini (instead of p app , as in the proof of Theorem 1) The arcs connecting the places and transitions known from the construction of Theorem 1 are as before, with the exception of t app which connects the places p ini and p app , and the new transition t ini connecting p com and p ini (see Fig. 2 for the graphical representation and an example).
The input and output arcs associated with the new transitions, together with the new time intervals, are as follows.
Consider all r ∈ R i for some i, 1 ≤ i ≤ n .
The time intervals associated with the transitions described so far are [0, 0], while the weights of all the arcs above are one. The transitions defined in (a) initialize the rule application phase by putting a token to each of the necessary places after the appearance of a token in p ini activates them. The transitions described in (b)-(c) are represented by the dashed arrows in Fig. 2. They place a token to p pro(r) (or to p inh(r) ) if a token appears in p pro(r)(a) (or in p inh(r)(a) ) for each object a occurring in the promoter (or inhibitor) multisets associated with the rule r.
In addition to the above, -for each t col(r) , we have p ¬inh(r) , p inh(r) ∈ • t col(r) while t •

col(r)
is empty, and the time interval associated with t col(r) is [0, 0].
This transition disables the firing of t r (disables the simulation of rule r) if r should be inhibited (which is signaled by the presence of a token in p inh(r) ).
The set of output places of the above described transitions are empty, they serve as "sinks," they remove unnecessary tokens at the end of the rule application phase.
For the rest of the arcs and their weights, together with the rest of the transitions and their associated time intervals, see Fig. 2.
The time Petri net described above alternates its rule application phase and communication phase to simulate the computational steps of the membrane systems. The alternation of the phases is guided by the cycling of a token from p ini to p app , from there to p com , and then back to p ini . Simultaneously with the arrival of the token to p app , the rule application simulation subnets are also initialize for each rule, and then the checking of the presence of promoters and inhibitors start. The subnets for the rules which are not blocked after these checks can be executed, any of them repeatedly, until the available objects allow. (The results of the promoter and inhibitor checks are saved, so during the sequential simulation of a maximal parallel rule application step, rules can only become disabled when the objects on their left-hand sides are not available any more.) After the rule application phase is finished, the communication phase reorders the created objects to their goal regions as the system in the proof of Theorem 1 and in addition cleans up the garbage tokens left in the places which are used for the promoter/inhibitor checks of the rule application phase.
When the net arrives to a marking which corresponds to a halting configuration of the membrane system, then no rule application is possible, so no transitions can fire which are able to change the marking on the places corresponding to the membrane system configuration. This means that the representant of the halting membrane system configuration is "stabilized" in the sense of Sect. 3. ◻ Next, we turn our attention to membrane systems with dissolution. In such systems there exists a special object which can appear on the right sides of rules only. If such a rule is chosen in the actual maximal parallel rule application, then all the rules participating in that computational step are executed as usual, but after the maximal parallel step is over, the region where this rule was applied disappears, the objects wander into the parent region and the rules associated with it cease to operate.
Note that if a region i, 1 ≤ i ≤ n is dissolved during a computation, then not only the rules associated with i are disabled, but also some rules from other rule sets: those which contain the target indicator in i on their right-hand sides. On the other hand, not all rules which send objects to region i are discarded. Those which are associated with a child region of i and contain the target indicator out continue to operate, but the objects they send "out" are sent to the parent region of i instead.
With this in mind, we construct a time Petri net simulating the operation of a membrane system with dissolution.
Theorem 3 For any membrane system with dissolution, there is a time Petri net N simulating by stabilizing in configurations corresponding to the halting configurations of .

Proof Let
= (O, , w 1 , … , w n , R 1 , … , R n , ) be a membrane system with dissolution. We construct a time Petri net N = (P, T, F, V, m 0 , I) simulating . The construction again is an extension of the construction in the proof of Theorem 1. The rule application phase is very similar, except for the presence of new places corresponding to the appearance of the symbol symbolizing the dissolution of the membranes. The main difference manifests itself in the definition of the communication phase: we introduce a new phase, a "cleanup" phase for moving the elements of previously dissolved membranes to the parent regions. In addition, we also need to deal with blocking the application of certain rules which would send objects to the dissolved regions.
First we define the set of places.
where P 0 ∪P 0 ∪ {p app , p com } are as in the proof of Theorem 1, and The initial marking corresponds to the initial configuration of with p app also containing a token as before, and in addition, m 0 (p r ) ≥ 1 for all rules r ∈ R i for i, 1 ≤ i ≤ n , the exact value depending on the number of ways r could be disabled due to the dissolving of membranes. More precisely, the value of m 0 (p r ) is the number of different target indicators of the form in j on the right-hand side of rule r, or if this number is zero, then m 0 (p r ) = 1 . If p r looses at least one of these tokens during the computation, then transition t r corresponding to rule r will not be able to fire any more. The role of the places ( , i), (̄, i) is similar to the places of P 0 and P 0 : if the execution of some rule introduces in a region i, then a token arrives at ( , i) . Then, in the communication phase this token is moved to (̄, i) where it remains, signaling to the rest of the system the fact that membrane i is dissolved.
The other new place p cle is used to signal the beginning of the cleanup phase, a new phase of the simulation when the contents of dissolved membranes are moved into the parent region. Fig. 3 The Petri net simulating a membrane system with dissolution. In a, b, the subnets corresponding to the application and communication phases of the rule r ∶ ab → c(d, in 3 ) 2 are shown. When a membrane i is dissolved, the subnet in c is also activated before the communication phase. The subnet in d is active in the celanup phase which is between the rule application and the communication phases. It moves the tokens representing the contents of dissolved membranes to places from where they will be moved during the communication phase to places corresponding to the parent region The transitions and the arcs are constructed as follows (see also Fig. 3 for a graphical representation of the most important subnets). Let where T = T 0 ∪T 0 ∪ {t com , t app } has the same role as in the proof of Theorem 1, but some additional arcs are needed (see Fig. 3a).
-Each t r ∈ T 0 where r ∈ R i for some i, 1 ≤ i ≤ n , is also connected to the places p r as p r ∈ • t r ∩ t • r with arcs of weight m 0 (p r ) . This has the effect that if the number of tokens is decreased in p r , then the transition t r simulating the execution of rule r cannot become enabled (making rule r disabled in the subsequent stages of the simulation). Moreover, if the rule r contains the dissolution symbol on its right-hand side, then t r is also connected to the place ( , i) as ( , i) ∈ t • r with an arc of weight one. The time interval associated with t r is [0, 0].
The rest of the transitions are defined as follows. Let In addition to s p ∈T 0 , to execute the communication phase we also need the transitions s p for each p ∈ P 0 (see Figure 3(b)).
-Fo r e a ch i, 1 ≤ i ≤ n a n d a ∈ O , we h ave (̄, i) ∈ • s (a,i) ∩ s (a,i) • and p com , (ā, i) ∈ • s (a,i) , (ā, j) ∈ s (a,i) • where j is the parent membrane of i, with the weight of all these arcs being one, and the associated time interval being [0, 0]. If the communication phase is enabled by p com and a token is present in (̄, i) , that is, if membrane i has been dissolved in some earlier step of the computation, then the tokens are moved from the places corresponding to objects in region i to the places corresponding to the same type of objects in the parent membrane.
If there is no token in (̄, i) (membrane i is not dissolved), then the transitions in T 0 work as in the proof of Theorem 1, but to achieve the priority of s (a,i) over s (a,i) , the later has an associated time interval of [1,1].
The transitions t i , 1 ≤ i ≤ n , are used to disable the rules with the target indicator in i on their right-hand side when membrane i is dissolved (see Fig. 3c). The arcs are defined as follows.
-For each i, 1 ≤ i ≤ n , we have ( , i) ∈ • t i and (̄, i) ∈ t i • . Moreover, for all rules r with at least one object (a, in i ) on their right-hand side for some a ∈ O , we have p r ∈ • t i . The time interval associated with these transitions is [0, 0]. When a token appears in ( , i) , that is, when membrane i is dissolved, the rules with target indicator in i on their right-hand sides are disabled by removing tokens from the corresponding places. If a rule r could be disabled more than once because it contains more than one different types of such target indicators on its right-hand side, then the same number of tokens is assigned to p r by the initial marking, so the functioning of the net is not blocked (it does not run out of tokens) when it tries to disable a rule which is already blocked.
The transitions t p , p ∈ P 0 are used to perform a cleanup phase during which the objects of dissolved membranes are moved to places from where they will be transferred to the parent region during the following communication phase (see Figure 3(d)).
-F o r e a ch i, 1 ≤ i ≤ n a n d a ∈ O , we h ave p cle , (a, i), ( , i) ∈ • t (a,i) and (ā, i) ∈ t • (a,i) with all the arcs having weight one, and the transition having the associated time interval [0, 0]. The cleanup process is invoked once for each dissolved membrane when a token arrives to ( , i) , that is, when membrane i has been dissolved. After the initiation of the cleanup phase by a token at p cle , the objects in places corresponding to membrane i are moved to the intermediate place from where they are transferred to the parent region of region i in the communication phase by the subnet already discussed above, depicted in Fig. 3b.
The functioning of the Petri net N is governed by a token circulating between the places p app , p cle , and p com . Initially, there is a token in p app which is moved to p cle by transition t cle in the time interval [1,1] when the rule application phase is finished, that is, when there are no rule simulating transitions left which can fire. When the token is in t cle , the objects of the regions that have been dissolved in the previous phase are prepared for being moved to the parent region. This is realized in the communication phase which is initiated when t com moves the token further to p com , the associated time interval being also [1,1]. Finally, when all tokens representing the objects are in their correct places, the application phase is activated again by moving the token back to p app by t app at time interval [2,2].
If no more rule application simulating transitions can fire, that is, when the corresponding configuration of the simulated membrane system is a halting configurations, then the only possible computation of the net is the cycling of the token between p app , p cle , and p com , thus, it has stabilized while representing a halting membrane system configuration. ◻ Finally, we tackle the problem of the representation of membrane systems with priorities in terms of Petri nets. Again, our construction is an extension of the core model presented in the proof of Theorem 1. We will modify the simulation of the rule application phase in order to account for the treatment of the new feature, but let us start with examining the role of priorities in membrane systems computations.
The system 1. r is applicable, that is, lhs(r) ≤ u i , and 2. for every r � ∈ R i such that r ′ > r , r ′ is not applicable.
Let r 1 , r 2 ∈ R i be two rules of region i, and assume that (r 1 , r 2 ) ∈ , that is, r 1 > r 2 . Then, considering a computational step, r 2 can be applied if r 2 is applicable and in addition, r 1 is not applicable (in the usual sense ). For example, if u i = a 2 b , r 1 = ab → d and r 2 = a → c , then the result of the maximal parallel step will be ad, instead of cd, since r 1 > r 2 and r 1 is applicable, which implies that r 2 cannot be applied in that maximal parallel step at all.
To simulate this behavior in our construction, we have to pick out the applicable rules and examine the priority relations in order to obtain the rules that are strongly applicable. We do this by stratifying the various tasks that have to be performed in the rule application phase with respect to time. Finding the strongly applicable rules takes place before the actual rule applications are simulated.

Theorem 4 For any membrane system
with priorities, there is a time Petri net N simulating the computations of by stabilizing in configurations corresponding to the halting configurations of .
Proof Let = (O, , w 1 , … , w n , R 1 , … , R n , ) a membrane system with priorities, and let us define the time Petri net N = (P, T, F, V, m 0 , I) as follows. We extend the net constructed in the proof of Theorem 1 by modifying the rule application phase. Before simulating the rule applications, we select those rules that are applicable, then deactivate the simulating subnets of those ones which are not strongly applicable. Then, the communication phase is simulated in the same way as in the proof of Theorem 1.
The set of places is defined as where P 0 ∪P 0 ∪ {p app , p com } are as in the proof of Theorem 1, and The new places keep track of the applicability and strong applicability of rules. A token in p A r for some rule r signals the applicability of r, while an additional token in p B r means that r is blocked by an applicable rule of higher priority, and the places p r 1 >r 2 ∈ P � contain a token if r 1 > r 2 holds according to . (The role of the places of type p r 1 >r 2 will be discussed later.) The initial marking corresponds to the initial configuration of the membrane system, as before, but in addition, instead of p app , the initial marking places a token in the new place p ini which activates the first phase of the applicability check of the rules. Thus, m 0 (p ini ) = m 0 (p r 1 >r 2 ) = 1 for r 1 > r 2 .
The transitions are defined as where T 0 ∪T 0 ∪ {t com , t app } play the same role as in the previous constructions. The transitions in T 0 are responsible for the simulation of the communication phase, they are defined exactly as before. The places t ini , t app , and t com are responsible for initiating the different phases of the Petri net computation by moving a token along p ini , p app , p com , and then back to p ini again. The corresponding arcs are P = P 0 ∪P 0 ∪ {p app , p com } ∪ P � ∪ P � ∪ {p ini }, P � ={p A r , p B r | r is a rule occurrence in }, P � ={p r 1 >r 2 ,p r 1 >r 2 | (r 1 , r 2 ) ∈ }. Fig. 4 Subnet for checking the applicability of a rule r ∶ u → v ∈ R 1 with u = ab 2 . If at least one a and two bs are present in region 1, a token is sent to p A r

Conclusions
In this paper, we have made a step forward in relating the membrane systems and Petri nets. We simulated membrane systems with promoters/inhibitors, membrane dissolution, and priority on the rules with time Petri nets, by further developing the Petri net model presented in [1]. We were able to simulate these sophisticated membrane computing features by preserving an important characteristic property of Petri nets; namely, the firings of the transitions can take place in any order: we do not impose any additional condition on the transition sequences in order to obtain the time Petri net model.
For a possible continuation of this line of research, it would be interesting to investigate the possibility of simulating membrane systems using other ways of synchronization, see [2,4] for examples of such systems.
As another interesting direction for future research, we would also like to mention the descriptional complexity aspects of the presented simulations. It would be fruitful to conduct a comparative study on the sizes of the Petri net components necessary for simulating the different variants of membrane systems.