Enhanced Membrane Computing Algorithm for SAT Problems Based on the Splitting Rule

: Boolean propositional satisfiability (SAT) problem is one of the most widely studied NP-complete problems and plays an outstanding role in many domains. Membrane computing is a branch of natural computing which has been proven to solve NP problems in polynomial time with a parallel compute mode. This paper proposes a new algorithm for SAT problem which combines the traditional membrane computing algorithm of SAT problem with a classic simplification rule, the splitting rule, which can divide a clause set into two axisymmetric subsets, deal with them respectively and simultaneously, and obtain the solution of the original clause set with the symmetry of their solutions. The new algorithm is shown to be able to reduce the space complexity by distributing clauses with the splitting rule repeatedly, and also reduce both time and space complexity by executing one-literal rule and pure-literal rule as many times as possible.


Introduction
Boolean satisfiability problem, namely, SAT problem, is one of the most important problems of theoretical computer science. Its range of application includes multiple significance areas [1], such as mathematics, artificial intelligence, data mining, circuit design, etc., and it has attracted much attention since it was put forward. Since the 1960s, research has produced several models of SAT solvers, such as conflict driven clause learning [2], CDCL for short, in which its basic structure comes from the DPLL(Davis-Putnam-Logemann-Loveland) algorithm [3]. This model has made improvements to conflict analysis, clause learning, and some other aspects and has occupied the main battleground of SAT competitions. Representative solvers of this model include Mini-SAT [4], Lingeling [5], Chaff [6], and Glucose [7] all of which have received many achievements in international SAT competitions. With improvements of the SAT algorithm performance, many application examples can obtain satisfactory solutions in a given period of time, and SAT solvers are gradually being applied to more and more actual fields, such as circuit design verification [8,9] and cryptanalysis [10], however, as the first problem which has been proven as NP problem [11], the primary research direction of SAT problem is to reduce its computational complexity. Meanwhile, NP problems can transfer between each other in polynomial time, and therefore previous, current and future studies are also efforts to solve NP problems.
In recently decades, the research of SAT solvers has been mainly focused on three directions, complete solution algorithm, incomplete solution algorithm, and parallel solution algorithm. The membrane computing algorithm of SAT problems, which we are going to discuss, is a kind of parallel algorithm, which can solve any SAT problem in polynomial time but with exponential space occupation [12]. Among the three types of SAT solvers mentioned above, the complete solution algorithm is certain to obtain the solution of a given SAT problem, but it takes an unacceptable amount of time. By comparison, the incomplete solution algorithm uses less time, but it is not able to ensure results. The disadvantages of these two algorithms can both be solved by the algorithm of membrane computing.
Membrane computing is a branch of natural computing, which was proposed in 1998 by professor Gheorghe Păun when he visited Finland [13]. Five years later, the Institute of Scientific Information listed it in the fast-growing frontier area of computational science. The membrane computing system, also known as P system, is a kind of distributed parallel computational model, with good computational performance by referring to and simulating the way cells, tissues, organs, or other biological structures process chemical substances, which has been provn to have the computing power of Turing machine, and a computing power to solve NP problems in polynomial time [14][15][16][17][18]. This characteristic has attracted significant attention from the scientific community who have promoted its development tremendously. To be specific, because membrane computation is performed at the cellular level, biochemical reactions and material transfer at the cellular level can be understood as computational processes. The cell membrane divides the cell into compartments, each compartment synchronously processes multiple resets of objects (corresponding to evolving compounds in the cell), the objects permeate through membranes, the membranes are dissolved, split, and produced, and their penetrability can also be changed. A series of transfers of a system is called a computation, and the calculation result is defined as the objects that appear in a particular membrane (also known as the output membrane) at termination. As a typical type of NP problem, solving SAT problems with membrane computing has a long history [19][20][21][22][23]. Although membrane computing has strong computational power, it is predicted that there is still an upper limit, and therefore developing a new model of membrane computing for solving SAT problems that simplifies algorithms' structure is also important, which is the aim of this paper.
In this paper, the traditional membrane computing algorithm of SAT problems is combined with a typical classic simplification rule, the splitting rule, to improve the algorithm's structure, from assigning values to all clauses in a membrane to dividing the given clauses into two parts, and deals with them respectively and simultaneously. Because this divide operation can be executed as many times as needed, it significantly reduces the space occupation of the algorithm. Meanwhile, it is obvious that a clause set dealt by the splitting rule must not include tautologies, one literals, and pure literals, and therefore it is indispensable to operate the following three simplified rules beforehand: tautology rule, one-literal rule, and pure-literal rule. The tautology rule needs only to be done once, at the beginning, and it does not make contributions to the simplification of the algorithm, however, the one-literal rule and pure-literal rule are two rules which can be used repeatedly and intensively, they can decrease the number of membrane divisions during the assignment process of the clause set, and can assign more than one value at one time, and therefore both space and time complexity of the algorithm is reduced.
The remainder of the paper is organized as follows: Section 2 provides some preliminary and review about P system and the traditional membrane computing algorithm for SAT, Section 3 proposes a new algorithm for SAT problem by combining the traditional membrane computing algorithm for SAT with splitting rule, in Section 4 an example is provided to illustrate the proposed algorithm, and the paper is concluded in Section 5.

