Advertisement

P systems with proteins: a new frontier when membrane division disappears

  • David Orellana-MartínEmail author
  • Luis Valencia-Cabrera
  • Agustín Riscos-Núñez
  • Mario J. Pérez-Jiménez
Regular Paper
  • 38 Downloads

Abstract

P systems with active membranes are usually defined as devices hierarchically structured that evolve through rewriting rules. These rules take the inspiration on the chemical reactions that happen within a cell and the role of both the inner and the plasma membranes as a “filter”, letting components pass or not. Classically, these systems are non-cooperative, that is, the left-hand side of the rules has at most one object. Using polarizations, dissolution or cooperation, these systems have been proved to have enough power to efficiently solve computationally hard problems, obtaining new complexity frontiers with respect to their non-cooperative counterparts. In this paper, division rules are interchanged by separation rules. While the first ones produce two new membranes and two new objects, duplicating the objects within the original one, separation rules distribute the objects of the original membrane into the two new created membranes, so no new objects are created in this way. To obtain new objects, a rule of the type \([ \, a \rightarrow a^{2} \, ]\) would be needed to accomplish that feature that seems to be necessary to obtain efficient solutions to NP-complete problems. Here, we present the limits when using separation rules instead of division rules.

Keywords

Membrane Computing Active membranes Proteins Computational complexity theory 

1 Introduction

Membrane Computing is a widely studied research field in which special types of devices, called membrane systems or P systems, are used to solve different kinds of problems. From formal languages results [19] to power systems fault diagnosis [20], passing through a broad variety of research fields, different variants of them have been developed depending on the nature of the problem.

Usually, two big classes of these devices are studied: P systems that take inspiration by the hierarchical structure of a single cell, called cell-like P systems [19], and the ones inspired by networks of cells that interchange “information” between them as in multicellular living beings, both as the transport of components in tissues with tissue-like P systems [14] and as interconnections between neurons in the brain [11].

Since the formal definition of recognizer P systems [22], computational complexity theory has been studied in the framework of Membrane Computing obtaining new frontiers between feasible and presumed efficient families of membrane systems, that is, families of membrane systems that can solve problems only from the class P and families of membrane systems that can solve NP-complete problems in an efficient way, respectively.

For instance, in the framework of P systems with active membranes without dissolution rules, the use of polarizations let membranes to “cooperate” in some way with objects within them. In [33], a solution to SAT is given by means of P systems with active membranes with division rules only for elementary membranes and without dissolution rules. It is demonstrated in [10] that by not using dissolutions, the power to solve efficiently NP-complete problems is removed.

Another way to obtain the feature of cooperation is using two or more objects in the left-hand side of the rule. Chemical reactions in living cells are usually produced by the reaction of two or more components, some of them only acting as mere assistants of the reaction, not changing through the process of it. Catalysts have been widely investigated in the framework of Membrane Computing, separating the working alphabet in two parts: “Normal” objects, that can evolve through the computation, and catalysts, that act as helpers for the firing of the rules of the system. Several results in universality have been found [3, 26, 27]. As catalysts do not change by the firing of a rule, proteins can be seen as a generalization of them, having the ability of changing while reacting with other chemical components to obtain new products. While using these components in [17, 24, 28], solutions to QBF-SAT, a well-known PSPACE problem, are given by these kinds of systems. Both the power of the proteins and division rules are used to create intricate tree structures and to let objects evolve.

Another way to create an exponential workspace in terms of membranes in polynomial time apart from division rules is by separation rules. Introduced in [15], they are fired in the same way of division rules, but instead creating two new objects and replicating the rest of them, objects present in the membrane are distributed in the two new created membranes. The restriction of these rules is that it creates an exponential workspace in terms of membranes in polynomial time, but not in terms of objects. The present work is devoted to study the results from [17, 24, 28], while interchanging division rules by separation rules, paying special attention to any possible new frontier of efficiency that can be created by means of these syntactical ingredients.

The paper is organized as follows: next section is devoted to introduce basic concepts which make the work self-contained. In the next section, we will introduce P systems with proteins on membranes. In Sect. 4, an answer to the problem stated in [25] is given. The paper is closed with some conclusions and defining future research lines.

2 Preliminaries

Here, we introduce some preliminary concepts that are going to be used through the work.

2.1 Alphabets and multisets

An alphabet\(\varGamma \) is a non-empty set and their elements are called symbols. A stringu over \(\varGamma \) is an ordered finite sequence of symbols, that is, a mapping from a natural number \(n \in \mathbb {N}\) onto \(\varGamma \). The number n is called the length of the string u and it is denoted by |u|. The empty string (with length zero) is denoted by \(\lambda \). The set of all strings over an alphabet \(\varGamma \) is denoted by \(\varGamma ^*\). A language over \(\varGamma \) is a subset of \(\varGamma ^*\).

A multiset over an alphabet \(\varGamma \) is an ordered pair \((\varGamma ,f)\) where f is a mapping from \(\varGamma \) onto the set of natural numbers \(\mathbb {N}\). The support of a multiset \(m=(\varGamma ,f)\) is defined as \(supp(m)=\{x\in \varGamma \,|\,f(x)> 0\}\). A multiset is finite (respectively, empty) if its support is a finite (respectively, empty) set. We denote by \(\emptyset \) the empty multiset. Let \(m_1=(\varGamma ,f_1)\), \(m_2=(\varGamma ,f_2)\) be multisets over \(\varGamma \), then the union of \(m_1\) and \(m_2\), denoted by \(m_1+ m_2\), is the multiset \((\varGamma ,g)\), where \(g(x)=f_1(x)+f_2(x)\) for each \(x\in \varGamma \). We denote by \(M_f(\varGamma )\) the set of all multisets over \(\varGamma \).

2.2 Graphs and trees

