#### Abstract

*Presumably efficient* computing models are characterized by their capability to provide polynomial-time solutions for **NP**-complete problems. Given a class of recognizer membrane systems, denotes the set of decision problems solvable by families from in polynomial time and in a uniform way. is closed under complement and under polynomial-time reduction. Therefore, if is a presumably efficient computing model of recognizer membrane systems, then **co**-**NP** . In this paper, the lower bound **co**-**NP** for the time complexity class is improved for any presumably efficient computing model of recognizer membrane systems verifying some simple requirements. Specifically, it is shown that **co**-**DP** is a lower bound for such , where **DP** is the class of differences of any two languages in **NP**. Since **co**-**NP** **co**-**DP**, this lower bound for delimits a thinner frontier than that with **co**-**NP**.

#### 1. Introduction

Membrane Computing is a computing paradigm inspired by some basic biological features. Specifically, it is inspired by the structure and functioning of the living cells, as well as from the cooperation of cells in tissues, organs, and organisms. This paradigm provides distributed, parallel nondeterministic computing models whose computational devices are generically called *membrane systems* or *P systems* and has processing units called *compartments*. In this framework, there basically exist two ways to consider computational devices: cell-like membrane systems and tissue-like membrane systems. The former uses the biological membranes arranged hierarchically as compartments, inspired by the structure of the cell. The latter takes as compartments the cells placed in the nodes of a directed graph, which is inspired by the cell intercommunication in tissues.

*Recognizer membrane systems* were introduced in [1], in order to provide a natural framework in Membrane Computing, aiming to solve decision problems by means of language recognition. A recognizer membrane system has the following additional syntactic and semantic peculiarities: (a) the working alphabet has two distinguished objects (yes and no); (b) there exist an input compartment, and there is also an input alphabet strictly contained in the working alphabet; (c) the initial content of each compartment is a multiset of objects from the working alphabet not belonging to the input alphabet; (d) all computations halt; and (e) for each computation and only at its last step, either object yes or object no (but not both) must have been released to the environment. Recognizer membrane systems can only have accepting or rejecting computations, depending on whether they return yes or no to the environment, respectively.

On this basis, given a recognizer membrane system , for each multiset over the input alphabet, we denote by the membrane system obtained from by adding the multiset to the content of the input membrane at the initial configuration. Unlike a Turing machine, all the elements that make up a recognizer membrane system have a finite description. Therefore, while a decision problem (with infinite instances) can be solved by a single Turing machine, an infinite family of recognizer membrane systems is necessary to solve it. We say that a family of recognizer membrane systems solves a decision problem in polynomial time in a uniform way if such family can be generated by a deterministic Turing machine working in polynomial time, and there exists a pair of polynomial-time computable functions over the set of instances of verifying the following: (a) for each instance , is a natural number and is an input multiset of the system ; (b) for each , the set is a finite set; and (c) the family is *polynomially bounded*, *sound*, and *complete* with regard to . The pair is called a *polynomial encoding* from the decision problem to the family . For more details, see [2]. Given a computing model of recognizer membrane systems, denotes the set of decision problems solvable by families from in polynomial time in a uniform way. The class is closed under complement and under polynomial-time reduction [2].

A computing model is said to be *efficient* (respectively, *presumably efficient*) if it has the ability to provide polynomial-time solutions for intractable problems (resp., **NP**-complete problems) [3]. The term *presumably efficient* refers to the fact that, as generally believed, if **P** **NP** then each **NP**-complete problem is intractable and, consequently, any presumably efficient model would be efficient. The computing model of recognizer P systems with active membranes and electrical charges is presumably efficient [4], as well as the computing model of recognizer polarizationless P systems with active membranes which makes use of dissolution rules and division for elementary and nonelementary membranes [5]. However, the computing model of recognizer polarizationless P systems with active membranes not making use of dissolution rules is not efficient, even when allowing division rules for elementary and nonelementary membranes [5]. Thus, if is a presumably efficient computing model of recognizer membrane systems, then **co**-**NP** .

Several variants of P systems have been demonstrated to be presumably efficient. A solution to QSAT has been given in the framework of P systems with active membranes and division rules for elementary and nonelementary membranes but only evolution rules of the RHS limited to length 1 [6]. When creation rules are used instead of division rules as a method of generating an exponential workspace in polynomial time, it is possible to get rid of polarizations to obtain a solution to the QSAT problem [7]. A new research line taking tissue P systems with symport/antiport rules where objects can evolve during the application of the rules has been developed recently. Several results have been obtained, and new solutions to **NP**-complete problems have been given in this framework [8].

