A Turing machine simulation by P systems without charges

TL;DR

This paper demonstrates that a simplified class of P systems without charges can simulate deterministic Turing machines in polynomial time under weaker uniformity conditions, expanding their computational capabilities.

Contribution

It introduces a new simulation method for Turing machines using P systems without charges with reduced uniformity and membrane nesting requirements.

Findings

P systems without charges can simulate polynomial-time Turing machines.

Simulation works under weaker uniformity conditions.

Potential for embedding into more complex membrane structures.

Abstract

It is well known that the kind of P systems involved in the definition of the P conjecture is able to solve problems in the complexity class $\mathbf{P}$ by leveraging the uniformity condition. Here we show that these systems are indeed able to simulate deterministic Turing machines working in polynomial time with a weaker uniformity condition and using only one level of membrane nesting. This allows us to embed this construction into more complex membrane structures, possibly showing that constructions similar to the one performed in [1] for P systems with charges can be carried out also in this case.

Figures

Equations

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

$$\Lambda =$$

$$\cup \{(i,j{)}^{\prime }|i\in \{0,\dots ,p(n)\},j\in \{0,\dots ,p(n)-1\}\}.$$

$$\Gamma =$$

$$\cup \{q_{i,j,k}|i,j\in \{0,\dots ,p(n)\},0\le k\le m+5,q\in Q\}$$

$$\cup \{q_{i,j,k,a}|i,j\in \{0,\dots ,p(n)\},0\le k\le m+5,q\in Q,a\in \Sigma \}$$

$$\cup \{a_i|a\in \Sigma ,i\in \{0,\dots ,p(n)\}\}\cup \{q^I\}$$

$$a_i[{]}_{(i,0)}\to [a_{i,0,0}{]}_{(i,0)}$$

$$[q^I\to q_{0,0,0}^I{]}_0$$

$$[a_{i,j,k}\to a_{i,j,k+1}{]}_{(i,j)}$$

$$[a_{i,j,k}{]}_{(i,j)}\to a_{i,j,k+1}$$

$$[a_{i,j,k}\to a_{i,j,k+1}{]}_0$$

$$q_{i,j,0}[{]}_{(i,j)}\to [q_{i,j,1}{]}_{(i,j)}$$

$$[q_{i,j,k}\to q_{i,j,k+1}{]}_{(i,j)}$$

$$[q_{i,j,k}\to q_{i,j,k+1,{\phi }^{-1}(k)}{]}_0$$

$$[q_{i,j,k,a}\to q_{i,j,k+1,a}{]}_0$$

$$a_{i,j,m+1}[{]}_{(i,j{)}^{\prime }}\to [a_{i,j,m+2}{]}_{(i,j{)}^{\prime }}$$

$$[q_{i,j,m+1,a}\to q_{i,j,m+2,a}{]}_0$$

$$[a_{i,j,m+2}\to a_{i,j,m+3}{]}_{(i,j{)}^{\prime }}$$

$$q_{i,j,m+2,a}[{]}_{(i,j{)}^{\prime }}\to [q_{i,j,m+3,a}{]}_{(i,j{)}^{\prime }}$$

$$[a_{i,j,m+3}\to a_{i,j,m+4}{]}_{(i,j{)}^{\prime }}$$

$$[q_{i,j,m+3,a}{]}_{(i,j{)}^{\prime }}\to q_{i,j,m+4,a}$$

$$[a_{i,j,m+4}{]}_{(i,j{)}^{\prime }}\to a_{i,j,m+5}$$

$$[a_{i,j,m+4}\to ϵ{]}_0$$

$$[q_{i,j,m+4,a}\to q_{i,j,m+5,a}{b}_{i+d,j,m+5}{]}_0$$

$$\delta (q,a)=(r,b,i+d)$$

$$a_{i,j,m+5}[{]}_{(i,j+1)}\to [a_{i,j+1,0}{]}_{(i,j+1)}$$

$$[q_{i,j,m+5,a}\to r_{i+d,j+1,0}{]}_0$$