Let us recall some notions related with graph theory (see [7] for details). An undirected graph is an ordered pair (VE) where V is a set whose elements are called nodes or vertices and \(E=\{\{x,y\} \mid x \in V, y \in V, x \ne y \}\) whose elements are called edges. A path of length \(k \ge 1\) from a node u to a node v in a graph (VE) is a finite sequence \((x_0, x_1, \dots ,x_k)\) of nodes such that \(x_0=u\), \(x_k=v\) and \(\{x_i,x_{i+1}\} \in E\), for \(0 \le i \le k-1\). If \(k \ge 2\) and \(x_0=x_k\) then we say that the path is a cycle of the graph. A graph with no cycle is said to be acyclic. An undirected graph is connected if there exists a path between every pair of nodes.

A rooted tree is a connected, acyclic, undirected graph in which one of the vertices (called the root of the tree) is distinguished from the others. Given a node x (different from the root), if the last edge on the (unique) path from the root of the tree to the node x is \(\{x,y\}\) (in this case, \(x \ne y\)), then y is the parent of node x and x is a child of node y. The root is the only node in the tree with no parent. A node with no children is called a leaf.

3 P systems with proteins on membranes

First introduced in [17], proteins are used in P systems as “activators” of rules. As in living cells, where proteins regulate certain chemical reactions to occur [1], proteins are devoted to decide which rules are applicable in a specific step.

To give a precise explanation of the behavior of these systems, we define both their syntax and semantics, introducing separation rules to have an alternative to division rules to create an exponential workspace in linear time in terms of membranes. These rules have been widely used in other models of P systems, both cell like [31] and tissue like [15].

Definition 1

