A Gentle Introduction to Membrane

Systems and Their Computational

Properties

Alberto Leporati, Luca Manzoni, Giancarlo Mauri,Antonio E. Porreca, Claudio Zandron

Dipartimento di Informatica, Sistemistica e ComunicazioneUniversita degli Studi di Milano-Bicocca

Viale Sarca 336, Building U14, 20126 Milano, Italy

leporati/luca.manzoni/mauri/porreca/zandron@disco.unimib.it

1 Introduction

The theory of computation investigates the nature and properties of algorithmicprocedures. This field emerged in the 20s and 30s of the 20th century fromthe work on the philosophy and the foundations of mathematics. Of greatimportance and inspiration was David Hilbert’s ambitious program to “disposeof the foundational questions in mathematics once and for all” [34], that ledto fundamental results in logic such as Gdel’s incompleteness theorems [6], andultimately to the birth of recursion theory (nowadays mostly referred to ascomputability theory) and computer science itself.

The formal notion of computability that is almost universally adopted todayis due to Alan Turing, who introduced in his ground-breaking paper On com-putable numbers, with an application to the Entscheidungsproblem [32] a simple,elegant and convincing mathematical formalisation of the notion of computa-tion, as it is carried out by a human executor equipped with enough scratchpaper. Turing’s work showed that, as long as we accept his notion of compu-tation, there exist well-formed mathematical questions whose answer cannot becomputed. In particular, one of the main challenges of Hilbert’s program, theEntscheidungsproblem (finding a decision procedure for the validity of state-ments in first-order logic) was proved to be unsolvable.

This formalisation, that rapidly became known as the Turing machine, is stillthe reference model for computing devices in theoretical computer science, as italso enjoys the property of being a good model of actual electronic computers;this is also due to the fact that it was itself an inspiration for the design ofautomatic computing machinery [5].

With the development of computers as a technology, being able to solvea particular problem proved not to be satisfying: fast, efficient solutions areneeded. This led to the development of computational complexity theory, pio-neered [9] by Hartmanis and Stearns in the paper On the computational com-plexity of algorithms [12], that also gives the name to the field. Identifying

1

the notion of “efficient” with “polynomial-time computable” is due [9] to Ed-monds [7], while the central question of complexity theory, whether P = NP,arose from the work of Cook [4] and Karp [16]. This question has shaped thewhole development of the field, and still remains open today.

However, the theory of computation is not entirely about Turing machines.Several authors sought to draw inspiration from the way nature “computes”in order to define alternative, unconventional computing models, or, from theopposite point of view, to interpret natural phenomena as computation [1].For instance, artificial neural networks [21] are inspired by the functioning ofneurons in the brain, and genetic algorithms seek to solve computationally hardproblems by simulating the processes of mutation, mating and natural selection.A clear example of biological inspiration is given by DNA computing, whichprovided an actual in vitro implementation of an algorithm for the Hamiltonpath problem [2] (the theory was initiated a few years earlier, particularly byHead [13]).

Inspired by the work on DNA computing [26], Pun introduced in 1998 [24]the notion of membrane systems, initially called super-cells, and nowadays usu-ally known as P systems. Here the computing device is an abstraction of biolog-ical cells. Unlike in neural networks, we do not deal with cells as atomic objects:as the name suggests, the focus is on the membranes that define the cells andtheir internal compartments, which work together by performing different indi-vidual functions. The chemical environment of the various compartments aredescribed in terms of multisets of symbols (i.e., sets in which each symbol hasa multiplicity). Another defining feature of P systems (as they were initiallydefined) is maximal parallelism: as many operations as possible are carried outsimultaneously, and no part of the system remains inactive if it can carry outsome part of the computation.

Although P systems have also been investigated from the perspectives ofbioinformatics and systems biology, where they might be used as models of bio-logical phenomena in computer simulations, most of the research in membranecomputing has been carried out from a language-theoretic (including the seminalpaper [24]), computability-theoretic and complexity-theoretic standpoint.

In the literature, many variants using various kinds of rules and differentfeatures have been considered and investigated in this respect. For example,the notion of multiset rewriting employed in the original model of P system [24]is context-sensitive (or cooperative, which is the term normally used in mem-brane computing). Other classes of P systems, however, possess other featuresthat make them extremely powerful from a computational perspective: as a con-sequence, the use of context-free (or non-cooperative) rewriting rules has alsobeen considered. Here, for the sake of explanation, we will present a simplifiedmodel using only basic ingredients and simple cooperative rewriting rules. Af-ter presenting some basic definitions, we will first show that such systems areTuring complete, by simulating register machines, a well known universal com-puting device, and we will show that direct simulation of Turing machines istime efficient. Then, by exploiting the possibility of creating new membranes bydivision of existing ones, we will show how to solve all problems from the com-plexity classes NP and PSPACE in polynomial time (and exponential space) bymeans of membrane systems. At the end of the chapter, we will shortly discusshow cooperation can be avoided, and we will provide pointers to the literatureconcerning main variants considered in the framework of membrane computing.

2

2 Membrane structures

The main feature of all variants of P systems is their membrane structure. Sev-eral variants have been proposed in the literature [27], but we consider herethe original cell-like shape [24]: a hierarchy of membranes nested to an arbi-trary depth. There is a clear bijective mapping between the set of membranesand the regions they define, delimited by the membrane itself from the outside,and any membrane immediately included in it from the inside. The outermostmembrane (sometimes called the skin) separates the actual P system from thesurrounding environment, which is a further implied region also playing a rolein the computation. Membranes not containing further membranes inside themare called elementary ; the others are called nonelementary.

The abstract shape of a membrane structure in any given instant is mathe-matically represented by a rooted, unordered tree. Here the membranes (equiva-lently, the regions they delimit) correspond to vertices, the outermost membranebeing associated with the root of the tree, and an edge between two vertices in-dicates that the corresponding membranes are located one immediately insidethe other; the “parent” and “child” roles are implied by the distance from theroot. The leaves of the tree correspond to elementary membranes, while theinternal nodes correspond to the nonelementary ones. The tree is unordered(i.e., there is no distinguishable “first” or “leftmost” child) because we do notkeep track of any spatial relation between the membranes other than simplecontainment1.