The main contribution of this paper is to provide a lower bound for delimiting a frontier with such class that is thinner to the one found with respect to **co**-**NP**, with being a presumably efficient computing model of recognizer membrane systems verifying some simple requirements (e.g., in the case of cell-like membrane systems, allowing object evolution rules, dissolution rules, and communication rules). It is also worth pointing out that the methodology used to obtain this result is constructive in the following sense: given an **NP**-complete problem , a **DP**-complete problem is associated, in such a manner that if then , for such kind of presumably efficient computing model of recognizer membrane systems.

The remainder of this paper is structured as follows. Section 2 will be devoted to introduce some concepts that can be useful to understand the rest of the work. The complexity class **DP** is introduced in Section 3, where the main theorem presented in this paper is established. In Section 4, the methodology will be applied with an example. Finally, in Section 5, the most relevant conclusions are drawn, and some possible further developments are outlined.

#### 2. Preliminaries

In order for the paper to be self-contained, several basic concepts and results will be introduced to facilitate a better understanding of the text.

An *alphabet* is a nonempty set whose elements are called *symbols*. A *string * over an alphabet is an ordered finite sequence of symbols. The *length* of a string , denoted by , is the number of occurrences of symbols that it contains. The empty string (with length 0) contains no symbols, and it is denoted by . The set of all strings over an alphabet is denoted by . A *language* over is a subset of . If are languages over , the set-theoretic *difference* of and (in this order), denoted by , is defined as follows: .

A *multiset * over an alphabet is a mapping from onto the set of natural numbers. A multiset over is finite (respectively, empty) if the set is a finite (respectively, empty) set. If are multisets over , then the *union* of and , denoted by , is the multiset over defined as follows: , for each .

##### 2.1. The Cantor Pairing Function

The Cantor pairing function is the mapping from onto defined as follows: the natural number is associated with every ordered pair of natural numbers. We denote it by , that is, . The Cantor pairing function is a primitive recursive function and bijective from onto . Consequently, for each natural number , there exists a unique pair of natural numbers such that .

##### 2.2. Decision Problems and Languages

A decision problem is an ordered pair , where is a language over a finite alphabet and is a total Boolean function over . The elements of are called *instances* of the problem . If (respectively, ) then we say that the answer of the problem for instance is “yes” (respectively, “no”). Each decision problem has associated a language over : the set of instances whose answer is “yes.” Conversely, every language over an alphabet has associated a decision problem whose set of instances is , and for each the answer of the problem is “yes” if and only if .

The *complement problem * of a decision problem is the decision problem with the same set of instances, characterized by the following property. For each instance , the answer of for is “yes” if and only if the answer of for is “no.” Obviously, . In accordance with this definition, a problem is an **NP**-complete problem if and only if its complement problem is a **co**-**NP**-complete problem.

##### 2.3. The Satisfiability Problem

Let us recall that the set of propositional Boolean variables is a countably infinite set such that each of their elements can take only two possible Boolean values (*truth values*) from . *Boolean expressions* are captured through the recursive definition of the minimal set verifying: (a) any propositional Boolean variable is in ; (b) if is in then its negation is also in ; and (c) if and are in then its disjunction is also in . Every Boolean expression has a finite number of Boolean variables associated with it, being denoted by . A truth assignment for a Boolean expression is a mapping from onto the set . According to the classical definition of truth tables for negation and disjunction, every truth assignment for a Boolean expression provides a unique Boolean value to it. If the associated truth value is 1, then it is said that makes the Boolean expression true.

A *literal* is a Boolean variable or the negation of a Boolean variable. A *clause* is a finite disjunction of literals. Moreover, a Boolean expression is in conjunctive normal form if it is a finite conjunction of clauses. We say that a Boolean expression is in a *simplified conjunctive normal form* if it is in conjunctive normal form, literals are not repeated in each clause, and a literal and its negation do not appear in the same clause. We say that a Boolean expression is *satisfiable* if and only if there exists a truth assignment for making such an expression true. Let us recall that the satisfiability problem, denoted by SAT, is the problem of deciding whether a given Boolean formula in a simplified conjunctive normal form is satisfiable. The complement problem is denoted by : *determining whether or not a Boolean expression in a simplified conjunctive normal form is unsatisfiable*. That is, given a Boolean expression in a simplified conjunctive normal form, determine whether any truth assignment for makes it false. It is well known that the SAT problem is an **NP** complete problem [9]. Thus, the UNSAT problem is a **co**-**NP** complete problem.

