Characterizing PSPACE with shallow non-confluent P systems

  • Alberto LeporatiEmail author
  • Luca Manzoni
  • Giancarlo Mauri
  • Antonio E. Porreca
  • Claudio Zandron
Regular Paper


In P systems with active membranes, the question of understanding the power of non-confluence 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, non-confluence 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 non-confluence to shallow P systems is equal to the power gained by confluent P systems when non-elementary membrane division and polynomial depth are allowed, thus suggesting a connection between the roles of non-confluence and nesting depth.


P systems Active membranes Non-confluent PSPACE 

1 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 non-confluent recognizer P systems with active membranes with charges can efficiently solve \(\mathbf{PSPACE }\)-complete problems even in the shallow case and even when send-in 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 non-confluent 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 non-confluent 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]. Non-confluent 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 non-confluence. 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

A P system with active membranes with elementary division rules of initial degree \(d \ge 1\) is a tuple
$$\begin{aligned} \varPi = (\varGamma , \varLambda , \mu , w_{h_1}, \ldots , w_{h_d}, R) \end{aligned}$$
  • \(\varGamma \) is an alphabet, i.e., a finite non-empty 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 one-to-one 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.

The rules in R are of the following types:
  1. (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).

  2. (b)

    Send-in 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 \).

  3. (c)

    Send-out 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 \).

  4. (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.

The instantaneous configuration of a membrane of label h consists of its charge \(\alpha \) and the multiset w of objects it contains at a given time. It is denoted by \([w]_{h}^{\alpha }\). The (full) configuration\(\mathcal {C}\) of a P system \(\varPi \) at a given time is a rooted, unordered tree; the root is a node corresponding to the external environment of \(\varPi \) and has a single subtree corresponding to the current membrane structure of \(\varPi \). Furthermore, the root is labelled by the multiset located in the environment, and the remaining nodes by the configurations \([w]_{h}^{\alpha }\) of the corresponding membranes. In the initial configuration of \(\varPi \), the configurations of the membranes are \([w_{h_1}]_{h_1}^{0}, \ldots , [w_{h_d}]_{h_d}^{0}\).

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.

A computation step changes the current configuration according to the following set of principles:
  • 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 left-hand 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 micro-steps 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 re-enter 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.

A halting computation of a P system \(\varPi \) is a finite sequence \({\mathcal {\varvec{C}}} = (\mathcal {C}_0, \ldots , \mathcal {C}_k)\) of configurations, where \(\mathcal {C}_0\) is the initial configuration, every \(\mathcal {C}_{i+1}\) is reachable from \(\mathcal {C}_i\) via a single computation step, and no rules of \(\varPi \) are applicable in \(\mathcal {C}_k\). A non-halting computation \({\mathcal {\varvec{C}}} = (\mathcal {C}_i : i \in \mathbb {N} )\) consists of infinitely many configurations, again starting from the initial one and generated by successive computation steps, where the applicable rules are never exhausted.

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 non-confluent 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

A family of P systems \({\varvec{\varPi }} = \{ \varPi _x : x \in \varSigma ^\star \}\) is (polynomial-time) uniform if the mapping \(x \mapsto \varPi _x\) can be computed by two polynomial-time deterministic Turing machines E and F as follows:
  • \(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.

The family \({\varvec{\varPi }}\) is said to be (polynomial-time) semi-uniform if there exists a single deterministic polynomial-time Turing machine H such that \(H(x) = \varPi _x\) for each \(x \in \varSigma ^\star \).

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 polynomial-time uniform or semi-uniform families of non-confluent shallow P systems with active membranes with charges by \(\mathbf{NPMC}_{\mathcal {AM}(\mathrm{depth-1},-\mathrm{d},-\mathrm{ne})}^{[\star ]}\), where \([\star ]\) denotes optional semi-uniformity. If no restriction on the depth of the membrane structure is present, but both non-elementary 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 semi-uniform family of non-confluent shallow recognizer P systems with active membranes with charges, and let H be the TM of the semi-uniformity 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 “hard-coding” 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 polynomial-size 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 polynomial-time 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 polynomial-space deterministic TM.

Proposition 1

\(\mathbf{NP}^{\mathbf{NPSPACE}} = \mathbf{PSPACE}\).


Clearly \(\mathbf{NP}^{\mathbf{NPSPACE}} \supseteq {\mathbf{PSPACE}}\), hence only the opposite inclusion needs to be proved. Let N be a polynomial-time nondeterministic TM with access to an oracle for a language \(L \in \mathbf{NPSPACE}\). Let D be a deterministic polynomial-space TM built in the following way:
  • 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 polynomial-space 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.

Since D can faithfully simulate N and its oracle queries, D can recognize the same language as N, thus showing that \(\mathbf{NP}^{\mathbf{NPSPACE}} \subseteq \mathbf{PSPACE}\), as desired. \(\square \)

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 polynomial-time 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 (rt), where \(r \in R\) is either a send-in rule from the outermost membrane to one of the internal membranes or a send-out rule from one of the internal membranes to the outermost membrane, and \(t \in \{0, \ldots , T-1\}\) 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 (at) where \(a \in \varGamma \) is an object type and \(t \in \{0, \ldots , T-1\}\) 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].

The simulation procedure of the outermost membrane is detailed as Algorithm 1. There, label h always indicates the outermost membrane and the label k an internal membrane label, while \(|w|_a\) denotes the number of instances of the object a inside the multiset w. The applicability of a rule refers, in the algorithm, to the fact that the indicated membrane must have the correct charge \(\alpha \) and, if the rule is blocking, that the membrane has not already been used by another blocking rule in the same time step. For example, the condition on line 14 of Algorithm 1 is never verified once another send-out rule has been simulated in a previous iteration of the loop for the current time step.

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 send-in 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 send-out 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 send-out 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 send-in 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 sent-in into the internal membranes, nor were they subject to applicable send-out or evolution rules. In particular, if an applicable evolution or send-out 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

Let us now show that also the oracle which is used by M during the simulation of \(\varPi _x\) to query about the behavior of the internal membranes can be simulated in nondeterministic polynomial space. The query answered by the oracle is the following:

Is there an halting computation of length t of the internal membranes consistent with the rule applications guessed?

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 depth-first 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 unbounded-depth systems. The actual algorithm implemented to answer the query is presented in Algorithm 2.

Lines 1–3 perform the initial set-up, 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 right-hand-side 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 send-in and send-out rules (lines 12–17 and lines 18–23, respectively) is performed similarly. Since we are working in a situation of non-confluence, 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 send-in and send-out 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 send-in rule to the currently simulated membrane. Since \(\mathcal {U}(a, t')\) indicates the number of objects that were available for the application of send-in 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{depth-1},-\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 non-elementary division is present, the simulation of the outermost membrane can be extended to include all non-elementary membranes: since all non-elementary 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 non-elementary division) do not prevent non-confluent 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 (non-constant) depth where non-elementary 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 non-confluent 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 non-confluence is already present?



  1. 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. 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. 3.
    Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Monodirectional P systems. Nat Comput. 2016;15(4):551–64.MathSciNetCrossRefGoogle Scholar
  4. 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. 5.
    Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Shallow non-confluent 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. 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. 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. 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. 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. 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. 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. 12.
    Păun Gh, Rozenberg G, Salomaa A, editors. The Oxford handbook of membrane computing. Oxford: Oxford University Press; 2010.zbMATHGoogle Scholar
  13. 13.
    Pérez-Jiménez MJ, Romero-Jiménez A, Sancho-Caparrini F. Complexity classes in models of cellular computing with membranes. Nat Comput. 2003;2(3):265–84.MathSciNetCrossRefzbMATHGoogle Scholar
  14. 14.
    Porreca AE, Leporati A, Mauri G, Zandron C. Recent complexity-theoretic results on P systems with active membranes. J Logic Comput. 2015;25(4):1047–71.MathSciNetCrossRefzbMATHGoogle Scholar
  15. 15.
    Porreca AE, Mauri G, Zandron C. Non-confluence in divisionless P systems with active membranes. Theor Comput Sci. 2010;411(6):878–87.MathSciNetCrossRefzbMATHGoogle Scholar
  16. 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. 17.
    Sosík P, Rodríguez-Patón A. Membrane computing and complexity theory: a characterization of PSPACE. J Comput Syst Sci. 2007;73(1):137–52.MathSciNetCrossRefzbMATHGoogle Scholar
  18. 18.
    Zandron C, Ferretti C, Mauri G. Solving NP-complete 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

Copyright information

© Springer Nature Singapore Pte Ltd. 2019

Authors and Affiliations

  1. 1.Dipartimento di Informatica, Sistemistica e ComunicazioneUniversità degli Studi di Milano-BicoccaMilanItaly
  2. 2.Aix Marseille UniversitéUniversité de Toulon, CNRS, LISMarseilleFrance

Personalised recommendations