Membranes are not only set apart by their position in the membrane struc-ture, but also by the role they supposedly perform. This is represented inP systems by attaching a label taken from a finite set Λ to each membrane (for-mally, to the vertex representing it in the corresponding unordered tree). As weshall see later, different labels correspond to different sets of rules that can beapplied to the membranes or their contents. Initially, each membrane must begiven a different label (although two distinct labels might be associated to thesame set of rules), while the process of membrane division may create multiplemembranes sharing the same label.

A membrane structure is traditionally described in a “linear” notation bymeans of a string of balanced brackets. Given the unordered rooted tree corre-sponding to the membrane structure, fix an arbitrary ordering of the children ofeach node. The resulting ordered tree, ignoring the node labels, is then uniquelyinterpreted as a string of balanced brackets belonging to the language definedby the following context-free grammar, beginning with the nonterminal S1:

S1 → [S2] S2 → [S2] | S2S2 | ε.

These are all the non-empty strings of balanced brackets having a single out-ermost pair. The nesting of brackets is induced by the shape of the tree (andobviously corresponds to the containment relation of the original membranestructure). Finally, each bracket is subscripted by the label of the correspond-ing membrane. An example of membrane structure, represented in a pictorialform, as a tree, and in bracket notation, can be found in Figure 1.

1There exist other variants of P systems, such as the spatial ones, where the positions ofmembranes and objects do actually matter [3].

3

h0

h1

h4

h3

h2

h0

h1h2

h3 h4

[[ ]h1 [[ ]h3 [ ]h4 ]h2

]h0

Figure 1: A membrane structure, and two formalisms representing it.

3 The content of regions

A single molecule can be represented abstractly as a symbol taken from an alpha-bet Γ. However, subsets of Γ are not an adequate description of a whole chemicalenvironment, as they do not carry any information related to the (absolute orrelative) quantities of molecules of the same species. Since the concentrations(that is, amounts) of chemicals in a region do actually matter from a metabolicstandpoint, we use multisets to describe them.

A multiset w over a set Γ is simply a function w : Γ → N, mapping eachobject to its multiplicity. Generalisations of the usual set-theoretic operationscan be defined on the sets of multisets over Γ; for instance, the union of multisetsw1 and w2 is the multiset where, for all a ∈ Γ, the object a has multiplicityw1(a) + w2(a). From an algebraic point of view, the set of multisets over Γ,with respect to the operation of union, is the free commutative monoid on Γ.Compare this to the set Γ? of strings, which is the free monoid on Γ: here theoperation (i.e., string concatenation) is not commutative. When describing thechemical environment of a region, we are interested in the number of molecules,but not in any particular ordering of them.

Another equivalent characterisation can be given in terms of equivalenceclasses of strings. For each string u ∈ Γ? and each symbol a ∈ Γ, let |u|a be thenumber of occurrences of a in u. Now let u and v be strings, and let the binaryrelation ' be defined by

u ' v if and only if |u|a = |v|a for all a ∈ Γ.

It is trivial to prove that ' is an equivalence relation, and in particular a con-gruence relation with respect to the operation of string concatenation. Then,the set of equivalence classes Γ?/ ' (together with the operation induced byconcatenation) is isomorphic to the set of multisets over Γ (together with theoperation of multiset union). This provides us with a simple way to denotemultisets in writing. Let w be a multiset, and let u be any string such thatw(a) = |u|a for all a ∈ Γ; then, we shall identify w with [u]/' (the equivalenceclass of u modulo ') and, furthermore, we shall drop the equivalence class no-tation, simply writing u for w, as the formal meaning of the symbol is implied;

4

correspondingly, multiset union will be written as string concatenation. Thisidentification justifies the following (informal) sentence, which is usually foundin the P systems literature: “a multiset w will be represented as a string u,together with all its permutations”, since permuting the symbols of u does notchange the number of their occurrences.

4 Computation rules

The elements we have described until now, i.e., the membrane structure andthe multisets contained in its regions, define the instantaneous configurationsof P systems. A configuration evolves by means of computation steps, where ineach step some rules inspired by the biology of cells are applied.

4.1 Object evolution rules

A first kind of computation rule describes simple chemical reactions taking placeinside a region. Consider, as an example, the following formula for the burningof methane as it may be described in a chemistry textbook:

CH4 + 2O2 → CO2 + 2H2O.

This notation describes how a molecule of methane (CH4) reacts with twomolecules of oxygen (O2) yielding a molecule of carbon dioxide (CO2) and twomolecules of water (H2O).2 The molecules on the left-hand side of the arroware called reactants or reagents, while those on the right-hand side are calledproducts.

This kind of reaction corresponds quite closely with a limited form of mul-tiset rewriting, where a certain submultiset is replaced by another one. Thenotation is also quite similar, as for multisets we shall write u → v to indicatethat multiset u is replaced by v. The general notion of multiset rewriting ismore abstract, and it usually disregards the law of conservation of mass. Ageneral chemical reaction viewed as a multiset rewriting rule possesses a pow-erful feature from a language-theoretic perspective: it is context-sensitive. Forinstance, methane may only burn if oxygen is also present, and we require atleast two molecules of oxygen for each molecule of methane.

The first kind of computation rules used by P systems, called object evolutionrules or rules of type (a), are thus denoted as follows:

[u→ v]h

This rule can be applied inside each membrane labelled by h ∈ Λ, having amultiset z which contains the multiset u, i.e. u ⊆ z. When the rule is applied,the multiset of objects defined by u is removed from z and is replaced by themultiset v.

4.2 Communication rules

The main role of cell membranes is that of delimiting and separating regionswhere different functions are performed. However, these distinct regions must

2The molecules involved in this reaction are, in turn, made of several atoms; however, inthis discussion we consider compound objects such as H2O as indivisible.

5

also cooperate: for instance, the products of a chemical reaction occurred inmembrane h1 might be stored inside membrane h2. The cell membranes arethus selectively permeable, allowing specific molecules to move between regions.

First consider the case when a multiset is absorbed by a membrane. Thiskind of rule is called send-in communication rule, or type (b) rule, and is formallywritten as:

u [ ]h → [v]h

This rule can be applied to a membrane having label h ∈ Λ; the region locatedoutside the membrane must also contain at least an instance of multiset u ∈ Γ∗.The effects of this rule is that the multiset u is removed from the outside region,and the multiset v ∈ Γ∗ appears inside the membrane. As a restriction, it isassumed that no object can be brought into the outermost membrane of theP system from the external environment.

The converse kind of rule describes the process by which a membrane expelsa multiset; these are called send-out communication rules or type (c) rules:

[u]h → [ ]h v

This rule can be applied to a membrane labelled by h ∈ Λ containing an in-stance of the multiset u. By applying this rule, the system removes u from themembrane, and places the multiset v ∈ Γ∗ into the region immediately outsidethe membrane.

4.3 Division rules

We have already seen that the membrane structure of a cell needs not remainunchanged during its entire lifespan. In fact, new membranes can be created.The quintessential example is given by the process of mitosis, whereby a wholecopy of the original cell is produced by division. The process of division alsooccurs internally in cells (that is, without involving the outermost cell mem-brane), as mitochondria also divide by binary fission [17]. In general, divisionallows the creation of new “processing units” when the need arises.

The corresponding division rules, or type (d) rules, have the following form:

[u]h → [v]h [w]h

A rule of this kind can be applied to a membrane labelled by h ∈ Λ and con-taining at least one instance of the multiset u ∈ Γ∗. Its effect is as follows: awhole new copy of the membrane is created and placed into the same region asthe original one; the contents are also copied, with the exception of the instanceof u mentioned above, which is replaced by an instance of v ∈ Γ∗ in one of thetwo resulting membranes, and by w ∈ Γ∗ in the other one. This kind of rulecannot be applied to the outermost membrane.

Notice that the membrane h can be elementary or nonelementary: the differ-ence is usually underlined by calling the corresponding rules elementary mem-brane division and nonelementary membrane division, respectively. In case h isa nonelementary membrane, all the membranes contained in it (as well as theircontent) are copied in both of the new instances of h.

6

5 A formal definition

We are now able to give a precise definition of our model of computation ofinterest.

Definition 1. A P system of initial degree d ≥ 1 is a structure Π = (Γ,Λ, µ, wh1,

. . . , whd, R) where

• Γ is the alphabet;

• Λ is the finite set of labels;

• µ is the membrane structure, a rooted undirected tree of d nodes labelledin a one-to-one way by elements of Λ;

• wh1, . . . , whd

, with h1, . . . , hd ∈ Λ, are multisets over Γ;

• R is a finite set of rules.

For each h ∈ Λ, the multiset wh describes the objects initially located in theregion delimited by the membrane labelled by h.

5.1 Configurations and computations

An instantaneous configuration of Π is given by the rooted unordered tree de-scribing its current membrane structure, augmented as follows: each node islabelled by a couple (h,w) where

• h ∈ Λ is the label of the corresponding membrane;

• w is the multiset over Γ contained in the membrane.

A computation step changes the current configuration by applying the rulesin a maximally parallel way, according to the following principles.

• Each membrane can be subject to at most one communication or divisionrule per step. Any number of evolution rules can be simultaneously appliedinside the same membrane, except for the restrictions on objects describedbelow.

• Each object can be subject to at most one rule per step.

• A maximal combination of rules must be applied during each step. Eachobject that appears on the left-hand side of an applicable evolution, com-munication, or division rule must be subject to exactly one of them. Wesay that a rule is “applicable” if the label of the membrane containing theobject corresponds to those appearing on the left-hand side of the rule.The only objects that do not evolve are those associated to no applicablerule (or to no rule at all).

• Each membrane that appears on the left-hand side of an applicable (i.e.,having the correct labels on the left-hand side) communication or divisionrule must be subject to exactly one of them. The only membranes thatdo not evolve are those associated to no applicable rule (or to no rule atall).

7

• When several maximally parallel combinations of rules can be applied atthe same time, a nondeterministic choice between them is made. As aconsequence, in the general case multiple possible configurations can bereached by performing a computation step.

• After a legitimate maximally parallel combination of rules has been chosen(i.e., every membrane and object that can evolve has been assigned toa rule), the rules are applied in a logical bottom-up (depth-first) way,from the elementary membranes towards the outermost one. Inside eachmembrane in turn, first all object evolution rules are applied, then theremaining communication or division rule.

The maximal parallel way of applying the rules may be easily visualized asfollows. Note that this is not the only way used in the literature to apply therules: other common strategies are sequential application and minimal paral-lelism, whose details of operation can be found in the Handbook of MembraneComputing [27]. Assume that a given region of a P system contains a multisetu of objects and a set R of rules. Each of these rules is either enabled by theobjects in u (that is, the rule could in principle be applied to such objects) ornot enabled, depending upon whether u contains the multiset of objects thatappears in the left hand side (LHS) of the rule. Choose one of the enabled rules,and mark as used the objects of u that appear in the LHS of the rule. Nowrepeat the process with the remaining (unmarked) objects of u: select one ofthe rules enabled by them, and mark the objects used by the rule. Repeat theprocess until all objects are marked as used, or the remaining objects do notenable any rule.

Since at each step one rule is chosen in a nondeterministic way, the sameinitial multiset u of objects may lead to several different choices of the rules tobe applied. For this reason, in the literature it is usually told that the rules areapplied in a nondeterministic and maximally parallel way. Notice that no ruleis actually applied until all the rules have been selected; they are then applied inparallel, each one consuming the objects mentioned in its LHS, and producingall the objects listed in the right hand side. The selection process together withthe parallel application of all selected rules, in each of the regions determined bythe membrane structure, constitutes a single computation step of the P system.A global clock is assumed, that synchronizes the operation of all the regions ofthe system; each computation step takes a single clock tick.

Let us also note that maximal parallelism does not imply that the maximalnumber of rules which can be applied with the objects in u will be selected.Instead, maximal parallelism means that no additional rule should be applicablein the same step to idle objects of u. The difference between the two approachescan be seen through a simple example.

Example 2. Assume that a region contains the following set of rules:

r1 : ab→ v1 r2 : c→ v2 r3 : bc→ v3