##### 2.4. The Polynomial-Time Hierarchy and the Boolean Hierarchy

Let us recall that if is a time complexity class and is an oracle (a set of queries) then is the class of all languages decidable by deterministic or nondeterministic Turing machines working in time bound as in and having as oracle (see [10], for details).

The *polynomial-time hierarchy* was introduced by Stockmeyer [11], inspired by the Kleene arithmetical hierarchy [12], where recursive time is replaced by deterministic polynomial time. The polynomial-time hierarchy is a sequence of complexity classes defined as follows: and , , and , for each . The first level of this hierarchy is , , and = **co**-**NP** and the second level is , , and = **co**-**NP**. The *cumulative polynomial-time hierarchy* is the class .

The *Boolean hierarchy* is a sequence of complexity classes obtained from **NP** by means of Boolean operations (union, intersection, and complementation). It was defined in [13] as follows: , and , , for each . Sometimes, sets are denoted by . The first level of this hierarchy is **NP** and the second level is the set of languages which are intersections of a language in **NP** and another one in **co**-**NP**.

#### 3. The Complexity Class DP

The complexity class **DP** was introduced by Papadimitriou and Yannakis in 1982 [14] as follows.

*Definition 1. *A language is in the class **DP** if and only if there are two languages and such that and .

The complexity class **DP** can be easily characterized by the following property: a language is in **DP** if and only if there exist two languages and in **NP** such that . Class **DP** is the second level in the Boolean hierarchy. Besides, classes in the Boolean hierarchy can be described by finite unions of **DP** sets (or by finite intersections of **co**-**DP** sets). For more details, see [13, 15].

The complexity class **DP** can also be expressed in terms of decision problems as follows: a decision problem is in class **DP** if and only if the language associated with it belongs to class **DP**, that is, if there are two decision problems and such that are languages in **NP** and . It is easy to prove that **co**-**NP** **co**-**DP**.

Next, we define the *product of two decision problems*, and some properties of the new concept are analyzed.

*Definition 2. *Let and be two decision problems. The *product problem* of and , denoted by , is the decision problem defined as follows: = , and for each , we have if and only if and .

A product problem can be naturally associated to a problem . This problem is the *product problem*, defined as follows: such that , being the complementary problem of ; if and only if .

According to these definitions, the following results concerning to the product of two decision problems are obtained.

Proposition 1. *Let be decision problems:*(i)*If and co-NP, then *(ii)

*If is an*(iii)

**NP**complete problem and is a**co**-**NP**complete problem, then is a**DP**complete problem*If is an*

**NP**complete problem, then the product problem is a**DP**complete problem*Since the SAT problem is an*

**NP**complete problem, we deduce that the product problem is a**DP**complete problem. This problem is referred as the SAT-UNSAT problem [10] and can be expressed as follows: given two Boolean expressions and in simplified conjunctive normal forms, determine whether or not is satisfiable and is unsatisfiable.#### 4. The Methodology

The main result of this paper refers to the robustness of the complexity class associated with some computing models of recognizer membrane systems, with respect to the operation product of two decision problems.

Main Theorem 1. *Let be a computing model of recognizer noncooperative cell-like P systems allowing dissolution rules, object evolution rules, and communication rules send-in and send-out. If and are decision problems belonging to the time complexity class , then .*

*Proof. *First, without loss of generality, we can assume that the semantics associated with the application of the rules of systems from is similar to P systems with active membranes, that is, at one transition step, a membrane can be a subject of only one rule of type dissolution, communication, or division, but object evolution rules are applied simultaneously with one of these rules and, moreover, in a maximal way. By using a different semantics, only few parameters that will appear in the proof should be modified.

For , let be a family of membrane systems from solving in polynomial-time in a uniform way. Let be a polynomial encoding from into . Let be a polynomial function such that, for each instance from , any computation of performs at most steps. In this situation, a family of membrane systems from will be defined from and , in such a manner that provides a uniform and polynomial-time solution to the product problem . The family will be called the *product family* of families and , and it will be denoted by .

First, a pair of polynomial-time functions over the set of instances of is considered as follows: (a) and (b) , for each . Hence, we want the instance to be processed by the system with input multiset . In the following, the membrane system will be explicitly defined from and , for each , so that (a) if there exist accepting computations of the systems and , then and (b) if , then any computation of and any computation of are accepting ones. According to this, will be a polynomial encoding from the product problem into the family . It is worth pointing out that, in fact, only membrane systems such that are defined, and this is enough to achieve our goal.