Preliminaries
This section provides some preliminaries to be used in the present work.

Membrane Computing System (P System)
A membrane computing system [24] can be defined as ∏ = (O, , , , ), of which: O is a finite and nonempty alphabet of objects; μ is a membrane structure made up by several membranes; denotes the character string inside the nth membrane in the initial state; is a finite set of the evolutionary rules which are carried out inside the ith membrane; is the membrane which stores the final result.

Tradtional Membrane Computing Algorithm of SAT Problems
Using membrane computing system to solve SAT problem has decades of history. Figure 1 shows the process diagram of the traditional membrane computing algorithm of SAT problems [24]. From the above diagram, shown in Figure 1, it is clear that this algorithm consists of the following two steps, except the input and output steps: Step 1: Copy the, then, 2nd membranes by cell division n times and allocate literals x and y , respectively to the two copies of one membrane during the ith copy ir 1, n ∩, , its time complexity is O 1 , and its once execution makes the space occupation of this algorithm twice as much as before.
Step 2: Assign the allocated literals in each 2nd membrane as true to the given clause set, its time complexity is O 1 , and since it is completed with sending each allocated literal into all membrane M s which is inside the same 2nd membrane, the largest increase in space occupation of this algorithm during its execution process is O 2 n m − 1 , and the space occupation of this algorithm will decrease to O 2 after its execution process.
To sum up, the time complexity of this algorithm is O n , and since the biggest initial space occupation of this algorithm is O nm , the space complexity of this algorithm is O 2 nm O 2 n m − 1 O 2 nm .

Simplification Rules
Splitting Rule [25]: Assume a clause set S can be arranged into a form such as Tautology Rule [25]: Delete tautologies, namely the clauses which include complemental pairs of literals, from a clause set does not change if an assignment satisfies this clause set.
One-literal Rule [25]: Assume a clause set S includes a clause which only contains one literal L, then L is a single literal of S. Since one-literal clause can only be satisfied by assignments which assign its single literal as true, if S is empty after deleting the clauses contain S's single literals from S, S can be satisfied by any assignments which assign its single literals as true, or else S is satisfied by assignment after deleting the clauses contain S's single literals from it and deleting literal the negations of S's single literals from all of its clauses if and only if S is satisfied by an assignment ∪ S's single literals are all true .
Pure-literal Rule [25]: Assume a clause set S includes literal L but excludes literal L, then L is a pure literal of S. Since the clause which contains pure literals can only be satisfied by assignments which assign the pure literals contained by it as true, if S is empty after deleting the clauses contain S's pure literals from S, S can be satisfied by any assignments which assign its pure literals as true, or else S is satisfied by assignment after deleting the clauses contain S's pure literals from it if and only if S is satisfied by an assignment ∪ S's pure literals are all true .