r4 : a3c2 → v4 r5 : ad→ v5

and the multiset of objects u = a3b2c2 (which is a shorthand for aaabbcc, or anyother permutation of this string).

8

Then, the following multisets of rules can be obtained through the selectionprocess described above, and are indeed maximally parallel:

{(r1, 2), (r2, 2)}{(r3, 2)}{(r1, 1), (r2, 1), (r3, 1)}

Here the notation (ri, n) indicates that the multiplicity of rule ri is n, that is,rule ri has been selected n times. It is easily seen that fact of being maximallyparallel is not related in any way with the number of rules which is selected tobe applied.

A halting computation of Π is a sequence of configurations (C0, . . . , Ck) start-ing from the initial one such that every Ci+1 is reachable from Ci by performinga single computation step, and no rule at all can be applied in Ck. If Π neverreaches a halting configuration, the result is an infinite, non-halting computation(Ci : i ∈ N).

In the next sections we show that the model of P systems we have definedis able to:

• simulate register (counter) machines and Turing machines, hence P sys-tems constitute a universal (in the sense of Turing-complete) model ofcomputation;

• solve NP-complete problems (and thus all problems in the class NP) inpolynomial time (and exponential space), by exploiting elementary mem-brane division rules to simulate the computations of nondeterministic Tur-ing machines;

• solve all problems in the complexity class PSPACE, in polynomial timeand exponential space, by using division rules for nonelementary mem-branes to simulate the computations of alternating Turing machines.

We just recall that NP is the class of decision problems (equivalently, lan-guages) which can be solved (resp., accepted) by nondeterministic Turing ma-chines working in polynomial time with respect to the input size. Similarly,PSPACE is the class of decision problems (resp., languages) that can be solved(resp., accepted) by deterministic or nondeterministic Turing machines operat-ing in polynomial space with respect to the input size. An excellent referencefor the computational properties of these (as well as many others) complexityclasses is [23].

6 Universality of multiset rewriting

Cooperative (or context-sensitive) multiset rewriting rules u → v, even usingonly two symbols on the left-hand side, are powerful enough to reach com-putational universality. This result is actually simple enough to work as anintroductory example.

Let us consider register machines, also called counter machines or programmachines, as described by Minsky [22]. This model, inspired by the workingof electronic computers, is able to compute any recursive function on natural

9

numbers. A register machine consists of a finite number of registers r1, . . . , rn,each one containing a non-negative integer (i.e., a natural number). The inputof the register machine is located in register r1, while the remaining registersare initially null (i.e., they contain zero). The behaviour of the counter machineis described by a finite sequence of instructions, uniquely labelled by naturalnumbers, and a program counter stores the label of the instruction currentlybeing executed. The program counter is, by convention, initially null.

The variant of register machine we consider here only has two kinds of in-structions. The first kind is an increment instruction, which is denoted by thesyntax

i : inc(r), j

Here i is the label of the instruction, r is the name of a register, and j is aninstruction label. The execution of this instruction causes the increment by oneof the value of register r, and changes the value of the program counter to j.

The second type of instruction is a conditional decrement, with the syntax

i : dec(r), j, k

where i is the label of the instruction, r is a register, and j and k two furtherinstruction labels. The execution of this instruction depends on the currentvalue of register r. If this is greater than zero, then it is decremented by oneand the computation proceeds with the instruction labelled by j; otherwise, theregister remains null and the program counter is set to k.

The computation of the register machine begins with the initial value of theprogram counter and proceeds by updating it according to the current instruc-tion. The computation halts when the program counter reaches a value notassociated with any instruction; alternatively, the computation can go on for-ever if this never happens. Halting computations can be considered to produce,as output, the final value of register r1.

An instantaneous configuration (i, x1, . . . , xn) of the register machine con-sists of the value of the program counter i and the values x1, . . . , xn of theregisters r1, . . . , rn. Such configuration can be encoded as a multiset over thealphabet

{pi : i is a label appearing in the program} ∪ {r1, . . . , rn}

where the multiplicity of rj is exactly the value xj of register rj for 1 ≤ j ≤n, and exactly one of the pi’s occurs and with multiplicity one, represent-ing the current value of the program counter. Hence, an arbitrary configu-ration (i, x1, . . . , xn) of the register machine is encoded as pi r

x11 · · · rxn

n .The instructions of the register machine are simulated by multiset rewrit-

ing rules operating in the maximally parallel way. Each increment instruc-tion i : inc(r), j is implemented as a single rewriting rule

pi → pjr

which simultaneously replaces the program counter symbol with the updatedone, and increments by one the multiplicity of symbol r as required.

10

A conditional decrement instruction i : dec(r), j, k requires checking whethersymbol r occurs with multiplicity zero or greater than zero; this can be imple-mented by using appropriately synchronised cooperative rewriting rules [10].First of all, symbol pi is rewritten by

pi → p′i dr

where symbol dr will try to delete an occurrence of r, while p′i waits one step inorder to allow this decrement to occur:

drr → d′r p′i → p′′i

Notice that the first rule can only be applied when at least one instance ofsymbol r occurs: in that case, symbol d′r is produced; otherwise, symbol drremains inert and is carried on to the next configuration. Symbol p′′i is able todiscriminate between these two cases by applying one of the following mutuallyexclusive rules:

p′′i d′r → pj p′′i dr → pk

The rule that is actually applied produces the correct symbol encoding theupdated value of the program counter.

The rules described above, applied to the encoding of a configuration ofthe register machine, produce (in up to three steps) the encoding of the nextconfiguration, obtained by executing the prescribed inc or dec operation. Thisprocedure halts if and when the simulated register machine halts; in that case,the output of the register machine can be recovered from the multiplicity ofsymbol r1.

7 Efficient simulation of polynomial-time Tur-ing machines

Although cooperative multiset rewriting rules suffice to attain universality, theregister machines simulated in the previous section are, in general, exponen-tially slower than the reference model for efficient computation, namely Turingmachines [8].

