Characterizing PSPACE with shallow nonconfluent P systems
Abstract
In P systems with active membranes, the question of understanding the power of nonconfluence within a polynomial time bound is still an open problem. It is known that, for shallow P systems, that is, with only one level of nesting, nonconfluence allows them to solve conjecturally harder problems than confluent P systems, thus reaching \(\mathbf{PSPACE }\). Here we show that \(\mathbf{PSPACE }\) is not only a bound, but actually an exact characterization. Therefore, the power endowed by nonconfluence to shallow P systems is equal to the power gained by confluent P systems when nonelementary membrane division and polynomial depth are allowed, thus suggesting a connection between the roles of nonconfluence and nesting depth.
Keywords
P systems Active membranes Nonconfluent PSPACE1 Introduction
While families of confluent recognizer P systems with active membranes with charges are known to characterize the complexity class \(\mathbf{PSPACE }\) when working in polynomial time [7, 16, 17], their computational power when the nesting level is constrained to one (i.e., only one level of membranes inside the outermost membrane, usually called shallow P systems) is reduced to the class \(\mathbf{P }^{\#\mathbf{P }}\), which is conjecturally smaller [1]. Since that complexity class often appears when studying the computational power of shallow systems, even with different rules or semantics [4, 8, 10], it is interesting when “flat” systems are able to go outside that class and reach \(\mathbf{PSPACE }\). While confluent P systems can make use of nondeterminism, they are constrained in returning the same result for all computations starting from the same initial configuration. However, by accepting when at least one computation accepts, like nondeterministic Turing Machines (TM) traditionally do, P systems can make use of the entire power of nondeterminism: uniform families of nonconfluent recognizer P systems with active membranes with charges can efficiently solve \(\mathbf{PSPACE }\)complete problems even in the shallow case and even when sendin rules are disallowed (i.e., for monodirectional systems) [5]. Here we show that, in fact, \(\mathbf{PSPACE }\) is a characterization of this kind of shallow nonconfluent P systems when they work in polynomial time. This result shows that the complex relation between computational power, nesting depth, and monodirectionality present for confluent P systems is absent in the nonconfluent case. In particular, in the confluent case, systems with no nesting characterize \(\mathbf{P }\) [18] whereas, additional nesting gives additional power [2] until reaching \(\mathbf{PSPACE }\) when unlimited nesting is allowed [16, 17]. In the monodirectional case even unlimited nesting cannot escape \(\mathbf{P }^\mathbf{NP }\), which is conjecturally smaller [3]. Nonconfluent systems, on the other hand, characterize \(\mathbf{NP }\) when there are no internal membranes [15] and immediately gain the full power of \(\mathbf{PSPACE }\) with only one level of nesting. Furthermore, at least for shallow systems, this provides an exact characterization. It is, therefore, natural to ask what is the relation between the mechanisms that empower confluent P systems and the full power of nonconfluence. Are the former ones only a way to simulate the latter?
2 Basic notions
For an introduction to membrane computing and the related notions of formal language theory, we refer the reader to The Oxford Handbook of Membrane Computing [12], for the topics related to time complexity we refer to [14], for space (instead of time) complexity, we refer to [9], finally, to show how the rules recalled here can be employed to simulate more complex rules and behaviors, we refer to [6]. Here we recall the formal definition of P systems with active membranes using only elementary division rules.
Definition 1

\(\varGamma \) is an alphabet, i.e., a finite nonempty set of symbols, usually called objects;

\(\varLambda \) is a finite set of labels for the membranes;

\(\mu \) is a membrane structure (i.e., a rooted unordered tree, usually represented by nested brackets) consisting of d membranes labelled by elements of \(\varLambda \) in a onetoone way;

\(w_{h_1}, \ldots , w_{h_d}\), with \(h_1, \ldots , h_d \in \varLambda \), are multisets (finite sets whose elements have a multiplicity) of objects in \(\varGamma \), describing the initial contents of the d regions of \(\mu \);

R is a finite set of rules.
Each membrane possesses, besides its label and position in \(\mu \), another attribute, called electrical charge, which can be either neutral (0), positive (\(+\)) or negative (−) and is always neutral at the beginning of the computation.
 (a)
Object evolution rules, of the form \([\alpha \rightarrow w]_{h}^{\alpha }\).
They can be applied inside a membrane labelled by h, having charge \(\alpha \) and containing an occurrence of the object a; the object a is rewritten into the multiset w (i.e., a is removed from the multiset in h and replaced by the objects in w).
 (b)
Sendin communication rules, of the form \(a \, [\;]_h^\alpha \rightarrow [b]_h^\beta \).
They can be applied to a membrane labelled by h, having charge \(\alpha \) and such that the external region contains an occurrence of the object a; the object a is sent into such membrane labelled by h becoming b and, simultaneously, the charge of h is changed to \(\beta \).
 (c)
Sendout communication rules, of the form \([a]_{h}^{\alpha } \rightarrow [\;]_h^{\beta }b\).
They can be applied to a membrane labelled by h, having charge \(\alpha \) and containing an occurrence of the object a; the object a is sent out from h to the outside region becoming b and, simultaneously, the charge of h becomes \(\beta \).
 (e)
Elementary division rules, of the form \([a]_{h}^{\alpha } \rightarrow [b]_{h}^{\beta }\, [c]_{h}^{\gamma }\)
They can be applied to a membrane labelled by h, having charge \(\alpha \), containing an occurrence of the object a but having no other membrane inside (an elementary membrane); the membrane is divided into two membranes having label h and charges \(\beta \) and \(\gamma \), respectively; the object a is replaced, respectively, by b and c, while the other objects of the multiset are replicated in both membranes.
A P system is shallow if it contains at most one level of membranes inside the outermost membrane. This means that all the membranes contained in the outermost membrane are elementary, i.e., they contain no other nested membrane.

Each object and membrane can be subject to at most one rule per step, except for object evolution rules: inside each membrane, several evolution rules can be applied simultaneously.

The application of rules is maximally parallel: each object appearing on the lefthand side of evolution, communication, or division rules must be subject to, at most, one of them (unless the current charge of the membrane prohibits it). Analogously, each membrane can only be subject to one communication or division rule (types (b)–(e)) per computation step; these rules will be called blocking rules in the rest of the paper. In other words, the only objects and membranes that do not evolve are those associated with no rule, or only to rules that are not applicable due to the electrical charges.

When several conflicting rules can be applied at the same time, a nondeterministic choice is performed; this implies that, in general, multiple possible configurations can be reached after a computation step.

In each computation step, all the chosen rules are applied simultaneously (in an atomic way). However, in order to clarify the operational semantics, each computation step is conventionally described as a sequence of microsteps whereby each membrane evolves only after their internal configuration (including, recursively, the configurations of the membrane substructures it contains) has been updated. In particular, before a membrane division occurs, all chosen object evolution rules must be applied inside it; this way, the objects that are duplicated during the division are already the final ones.

The outermost membrane cannot be divided, and any object sent out from it cannot reenter the system again. Hence, the environment only has a passive role and acts mainly as a place where the result of the computation can be collected.
P systems can be used as language recognisers by employing two distinguished objects \({\textsf {yes}}\) and \({\textsf {no}}\): in this case we assume that all computations are halting, and that either one copy of object \({\textsf {yes}}\) or one of object \({\textsf {no}}\) is sent out from the outermost membrane, and only in the last computation step, in order to signal acceptance or rejection, respectively. If all computations starting from the same initial configuration are accepting, or all are rejecting, the P system is said to be confluent. In this paper we deal, however, with nonconfluent P systems, where multiple computations can have different results and the overall result is established as for nondeterministic TM: it is acceptance iff an accepting computation exists [13].
In order to solve decision problems (or, equivalently, decide languages) over an alphabet \(\varSigma \), we use families of recogniser P systems \({\varvec{\varPi }} = \{ \varPi _x : x \in \varSigma ^\star \}\). Each input x is associated with a P system \(\varPi _x\) deciding the membership of x in a language \(L \subseteq \varSigma ^\star \) by accepting or rejecting. The mapping \(x \mapsto \varPi _x\) must be efficiently computable for inputs of any length, as discussed in detail in [11].
Definition 2

\(F(1^n) = \varPi _n\), where n is the length of the input x and \(\varPi _n\) is a common P system for all inputs of length n, with a distinguished input membrane.

\(E(x) = w_x\), where \(w_x\) is a multiset encoding the specific input x.

Finally, \(\varPi _x\) is simply \(\varPi _n\) with \(w_x\) added to its input membrane.
Any explicit encoding of \(\varPi _x\) is allowed as output of the construction, as long as the number of membranes and objects represented by it does not exceed the length of the whole description, and the rules are listed one by one. This restriction is enforced to mimic a (hypothetical) realistic process of construction of the P systems, where membranes and objects are presumably placed in a constant amount during each construction step and require actual physical space proportional to their number; see also [11] for further details on the encoding of P systems.
In the following, we denote the class of problems solvable by polynomialtime uniform or semiuniform families of nonconfluent shallow P systems with active membranes with charges by \(\mathbf{NPMC}_{\mathcal {AM}(\mathrm{depth1},\mathrm{d},\mathrm{ne})}^{[\star ]}\), where \([\star ]\) denotes optional semiuniformity. If no restriction on the depth of the membrane structure is present, but both nonelementary division and dissolution rules are forbidden, then the corresponding class of problems is denoted by \(\mathbf{NPMC}_{\mathcal {AM}(\mathrm{d},\mathrm{ne})}^{[\star ]}. \)
3 Nondeterministic simulation with oracles
Let \({\varvec{\varPi }}\) be a semiuniform family of nonconfluent shallow recognizer P systems with active membranes with charges, and let H be the TM of the semiuniformity condition of \({\varvec{\varPi }}\). We are going to define a machine M working in polynomial space such that on input H and x Turing machine M accepts iff the P system \(H(x) = \varPi _x\) of \({\varvec{\varPi }}\) accepts in polynomial time. Notice that a single machine M suffices for all families of P systems. The machine associated with a specific family \({\varvec{\varPi }}\) of P systems can be obtained by “hardcoding” the input H to M.
First of all, on input H and x, machine M simulates machine H with x as input to obtain a polynomialsize description of \(\varPi _x\). To simplify the description of the procedure used by machine M to simulate \(\varPi _x\), without loss of generality we will assume M to work as a nondeterministic polynomialtime TM with access to an oracle for a problem in \(\mathbf{NPSPACE}=\mathbf{PSPACE}\). As the following result shows, both this nondeterministic behavior and the oracle queries can still all be simulated using a polynomialspace deterministic TM.
Proposition 1
\(\mathbf{NP}^{\mathbf{NPSPACE}} = \mathbf{PSPACE}\).
Proof

D simulates N until a query is performed. This simulation, including the nondeterministic choices of N, can be performed in polynomial space by D, since \(\mathbf{NP} \subseteq \mathbf{PSPACE}\).

Since \(L \in \mathbf{NPSPACE}\) and \(\mathbf{NPSPACE} = \mathbf{PSPACE}\), there exists a deterministic polynomialspace TM deciding L that can be simulated by D to answer any query performed by N while still using only a polynomial amount of space. Once a query has been answered, D can resume the simulation of N.
We can now describe how the simulation of \(\varPi _x\) is carried on by M. In the following, we assume that the size of the input x is n, and that each computation of \(\varPi _x\) requires at most T time steps before halting and producing a result. By hypothesis T is polynomial with respect to n.
3.1 Simulation of the outermost membrane
The main idea of this construction is to simulate the evolution of the outermost membrane directly by means of a nondeterministic polynomialtime TM. All interactions with the internal membranes are performed via nondeterministic guesses. That is, for each communication rule and for each time step, the number of rules that are applied between the outermost and the inner membranes is guessed in a nondeterministic way. If \({\textsf {yes}}\) has been sent out by the simulation of the outermost membrane, an oracle query is performed to check whether all performed interactions with the inner membranes were consistent with this information, that is, whether a computation of the inner membranes able to perform the guessed interactions actually exists. If the query returns a positive answer, then a computation of the entire system actually producing \({\textsf {yes}}\) exists. In any other case, the simulating machine rejects, since either an invalid simulation of the outermost membrane—and of the P system—was produced, or the simulation itself was correct but the simulated computation was a rejecting one.
To perform this construction we build a table \(\mathcal {T}\) indexed by pairs of the form (r, t), where \(r \in R\) is either a sendin rule from the outermost membrane to one of the internal membranes or a sendout rule from one of the internal membranes to the outermost membrane, and \(t \in \{0, \ldots , T1\}\) is a time step. The entry \(\mathcal {T}(r, t)\) represents the number of times rule r has been applied at the time step t. It is important to notice that table \(\mathcal {T}\) can be stored using a polynomial amount of space. In fact, the number of entries is limited by the size of R (which, by uniformity condition, is polynomial in the input size n), and by the number T of time steps needed for the P system to halt. We only need to prove that each entry \(\mathcal {T}(r,t)\) can be stored in a polynomial amount of space.
Let \(m \in \mathbb {N}\) be the number of internal membranes in the initial configuration of \(\varPi _x\). By the semantics of the rules of P systems, the number of objects sent in to internal membranes or sent out from them after t time steps cannot be greater than \(m \times 2^t\), where the second multiplicative factor is the maximum number of membranes per label that can be obtained by membrane division in t time steps. Since this value is exponential in t, it can be represented by a polynomial number of bits with respect to \(t \le T\). Thus, each entry of \(\mathcal {T}\) requires at most a polynomial amount of space with respect to n. We denote the maximum value attainable by an entry of \(\mathcal {T}\) by \(\mathsf {K}\).
Apart from keeping track of the communication rules applied between the outermost and the internal membranes, we also need to assure that all rules are applied in a maximally parallel way. To do so, we define another table \(\mathcal {U}\) indexed by pairs of the form (a, t) where \(a \in \varGamma \) is an object type and \(t \in \{0, \ldots , T1\}\) is, as before, a time step. The entry \(\mathcal {U}(a, t)\) represents the number of objects of type a in the outermost membrane that had no rule applied to them at time t. Table \(\mathcal {U}\) can, too, be stored in a polynomial amount of space, since each entry is at most exponential in value, and thus, requires only a polynomial number of bits to be described. In fact, suppose that an object can be rewritten into m copies by an evolution rule; even if such a rule is applied at every time step on each copy of the object produced, after t time steps the total number of objects present will be at most \(m^t\), which can be represented using \(t \log m\) bits [14].
Lines 1–3 perform the initialization of the algorithm, setting the initial content and charge of the outermost membrane and declaring the environment initially empty. The main simulation loop is performed in lines 4–29. Since the maximum number of time steps needed for \(\varPi _x\) to produce a result is T, the simulation loop is repeated at most T times. If the loop ends without having produced either \({\textsf {yes}}\) or \({\textsf {no}}\) in the environment while simultaneously halting, the simulation performed did not correspond to any actual computation of \(\varPi _x\); thus a negative answer must be produced (line 30).
Lines 5–7 deal with the sendin rules from the outermost membrane to the inner membranes. Since the number of internal membranes where the rule r can be applied is not known, the number is nondeterministically chosen and is bounded by the minimum number of inner membranes and the number of objects of type a in the outermost membrane (line 6). The guessed number of internal membranes saved in table \(\mathcal {T}\) and the effect of the rules on the multiset w are scheduled for application (line 7). Notice that, since the state of the internal membranes is not stored, this amounts to the removal of \(\mathcal {T}(r, t)\) instances of objects of type a from w.
Lines 8–10 deal with sendout rules from the internal membranes to the outermost membrane. As before, since the configuration and number of the internal membranes is not known, the number of times this rule is applied is nondeterministically guessed (line 9), saved in table \(\mathcal {T}\), and the appearance of the corresponding objects of type b in w is scheduled (line 10).
Lines 11–13 perform the simulation of the evolution rules inside the outermost membrane. Since the simulated system is nondeterministic, the actual number of applications of each rule is guessed (line 12) before the actual effects of the rule applications are scheduled (line 13).
Lines 14–19 deal with the application of sendout rules from the outermost membrane to the environment. First of all, a nondeterministic guess is performed to decide whether the rule is actually applied (line 15). If so, then the actual effects of the rules are scheduled for application (lines 16–19).
The table \(\mathcal {U}\) is then updated to memorize the number of objects that were not subjected to any rule (lines 20–21). This will be used during the query process to ensure that the sendin rules from the outermost membrane to the internal membranes were actually applied in a maximally parallel way.
All the scheduled modifications to the content and charge of the outermost membrane and to the environment are now executed (line 22). If there are irreconcilable problems in the maximally parallel application of the rules then a rejection is performed (lines 23–24). This happens when there are objects that remained idle in the outermost membrane, since they were not selected to be sentin into the internal membranes, nor were they subject to applicable sendout or evolution rules. In particular, if an applicable evolution or sendout rule involving an object a exists then no copy of the object should remain idle.
Finally, if either \({\textsf {yes}}\) or \({\textsf {no}}\) appears in the environment (lines 25–29) then it is necessary to check whenever the guesses performed for the interaction with the internal membranes were accurate, and no further rules are applicable in the next time step in the outermost membrane (lines 26–29). If the answer to the query is positive and no further rules were actually applicable, then the simulation can either accept or reject accordingly (line 27). Otherwise, the simulation performed did not correspond to any actual computation of \(\varPi _x\) and thus it must reject (line 29).
Algorithm 1 can be executed in polynomial time by a nondeterministic TM with access to an oracle to perform the query procedure. In fact, both the outer loop and the inner loops are executed only a polynomial amount of times (either bounded by the time needed for \(\varPi _x\) to halt, or by the number of rules in the system). All the other operations, including checking the applicability of rules, can be performed in polynomial time, given an efficient description of the configuration of the outermost membrane, in which the number of copies of objects are stored in binary. Furthermore, all nondeterministic guesses involve a polynomial amount of bits.
3.2 Simulation of the oracle
The main idea underlying the possibility of answering this query in nondeterministic polynomial space is to simulate each membrane sequentially and keep track of the communication rules that are applied while comparing them with the ones guessed by the simulation of the outermost membrane. If division is applied then only the simulation of one of the dividing membranes is immediately carried out (as performing them all at the same time might require exponential—instead of polynomial—space) while the other membrane is pushed into a stack, thus performing a depthfirst simulation of the membrane hierarchy. This ensures that a polynomial amount of space suffices: it is the space needed to simulate one membrane, plus a stack in which the number of elements is at most T, one for each time step. This algorithm is similar to the deterministic one presented in [17], although with an explicit stack instead of a recursive definition, and the further difference that the algorithm was able to work for unboundeddepth systems. The actual algorithm implemented to answer the query is presented in Algorithm 2.Is there an halting computation of length t of the internal membranes consistent with the rule applications guessed?
Lines 1–3 perform the initial setup, where a new stack S is filled with the configuration of all internal membranes at the initial time step, i.e., \(t = 0\). In particular, for each membrane the multiset of objects contained, label, charge, and time step of the simulation are all pushed as a single record into S.
In the main loop of lines 4–32 the simulation of all internal membranes is performed one at a time. This loop is executed until the stack of membranes to be simulated is not empty, which might require an exponential amount of time.
Once a new membrane to be simulated starting at time\(t_{\mathsf {push}}\) has been extracted (line 5) the simulation of the membrane proceeds up to time step t, which is given as input as part of the query (loop of lines 6–30) and represents the time at which the simulation of the outermost membrane has suspended in order to perform the query.
In lines 7–11, for each applicable division rule, i.e., the correct object and charge are present and the membrane has not already been used by a blocking rule in this time step, a nondeterministic choice is performed (line 8) to decide if the rule is actually applied. If so (lines 9–11), then the modifications described by the first half of the righthandside of the rule are performed, while the other membrane resulting from the division will be pushed on the stack S at the end of the simulation of the current time step (line 30). This cannot be performed earlier since the rewriting rules are applied, by the semantics of rule application in P systems, before the division actually takes place.
The simulation of both sendin and sendout rules (lines 12–17 and lines 18–23, respectively) is performed similarly. Since we are working in a situation of nonconfluence, even if a rule is applicable, to actually decide whether to apply it, a nondeterministic guess is performed (line 13 and line 19, respectively). In both cases the modifications to be performed to the membrane configuration are scheduled for later execution (lines 16–17 and lines 22–23, respectively). Since sendin and sendout are communication rules between the outermost membrane and the internal membranes, each time one of them is applied the value of \(\mathcal {T}(r, t')\) is decremented (line 15 and line 21, respectively). If, at the end of the simulation, the number of guessed applications and the real number of applications of the communication rules coincide, all entries \(\mathcal {T}(r, t')\) should be 0 (line 33).
The application of evolution rules (lines 24–26), their effect being limited to the internal state of the membrane, is simpler. As usual, which rules are actually applied is determined by a nondeterministic choice (line 25).
Once all rule applications have been decided, the actual modifications to the state of the membrane are applied (line 27) and, if the rule application was not maximally parallel then the computation rejects (lines 28–29). This can be verified by checking if there still exist objects inside the membrane with applicable rules but no rule was applied to them, that is, if \(\mathcal {U}(a, t')\) is positive for some \(a \in \varGamma \) with an applicable sendin rule to the currently simulated membrane. Since \(\mathcal {U}(a, t')\) indicates the number of objects that were available for the application of sendin rules from the outermost membrane but no internal membrane was available, such an inconsistency would denote that the simulation of the internal membranes had no correspondence to the already performed simulation of the outermost membrane.
If a division rule was applied, then the configuration of the second membrane resulting from division is pushed to the stack S (line 30). Here, an instance of the object b is replaced by an instance of object c and the charge is changed from \(\beta \) to \(\gamma \) to obtain from the current membrane an instance corresponding to the other one obtained by division.
Before proceeding with the simulation of another membrane, we check that after t steps the computation in this membrane has actually halted (lines 31–32); otherwise, the current computation must reject (line 32).
After the simulation of all internal membranes is finished, i.e., the stack was emptied, a check on the entries of \(\mathcal {T}\) is performed. If all and every communication rule application guessed during the simulation of the outermost membrane was actually executed, then all entries of \(\mathcal {T}\) should be 0. A positive (resp., negative) value for \(\mathcal {T}(r, t)\) denotes that less (resp., more) applications of rule r at time t were performed than the number that was guessed.
If at least one accepting computation of the machine simulating the oracle query exists then the answer to the query is positive. Since the result given by Algorithm 2 provides the correct answer to the query performed by Algorithm 1, the simulation of the innermost and the outermost membranes are “glued” together, showing that the result produced by Algorithm 1 is correct. Combining this simulation with the inverse simulation presented in [5], we can then state the main result of the paper:
Theorem 1
\(\mathbf{PSPACE} = \mathbf{NPMC}_{\mathcal {AM}(\mathrm{depth1},\mathrm{d},\mathrm{ne})}^{[\star ]}\). \(\square \)
As long as no dissolution is allowed, the property of being elementary is a static one and, if no nonelementary division is present, the simulation of the outermost membrane can be extended to include all nonelementary membranes: since all nonelementary membranes can never divide and are at most polynomial in number, their simulation can be performed directly inside Algorithm 1, without requiring any superpolynomial growth in the space needed by the algorithm. Therefore, we can state the following result:
Corollary 1
\(\mathbf{PSPACE} = \mathbf{NPMC}_{\mathcal {AM}({\mathrm{d},\mathrm{ne}})}^{[\star ]}\). \(\square \)
4 Conclusions
We have shown that, differently from confluent P systems, monodirectionality and a restriction on the depth of the system to 1 [3] (or, equivalently, the absence of both dissolution and nonelementary division) do not prevent nonconfluent P systems from reaching \(\mathbf{PSPACE}\) in polynomial time. It remains open to establish if this upper bound can be extended to membrane structures of higher (nonconstant) depth where nonelementary division is allowed. Since both monodirectionality and nesting depth have a huge influence in the computational power of confluent systems, it would be worthwhile to understand why they do not provide an analogous increase to nonconfluent systems. These features are usually employed by algorithms designed for confluent P systems to simulate the power of nondeterminism, so the question is: are they always useless when nonconfluence is already present?
Notes
References
 1.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Simulating elementary active membranes, with an application to the P conjecture. In: Gheorghe M, Rozenberg G, Sosík P, Zandron C, editors. Membrane computing, 15th International conference, CMC 2014, lecture notes in computer science, vol. 8961. New York: Springer; 2014. p. 284–99.Google Scholar
 2.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Membrane division, oracles, and the counting hierarchy. Fund Inf. 2015;138(1–2):97–111.MathSciNetzbMATHGoogle Scholar
 3.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Monodirectional P systems. Nat Comput. 2016;15(4):551–64.MathSciNetCrossRefGoogle Scholar
 4.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. The counting power of P systems with antimatter. Theor Comput Sci. 2017;701:161–73.MathSciNetCrossRefzbMATHGoogle Scholar
 5.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Shallow nonconfluent P systems. In: Leporati A, Rozenberg G, Salomaa A, Zandron C, editors. Membrane computing, 17th international conference, CMC 2016. Lecture notes in computer science, vol. 10105. New York: Springer; 2017. p. 307–16.Google Scholar
 6.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. A toolbox for simpler active membrane algorithms. Theor Comput Sci. 2017;673:42–57.MathSciNetCrossRefzbMATHGoogle Scholar
 7.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Solving QSAT in sublinear depth. In: Hinze T, Rozenberg G, Salomaa A, Zandron C editors. Membrane computing, CMC 2018. Lecture notes in computer science, vol 11399. Cham: Springer; 2019.Google Scholar
 8.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Subroutines in P systems and closure properties of their complexity classes. Theor Comput Sci. 2018.Google Scholar
 9.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. A survey on space complexity of P systems with active membranes. Int J Adv in Eng Sci Appl Math. 2018;10(3):221–9.MathSciNetCrossRefGoogle Scholar
 10.Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Characterising the complexity of tissue P systems with fission rules. J Comput Syst Sci. 2017;90:115–28.MathSciNetCrossRefzbMATHGoogle Scholar
 11.Murphy N, Woods D. The computational power of membrane systems under tight uniformity conditions. Nat Comput. 2011;10(1):613–32.MathSciNetCrossRefzbMATHGoogle Scholar
 12.Păun Gh, Rozenberg G, Salomaa A, editors. The Oxford handbook of membrane computing. Oxford: Oxford University Press; 2010.zbMATHGoogle Scholar
 13.PérezJiménez MJ, RomeroJiménez A, SanchoCaparrini F. Complexity classes in models of cellular computing with membranes. Nat Comput. 2003;2(3):265–84.MathSciNetCrossRefzbMATHGoogle Scholar
 14.Porreca AE, Leporati A, Mauri G, Zandron C. Recent complexitytheoretic results on P systems with active membranes. J Logic Comput. 2015;25(4):1047–71.MathSciNetCrossRefzbMATHGoogle Scholar
 15.Porreca AE, Mauri G, Zandron C. Nonconfluence in divisionless P systems with active membranes. Theor Comput Sci. 2010;411(6):878–87.MathSciNetCrossRefzbMATHGoogle Scholar
 16.Sosík P. The computational power of cell division in P systems: Beating down parallel computers? Nat Comput. 2003;2(3):287–98.MathSciNetCrossRefzbMATHGoogle Scholar
 17.Sosík P, RodríguezPatón A. Membrane computing and complexity theory: a characterization of PSPACE. J Comput Syst Sci. 2007;73(1):137–52.MathSciNetCrossRefzbMATHGoogle Scholar
 18.Zandron C, Ferretti C, Mauri G. Solving NPcomplete problems using P systems with active membranes. In: Antoniou I, Calude CS, Dinneen MJ, editors. Unconventional models of computation, UMC’2K, proceedings of the second international conference. New York: Springer; 2001. p. 289–301.CrossRefGoogle Scholar