A P system with proteins on membranes and membrane division of degree \(q \ge 1\) is a tuple
$$\begin{aligned} \varPi = \,(\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, {{\mathcal {E}}}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{out}}), \end{aligned}$$
where
  • \(\varGamma \) and P are finite multisets with \(\varGamma \cap P = \emptyset \), and \(\mathcal{E} \subseteq \varGamma \setminus P\);

  • \(\{\varGamma _0, \varGamma _1\}\) is a partition of the set \(\varGamma \), where \(\varGamma _0 \cup \varGamma _1 = \varGamma \), \(\varGamma _0 \cap \varGamma _1 = \emptyset \) and \(\varGamma _0,\varGamma _1\) are non-empty sets if separation rules are used, \(\varGamma _0 = \varGamma _1 = \emptyset \) otherwise;

  • \(\{P_0, P_1\}\) is a partition of the set P, where \(P_0 \cup P_1 = P\), \(P_0 \cap P_1 = \emptyset \) and \(P_0, P_1\) are non-empty sets if separation rules are used, \(P_0 = P_1 = \emptyset \) otherwise;

  • \(\mu \) is a rooted tree;

  • \(\mathcal{M}_1, \dots , \mathcal{M}_q\) are multisets over \(\varGamma \);

  • \(\mathcal{Z}_1, \dots , \mathcal{Z}_q\) are multisets over P;

  • \(\mathcal{R}_1, \dots , \mathcal{R}_q\) are finite sets of rules associated with the nodes of the graph of the following forms:
    • (1) \([ \, p \, | \, a \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\) (in-membrane object evolution rules);

    • (2) \(a \, [ \, p \, | \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\) (out-membrane object evolution rules);

    • (3) \([ \, p \, | \, a \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\) (send-out communication rules);

    • (4) \(a \, [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\) (send-in communication rules);

    • (5) \(a \, [ \, p \, | \, b \, ]_i \rightarrow c \, [ \, p' \, | \, d \, ]_i, p, p' \in P, a, b, c, d \in \varGamma , 1 \le i \le q\) (antiport communication rules);

    • \((6_p)\)\(\ [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, ]_i [ \, p'' \, | \, ]_i, p, p', p'' \in P, 1 \le i \le q, i \ne i_{\mathrm{out}}\) (protein-based division rules)

    • \((6_o)\)\(\ [ \, | \, a \, ]_i \rightarrow [ \, | \, b\, ]_i [ \, | \, c \, ]_i, a, b, c \in \varGamma , 1 \le i \le q, i \ne i_{\mathrm{out}}\) (object-based division rules)

    • \((6'_p)\)\(\ [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, ]_i [ \, p'' \, | \, ]_i, p, p', p'' \in P, 1 \le i \le q, i \ne i_{\mathrm{out}}\) (protein-based division rules)

    • \((6'_o)\)\(\ [ \, | \, a \, ]_i \rightarrow [ \, | \, b\, ]_i [ \, | \, c \, ]_i, a, b, c \in \varGamma , 1 \le i \le q, i \ne i_{\mathrm{out}}\) (object-based division rules)

  • \(i_{\mathrm{out}} = 0\) is the output membrane.

A P system with proteins on membranes and membrane division (respectively, membrane separation) of degree \(q \ge 1,\)
$$\begin{aligned} \varPi = (\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{out}})~, \end{aligned}$$
1 can be viewed as a set of q membranes, labeled by \(1, \dots , q\) arranged in a hierarchical structure \(\mu \) given by a rooted tree whose root is called the skin membrane, such that: (1) \(\mathcal{M}_1, \dots , \mathcal{M}_q\) represent the multisets of objects initially placed in the q membranes of the system; (2) \(\mathcal{Z}_1, \dots , \mathcal{Z}_q\) represent the multisets of proteins initially placed in the q membranes of the system; (3) \(\mathcal{E}\) is the set of objects initially located in the environment of the system, all of them available in an arbitrary number of copies; and (4) \(i_{\mathrm{out}}\) represents a distinguished region which will encode the output of the system. We use the term regioni (\(0 \le i \le q\)) to refer to membrane i in the case \(1 \le i \le q\) and to refer to the environment in the case \(i = 0\).

It is worth pointing out that some restrictions can be added to these systems. In fact, a proposed restriction is to allow the change of protein within a rule, that is, the protein on the right-hand side of the rule can be different from the one of the left-hand side. On the one hand, if rules are restricted to have the same protein on both sides, for instance, \([ \, p \, | \, a \, ]_i \rightarrow [ \, p \, | \, b \, ]_i\), then we denote them by nres (from “restricted”), where n is the identifier of the rule. On the other hand, if proteins are allowed to change, we denote rules by ncp (from “change protein”).

A configuration at any instant of such kind of P system is described by the membrane structure of the system, the multisets of objects in each membrane, the multisets of proteins in each membrane and the multiset of objects over \(\varGamma \setminus \mathcal{E}\) in the environment at the moment. The initial configuration of \(\varPi ~=~(\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{out}})\) is \((\mu ,\mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q; \emptyset )\).

An in-membrane object evolution rule \([ \, p \, | \, a \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the object a and the protein p. By applying such rule, object a and protein p in region i from \(\mathcal{C}_t\) are consumed and object b and protein \(p'\) are generated in region i from \(\mathcal{C}_{t+1}\).

An out-membrane object evolution rule \(a \, [ \, p \, | \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region p(i) from \(\mathcal{C}_t\) which contains the object a and a region i from \(\mathcal{C}_t\) which contains the protein p. By applying such rule, object a in region p(i) and protein p in region i from \(\mathcal{C}_t\) are consumed and object b is generated in region p(i) and protein \(p'\) is generated in region i from \(\mathcal{C}_{t+1}\).

A send-out communication rule \([ \, p \, | \, a \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the object a and the protein p. By applying such rule, object a and protein p in region i from \(\mathcal{C}_t\) are consumed and object b is generated in region p(i) and protein \(p'\) is generated in region i from \(\mathcal{C}_{t+1}\).

A send-in communication rule \(a \, [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region p(i) from \(\mathcal{C}_t\) which contains the object a and a region i from \(\mathcal{C}_t\) which contains the protein p. By applying such rule, object a in region p(i) and protein p in region i from \(\mathcal{C}_t\) are consumed and object b and protein \(p'\) are generated in region i from \(\mathcal{C}_{t+1}\).

An antiport communication rule \(a \, [ \, p \, | \, b \, ]_i \rightarrow c \, [ \, p' \, | \, d \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region p(i) from \(\mathcal{C}_t\) which contains the object a and a region i from \(\mathcal{C}_t\) which contains the object b and the protein p. By applying such rule, object a in region p(i) and object b and protein p in region i from \(\mathcal{C}_t\) are consumed and object c is generated in region p(i) and object d and protein \(p'\) are generated in region i from \(\mathcal{C}_{t+1}\).

A protein-based division rule \([ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, ]_i [ \, p'' \, | \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the protein p. By applying such rule, protein p in region i from \(\mathcal{C}_t\) is consumed, two new membranes with label i are generated at configuration \(\mathcal{C}_{t+1}\) and objects and proteins from the original membrane are duplicated in both new membranes, except protein p that evolves in a protein \(p'\) that goes to one of the new membranes, and a protein \(p''\) that goes to the other one.

An object-based division rule \([ \, | \, a \, ]_i \rightarrow [ \, | \, b \, ]_i [ \, | \, c \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the object a. By applying such rule, object a in region i from \(\mathcal{C}_t\) is consumed, two new membranes with label i are generated at configuration \(\mathcal{C}_{t+1}\) and objects and proteins from the original membrane are duplicated in both new membranes, except object a that evolves in an object b that goes to one of the new membranes, and an object c that goes to the other one.

A protein-based separation rule \([ \, p \, | \, ]_i \rightarrow [ \, P_0 \, | \, \varGamma _0 \, ]_i [ \, P_1 \, | \, \varGamma _1 \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the protein p. By applying such rule, protein p in region i from \(\mathcal{C}_t\) is consumed, two new membranes with label i are generated at configuration \(\mathcal{C}_{t+1}\) and objects and proteins from the original membrane are distributed in both new membranes, proteins in \(P_0\) and objects in \(\varGamma _0\) go to one of the new membranes and proteins in \(P_1\) and objects in \(\varGamma _1\) go to the other one.

An object-based separation rule \([ \, | \, a \, ]_i \rightarrow [ \, P_0 \, | \, \varGamma _0 \, ]_i [ \, P_1 \, | \, \varGamma _1 \, ]_i \in \mathcal{R}_i\) is applicable at a configuration \(\mathcal{C}_t\) at an instant t if there is a region i from \(\mathcal{C}_t\) which contains the object a. By applying such rule, object a in region i from \(\mathcal{C}_t\) is consumed, two new membranes with label i are generated at configuration \(\mathcal{C}_{t+1}\) and objects and proteins from the original membrane are distributed in both new membranes, proteins in \(P_0\) and objects in \(\varGamma _0\) go to one of the new membranes and proteins in \(P_1\) and objects in \(\varGamma _1\) go to the other one.

It makes no sense in this kind of systems to define the length concept, because all the rules have a fixed amount of objects involved in them.

The rules of these systems are applied in a maximally parallel manner, and we have the restriction that when a membrane i is divided or separated at one transition step, then no other rules can be applied for that membrane i at that step.

A transition from a configuration \(\mathcal{C}_t\) to another configuration \(\mathcal{C}_{t+1}\) is obtained by applying rules in a maximally parallel manner following the previous remarks. A computation of the system is a (finite or infinite) sequence of transitions starting from the initial configuration, where any term of the sequence other than the first, is obtained from the previous configuration in one transition step, and it is denoted by \(\mathcal{C}_t \Rightarrow _\varPi \mathcal{C}_{t+1}\). If the sequence is finite (called halting computation) then the last term of the sequence is a halting configuration, that is, a configuration where no rule is applicable to it. A computation gives a result only when an halting configuration is reached, and that result is encoded by the multiset of objects present in the output region \(i_{\mathrm{out}}\). A natural framework to solve decision problems is to use recognizer P systems.

Definition 2

A recognizer P system with proteins on membranes and membrane division/separation of degree \(q \ge 1\) is a tuple
$$\begin{aligned} \varPi \,=\, (\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \varSigma , \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{in}}, i_{\mathrm{out}}) \end{aligned}$$
where:
  • the tuple \(\varPi = (\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{out}})\) is a P system with proteins on membranes and membrane division/separation of degree \(q \ge 1\), where \(\varGamma \) strictly contains an (input) alphabet \(\varSigma \) and two distinguished objects yes and no, and \(\mathcal{M}_i\) (\(1 \le i \le q\)) are multisets over \(\varGamma \setminus \varSigma \);

  • \(i_{\mathrm{in}} \in \{1, \dots , q\}\) is the input membrane and \(i_{\mathrm{out}}\) is the label of the environment;

  • for each multiset m over the input alphabet \(\varSigma \), any computation of the system \(\varPi \) with input m starts from the configuration \((\mathcal{M}_1, \dots , \mathcal{M}_{i_{\mathrm{in}}} + m, \dots , \mathcal{M}_q; \emptyset )\), always halts and either object yes or object no (but not both) must appear in the environment at the last step.

Next, we define the concept of solving a problem in a uniform way and in polynomial time by a family of recognizer P systems with proteins on membranes and membrane division/separation.

Definition 3

A decision problem \(X = (I_X, \theta _X)\) is solvable in a uniform way and in polynomial time by a family \(\mathbf{\varPi } = \{\varPi (n) | n \in \mathbb {N}\}\) of recognizer P systems with proteins on membranes and membrane division/separation. if the following conditions hold:
  • the family \(\mathbf{\varPi }\) is polynomially uniform by Turing machines;

  • there exists a polynomial encoding (cods) of \(I_X\) such that: (1) for each instance \(u \in I_X\), s(u) is a natural number and cod(u) is an input multiset of the system \(\varPi (s(u))\); (2) for each \(n \in \mathbb {N}\), \(s^{-1}(n)\) is a finite set; and (3) the family \(\mathbf{\varPi }\) is polynomially bounded, sound and complete with regard to (Xcods).

4 Upper bound of P systems with proteins and separation rules

In [25], an open problem in this framework is given:

Open Problem 5: What is the computational power of families of these P systems without membrane division? Do they characterize the class P , and what happens under various restrictions on the form of the rules?

In this work, we are going to demonstrate not only that it characterizes the class P, but also that the answer stands even while using separation rules as a method to create an exponential workspace in linear time. The “mode” the rules we are going to use is allowing protein change.

4.1 Representation of P systems with proteins on membranes and membrane separation

Let \(\varPi = (\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \varSigma , \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q, \mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{in}}, i_{\mathrm{out}})\) be a recognizer P system with proteins on membranes and membrane separation. We denote by \(\mathcal{R}_E\) (resp., \(\mathcal{R}_S\)) the set of evolution and communication rules (resp., separation rules) of \(\varPi \). We will fix a total order in \(\mathcal{R}_E\) and a total order in \(\mathcal{R}_S\). Because several membranes with the same label are generated by separation rules, to identify the different membranes with the same label, the following recursive definition is used to modify the labels of the new generated membranes:
  • We denote the label of a membrane as a pair \((i, \sigma )\), where \(1 \le i \le q\) and \(\sigma \in \{0, 1\}^*\) is a binary string.

  • If a separation rule is applied to a membrane with label \((i, \sigma )\), then the new created membranes will be labeled by \((i, \sigma 0)\) and \((i, \sigma 1)\), respectively. We mention that for the system during any computation, we consider a lexicographical order over the set of labels of membranes.

Neither evolution nor communication rules between membranes make the labels of membranes change.
A configuration at an instant t of such kind of P system is described by the multisets of objects over \(\varGamma \) contained in each membrane and the multiset of objects over \(\varGamma \setminus \mathcal{E}\) in the environment. Hence, a configuration of \(\varPi \) can be described as follows:
$$\begin{aligned} \{(a,i,\sigma ) \mid a \in \varGamma \cup \{\lambda \}, 1 \le i \le q, \sigma \in \{0,1\}^*\} \cup \{(a,0) \mid a \in \varGamma \setminus \mathcal{E}\} \end{aligned}$$
We use LHS and RHS to refer to the left-hand side and the right-hand side of a rule. They are defined in a natural way according to the definition of a rule:
  • \([ \, p \, | \, a \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i\), with \(p, p' \in P\) and \(a, b \in \varGamma \). Then, we denote by \(n \cdot LHS(r, (i, \sigma _i)) = (p, i, \sigma _i)^n (a, i, \sigma _i)^n\), and by \(n \cdot RHS(r, (i, \sigma _i)) = (p', i, \sigma _i)^n (b, i, \sigma _i)^n\).

  • \(r \equiv a \, [ \, p \, | \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i\), with \(p, p' \in P\) and \(a, b \in \varGamma \). Then, we denote by \(n \cdot LHS(r, (i, \sigma _i)) = (p, i, \sigma _i)^n (a, j, \sigma _j)^n\), and by \(n \cdot RHS(r, (i, \sigma _i)) = (p', i, \sigma _i)^n (b, j, \sigma _j)^n\), being \((j, \sigma _j)\) the parent membrane of the membrane \((i, \sigma _i)\).

  • \(r \equiv [ \, p \, | \, a \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i\), with \(p, p' \in P\) and \(a, b \in \varGamma \). Then, we denote by \(n \cdot LHS(r, (i, \sigma _i)) = (p, i, \sigma _i)^n (a, i, \sigma _i)^n\), and by \(n \cdot RHS(r, (i, \sigma _i)) = (p', i, \sigma _i)^n (b, j, \sigma _j)^n\), being \((j, \sigma _j)\) the parent membrane of the membrane \((i, \sigma _i)\).

  • \(r \equiv a \, [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i\), with \(p, p' \in P\) and \(a, b \in \varGamma \). Then, we denote by \(n \cdot LHS(r, (i, \sigma _i)) = (p, i, \sigma _i)^n (a, j, \sigma _j)^n\), and by \(n \cdot RHS(r, (i, \sigma _i)) = (p', i, \sigma _i)^n (b, i, \sigma _i)^n\), being \((j, \sigma _j)\) the parent membrane of the membrane \((i, \sigma _i)\).

  • \(r \equiv a \, [ \, p \, | \, b \, ]_i \rightarrow c \, [ \, p' \, | \, d \, ]_i \in \mathcal{R}_i\), with \(p, p' \in P\) and \(a, b, c, d \in \varGamma \). Then, we denote by \(n \cdot LHS(r, (i, \sigma _i)) = (p, i, \sigma _i)^n (a, j, \sigma _j)^n (b, i, \sigma _i)^n\), and by \(n \cdot RHS(r, (i, \sigma _i)) = (p', i, \sigma _i)^n (c, j, \sigma _j)^n (d, i, \sigma _i)^n\), being \((j, \sigma _j)\) the parent membrane of the membrane \((i, \sigma _i)\).

  • \(r \equiv [ \, p \, | \, ]_i \rightarrow [ \, P_0 \, | \, \varGamma _0 \, ]_i [ \, P_1 \, | \, \varGamma _1 \, ]_i \in \mathcal{R}_i\), with \(p \in P\). Then, we denote by \(LHS(r,(i,\sigma _i)) = (p,i,\sigma _i)\).

  • \(r \equiv [ \, | \, a \, ]_i \rightarrow [ \, P_0 \, | \, \varGamma _0 \, ]_i [ \, P_1 \, | \, \varGamma _1 \, ]_i \in \mathcal{R}_i\), with \(a \in \varGamma \). Then, we denote by \(LHS(r,(i,\sigma _i)) = (a,i,\sigma _i)\).

If \(\mathcal{C}_t\) is a configuration of \(\varPi \), then the multiset obtained by replacing in \(\mathcal{C}_t\) every occurrence of \((x, i, \sigma )\) by \((x, i, \sigma ')\) is denoted by \(\mathcal{C}_t + \{(x, i, \sigma ) / \sigma '\}\). Moreover, we denote by \(\mathcal{C}_t + m\) (respectively, \(\mathcal{C}_t \setminus m\)) a multiset m of labelled objects addition to (resp., removal from) the configuration \(\mathcal{C}_t\).

Next, we show that P systems with proteins on membranes and membrane separation can only solve tractable problems.

If \(\mathcal{C} = (\mathcal{C}_0, \mathcal{C}_1, \dots , \mathcal{C}_n)\) is a halting computation, then we denote by \(|\mathcal{C}| = n+1\) the length of \(\mathcal{C}\). For each i (\(1 \le i \le q\)), the multiset of objects over \(\varGamma \) contained in all membranes labelled by i at configuration \(\mathcal{C}_t\) is denoted by \(\mathcal{C}_{t,o}(i)\), and the multiset of proteins over P contained in all membranes labelled by i at configuration \(\mathcal{C}_t\) by \(\mathcal{C}_{t,p}(i)\). We denote by \(\mathcal{C}_t(0)\) the multiset of objects over \(\varGamma \setminus \mathcal{E}\) contained in the environment at configuration \(\mathcal{C}_t\). We define in a natural way \(\mathcal{C}^*_{t,o} = \mathcal{C}_t(0) + \mathcal{C}_{t,o}(1) + \dots + \mathcal{C}_{t,o}(q)\) and \(\mathcal{C}^*_{t,p} = \mathcal{C}_{t,p}(1) + \dots + \mathcal{C}_{t,p}(q)\). Finally, the finite multiset \(\mathcal{C}_t(0) + \mathcal{C}_{t,o}(1) + \mathcal{C}_{t,p}(1) + \dots + \mathcal{C}_{t,o}(q) + \mathcal{C}_{t,p}(q) = \mathcal{C}^*_{t,o} + \mathcal{C}^*_{t,p}\) is denoted by \(\mathcal{C}^*_t\).

Lemma 1

Let \(\varPi \) be a recognizer P system with proteins on membranes and membrane separation. Let \(M = |\mathcal{M}_1 + \dots + \mathcal{M}_q|\), \(Z = |\mathcal{Z}_1 + \dots + \mathcal{Z}_q|\) and let \(\mathcal{C} = (\mathcal{C}_0, \dots , \mathcal{C}_n)\) be a computation of \(\varPi \). Then, we have
  1. 1.

    \(|\mathcal{C}^*_0| = M + Z = S\), and for each t, \(0 \le t \le n-1\), \(|\mathcal{C}^*_{t+1}| \le |\mathcal{C}^*_t| + Z\);

     
  2. 2.

    for each t, \(0 \le t \le n\), \(|\mathcal{C}^*_t| \le S + t \cdot Z\); and

     
  3. 3.

    the number of created membranes along the computation \(\mathcal{C}\) by the application of membrane separation rules is bounded by \(2M+(2+2n)Z\).

     

Proof

  1. (1)
    Let us notice that \(|\mathcal{C}^*_0| = |\mathcal{C}_0(0) + \mathcal{C}_0(1) + \dots + \mathcal{C}_0(q)| = |\mathcal{M}_1 + \dots + \mathcal{M}_q| + |\mathcal{Z}_1 + \dots + \mathcal{Z}_q| = M + Z = S\). Let \(\varPi \) be a recognizer P system with proteins on membranes and membrane separation, \(\mathcal{R}_1, \dots , \mathcal{R}_q\) be the sets of rules associated with \(\varPi \), which contains the following types of communication rules:
    • \([ \, p \, | \, a \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\).

    • \(a \, [ \, p \, | \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\).

    • \([ \, p \, | \, a \, ]_i \rightarrow b \, [ \, p' \, | \, ]_i \in \mathcal{R}_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\).

    • \(a \, [ \, p \, | \, ]_i \rightarrow [ \, p' \, | \, b \, ]_i \in \mathcal{R}_i, p, p' \in P, a, b \in \varGamma , 1 \le i \le q\).

    • \(a \, [ \, p \, | \, b \, ]_i \rightarrow c \, [ \, p' \, | \, d \, ]_i \in \mathcal{R}_i, p, p' \in P, a, b, c, d \in \varGamma , 1 \le i \le q\).

    For each t, \(0 \le t \le n-1\), in the transition from configuration \(\mathcal{C}_t\) to configuration \(\mathcal{C}_{t+1}\), by using any rule, at least one object and one protein from \(\mathcal{C}_t\) is consumed and at most one object and one protein is produced in \(\mathcal{C}_{t+1}\). Let us note that by the out-membrane object evolution rules, send-in communication rules and antiport communication rules, if \(i = i_{skin}\), then p must be different from \(p'\). In other case, a computation would not halt. If \(a \in \mathcal{E}\), then a new object is created in the system. So the number of objects created in a single computation step is bounded by Z, that is, the number of proteins present in the system in configuration \(\mathcal{C}_t\), taking into account that the number of proteins in each cell does not increase throughout the computation. By means of separation rules, neither new objects nor proteins are going to appear. Hence, in any transition step, the number of objects in the system is increased at most in Z new objects.
     
  2. (2)

    By induction on t. Let us start analyzing the basic case \(t = 0\). The result is trivial because of \(|\mathcal{C}^*_0| = S\). By induction hypothesis, let us suppose the result holds for t, \(0 \le t \le n-1\). Then \(|\mathcal{C}^*_{t+1}| \le |\mathcal{C}^*_t| + Z\), that is true because of (1), and by induction hypothesis we know that \(|\mathcal{C}^*_t| \le S + t \cdot Z\), so \(|\mathcal{C}^*_{t+1}| \le | \mathcal{C}^*_t | + Z \le S + t \cdot Z + Z = S + (t+1) \cdot Z\). Hence, the result holds for \(t+1\).

     
  3. (3)

    According to the fact that the application of a separation rule consumes an object and produces two new membranes, result (3) can be obtained from (2) easily, since the maximum number of separation rules that can be performed in this kind of systems comes defined by the initial multisets of elements. If new objects are created as explained in (2), then at most \(n \cdot Z\) new objects can be created in n computation steps, therefore at most \(n \cdot Z\) separation rules can be applied by means of these objects. Therefore, if each of the initial \(M + Z\) objects and these \(n \cdot Z\) objects fire a separation rules, then the number of membranes created by means of them is \(2 \cdot ((M + Z) + (n \cdot Z)) = 2M + (2 + 2n) \cdot Z\).

     
\(\square \)
Next, a deterministic algorithm \(\mathcal{A}\) working in polynomial time is presented. The algorithm receives as input a P system with proteins on membranes and membrane separation \(\varPi \) and an input multiset m of \(\varPi \), in such manner that algorithm \(\mathcal{A}\) reproduces the behavior of a computation of \(\varPi + m\). If the system \(\varPi \) is confluent, then the algorithm \(\mathcal{A}\) will provide the same answer as \(\varPi \). We give the following pseudocode of the algorithm \(\mathcal{A}\) to describe the simulation process:

The algorithm \(\mathcal{A}\) receives a recognizer P system with proteins on membranes and membrane separation of degree q with “cp” rules \(\varPi = (\varGamma , \varGamma _0, \varGamma _1, P, P_0, P_1, \mathcal{E}, \mu , \mathcal{M}_1/\mathcal{Z}_1, \dots , \mathcal{M}_q/\mathcal{Z}_q,\mathcal{R}_1, \dots , \mathcal{R}_q, i_{\mathrm{out}})\), being m an input multiset for this system. Let \(M = |\mathcal{M}_1 + \dots + \mathcal{M}_q|\), \(Z = |\mathcal{Z}_1 + \dots \mathcal{Z}_q|\) and \(S = M + Z\). Let any computation of \(\varPi \) perform at most n transition steps, \(n \in \mathbb {N}^+\). Hence, from Lemma 1, the number of membranes in the system along any computation is bounded by \(2M+(2+2n)Z\).

A transition of a recognizer P system \(\varPi + m\) is performed in two phases: selection phase and execution phase.
It is easy to check that this algorithm is deterministic and the running time of this algorithm is polynomial in the size of \(\varPi \) because the number of cycles of the first main loop for is of the order \(O(|\mathcal{R}| \cdot (M + Z))\); and the number of cycles of the second main loop for is of the order \(O(|\mathcal{R}| \cdot (M + Z) \cdot (|\varGamma | + |P|))\).

This algorithm is deterministic and the running time of this algorithm is polynomial in the size of \(\varPi \) because the number of cycles of the first main loop for is of the order \(O(|\mathcal{R}| \cdot (M + Z))\); and the number of cycles of the second main loop for is of the order \(O(|\mathcal{R}| \cdot (M + Z) \cdot (|\varGamma |^2 + |P|^2))\).

Theorem 1

Only problems from class P can be solved efficiently by P systems with proteins on membranes and membrane separation.

Proof

Because the complexity class of recognizer P systems with proteins on membranes and membrane separation is closed under polynomial time reduction and non-empty, P is a subset of this class. In what follows, we show the reverse inclusion. Let X a decision problem that can be solved efficiently by recognizer P systems with proteins on membranes and membrane separation and let \(\mathbf{\varPi } = \{\varPi (n) \mid n \in \mathbb {N}\}\) be a family of these kinds of P systems solving X according to Definition 3. Let (cods) be a polynomial encoding associated with that solution. If \(u \in I_X\) is an instance of the problem X, then u will be processed by the system \(\varPi (s(u)) + cod(u)\). We consider the following deterministic algorithm \(\mathcal{A}'\):
The algorithm \(\mathcal{A}'\) receives an instance u of the decision problem \(X = (I_X, \theta _X)\), and working in a polynomial time. The following three assertions are equivalent:
  • \(\theta _X = 1\), that is, the answer of problem X to instance u is affirmative.

  • Every computation of \(\varPi (s(u)) + cod(u)\) is an accepting computation.

  • The output of the algorithm \(\mathcal{A}'\) with input u is yes.

Hence, \(X \in \mathbf{P}\). \(\square \)

5 Conclusions and future work

In this work, P systems with proteins on membranes and separation rules have been studied. In [17, 24, 28], efficient solutions to QBF-SAT are described using division rules as a method to obtain an exponential workspace in terms of membranes. As usual, compare them to separation rules makes the latter seem weaker from a computational complexity point of view. Several results in other frameworks comparing division rules and separation rules lead one to believe that not only an exponential workspace in terms of membranes is sufficient, but also that it has to go along with exponential workspace in terms of objects to solve computationally hard problems efficiently [13, 29, 30, 32].

Some interesting research lines are given by the open problems stated in [25], such as the role of the ability to change the proteins in a rule while using division rules, or allowing division only for elementary membranes, as well as in another publications [12, 18].

An important result would be the demonstration of the force of separation rules compared with division rules, that is, if separation rules are not stronger than division rules in any case.

Footnotes

  1. 1.

    Let us note that \(\varGamma _0\), \(\varGamma _1\), \(P_0\) and \(P_1\) are usually omitted when separation rules are not used.

Notes

Acknowledgements

This work is supported by the research project TIN2017-89842-P, cofinanced by Ministerio de Economía, Industria y Competitividad (MINECO) of Spain, through the Agencia Estatal de Investigación (AEI), and by Fondo Europeo de Desarrollo Regional (FEDER) of the European Union. The authors also acknowledge the Grants No 61320106005 of the National Natural Science Foundation of China.

References

  1. 1.
    Alberts B, Johnson A, Lewis J, Raff M, Roberts K, Walter P. Molecular biology of the cell. 4th ed. New York: Garland Science; 2002.Google Scholar
  2. 2.
    Alhazov A, Freund R, Ivanov S. Extended spiking neural P systems with states. In: Graciani C, Orellana-Martín D, Riscos-Núñez A, Romero-Jiménez Á, Valencia-Cabrera L, editors. Proceedings of the fourteenth brainstorming week on membrane computing, Seville , 2016. p. 43–58. Report RGNC 01/2016, Fénix Editora, 2016.Google Scholar
  3. 3.
    Alhazov A, Freund R. Variants of small universal P systems with catalysts. Fundam Inform. 2015;138(1–2):227–50.MathSciNetzbMATHGoogle Scholar
  4. 4.
    Bahi JM, Bienia W, Côté N, Guyeux C. Is protein folding problem really a NP-complete one? First investigations, (2013). arXiv:1306.1372.
  5. 5.
    Brijder R, Cavaliere M, Riscos-Núñez A, Rozenberg G, Sburlan D. Membrane systems with proteins embedded in membranes. Theor Comput Sci. 2008;404(1–2):26–39.MathSciNetCrossRefzbMATHGoogle Scholar
  6. 6.
    Cardona M, Colomer MA, Pérez-Jiménez MJ, Sanuy D,Margalida A. Modeling ecosystems using P systems: The bearded vulture, a case study. Membrane Computing, 9th International Workshop, WMC 2008, Edinburgh, UK, July 28-31, 2008, Revised Selected and Invited Papers. Lecture Notes in Computer Science, 2008;5391(2009):137–56.Google Scholar
  7. 7.
    Cormen TH, Leiserson CE, Rivest RL. An introduction to algorithms. Cambridge: The MIT Press; 1994.Google Scholar
  8. 8.
    Frisco P, Gheorghe M, Pérez-Jiménez MJ. Applications of Membrane Computing in Systems and Synthetic Biology. Emergence, Complexity and Computation (Series ISSN 2194-7287), Volume 7. Springer International Publishing, eBook ISBN: 978-3-319-03191-0, Hardcover ISBN: 978-3-319-03190-3, 2014, XVII + 266 pages ( https://doi.org/10.1007/978-3-319-03191-0).
  9. 9.
    Gutiérrez-Naranjo MÁ, Pérez-Jiménez MJ, Riscos-Núñez A, Romero-Campero FJ. Characterizing tractability by cell-like membrane systems. In: Subramanian KG, Rangarajan K, Mukund M, editors. Formal models, languages and applications, World Scientific, Series in Machine Perception and Artificial Intelligence 66, chapter 9; Singapore: 2006. p. 137-154.Google Scholar
  10. 10.
    Gutiérrez-Naranjo MÁ, Pérez-Jiménez MJ, Riscos-Núñez A, Romero-Campero FJ. On the power of dissolution in P systems with active membranes. In: Freund R, Păun Gh, Rozenberg Gr, Salomaa A, editors. Membrane computing. Vienna: 6th International Workshop, WMC 2005; 2005 Revised Selected and Invited Papers. Lecture Notes in Computer Science, 3850, 224-240; 2006.Google Scholar
  11. 11.
    Ionescu M, Păun Gh, Yokomori T. Spiking beural P systems. Fundam inform. 2006;71(2–3):279–308.zbMATHGoogle Scholar
  12. 12.
    Leporati A, Manzoni L, Mauri G, Porreca AE, Zandron C. Open problems in membrane computing and how not to solve them. Bull Int Membr Comput Soc. 2018;5:69–76.zbMATHGoogle Scholar
  13. 13.
    Macías-Ramos LF, Song B, Valencia-Cabrera L, Pan L, Pérez-Jiménez MJ. Membrane fission: a computational complexity perspective. Complexity. 2016;21(6):321–34.MathSciNetCrossRefGoogle Scholar
  14. 14.
    Martín-Vide C, Păun Gh, Pazos J, Rodríguez-Patón A. Tissue P systems. Theor Comput Sci. 2003;296(2):295–326.MathSciNetCrossRefzbMATHGoogle Scholar
  15. 15.
    Pan L, Ishdorj T-O. P systems with active membranes and separation rules. J Univ Comput Sci. 2004;10(5):630–49.MathSciNetGoogle Scholar
  16. 16.
    Pan L, Păun Gh, Pérez-Jiménez MJ, Song T. Bio-inspired Computing: Theories and Applications. Communications in Computer and Information Science (Series ISSN 1865-0929), Volume 472, Springer-Verlag Berlin Heidelberg, Print ISBN: 978-3-662-45048-2, Online ISBN: 978-3-662-45049-9, 2014, p. XX + 672 ( https://doi.org/10.1007/978-3-662-45049-9).
  17. 17.
    Păun A, Popa B. P systems with proteins on membranes and membrane division. Developments in language theory, DLT, lecture notes in computer science, vol. 4036. Berlin, Heidelberg: Springer; 2006. p. 292–303.zbMATHGoogle Scholar
  18. 18.
    Păun Gh. A Dozen of (Meta/Mega?) research topics. Bull Int Membr Comput Soc. 2017;4:107–12.Google Scholar
  19. 19.
    Păun Gh. Computing with membranes. J Comput Syst Sci. 2000;61(1):108–43 and Turku Center for CS-TUCS Report No. 208, 1998.MathSciNetCrossRefzbMATHGoogle Scholar
  20. 20.
    Peng H, Wang J, Ming J, Shi P, Pérez-Jiménez MJ, Yu W, Tao Ch. Fault diagnosis of power systems using intuitionistic fuzzy spiking neural P systems. IEEE transactions on smart grid. 2017;9(5):4777–84.  https://doi.org/10.1109/TSG.2017.2670602 (in press).CrossRefGoogle Scholar
  21. 21.
    Pérez-Jiménez MJ, Riscos-Núñez A, Romero-Jiménez Á, Woods D. Complexity: Membrane division, membrane creation. In: Păun Gh, Rozenberg G, A. Salomaa, editors. The Oxford handbook of membrane computing, vol. 12. Oxford: Oxford University Press; 2009. p. 302–36.Google Scholar
  22. 22.
    Pérez-Jiménez MJ, Romero-Jiménez Á, Sancho-Caparrini F. Complexity classes in models of cellular computing with membranes. Nat Comput. 2003;2(3):265–85.  https://doi.org/10.1023/A:1025449224520.MathSciNetCrossRefzbMATHGoogle Scholar
  23. 23.
    Romero-Campero FJ, Pérez-Jiménez MJ. A model of the quorum sensing system in vibrio Fischeri using P systems. Artif Life. 2008;14(1):95–109.  https://doi.org/10.1162/artl.2008.14.1.95.CrossRefGoogle Scholar
  24. 24.
    Song B, Pérez-Jiménez MJ, Pan L. An efficient time-free solution to QSAT problem using P systems with proteins on membranes. Inform Comput. 2017;256:287–99.MathSciNetCrossRefzbMATHGoogle Scholar
  25. 25.
    Sosík P. Attacking hard problems beyond NP: a survey. Bull Intern Membr Comput Soc. 2017;4:89–106.Google Scholar
  26. 26.
    Sosík P. The power of catalysts and priorities in membrane systems. Grammars. 2003;6(1):13–24.MathSciNetCrossRefzbMATHGoogle Scholar
  27. 27.
    Sosík P, Freund R. P Systems without priorities are computationally universal. In Gh. Păun, Gr. Rozenberg, A. Salomaa, C. Zandron editors. Membrane Computing. Internat. Workshop, WMC-CdeA 2002, Curteă de Argeș, Romania, August 2002, Lecture Notes in Computer Science, 2597, Springer, Berlin, 2003. p. 400–409.Google Scholar
  28. 28.
    Sosík P, Păun A, Rodríguez-Patón A. P systems with proteins on membranes characterize PSPACE. Theor Comput Sci. 2013;488:78–95.MathSciNetCrossRefzbMATHGoogle Scholar
  29. 29.
    Valencia-Cabrera L, Orellana-Martín D, Riscos-Núñez A, Pérez-Jiménez MJ. Minimal cooperation in polarizationless P systems with active membranes. In C. Graciani, Gh. Păun, D. Orellana-Martín, A. Riscos-Núñez, L. Valencia-Cabrera (eds.) Proceedings of the Fourteenth Brainstorming Week on Membrane Computing, 1-5 February, Sevilla, Spain, 2016. p. 327-356.Google Scholar
  30. 30.
    Valencia-Cabrera L, Orellana-Martín D, Martínez-del-Amor MÁ, Pérez-Jiménez MJ, Riscos-Núñez A. Polarizationless P systems with active membranes: computational complexity aspects. J Autom Lang Comb. 2016;21(1–2):107–23.MathSciNetzbMATHGoogle Scholar
  31. 31.
    Valencia-Cabrera L, Song B, Macías-Ramos LF, Pan L, Riscos-Núñez A, Pérez-Jiménez MJ. Computational Efficiency of P Systems with Symport/Antiport Rules and Membrane Separation. Proceedings of the Thirteenth Brainstorming Week on Membrane Computing, Seville, 2015. Report RGNC 01/2015, Fénix Editora; 2015. p. 325–370.Google Scholar
  32. 32.
    Valencia-Cabrera L, Song B, Macías-Ramos LF, Pan L, Riscos-Núñez A, Pérez-Jiménez MJ. Minimal cooperation in P systems with symport/antiport: A complexity approach. In: Macías LF, Păun Gh, Riscos A, Valencia L, editors. Proceedings of the thirteenth brainstorming week on membrane computing. Sevilla: Fénix Editora; 2015.Google Scholar
  33. 33.
    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. London: Springer; 2001. p. 289–301.CrossRefGoogle Scholar
  34. 34.
    G. Zhang, M.J. Pérez-Jiménez, M. Gheorghe. Real-life applications with Membrane Computing. Emergence, Complexity and Computation (Series ISSN 2194-7287), Volume 25. Springer International Publishing, Online ISBN: 978-3-319-55989-6, Print ISBN: 978-3-319-55987-2, 2017, p. X + 367 ( https://doi.org/10.1007/978-3-319-55989-6).

Copyright information

© Springer Nature Singapore Pte Ltd. 2019

Authors and Affiliations

  • David Orellana-Martín
    • 1
    Email author
  • Luis Valencia-Cabrera
    • 1
  • Agustín Riscos-Núñez
    • 1
  • Mario J. Pérez-Jiménez
    • 1
  1. 1.Research Group on Natural Computing, Department of Computer Science and Artificial IntelligenceUniversidad de SevillaSevillaSpain

Personalised recommendations