Turing machines themselves can be simulated by multiset rewriting systemswhen the space employed (i.e., the tape length m) is a priori known. Thesymbols in a multiset does not, by themselves, possess the linear ordering of thesymbols on the tape of a Turing machine. This can be simulated by indexing thesymbols of the tape alphabet Σ of the Turing machine with integer subscriptsranging from 1 to m, the space bound previously assumed. This allows us toencode the first m tape cells (including the blank ones) as a multiset of msymbols. The current state q of the Turing machine, ranging over the set ofstates Q, and the current position i of the tape head (also ranging from 1 to m)can be encoded by an extra symbol qi, which contains both pieces of information.For instance, a sample Turing machine configuration is encoded as follows:

a a b a

q

a1 a2 q2 b3 a4 �5 �6

11

a a b a

q

a1 a2 q2 b3 a4 �5 �6

a b b a

r

a1 b2 b3 r3 a4 �5 �6

Figure 2: On the left, a Turing machine performing the transition δ(q, a) =(r, b,+1) and, on the right, the corresponding rewriting step between two mul-tisets encoding the configurations of the Turing machine.

Let δ : Q × Σ → Q × Σ × {−1, 0,+1} be the transition function of the Turingmachine. Each transition δ(q, a) = (r, b, d) is implemented by a rewriting rulefor each position 1 ≤ i ≤ m of the tape:

qi ai → ri+d bi

These rules simultaneously update the state and head position of the simulatedTuring machine, and the content of the cell previously located under the tapehead, as exemplified in Figure 2.

This simulation is carried out efficiently, actually in “real time” (each stepof the Turing machine is simulated by a single rewriting step), and shows thatmultiset rewriting can be efficient, whenever the space bound is known. Thismeans that, unlike the register machine simulation (where a single rewritingsystem simulates the given register machine on all possible inputs), a family ofrewriting systems is needed, depending on the space bound (which is, ultimately,a function of the length of the input string).

The rewriting systems of the family differ only with respect to the subscriptsof its symbols, since the rules simulating the transitions of the Turing machineare simply replicated for each cell index. This means that the family is uni-form: there exists a single algorithm (and an efficient one on top of that) forconstructing the m-th member of the family, where m is the length of the tapeto be simulated. This echoes similar constructions for models of computationsuch as families of Boolean circuits [33], where the shape of each circuit does,of course, depend on the number of input bits.

8 Simulating nondeterminism with membranedivision

Using membranes allows us to partition the space in multiple regions evolvingin parallel, possibly according to distinct sets of rules. For instance, the rewrit-ing rule u1 → v1 might only be associated with membrane label h, while therewriting rule u2 → v2 is associated with label k. We denote such region-specific

12

rules with the syntax

[u1 → v1]h [u2 → v2]k

A mechanism to allow distinct regions to exchange objects is given by com-munication rules, either sending multisets towards the region outside a mem-brane h, or towards an internal membrane k:

[u1]h → [ ]h v1 u2 [ ]k → [v2]k

These rules send out the objects in the multiset u1 (resp., send in u2) towardsthe target region, while simultaneously rewriting the multiset into v1 (resp., v2).Notice that a send-in communication rule is a potential source of nondetermin-ism, in the case that the region where the rule is applied contains two or moremembranes with label k. By using communication rules, the multisets can bemoved around the P system, allowing distinct processing to occur, such as con-ditional behaviour or “subroutines”.

The role of membranes becomes dramatic when new membranes can becreated during the computation. The most common approach is membranedivision, which mimics the biological process of binary fission (occurring, forinstance, in cell mitosis). A simple kind of membrane division rule has the form

[u]h → [v]h [w]h

where h is a membrane label and u, v, w are multisets. This rule is applicable toa region delimited by a membrane with label h that contains u as a submultiset.Membrane h is duplicated, its content is replicated inside both resulting mem-branes, with the exception that multiset u is rewritten into v in one membrane,and into w in the other one. This allows us to differentiate the two membranes,which can then operate in parallel on distinct data.

If further rules are simultaneously applicable inside membrane h, the usualsemantics [25] requires the division process to logically occur after the remainingrules have been applied, although this only requires a single time step. Thisway, the only difference between the two resulting copies of membrane h isgiven by the two multisets v, w on the right-hand side of the division rule.If membrane h contains further membranes, the whole subtrees are replicatedwhen the membrane divides.

The power of membrane division stems from the possibility to repeatedlyapply division rules, creating in polynomial time an exponential number ofmembranes working in parallel. This allows us, for instance, to simulate nonde-terminism using parallelism.

Let us consider the Turing machine simulation of Section 7, and extend it tonondeterministic Turing machines, allowing the transition function δ to assume(without loss of generality) one or two values for each input pair (q, a). Letus place the multiset encoding the instantaneous configuration of the Turingmachine inside a membrane h. A deterministic transition δ(q, a) = {(r, b, d)} issimulated as before, by the rules

[qi ai → ri+d bi]h for 1 ≤ i ≤ m

On the other hand, a nondeterministic transition δ(q, a) = {(r, b, d), (s, c, e)}can be simulated by dividing the membrane, and carrying on the two possible

13

computations in parallel, inside the two resulting membranes:

[qi ai]h → [ri+d bi]h [si+e ci]h for 1 ≤ i ≤ m

When the simulated Turing machine reaches a halting state, either an acceptingstate qyes or a rejecting state qno , the corresponding object qyes,i or qno,i (forsome 1 ≤ i ≤ m, corresponding to the position where the tape head is locatedupon halting) is sent out by a communication rule

[qyes,i]h → [ ]h qyes for 1 ≤ i ≤ m[qno,i]h → [ ]h qno for 1 ≤ i ≤ m

The final result of the simulated Turing machine is given by the multiplicity ofthe object qyes in the outside region when the P system halts: acceptance ifthere is at least one instance of qyes (corresponding to at least one acceptingcomputation of the Turing machine), and rejection otherwise (if all simulatedcomputations were rejecting).

Figure 3 shows the correspondence between the nondeterministic choices ofa Turing machine and the membranes obtained by division and operating inparallel in the P system simulating it.

9 Simulating alternation using non-elementarymembrane division

The simulation of nondeterministic Turing machines in Section 8 only requiresdivision rules for elementary membranes. The efficiency of P systems increases3