Definition
This part is the elements' definitions of the algorithm's membrane computing structure as follows: (1) O: {x , y , denote the literals of given clause set; h, denotes the number of literals in a clause; t , f , are the literal symbols of x and y ; g, denotes the number of literals' symbols; a , denote the atoms of the given formulae; T , F , are objects in the literal list of 2nd membrane; c , e , are the transitive symbols of t and f ; p , denote the transport sign of membrane M ; z, denotes the number of membranes M i 1, … , m ; t , f , denote the assignments of literals x and y ; λ, δ, are the melting symbol of objects and membrane; Y, N, a, b, c, d, p, q, s, are aided symbols}.
(2) μ: the initial membrane structure is as figure 2: where denote the jth clause in the given clause set, | | represents the number of literals in = 1, … , .
In addition, there's a literal list inside 2nd membrane which is empty in the initial status, it is used to store the literals which would be assigned as true in all assignments which satisfy the inside clause set of 2nd membrane and the given clause set.
(4) R (i = 1, 2, M ) specific as described in the part of algorithm, and they are made up by three types of evolutionary rules: (a) → , copy the membrane i into two copies when it or them contains object a, turn a in two copies into b and c respectively; (b) a → b|c or ¬c, turn a into b when c is existent or inexistent; (c) a → b c, in or out , turn a into b and c, meanwhile, send c into the membrane i or out the membrane which a was inside.

Compiling
As stated in the Introduction, the new membrane computing algorithm, proposed in this paper, is specifically based on the splitting rule and uses tautology rule, one-literal rule and pure-literal rule, and therefore for clarity this section compiles the simplified rules with membrane computing language, first, as follows: (1) Tautology rule: This rule is executed on the only 2nd membrane at the beginning of the calculation. Pick tautologies from the clauses inside membrane s, and mark the membrane s which contain tautologies with a delete symbol, r = (zp h x y → s, 1 ; Delete all contents inside the membrane s which are marked with a delete symbol: r = (hx → λ|s, 1) r = (hy → λ|s, 1) ; Delete the membrane s which are marked with a delete symbol, r = (s → δ, 1). (2) One-literal rule: This rule is executed on each 2nd membrane. Pick the one-literal clauses from the clauses inside membrane s, mark the literals of these selected one-literal clauses with one-literal symbols t , f , send these symbols outside their original membranes.
Then, judge if its inside clause set has complementary pairs of single literals with the one-literal symbols, if so, this clause set is unsatisfiable, so what we need to do is to delete this 2nd membrane and all its contents: If not, since all assignments which satisfy the inside clause set assign these single literals as true, add these one-literal symbols into the literal list of this 2nd membrane: , then package these one-literal symbols and copy this symbol pack into as many copies as membrane s inside this 2nd membrane, then send each copy into one membrane : ; Next execute following three operations respectively on the membrane s which contain different types of clauses: For the membrane whose inside clause includes some of these single literals, the inside clause can be satisfied by any assignment which assigns these single literals as true, so what needs to be done is delete it and all of its contents: r = (t zp hx → s, 1 r = (f zp hy → s, 1 ; For the membrane whose inside clause excludes these single literals, but includes some of their negations, the inside clause can be satisfied by an assignment which assigns these single literals as true if and only if it can still be satisfied by this assignment after deleting the negations of these single literals from it, so delete these negations: , for the same reason, if the inside clause is built only by the negations of single literals, the clause set inside this 2nd membrane is unsatisfiable, delete this membrane and all of its contents: , or else delete the left one-literal symbols in the end: ; For the membrane whose inside clause excludes single literals and their negations, we can just delete the one-literal symbols from this membrane . (3) Pure-literal rule: This rule is executed on each 2nd membrane as follows: Send all literals in the inside clause set outside from their original membranes: , then delete the repetitive literals: r = (x → x , 1) r = (y → y , 1) , finally delete the complemental pairs of literals: r = (x → gt |¬x , 1) r = (y → gf |¬y , 1) r = (g t f → λ, 1) ; At this point, the left literals are all pure literals of the inside clause set, since all assignments which satisfy the inside clause set assign these pure literals as true, what needs to be done is that add the symbols of them into the literal list of this 2nd membrane: r = (ga t → bt , 2) r = (ga f → bf , 2) , then package these one-literal symbols and copy these symbols into as many copies as membrane s inside this 2nd membrane, then send each copy into one membrane : Next execute following three operations, respectively, on the membrane s which contain different types of clauses: For the membrane whose inside clause includes some of these pure literals, the inside clause can be satisfied by any assignment which assigns these pure literals as true, therefore what needs to be done is delete it and all of its contents: r = (t zp hx → s, 1) r = (f zp hy → s, 1

;
For the membrane whose inside clause excludes single literals and their negations, we can just delete the one-literal symbols from this membrane : r = (t → , 2) r = (f → , 2) .
(4) Splitting rule: This rule is executed on each 2nd membrane whose inside clause set has no one-literal clause and pure-literal clause.
Splitting rule is supposed to be distributing the clauses in the given clause set into two parts which excludes a specified literal and its negation separately, and putting them into two new second membranes, but this operation is too complicated for the membrane computing program language, so we transpose the order of processes: First, we copy the 2nd membrane and its contents into two copies and allocate a specified literal and its negation to two copies, respectively, the allocated literal of each copy is the literal which its negation and the clauses contain it should be excluded by the inside clause set of this copy, since all assignments which satisfy the inside clause set of one of two copies and the inside clause of the original 2nd membrane assign the allocated literal of this copy as true, add the symbol of the allocated literal into the literal list of each copy: = zp , out, 4 , then send the literal symbols into each membrane which inside two copies respectively: r = (t p → t p , inM , 1 r = (f p → f p , inM , 1 ; Next execute following three operations, respectively, on the membrane s which contain different types of clause. For the membrane whose inside clause includes the allocated literal of the 2nd membrane which contains it, this inside clause should be excluded by the inside clause set of this 2nd membrane, so what needs to be done is delete it and all of its contents: r = (t p hx → s, 1 r = (f p hy → s, 1 r = (hx → λ|s, 1) r = (hy → λ|s, 1) r = (s → δ, 1) ; For the membrane whose inside clause includes the negation of the allocated literal of the 2nd membrane which contains it, this negation should be excluded by the inside clause, so delete this negation: r = (t hy → λ, 2) r = (f hx → λ, 2) ; For the membrane whose inside clause excludes the allocated literal of the 2nd membrane which contains this membrane and its negation, we can just delete the literal symbol from this membrane ; Since these four program modules have a lot of overlap, we can concordance them to realize the algorithm of this paper. The flowing chart of the new algorithm is shown in Figure 3. From the above diagram (Figure 3), it is clear that this algorithm is completed by repeat executing the following two steps, in the ith (1th < n) repeat: Step 1: Filtrate single literals and pure literals from the clause set in each 2nd membrane simultaneously, its time complexity is O(1) , the largest increase in space occupation of this algorithm during its execution process is no more than O(2 (m + 1 − i)(n + 1 − i)), and this increase will decrease to no more than O(2 (n + 1 − i)) after its execution process.
Step 2: Execute one of the following three substeps on each then 2nd membrane simultaneously based on the type of the 2nd membrane's inside clause set: For the 2nd membrane whose inside clause set has no single literals and pure literals, copy this 2nd membrane into two copies and allocate an atom of this inside clause set and its negation, respectively, to the two copies, then in each copy, delete the clauses which contains its allocated literal from its inside clause set and the negation of its allocated literal from the clauses inside its inside clause set; For the 2nd membrane whose inside clause set contains a complemental pair of single literals, delete this 2nd membrane and its contents; For the 2nd membrane whose inside clause set has single literals or pure literals and excludes any complemental pair of single literals, assign these single literals and pure literals as true to its inside clause set.
The time complexity of this step is O(1), and if the ith repeat is not the finial repeat, in the worst case, namely, in the case that all 2nd membranes' inside clause sets exclude single literals and pure literals, the largest increase in space occupation of this algorithm during the execution process of this step is no more than O(2 (m + 1 − i)(n + 1 − i)) + O(2 (m − i)), and the space occupation of this algorithm will decrease to no more than O(2 (m − i)(n − i)) after its execution process; if not, all 2nd membranes' inside clause set has single literals or pure literals and excludes any complemental pair of single literals, the largest increase in space occupation of this algorithm during the execution process of this step is no more than O(2 (m + 1 − i)), and the space occupation of this algorithm will decrease to 0 after its execution process.
Since the upper bound of this algorithm's repeat time is Min(n,m), the time complexity of this algorithm is O (Min(n, m)), the space complexity of this algorithm is: It is clear that the new algorithm is more efficient than the traditional algorithm. To be noted, the new algorithm's computing complexity is worked out based on its worst case, which almost never happens, such as assuming that no pure-literal and one-literal clause exist before the final repeat, but the traditional algorithm's computing complexity is worked out based on the general change of the time and space which it occupies, and therefore, in practice, the difference between the two algorithm will be much more significant.
In order to describe the difference between the new algorithm's computing complexity and its general time and space occupation, work out the three situations of the time and space occupation of the step 2's execution on a 2nd membrane in the ith repeat, of which the ith repeat is not the finial repeat as follows: If the 2nd membrane whose inside clause set has no single literals and pure literals, the time complexity is O(1), the largest increase in space occupation of this 2nd membrane, during the execution process, is no more than O((m + 1 − i)(n + 1 − i)) + O(2(m − i)) , and the space occupation of this 2nd membrane will decrease to no more than O(2(m − i)(n − i)) after the execution process, the new algorithm's computing complexity is worked out based on this situation; If the 2nd membrane whose inside clause set contains a complemental pair of single literals, the time complexity is O(1), the largest increase in space occupation of this 2nd membrane during the execution process is 0, and the space occupation of this 2nd membrane will decrease to 0 after the execution process; If the 2nd membrane whose inside clause set has single literals or pure literals and excludes any complemental pair of single literals, the time complexity is O(1), the largest increase in space occupation of this 2nd membrane during the execution process is no more than O((m − i)(n + 1 − i)), and the space occupation of this 2nd membrane will decrease to no more than O((m − i)(n − i)) after the execution process. In this situation, assume the inside clause set of this 2nd membrane has k (k ≤ n + 1 − i) single literals and pure literals, then k atoms of it have been assigned values simultaneously by this step.
Since the upper bound of the new algorithm's rest repeat time is no more than the biggest number of unassigned atoms of the then 2nd membranes' inside clause sets, the above step makes a contribution to reducing the repeat time of the new algorithm, namely reducing the time complexity of the new algorithm in the second and the third situations.
According to the above flow chart and program modules, we get the program of the object algorithm: : r = (zp h x y → s, 1 r = (t zp hx → s, 1 r = (f zp hy → s, 1 r = (hx → λ|s, 1) r = (hy → λ|s, 1) r = (t → λ|s, 1) r = (f → λ|s, 1) = (c → λ|s, 1) r = (s → δ, 1) r = (t hy → λ, 2) r = (f hx → λ, The following is the explanation: First, delete the membrane s which contain tautologies and their content with a delete symbol s: r = (zp h x y → s|¬s, 1 , this is how delete symbol s works in this algorithm: r = (hx → λ|s, 1) r = (hy → λ|s, 1) r = (t → λ|s, 1) r = (f → λ|s, 1) = (c → λ|s, 1) r = (s → δ, 1) ; Then filtrate single literals and pure literals from the clause set in each 2nd membrane respectively. First, execute the 22th rule to copy each membrane and its contents into two copies, r = ( zp ),2 , then for copy with mark c, release all literals of its inside clause to the 2nd membrane which contains it and generate literal symbols of all pure literals of this 2nd membrane's inside clause set with these released literals: r = (ℎ → λ|c, 4) = (c → δ|¬s, 4) r = (x → c |¬c , 1) r = (y → e |¬e , 1) r = (x → λ|c , 1) r = (y → λ|e , 1) r = (c e → λ, 1) r = (c → gt |¬e , 1) r = (e → gf |¬c , 1) , and for the copy without mark c, if its inside clause is a one-literal clause, mark the literal of this inside clause with one-literal symbol and send the one-literal symbol outside: r = (x → x (gt , out)|¬h , 5) r = (y → y (gf , out)|¬h , 5) ; Now execute following three operations on the 2nd membranes which contain different types of clause sets respectively: (a) For the 2nd membrane whose inside clause set has no single literals and pure literals, pick one of the atoms of the inside clause set which the splitting rules of it hasn't been executed in the calculation process, and copy this 2nd membrane and its contents into two copies, allocate the picked literal and its negation to two copies, then add the picked atom and its negation into the literal list of two copies respectively, r = [ z ] → t T f F | ∈ , 3 , then for each membrane inside these two copies, judge the type of its inside clause: , if its inside clause contains the allocated literal of the 2nd membrane which contains it, delete the membrane and its contents, if its inside clauses exclude the allocated literal of the 2nd membrane which contains this membranes , but contain its negation, delete this negation: r = (t zp hx → s, 1 r = (f zp hy → s, 1 r = (t hy → λ, 2) r = (f hx → λ, 2) r = (t → λ|h, 3) r = (f → λ|h, 3) ; (b) For the 2nd membrane whose inside clause set contains a complemental pair of single literals, delete this 2nd membrane and its contents with a unsatisfiable symbol N: r = (g t f → N|¬N, 1) , this is how unsatisfiable symbol N works in this algorithm: r = zp → szp , inM |N, 1 r = (a → λ|N, 1) r = (gt → λ|N, 1) r = (gf → λ|N, 1) r = (p → λ|N, 1) r = (T → λ|N, 1) r = ( → λ|N, 1) r = (N → δ, 1) , if all 2nd membranes have been deleted, there's no rule can be executed, the membrane structure has only the membrane which stores the final result left and this membrane is empty at this point, it means that S is unsatisfiable; (c) For the 2nd membrane whose inside clause set has single literals or pure literals and excludes any complemental pair of single literals, first add these single literals and pure literals into the literal list of this 2nd membrane: r = (gt → λ| , 1) r = (gf → λ| , 1) r = (ga t → bt |¬ , 2) r = (ga f → bf |¬ , 2) , then for each membrane inside this 2nd membrane, judge the type of its inside clause: r = (bp → bq[ ] |¬g, 1) , if its inside clause contains one of these single literals and pure literals, delete the membrane and its contents:

Example Illustration
In this section, we use an example to show how to solve a SAT problem with this new algorithm, we use clause set  includes no tautology. Filtrate single literals and pure literals from the clause set in each 2nd membrane respectively: 1. Copy each membrane and its contents into two copies (r ), figure 5 shows the membrane structure of this time. 2. Then for copy with mark c, release all literals of its inside clause to the 2nd membrane which contains it and generate literal symbols of all pure literals of this 2nd membrane's inside clause set with these released literals r ( , , -) , and for the copy without mark c, if its inside clause is a one-literal clause, mark the literal of this inside clause with one-literal symbol and send the one-literal symbol outside r ( , ) , figure 6 shows the membrane structure of this time. Execute the following operations on the 2nd membrane bases on the type of its inside clause set: 1. Add these single literals and pure literals into the literal list of this 2nd membrane r ( -) , figure 7 shows the membrane structure of this time. 2. Then for each membrane inside this 2nd membrane, judge the type of its inside clause r ( -) , figure 8 shows the membrane structure of this time. At this time, two of the S's atoms have been assigned, the membrane structures of the tradition algorithm which reach the same assign effect is as figure 9. 3. Next execute following three operations respectively on the membrane s which contain different types of clauses r ( , , -) , figure 10 shows the membrane structure of this time. Filtrate single literals and pure literals from the clause set in each 2nd membrane respectively: 1. Copy each membrane and its contents into two copies (r ) , figure 11 shows the membrane structure of this time. 2. Then for the copy with mark c, release all literals of its inside clause to the 2nd membrane which contains it and generate literal symbols of all pure literals of this 2nd membrane's inside clause set with these released literals r ( , , -) , and for the copy without mark c, if its inside clause is a one-literal clause, mark the literal of this inside clause with one-literal symbol and send the one-literal symbol outside r ( , ) , figure 12 shows the membrane structure of this time. Execute the following operations on the 2nd membrane bases on the type of its inside clause set: 1. Pick one of the atoms of the inside clause set which the splitting rules of it hasn't been executed in the calculation process, and copy this 2nd membrane and its contents into two copies, allocate the picked literal and its negation to two copies, then add the picked atom and its negation into the literal list of two copies respectively (r ), figure 13 shows the membrane structure of this time. At this time, two of the S's atoms have been assigned, the membrane structures of the tradition algorithm which reach the same assign effect is as figure 14. 2. Then for each membrane inside these two copies, judge the type of its inside clause r ( , ) , figure 15 shows the membrane structure of this time. 3. Next execute following three operations respectively on the membrane s which contain different types of clauses r ( , , -) , figure 16 shows the membrane structure of this time. Filtrate single literals and pure literals from the clause set in each 2nd membrane respectively: 1. Copy each membrane and its contents into two copies (r ) , figure 17 shows the membrane structure of this time. 2. Then for the copy with mark c, release all literals of its inside clause to the 2nd membrane which contains it and generate literal symbols of all pure literals of this 2nd membrane's inside clause set with these released literals r ( , , -) , and for the copy without mark c, if its inside clause is a one-literal clause, mark the literal of this inside clause with one-literal symbol and send the one-literal symbol outside r ( , ) , figure 18 shows the membrane structure of this time. Figure 18. The membrane structure during calculation (14).
Execute the following operations on the 2nd membrane bases on the type of its inside clause set: 1. Add these single literals and pure literals into the literal list of this 2nd membrane r ( -) , then for each membrane inside this 2nd membrane, judge the type of its inside clause r ( -) , figure 19 shows the membrane structure of this time.  2. Next execute following three operations respectively on the membrane s which contain different types of clauses r ( , , -) , figure 21 shows the membrane structure of this time. 3. Pick a 2nd membrane like this, and delete all 2nd membrane and their contents except the literal list of the picked 2nd membrane r ( -,, , ) , figure 22 shows the membrane structure of this time. So we get the calculation result: the given clause set , , , is satisfied by assignment = 1; = 1; = 1; = 1 .

Conclusions
Membrane computing is a type of natural computing, similar to the neural algorithm which has been widely used, however, unlike the neural algorithm, membrane computing is still not a reality, because its infinite parallel computing mode cannot be realized under current technical conditions, Nevertheless, calculating it as the way living bodies deal with data is desired, and therefore work towards it has never stopped as it is still just a fantasy. Even if it is realized and it works as well as our body cells, simplifying the algorithms based on it is still necessary because of their unimaginable but still limited computational power and the predictable crazy growing scale and needs of data treatment in the future. The work in this paper combines the membrane computing system with the traditional SAT problem simplification rules and obtains a fairly good effect, which has certain promotion and reference significance for the research field of membrane computing model and SAT problem solving model, and therefore has research value for related research fields. Meanwhile, this research indicates a feasible direction to improve membrane computing systems for different practice problems, which is to optimize the theoretical basis of this problem based on the character of P system. In addition, with respect to this research, in order to realize the membrane computing system, the strategy could be changed. Because membrane computing is a compute process which imitates the way cells work, the use of cells to simulate the compute process of SAT problems altogether should be considered. Although this has not been considered in this paper because of a lack of biological knowledge, it is a method that should be undertaken.