In what follows, we will denote , , and . Let us recall that given , there exists a unique pair of natural numbers such that . The underlying idea of the construction of is the following: when is considered as the input multiset of this system; then, computations of and are simulated. The answers of these systems are placed in a membrane where the final decision is taken; accepting computations of only come from accepting computations of and .

Without loss of generality we can assume that , for , are mutually disjoint, being the working alphabet of . Likewise, without loss of generality, we can assume the same with the corresponding sets of labels and . For , let be the maximum value of such that , and let be the depth of the input membrane of in the corresponding membrane structure. Let us denote , for , and . Systems will be “prepared” after steps, and computations of such systems will start at the next step. It will last transition steps. Besides, it will take steps to have both responses prepared to let give the answer.

The syntactical ingredients of are the following:(i)*Input alphabet.* The input alphabet is , being the input alphabet of , by replacing objects yes and no by objects and , for , respectively.(ii)*Working alphabet.* The working alphabet is where that is, objects are “copies” of objects , and objects in are counters for implementing a synchronization process.(iii)*Set of labels.* The set of labels is , where are different from each other, and .(iv)*Compartment structure.* The membrane structure of is obtained from the membrane structures , for , by adding four new nodes such that (a) is the skin membrane of ; (b) is the father of ; (c) is the father of ; (d) is the father of the skin membranes of , for ; and (e) is a new son of the input membrane of , for . More specifically, the membrane structure of is . It is graphically depicted in Figure 1.(v)*Initial multisets.* The initial multisets of are the following: if is the label of a membrane from whose initial multiset associated with is nonempty, then the initial multiset of is a “copy” of by replacing each symbol by . Moreover, and , for .(vi)*Set of rules.* The set of rules is , where is the set of rules of , for , obtained through the replacement of objects yes and no by objects and , respectively, in each rule. is the following set of rules.(1)*Rules for simultaneously transporting **from **to **, for ** and transforming it into **:*(1.1), for and for each .(1.2), for each and each membrane being either or being an ancestor of it.(2)*Rules for simultaneously transporting **from **to the input membrane **, by transforming it into **, for *:(2.1), for .(2.2).(2.3), for each .(3)*Rules for synchronizing the simulation of **in order to start at the**th transition step, for *:(3.1), for each .(3.2), for each .(4)*Rules for synchronizing the instant **in which the answers of **and **reach the membrane *:(4.1), for .(5)*Rules for the output of the system *:(5.1).(5.2), for .(5.3).(5.4).(5.5).(5.6).

##### 4.1. Input Membrane

The input membrane is the membrane labelled by .

An overview of the computations of is as follows.

The proposed solution can be structured in the following stages.(i)Transport stage It consists of several phases: for , in a simultaneous way, (a) the input multiset is transported from the input membrane of to the skin membrane of , being transformed into the multiset obtained from by replacing each symbol in by ; (b) then, is transported from the skin membrane to membrane ; finally, (c) moves from to the input membrane of , being transformed into .(ii)Simulation stage Computations of the system with input multiset are simulated, for .(iii)Output stage The system with input multiset sends the right answer to the environment according to the results obtained in the previous stage.

###### 4.1.1. Transport Stage

Once the input multiset is supplied to the system , by applying the rules from 1.1, multiset , for , enters into membrane transformed in . Next, by applying the rules from 1.2, multiset is transported to membrane . Then, multiset is transported from membrane to the input membrane of being transformed in , by dissolving the membrane (rule 2.2) and evolving objects to objects by applying the rules from 2.3. This process can be observed in a graphical way in Figure 1.

It is worth pointing out that, in this process, we must prevent the rules of from being applied. In order to do that rules from 3.1 handle copies of objects initially placed in membranes during transition steps, and rules from 3.2 transform those objects in objects in order to be used in the simulation of . Consequently, at the configuration , the simulation of , for , will start.

###### 4.1.2. Simulation Stage

The simulation of starts at the ()th transition step. Then, after at most transition steps, an answer will be sent to the membrane . Consequently, after at most transition steps, systems and will send their responses to membrane , where counter has been evolving from to by applying rules from 4.1.

###### 4.1.3. Output Stage

At the th transition step, the membrane is dissolved by applying the rule 5.1. Then, membrane will contain objects along with the two answers ( and/or ) provided by the simulations of , for .