by exploiting the division of non-elementary membranes, which replicates wholesubtrees of the membrane structure. This makes it possible to simulate notonly nondeterminism, but also alternation, which allows Turing machines tocharacterise the complexity class PSPACE in polynomial time [23].

Recall that an alternating Turing machine has a set of states Q partitionedinto existential and universal states. A configuration leads to acceptance ifeither

• the state of the machine is accepting, or

• the state of the machine is existential, and at least one successor configu-ration leads to acceptance, or

• the state of the machine is universal, and all successor configurations leadto acceptance.

The Turing machine is said to accept its input if the corresponding initial con-figuration leads to acceptance, and to reject otherwise. A sample alternatingcomputation tree is shown in Figure 4.

Notice that a standard nondeterministic Turing machine is simply an al-ternating Turing machine where all states are existential, and thus there is noalternation between existential and universal.

Let us consider an alternating Turing machine M working on input x;suppose, without loss of generality [23], that all computations have the same

3Under standard complexity theory assumptions, namely NP 6= PSPACE.

14

yes yesno no no no

t = 0

t = 1

t = 2

t = 3

t = 4

t = 0

t = 1

t = 2

t = 3

t = 4

t = 5

Figure 3: The computation tree of a nondeterministic Turing machine, withthe accepting computations highlighted in grey (top), and the correspondingparallel computation of a P system simulating it (bottom). Each nondetermin-istic transition of the Turing machine is simulated by a membrane division, ashighlighted by the corresponding arrows of the two diagrams. In the last com-putation step of the P systems (t = 5) the results of all simulated computationsare sent out to the outermost membrane.

15

1 0 0 1 1

t = 0

t = 1

t = 2

t = 3

t = 4

Figure 4: The computation tree of an alternating Turing machine (left), withthe kind of state, existential or universal, represented by an isomorphic circuitwith or and and gates, respectively (right).

length t. We simulate the machine by means of a P system by generating (viamembrane division rules) a membrane structure isomorphic to the computationtree of M . The initial membrane structure consists of t + 1 linearly nestedmembranes; since the rules will be the same for each membrane, these can beassumed to be all identically labelled by h. Notice that this last assumptionis not strictly compatible with the formal definition of membrane structure,but can be simulated by replicating all rules for each membrane label; we canthus safely make this assumption without changing the computing power of themodel. The encoding of the configuration of M (as described in Section 8) isinitially located inside the outermost membrane.

The simulation of each computation step of M is similar to the one illus-trated in Section 8, but before performing this simulation, the encoding of theconfiguration of M is moved one level deeper in the membrane structure, whileleaving behind an object (q, a) representing the current state of the Turing ma-chine and the object under its tape head. This process begins with the followingrule:

[qi ai → (q, a) qi,1 ai]h for q ∈ Q, a ∈ Σ, and 1 ≤ i ≤ m

The object qi,j , with 1 ≤ j ≤ m brings the object xj encoding the symbol onthe j-th tape cell of M into the internal membrane:

qi,j xj [ ]h → [q′i,j xj ]h for q ∈ Q, 1 ≤ i ≤ m, and 1 ≤ j ≤ m

If there remain objects to bring in (i.e., if j < m), the object q′i,j is sent outwith an incremented subscript:

[q′i,j ]h → [ ]h qi,j+1 for q ∈ Q, 1 ≤ i ≤ m, and 1 ≤ j < m

Otherwise, the configuration of M has been completely moved one level deeperin the membrane structure, while leaving the object (q, a) outside. The cur-rent computation step of M can now be simulated. If this is a deterministictransition δ(q, a) = {(r, b, d)}, then the P system applies one of the rewriting

16

rules

[q′i,m ai → ri+d bi]h for 1 ≤ i ≤ m

If the transition is nondeterministic, such as δ(q, a) = {(r, b, d), (s, c, e)}, thenthe P system applies a membrane division rule, which is non-elementary in allcomputation steps but the last one:

[q′i,m ai]h → [ri+d bi]h [si+e ci]h for 1 ≤ i ≤ m

Any subsequent computation steps are simulated recursively in the same way,at deeper and deeper levels of the membrane structure.

When a computation of the Turing machine reaches an accepting state qyesor a rejecting one qno in the last computation step, the corresponding object issent out as yes or no, respectively:

[qyes,i]h → [ ]h yes [qno,i]h → [ ]h no for 1 ≤ i ≤ m

The membrane immediately outside receives either one or two objects yes,nofrom its child (resp., children) membranes, depending on whether the corre-sponding transition was deterministic or nondeterministic. The object (q, a)that was left behind when that transition was simulated stores two pieces ofinformation: whether the transition was deterministic, and whether the state qof M at the time was existential or universal. This process is depicted in Fig-ure 5.

If the transition was nondeterministic and the state existential, then themembrane receives two objects. The configuration previously located insidethat membrane leads to acceptance if at least one of the two result objectsis yes. This information is recursively propagated back towards the outermostmembrane by using the rules

[(q, a) yes yes]h → [ ]h yes [(q, a) yes no]h → [ ]h yes [(q, a) no no]h → [ ]h no

that is, the two objects are combined by logical disjunction, corresponding toan existential nondeterministic choice.

Dually, if the transition was nondeterministic and the state universal, the tworesult objects are combined by logical conjunction, corresponding to a universalnondeterministic choice:

[(q, a) yes yes]h → [ ]h yes [(q, a) yes no]h → [ ]h no [(q, a) no no]h → [ ]h no

If the transition was instead deterministic, then the existential or univer-sal nature of the state is immaterial, and the unique result object is simplypropagated outside:

[(q, a) yes]h → [ ]h yes [(q, a) no]h → [ ]h no

A simple inductive reasoning shows that the yes or no object sent out from theoutermost membrane corresponds to the actual result of the simulated alternat-ing Turing machine.

17

(q1, a1)

(q1, a1)

(q2, a2)

t = 0 t = 1

t = 2 t = 3

t = 4

(q1, a1)

(q2, a2)

(q3, a3) (q4, a4)

qyes qno qyes qyesqno

(q5, a5) (q6, a6) (q7, a7)

(q3, a3) (q4, a4)

(q2, a2)

