Characterizing PSPACE with shallow non-confluent P systems

TL;DR

This paper proves that shallow non-confluent P systems with active membranes exactly characterize the complexity class PSPACE, clarifying the computational power of non-confluence in these systems.

Contribution

It establishes that non-confluent shallow P systems precisely characterize PSPACE, linking non-confluence and membrane nesting depth in computational power.

Findings

Non-confluent shallow P systems characterize PSPACE.

PSPACE is both an upper and lower bound for these systems.

Non-confluence provides computational power equivalent to deep confluent systems with membrane division.

Abstract

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 PSPACE. Here we show that 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.

Equations

$$\Pi =(\Gamma ,\Lambda ,\mu ,w_{h_1},\dots ,w_{h_d},R)$$

Full text

1 Introduction

While families of confluent recognizer P systems with active membranes with charges are known to characterize the complexity class ${\mathsf{PSPACE}}$ when working in polynomial time Sosik2003a ; Sosik2007a , 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 ${\mathsf{P}}^{\boldsymbol{\#}{\mathsf{P}}}$, which is conjecturally smaller Leporati2014d . 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 solve ${\mathsf{PSPACE}}$-complete problems even in the shallow case and even when send-in rules are disallowed (i.e., for monodirectional systems) Leporati2016a . Here we show that, in fact, ${\mathsf{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 ${\mathsf{P}}$ Zandron2001a whereas, additional nesting gives additional power Leporati2014e until reaching ${\mathsf{PSPACE}}$ when unlimited nesting is allowed Sosik2003a ; Sosik2007a . In the monodirectional case even unlimited nesting cannot escape ${\mathsf{P}}^{\mathsf{NP}}$, which is conjecturally smaller Leporati2016b . Non-confluent systems, on the other hand, characterize ${\mathsf{NP}}$ when there are no internal membranes Porreca2010a , and immediately gain the full power of ${\mathsf{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 Paun2010a . 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\geq 1$ is a tuple

[TABLE]

where:

• •

$\Gamma$ is an alphabet, i.e., a finite non-empty set of symbols, usually called objects;

• •

$\Lambda$ 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 $\Lambda$ in a one-to-one way;

• •

$w_{h_{1}},\ldots,w_{h_{d}}$, with $h_{1},\ldots,h_{d}\in\Lambda$, are multisets (finite sets whose elements have a multiplicity) of objects in $\Gamma$, 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 ([math]), positive ($+$) or negative ($-$) and is always neutral before the beginning of the computation.

The rules in $R$ are of the following types:

1. (a)

Object evolution rules, of the form $[a\to 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}\to[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 $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}\to[\;]_{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}\to[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$; 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 $\Pi$ at a given time is a rooted, unordered tree. The root is a node corresponding to the external environment of $\Pi$, and has a single subtree corresponding to the current membrane structure of $\Pi$. 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 $\Pi$, 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 exactly 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.

A halting computation of the P system $\Pi$ is a finite sequence $\vec{\mathcal{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 $\Pi$ are applicable in $\mathcal{C}_{k}$. A non-halting computation $\vec{\mathcal{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 yes and no: in this case we assume that all computations are halting, and that either one copy of object yes or one of object 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 Perez2003a .

In order to solve decision problems (or, equivalently, decide languages) over an alphabet $\Sigma$, we use families of recogniser P systems $\boldsymbol{\Pi}=\{\Pi_{x}:x\in\Sigma^{\star}\}$. Each input $x$ is associated with a P system $\Pi_{x}$ deciding the membership of $x$ in a language $L\subseteq\Sigma^{\star}$ by accepting or rejecting. The mapping $x\mapsto\Pi_{x}$ must be efficiently computable for inputs of any length, as discussed in detail in Murphy2011a .

Definition 2

A family of P systems $\boldsymbol{\Pi}=\{\Pi_{x}:x\in\Sigma^{\star}\}$ is (polynomial-time) uniform if the mapping $x\mapsto\Pi_{x}$ can be computed by two polynomial-time deterministic Turing machines $E$ and $F$ as follows:

• •

$F(1^{n})=\Pi_{n}$, where $n$ is the length of the input $x$ and $\Pi_{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, $\Pi_{x}$ is simply $\Pi_{n}$ with $w_{x}$ added to its input membrane.

The family $\boldsymbol{\Pi}$ is said to be (polynomial-time) semi-uniform if there exists a single deterministic polynomial-time Turing machine $H$ such that $H(x)=\Pi_{x}$ for each $x\in\Sigma^{\star}$.

Any explicit encoding of $\Pi_{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 in order 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 Murphy2011a 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 ${\mathsf{NPMC}}_{\mathcal{AM}\mathrm{(depth\mbox{-}1,-d,-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 ${\mathsf{NPMC}}_{\mathcal{AM}\mathrm{(-d,-ne)}}^{[\star]}$.

3 Nondeterministic Simulation with Oracles

Let $\boldsymbol{\Pi}$ 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 $\boldsymbol{\Pi}$. 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)=\Pi_{x}$ of $\boldsymbol{\Pi}$ accepts in polynomial time. Notice that a single machine $M$ suffices for all families of P systems. The machine associated with a specific family $\boldsymbol{\Pi}$ 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 $\Pi_{x}$. To simplify the description of the procedure used by machine $M$ to simulate $\Pi_{x}$, we will assume $M$ to work as a nondeterministic polynomial-time TM with access to an oracle for a problem in ${\mathsf{NPSPACE}}={\mathsf{PSPACE}}$. As the following result shows, both this nondeterministic behaviour and the oracle queries can still all be simulated using a polynomial-space deterministic TM.

Proposition 1

${\mathsf{NP}}^{\mathsf{NPSPACE}}={\mathsf{PSPACE}}$.

Proof

Clearly ${\mathsf{NP}}^{\mathsf{NPSPACE}}\supseteq{\mathsf{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{\mathsf{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 ${\mathsf{NP}}\subseteq{\mathsf{PSPACE}}$.

• •

Since $L\in{\mathsf{NPSPACE}}$ and ${\mathsf{NPSPACE}}={\mathsf{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 ${\mathsf{NP}}^{\mathsf{NPSPACE}}\subseteq{\mathsf{PSPACE}}$, as desired. ∎

We can now describe how the simulation of $\Pi_{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 $\Pi_{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 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, if 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 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 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)$ represent 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 number of internal membranes in the initial configuration of $\Pi_{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\leq 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\Gamma$ 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.

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 1 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–1 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 1–1. Since the maximum number of time steps needed for $\Pi_{x}$ to produce a result is $T$, the simulation loop is repeated at most $T$ times. If the loop ends without having produced either yes on no in the environment while simultaneously halting, the simulation performed did not correspond to any actual computation of $\Pi_{x}$, thus a negative answer must be produced (line 1).

Lines 1–1 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 maximum number of inner membranes and the number of objects of type $a$ in the outermost membrane (line 1). The guessed number of internal membranes saved in table $\mathcal{T}$ and the effect of the rules on the multiset $w$ is scheduled for application (line 1). 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 1–1 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 1), saved in table $\mathcal{T}$, and the appearance of the corresponding objects of type $b$ in $w$ is scheduled (line 1).

Lines 1–1 perform the simulation of the evolution rules inside the outermost membrane. Since the simulated system is non-confluent, the actual number of applications of each rule is guessed (line 1) before the actual effect of the rule applications are scheduled (line 1).

Lines 1–1 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 1). If so, then the actual effects of the rules are scheduled for application (lines 1–1).

The table $\mathcal{U}$ is then updated to memorize the number of objects that were not subjected to any rule (lines 1–1). 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 1). If there are irreconcilable problems in the maximally parallel application of the rules then a rejection is performed (lines 1–1). This happens when there were objects in the outermost membrane that were not selected to be sent-in into the internal membranes (this can be checked by looking at table $\mathcal{U}$), nor were they subject to applicable send-out or evolution rules.

Finally, if either yes or no appears in the environment (lines 1–1) 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 1–1). 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 1). Otherwise, the simulation performed did not correspond to any actual computation of $\Pi_{x}$ and we must reject (line 1).

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 $\Pi_{x}$ to halt or by the number or rules in the system). All 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 objects is stored in binary). Furthermore, all nondeterministic guesses are of a polynomial amount of bits.

3.2 Simulation of the Oracle

The query that is simulated by means of a nondeterministic machine working in polynomial space is the following one:

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

To be able to answer this query in nondeterministic polynomial space the main idea 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 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 Sosik2007a , although with an explicit stack instead of a recursive definition, and the further difference that their algorithm was able to work for unbounded-depth system. The actual algorithm implemented to answer the query is presented in Algorithm 2.

Lines 2–2 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 an single record into $S$.

In the main loop of lines 2–2 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 2) the simulation of the membrane proceeds up to time step $t$, which is given in input as part the query (loop of lines 2–2) and represents the time at which the simulation of the outermost membrane has suspended in order to perform the query.

In lines 2–2, 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 2) to decide if the rule is actually applied. If so (lines 2–2), 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 2). 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 2–2 and lines 2–2, respectively) is performed similarly. Since we are working in a situation of non-confluence, even if a rule is applicable, in order to actually decide whether to apply it, a nondeterministic guess is performed (line 2 and line 2, respectively). In both cases the modifications to be performed to the membrane configuration are scheduled for later execution (lines 2–2 and lines 2–2, 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^{\prime})$ is decremented. If, at the end of the simulation, the number of guessed applications and the real number of applications of the communication rules coincides, all entries $\mathcal{T}(r,t^{\prime})$ should be [math] (at line 2 and line 2, respectively).

The application of evolution rules (lines 2–2), 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 2).

Once all rule applications have been decided, the actual modifications to the state of the membrane are applied (line 2) and, if the rule application was not maximally parallel then the computation rejects (lines 2–2). This can be verified by checking if there still exist objects inside the membrane with applicable rules but no rule was applied to them, or if $\mathcal{U}(a,t^{\prime})$ is positive for some $a\in\Gamma$ with an applicable send-in rule to the currently simulated membrane. Since $\mathcal{U}(a,t^{\prime})$ indicates the number of objects that were available for the application of send-in 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 2). Here, an instance of the object $b$ has been replaced by an instance of object $c$ and the charge has been changed from $\beta$ to $\gamma$ to obtain from the current membrane a copy 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 2–2). Otherwise the current computation must reject (line 2).

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 [math]. 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. Furthermore, if there is a way to “glue” the simulation of the outermost membrane and of the internal membranes, then the result produced by Algorithm 1 was correct. Combining this simulation with the inverse simulation presented in Leporati2016a , we can then state the main result of the paper.

Theorem 3.1

${\mathsf{PSPACE}}={\mathsf{NPMC}}_{\mathcal{AM}\mathrm{(depth\mbox{-}1,-d,-ne)}}^{[\star]}$. ∎

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, allowing us to state the following result.

Corollary 1

${\mathsf{PSPACE}}={\mathsf{NPMC}}_{\mathcal{AM}\mathrm{(-d,-ne)}}^{[\star]}$. ∎

4 Conclusions

We have shown that, differently from confluent P systems, monodirectionality and a restriction on the depth of the system to $1$ (or, equivalently, the absence of both dissolution and non-elementary division) do not prevent non-confluent P systems from reaching ${\mathsf{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?