*Case 1. *Membrane from configuration contains at least an object . In this case, the answer must be negative. In fact, at the th step, by applying rule 5.2 one object dissolves the membrane and evolves to object NO. Simultaneously, by applying the rule 5.4, object evolves to object . Then, at configuration the skin membrane contains objects and one object or . Finally, at the next step, by applying the rule 5.3, object is sent out of system. A graphical interpretation of this case is present in Figure 2.

*Case 2. *Membrane from configuration does not contain any object . In this case, the answer must be affirmative. In fact, at the th step, by applying rule 5.4, object evolves to inside membrane . Then, membrane from configuration will contain objects , and . Next, by applying rule 5.5, object reaches membrane . Finally, an object yes is sent out to the environment by applying rule 5.6. A graphical interpretation of this case is present in Figure 3.

*Remark 1. *Concerning to the proof of Theorem 1, we would like to draw attention to two aspects: (a) recognizer membrane systems from class are required to allow the use of dissolution rules, object evolution rules, and communication rules (in both directions: send-in and send-out) and (b) an explicit solution of the product problem product is provided from two solutions of the problems involved in that operation.

Corollary 1. *Let be a presumably efficient computing model of recognizer cell-like P systems allowing dissolution rules, object evolution rules, and communication rules send-in and send-out. Then, DP co-DP .*

*Proof. *It suffices to note that if is an **NP** complete problem such that , then the product problem is a **DP** complete problem such that . Since the complexity class is closed under complement and under polynomial-time reduction, **DP** **co**-**DP** follows.

#### 5. Applying the Methodology to MAJORITY

In this section, we detail the application of the methodology through a simple example. For the sake of simplicity, a simple problem will be selected so the focus can be on the application of the problem. The application of the methodology to an **NP**-complete problem will be applied in [16].

Let be the set of all finite multisets over , and let be the number of appearances of symbol in the multiset . Let be the number of elements of .

Let be the MAJORITY problem. Let and if and only if , that is, if .

A uniform family of polarizationless P systems with dissolution rules can be designed for this purpose (the MAJORITY problem falls under the class **P**; therefore, it could be enough to use the function to encode the input as yes in the affirmative case and no in the negative case, but for the application of the methodology, we will make that will encode a 1 as an object and a 0 as an object ).

Let be the number of elements of the input instance. We define the recognizer polarizationless P system with dissolution rules:where(1).(2).(3).(4).(5)The set of rules is formed by the following rules:(a)These rules will carry the object to the membrane labelled by 1 if and only if there are at least objects 1:(b)These rules will make the object evolve to :(c)Rules for returning if object has arrived the membrane labelled by 1 in the configuration :(d)Rules for returning an object in case the object is not in membrane 1 in configuration :(6) and .

The system works are as follows: the instance is introduced in the input membrane as a multiset of objects and ( will encode a 1 as an object and a 0 as an object ). Objects will start dissolving membranes starting from the membrane labelled by to the membrane labelled by 3. If there are enough objects (that is, if there is a majority of 1 in the instance), then object will be in the membrane labelled by 1 in configuration . Therefore, object will go into membrane 2 and will dissolve it, avoiding object evolving into an object . While dissolving, object will be transformed into an object , that will go to the environment in the last step of the computation. If object is not present in the membrane 1, then object will be transported to membrane 1 as an object in the membrane 1 and will be sent to the environment in the last step of the computation. The system will take steps in the affirmative case, and steps in the negative case. With this solution to the MAJORITY problem, we can proceed to apply the methodology.

Let be the complementary problem of , that is, and . A solution to this problem could be given simply changing the role of objects and .

Letbe recognizer polarizationless P systems with dissolution rules that solves the instances of MAJORITY of size as described above. We can define a recognizer polarizationless P system with dissolution rules:which solves the instances of of size as follows. For doing disjoint, will consist on the symbols from in capital letters. All the rules are changed according to this. To make and disjoint, given , we change the label of to . In , we change objects and by and , respectively.

From here, we are going to define P system that will solve the problem , which is defined as follows. Let .

if and only if and . Let . Let , and . Let and . Let . Let and . We define a recognizer polarizationless P system with dissolution rules:where(i), where(ii), being and .(iii), where are different from each other, and(iv) .(v) and , for and for the rest of membranes.(vi)*Set of rules.* The set of rules is , where is the set of rules of , for , obtained through the replacement of objects yes and no by objects and , respectively, in each rule. is the following set of rules:(1)Rules for simultaneously transporting from to , for and transforming it into :