(q1, a1)

Figure 5: The computation tree of Figure 4 is simulated by the isomorphicmembrane structure of a P system with membrane division (bottom, t = 4),which is constructed by using send-in and membrane division from an initiallylinear membrane structure (t = 0). The internal membranes contain encodingsof configurations of the Turing machine, while the external ones each containan object storing the information needed to combine (by or or and) the resultsof the subcomputations being simulated by its children membranes.

18

10 Conclusions and pointers to the literature

In this chapter we tried to give a gentle introduction to P systems, using asimplified cell-based model. Indeed, since their first appearance in the literature[24], it has been clear that P systems constitute more a framework to defineclasses of abstract models of computation, rather than a specific model. Anumber of variants of P systems, and of models of computation inspired bythem, has been proposed in the last years.

A first class of these variants is obtained by removing or adding computa-tional features to the cell-based model we have described above. So, for example,when investigating computability and computational complexity issues, a com-mon observation made in the membrane computing community is that cooper-ative rules, having two or more objects in their LHS, are too powerful. Indeed,as we have shown above, it is very easy to obtain the computational power ofregister machines and of Turing machines (hence, universality) by means of asimple set of rules, and it is also easy to solve computationally difficult problemsin polynomial time. Among the ways proposed in literature to avoid coopera-tive rules, one of the most successful (in terms of number of papers published)is endowing membranes with an electric charge, which can be either positive(denoted with +), negative (−), or null (0). The resulting model is called Psystems with active membranes. The rules which can be used in this model arethe same as defined in section 4, with two important differences:

• all the membranes mentioned in each rule have an electrical charge. Thisallows us to partition the set of rules associated with the region enclosedby a membrane into classes, each one composed of rules which can onlybe applied under a given charge;

• the LHS of every evolution rule contains just one object. No constraintsare instead imposed on the multiset of objects that these rules can produceon their right hand side.

Adding electrical charges to membranes allows one to move cooperation frommultisets of objects to single objects and membranes. With this limited versionof cooperation, it clearly becomes more difficult to both obtain the computingpower of Turing-machines and solving NP-complete [25] or PSPACE-complete[30] problems. However, by using standardized constructions [19] it actuallybecomes much easier to design such systems. An extended literature exists onmembrane systems with active membranes, especially related with the capabilityof solving computationally hard problems: the reader may consult the referencesgiven at the end of this chapter to find good pointers to start with.

Another example of cell-based membrane systems is P systems with sym-port/antiport rules [28], in which the rules are cooperative and are inspiredfrom the coordinated transport of substances across the membranes. Indicatedwith x and y two multisets of objects, the rules may be of the following forms:

• (x, in): the objects of x are moved into the current region (where the ruleis defined) from the surrounding region;

• (x, out): the multiset x of objects is moved to the surrounding region;

19

• (x, in; y, out): the objects of x are moved from the surrounding region intothe current region, and simultaneously the objects of multiset y are movedin the opposite direction.

The first two kinds of rules are called symport rules, whereas the rule (x, in; y, out)is called an antiport rule. Even inside the class of cell-based symport/antiportP systems, some variants have been defined and their computational propertieshave been investigated; we refer the interested reader to [11] and to chapter 5of the Handbook of Membrane Computing [27].

Cell-based P systems are not the only model which has been proposed inthe literature. By neglecting the internal structure of cells, and focusing insteadthe attention on the connections between different cells, tissue P systems canbe defined [20]. In this model the cells are represented as the nodes of a graph,whose arcs indicate the connections between the cells, and thus provide a wayto represent inter-cellular communication. Such a communication occurs viarules that closely resemble the above mentioned antiport rules, and consistsof an exchange of substances between adjacent cells. The interested readercan find further information in chapter 9 of [27]. Also in this case, severalvariants of tissue P systems have been defined: in the original model [20] thecells had an internal state, a feature which has been dropped very soon sincein the computability and computational complexity setting it is considered toopowerful. On the other way, cell division rules have been added in order to allowthe systems to solve computationally difficult problems [29], just like it happenswith P systems with active membranes. However, the lack of internal structureprevents them from being able to solve PSPACE-complete problems; perhapssurprisingly, they turn out to be able to solve in polynomial time exactly theproblems in P#P, the class of problems solved by Turing machines with oraclesfor counting problems [18].

Tissue P systems have also inspired spiking neural (SN) P systems [15], inwhich the graph of cells represents a neural network, on its turn inspired bythe structure and functioning of living nervous systems. One peculiarity of SNP systems is that they use only one kind of objects, called the spike. Eachcell – called neuron in this model – contains a set of rules, which may be oftwo different types: spiking rules, that send a predefined number of spikes toall neighbouring neurons, and forgetting rules, that delete a predefined numberof spikes from the neuron itself. Spiking rules are enabled according to thenumber of spikes currently contained in the neuron: in fact, each rule has anassociated regular expression which determines a regular set of non-negativeinteger numbers, that describe when the rule is enabled to spike. Also in thiscase the Handbook of Membrane Computing [27] is a valuable resource to obtainfurther information, but the reader should also be aware that several furthervariants of spiking neural P systems have been defined and investigated in thelast few years.

For an updated bibliography, we refer the reader to the P systems Webpage [31] as well as to the Web page of the International Membrane Comput-ing Society [14], that publishes a Bulletin (four issues per year) containing thelatest news about P systems, and promotes the International series of Confer-ences on Membrane Computing (CMC), and Asian Conferences on MembraneComputing (ACMC). By consulting the Bulletin and the Proceedings of theseconferences, the reader will discover many other interesting P systems models,

20

such as (enzymatic) numerical P systems, P automata, population P systems,metabolic P systems, P systems with antimatter, SN P systems with anti-spikes,and still probabilistic and quantum and asynchronous variants, operating underdifferent modes of applying the rules. There is an entire world to be explored!

We conclude by remarking that in this chapter we took a theoretical ap-proach, interested to determine the computational properties of P systems whenconsidered as abstract models of computation. From the point of view of ap-plications there is once again a considerable literature on using P systems tomodel different kinds of biological and natural phenomena, and an even vasternumber of papers and software tools dealing with efficient simulations of severalvariants of P systems, exploiting the parallel computing power of modern GPUs.The above mentioned references and resources provide also in this case the bestpointers to start with.