$$\delta (q,a)=(r,b,i+d)$$

$$[q_{i,j,m+4,a}\to q_{i,j,m+5,(r,b,i+d)}{b}_{i+d,j,m+5}{]}_0$$

$$(r,b,i+d)\in \delta (q,a)$$

$$[q_{i,j,m+5,(r,b,i+d)}\to r_{i+d,j+1,0}{]}_0$$

Full text

1 Introduction

The construction of P systems simulating Turing machines (TM) using as few membranes (or cells) as possible and limiting the depth of the system is one of the “tricks” that allowed the nesting of multiple machines to solve problems in large complexity classes. For example, nesting of non-deterministic machines (where the non-determinism was simulated by membrane division) and a counting mechanism allows to characterize ${\mathsf{P}}^{\#{\mathsf{P}}}$, the class of all problems solvable by a deterministic TM with access to a $\#{\mathsf{P}}$ oracle [1, 3]. The same ideas can be applied to tissue P systems [4], where the different communication topology makes even more important to keep TM simulations compact [2].

The P conjecture is a long-standing open problem in membrane computing first presented in 2005 [7, Problem F] that, in its essence, asks what is the power of one charge when compared to two charges. We feel that one important step to determine the computational power of active membrane systems without charges and with membrane dissolution is to see which is the minimal system able to simulate a deterministic polynomial-time TM. Here we show that a shallow system is sufficient to perform such a simulation without delegating everything to the machine of the uniformity condition. Hopefully, this construction will allow us to define systems in which different TM can be “embedded” at different levels in a large membrane structure, thus making possible to mimic the construction performed in [1] for P systems with charges.

This paper is organized as follows: Section 2 will recall some basic notions on P systems. The main construction and result is presented in Section 3, while ideas for further research are presented in Section 4.

2 Basic Notions

For an introduction to membrane computing and the related notions of formal language theory and multiset processing, we refer the reader to The Oxford Handbook of Membrane Computing [8]. Here we recall the formal definition of P systems with active membranes using weak non-elementary division rules [6, 9].

Definition 1

A P system with active membranes with dissolution 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;

• •

$\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 with multiplicity) of objects in $\Gamma$, describing the initial contents of each of the $d$ regions of $\mu$;

• •

$R$ is a finite set of rules.

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

1. (a)

Object evolution rules, of the form $[a\to w]_{h}$.

They can be applied inside a membrane labelled by $h$ 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}\to[b]_{h}$.

They can be applied to a membrane labelled by $h$ and such that the external region contains an occurrence of the object $a$; the object $a$ is sent into $h$ becoming $b$. 3. (c)

Send-out communication rules, of the form $[a]_{h}\to[\;]_{h}\;b$.

They can be applied to a membrane labelled by $h$ and containing an occurrence of the object $a$; the object $a$ is sent out from $h$ to the outer region becoming $b$. 4. (d)

Dissolution rules, of the form $[a]_{h}\to b$.

They can be applied to a non-skin membrane labelled by $h$ and containing an occurrence of the object $a$; the object $a$ is sent out from $h$ to the outer region becoming $b$, the membrane $h$ ceases to exist and all the other objects it contains are sent into the outer region.

A computation step changes the current configuration according to the following principles:

• •

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. Analogously, each membrane can only be subject to one communication or dissolution rule (types (b)–(d)) per computation step; for this reason, these rules will be called blocking rules in the rest of the paper. As a result, the only objects and membranes that do not evolve are those associated with no rule.

• •

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 its internal configuration (including, recursively, the configurations of the membrane substructures it contains) has been updated.

• •

The outermost membrane (the root of the membrane structure) 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}$.

P systems can be used as language recognisers by employing two distinguished objects $\mathsf{yes}$ and $\mathsf{no}$: we assume that all computations are halting, and that either one copy of object $\mathsf{yes}$ or one of object $\mathsf{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 order to solve decision problems (or, equivalently, decide languages), 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 [5].

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 a specific membrane, called the 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 [5] for further details on the encoding of P systems.

3 Simulation of Polynomial-time Turing machines

In this section we provide a simulation of a deterministic TM working in polynomial time by a P system that uses only one level of nesting. Any information exchange between objects can happen only via dissolution. By applying different evolution rules, it is possible for an object to detect whether it is inside or outside an elementary membrane (i.e., to “know” if the elementary membrane where it was has been dissolved). By combining this mechanism with a timer, it is also possible to encode the time when the membrane was dissolved, thus allowing to evolve in different ways according to this additional information.

Let $M$ be a polynomial-time deterministic TM having alphabet $\Sigma$, set of states $Q$, and transition function $\delta:Q\times\Sigma\to Q\times\Sigma\times\{-1,+1\}$. We assume that, for an input of length $n$ machine $M$ halts in time $p(n)$ and, thus, it uses no more than $p(n)+1$ cells. We are going to define a P system $\Pi$ that simulates the computation of $M$ in $O(p(n)|\Sigma|)$ steps. That is, the simulation of every step of $M$ will require a number of steps in $\Pi$ that is proportional to the size of the alphabet of $M$, thus providing an efficient simulation.

The P system $\Pi$ has $(p(n)+1)^{2}+p(n)^{2}+p(n)+1$ labels, one for the skin membrane and two for each pair of time and position in the TM tape:

[TABLE]

Since we assume that no kind of membrane division is present, in the following we can identify membranes with labels, since each label is used by exactly one membrane. The semantics of the labels is that a membrane with label $(i,j)$ will represent the $i$-th cell of the TM tape at time $j$. The additional membrane $(i,j)^{\prime}$ is used in performing the transition between time steps $j$ and $j+1$, which also explains why the label is not present for time $p(n)$.

The set of objects of the simulating P system will be:

[TABLE]

where $m=|\Sigma|$ and $q^{I}$ is the initial state of the TM. The first three sets of the union represent, respectively, the symbols on the tape, the states of the TM, and the states of the TM together with the symbol currently present under the tape head. The last two sets are only used to encode the initial configuration of the TM. The value of $k$ ranges from [math] to $m+5$ because each step of the TM will be simulated in $m+5$ time steps.

Let $a_{1},a_{2},\ldots,a_{p(n)}$ be the initial contents of the TM tape. It is encoded in the initial configuration of $\Pi$ as the objects $a_{1,1},a_{2,2},\ldots,a_{p(n),p(n)}$ inside the skin membrane. As an example, if the initial content of the tape is $abba$, then it will be encoded by the multiset $a_{1}b_{2}b_{3}a_{4}$. The initial state $q^{I}$ is encoded by the object $q^{I}$. The following rules send the objects representing the TM tape inside the corresponding membranes: the object $a_{i}$ is sent into the membrane $(i,0)$ and is rewritten as $a_{i,0,0}$. At the same time the object $q^{I}$ is rewritten as $q^{I}_{0,0,0}$:

[TABLE]

These rules will not be further applied during the simulation. After this first “bookkeeping” step the actual simulation of one TM step can start; see Fig. 1 for an example.

Let $\varphi$ be a bijection from $\Sigma$ to $\{1,\ldots,m\}$ providing a total ordering of the TM alphabet. The main idea is to have each object representing the symbol $a$ written on position $i$ at time $j$ on the TM tape dissolving the membrane $(i,j)$ when its subscript is $i,j,\varphi(a)$. This means that any other object present in the same membrane (in our case, the object representing the current state of the TM) can infer the symbol under the tape head and act accordingly. The evolution of the objects representing the tape content for the first $m+1$ time steps of each TM step simulation is described by the following rules:

[TABLE]

Notice how the objects simply “count” in the subscript, except that when $k=\varphi(a)$ the membrane in which they are contained is dissolved.

At the same time the object representing the TM state enters the membrane $(i,j)$, representing that the tape head at time $j$ is in position $i$ and starts to count. When membrane $(i,j)$ is dissolved it is possible to infer the object that dissolved it, and thus the symbol on the tape under the tape head, which is represented by $\varphi^{-1}(a)$ (which is well defined since $\varphi$ is a bijection between $\Sigma$ and $\{1,\ldots,m\}$. The corresponding rules are:

[TABLE]

At time step $m+1$ in the simulation of the current TM step, all membranes with label $(i,j)$ (for all $i$ and with $j$ the current TM step being simulated) have been dissolved. Now the object representing the TM state continues to wait in the skin membrane while all the objects representing the TM tape are sent in into the corresponding membranes $(i,j)^{\prime}$. These membranes will be employed to delete the current content of the cell under the TM head and to replace it with the new symbol. The rules applied at time step $m+1$ are the following ones:

[TABLE]

Ones all the objects of the form $a_{i,j,k}$ have entered the membranes $(i,j)^{\prime}$, they wait for the object representing the TM state to enter:

[TABLE]

At time step $m+3$ the membrane containing the object representing the TM state is dissolved. In all other membranes the objects representing the TM tape wait for one more step:

[TABLE]

One of the focal point of this simulation algorithm happens at time step $m+4$ (always relative to the start of the simulation of the current TM step). Here, all the objects representing the tape content dissolve the membrane $(i,j)^{\prime}$ in which they are in. The only object not performing this step is the one that was sent into the skin membrane by the dissolution triggered by the object representing the TM state. That object is deleted (by being rewritten into the empty multiset $\epsilon$) and the state object produces its replacement according to the transition function $\delta$ of the TM:

[TABLE]

Notice that the state object will be actually rewritten from $q$ to $r$ during the next time step. Finally, the simulation of the next TM step can start by sending in all the objects representing the TM tape to the membranes $(i,j+1)$ and resetting the last component of their subscript. At the same time the object representing the TM state actually applies the transition function $\delta$ and rewrites itself:

[TABLE]

Notice that all rules, labels, and objects can be constructed by a logarithmic space TM. In fact, most of them are constructed by iterating either a constant or a polynomial number of times to produce the necessary subscripts. Since the counters are all at most polynomial in the number that they contain, they can be encoded in a logarithmic number of bits.

We can thus state the main result:

Theorem 3.1

$({\mathsf{L}},{\mathsf{L}})$-uniform families of confluent shallow P systems with active membranes with dissolution and without division can solve all problems in ${\mathsf{P}}$.

The result was already known for non-shallow system [5] but here there are two main innovations: the systems here are shallow, i.e., of depth $1$, and the construction is via a direct simulation of a Turing machine, which allows one to embed this construction into more complex membrane structures.

Notice that the construction presented here can be modified to simulate a non-deterministic TM by replacing the only two types of rules involving the transition function of the TM in a way to allow for a non-deterministic choice (due to having multiple rules in conflict):

[TABLE]

In the first rule the non-deterministic choice is remembered by writing it in the subscript. In this way, the only rule of the second kind that can fire is the one corresponding to the non-deterministic choice performed. We can then state the following theorem showing that a weaker uniformity condition is still sufficient to solve all ${\mathsf{NP}}$ problems with non-confluent systems:

Theorem 3.2

$({\mathsf{L}},{\mathsf{L}})$-uniform families of non-confluent shallow P systems with active membranes with dissolution and without division can solve all problems in ${\mathsf{NP}}$.

4 Conclusions

In this paper we showed that P systems without charges can still solve any decision problem in the complexity class ${\mathsf{P}}$ even when the power of the Turing machines involved in the uniformity conditions is reduced. The TM simulation presented here is quite modular and can be embedded in more complex membrane structures. The resulting simulation is also efficient, requiring a slowdown of only a constant multiplicative factor.

However, some problems remain open, and the most prominent one is to study if the construction presented in [1] can be replicated for systems with charges, possibly adding an additional nesting level to accommodate for the different TM simulation technique. Such a result would show that even without charges the entire counting hierarchy can be computed in constant depth. This is another step in trying to understand what are the features that actually grant P systems the power to go beyond the complexity class ${\mathsf{P}}$ and, in some cases, beyond the entire polynomial hierarchy.