References

[1] Scott Aaronson. Why philosophers should care about computational com-plexity. Technical report, http://eccc.hpi-web.de/report/2011/108/,2011.

[2] Leonard M. Adleman. Molecular computation of solutions to combinatorialproblems. Science, 266(5187):1021–1024, 1994.

[3] Roberto Barbuti, Andrea Maggiolo-Schettini, Paolo Milazzo, Giovanni Par-dini, and Luca Tesei. Spatial P systems. Natural Computing, 10(1):3–16,2011.

[4] Stephen A. Cook. The complexity of theorem-proving procedures. In Pro-ceedings of the Third Annual ACM Symposium on Theory of Computing,STOC ’71, pages 151–158, 1971.

[5] Jack Copeland, editor. The Essential Turing: Seminal Writings in Com-puting, Logic, Philosophy, Artificial Intelligence, and Artificial Life, Plusthe Secrets of Enigma. Oxford University Press, 2004.

[6] Martin Davis, editor. The Undecidable: Basic Papers on UndecidablePropositions, Unsolvable Problems and Computable Functions. RavenPress, 1965.

[7] Jack Edmonds. Paths, trees and flowers. Canadian Journal of Mathematics,17:449–467, 1965.

[8] Patrick C. Fischer, Albert R. Meyer, and Arnold L. Rosenberg. Countermachines and counter languages. Theory of Computing Systems, 2(3):265–283, 1968.

[9] Lance Fortnow and Steve Homer. A short history of computational com-plexity. Bulletin of the European Association for Theoretical ComputerScience, 80:95–133, 2003.

[10] Pierluigi Frisco. P systems, Petri nets, and program machines. In RudolfFreund, Gheorghe Paun, Grzegorz Rozenberg, and Arto Salomaa, editors,

21

Membrane Computing, 6th International Workshop, WMC 2005, volume3850 of Lecture Notes in Computer Science, pages 209–223. Springer, 2006.

[11] Pierluigi Frisco. Computing with Cells: Advances in Membrane Computing.Oxford University Press, New York, NY, USA, 2009.

[12] Juris Hartmanis and Richard E. Stearns. On the computational complex-ity of algorithms. Transactions of the American Mathematical Society,117:285–306, 1965.

[13] Tom Head. Formal language theory and DNA: An analysis of the genera-tive capacity of specific recombinant behaviors. Bulletin of MathematicalBiology, 49(6):737–759, 1987.

[14] International Membrane Computing Society (IMCS). http:

//membranecomputing.net/.

[15] Mihai Ionescu, Gheorghe Paun, and Takashi Yokomori. Spiking neural Psystems. Fundamenta Informaticae, 71(2,3):279–308, 2006.

[16] Richard M. Karp. Reducibility among combinatorial problems. In Com-plexity of Computer Computations, pages 85–104. Plenum Press, 1972.

[17] Tsuneyoshi Kuroiwa, Haruko Kuroiwa, Atsushi Sakai, Hidenori Takahashi,Kyoko Toda, and Ryuuichi Itoh. The division apparatus of plastids andmitochondria. International Review of Cytology, 181:1–41, 1998.

[18] Alberto Leporati, Luca Manzoni, Giancarlo Mauri, Antonio E. Porreca,and Claudio Zandron. Characterising the complexity of tissue P systemswith fission rules. Journal of Computer and System Sciences, 90:115–128,2017.

[19] Alberto Leporati, Luca Manzoni, Giancarlo Mauri, Antonio E. Porreca,and Claudio Zandron. A toolbox for simpler active membrane algorithms.Theoretical Computer Science, 673:42–57, 2017.

[20] Carlos Martın-Vide, Gheorghe Paun, Juan Pazos, and Alfonso Rodrıguez-Paton. Tissue P systems. Theoretical Computer Science, 296(2):295–326,2003.

[21] Warren S. McCulloch and Walter Pitts. A logical calculus of the ideasimmanent in nervous activity. Bulletin of Mathematical Biophysics, 7:115–133, 1943.

[22] Marvin Minsky. Computation: Finite and Infinite Machines. Prentice-Hall,1967.

[23] Christos H. Papadimitriou. Computational Complexity. Addison-Wesley,1993.

[24] Gheorghe Paun. Computing with membranes. Journal of Computer andSystem Sciences, 61(1):108–143, 2000.

[25] Gheorghe Paun. P systems with active membranes: Attacking NP-completeproblems. Journal of Automata, Languages and Combinatorics, 6(1):75–90,2001.

22

[26] Gheorghe Paun. Membrane computing: History and brief introduction. InErol Gelenbe and Jean-Pierre Kahane, editors, Fundamental Concepts inComputer Science, pages 17–41. Imperial College Press, 2009.

[27] Gheorghe Paun, Grzegorz Rozenberg, and Arto Salomaa, editors. TheOxford Handbook of Membrane Computing. Oxford University Press, 2010.

[28] Andrei Paun and Gheorghe Paun. The power of communication: P systemswith symport/antiport. New Generation Computing, 20(3):295–305, 2002.

[29] Gheorghe Paun, Mario J. Perez-Jimenez, and Agustın Riscos-Nunez. Tis-sue P systems with cell division. International Journal of Computers, Com-munications & Control, 3(3):295–303, 2008.

[30] Petr Sosık and Alfonso Rodrıguez-Paton. Membrane computing and com-plexity theory: A characterization of PSPACE. Journal of Computer andSystem Sciences, 73(1):137–152, 2007.

[31] P systems web site. http://ppage.psystems.eu/.

[32] Alan M. Turing. On computable numbers, with an application to theEntscheidungsproblem. Proceedings of the London Mathematical Society,42:230–265, 1936.

[33] Heribert Vollmer. Introduction to Circuit Complexity: A Uniform Ap-proach. Texts in Theoretical Computer Science: An EATCS Series.Springer, 1999.

[34] Richard Zach. Hilbert’s program then an now. In Dale Jacquette, editor,Philosophy of Logic, volume 5, pages 411–447. Elsevier, 2006.

23