A CLIPS Simulator for Recognizer P Systems with Active Membranes

A CLIPS Simulator for Recognizer P Systems with Active Membranes Mario P´ EREZ-JIM´ ENEZ, Francisco Jos´e ROMERO-CAMPERO Research Group on Natural Computing Department of Computer Science and Artificial Intelligence University of Sevilla Avda. Reina Mercedes s/n, 41012 Sevilla, Spain E-mail: {Mario.Perez, Francisco-Jose.Romero}@cs.us.es Abstract. In this paper we propose a new way to represent recognizer P systems with active membranes based on Production Systems techniques. This representation allows us to express the set of rules and the configurations in each step of the evolution as facts in a knowledge base. We provide a CLIPS program to simulate the evolutions of this variant of P systems. 1 Introduction In [3] a new model of computation called P systems, within the framework of Natural Computing (bio-inspired computing), was introduced by Gh. P˘aun. This model starts from the observation that the processes which take place in the complex structure of a living cell can be considered as computations. It is based upon the notion of membrane structure that is used to enclose computing cells in order to make them independent computing units. Also, a membrane serves as a communication channel between a given cell and other cells adjacent to it. Since these computing devices were introduced several variants have been considered. A fairly complete compendium about P systems can be found in [2]. The different variants of P systems found in the literature are generally thought as generating devices. Many of them have been proved to be computationally complete: they compute all Turing computable sets of natural numbers or all recursively enumerable languages, depending on the variant considered. The model we study here, recognizer P systems with active membranes (a recognizing language device), works with symbol-objects, and it provides rules of division for membranes. In particular, P systems with active membranes are studied in [2], section 7.2. The main goal of this paper is to show a representation of P systems with active membranes based on Production Systems techniques. Production Systems were first introduced by Post in 1943 in order to describe rewrite rules for symbol strings and are nowadays used as the basis for many rule-based systems. In this programming paradigm, rules are used to represent heuristics, or “rules of thumb”, which specify a set of actions to be performed for a given situation. A rule is composed of a left hand side portion (if part) and a right hand side portion (then part). The LHS 387 of a rule is a series of patterns which specify the facts (or data) which cause the rule to be applicable. The process of matching facts to patterns is called pattern matching. There exists a mechanism, called the inference engine, which automatically matches facts against patterns and determines which rules are applicable. The RHS of a rule is the set of actions to be executed when the rule is applicable. The actions of applicable rules are executed when the inference engine is instructed to begin execution. By using a resolution strategy, the inference engine selects a rule and then the actions of the selected rule are executed (which may affect the list of applicable rules by adding or removing facts). The inference engine then selects another rule and executes its actions. This process continues until no applicable rules remain. The paper is organized as follows: Section 2 briefly presents some ideas about the analogies between P systems and Production Systems. Section 3 recalls recognizer P systems with active membranes, input membrane and external output. Section 4 introduces CLIPS as a programming language used in Production Systems. Section 5 introduces the way to represent all basic ingredients of this variant of P systems. Section 6 studies the designed algorithm to simulate recognizer P systems and Section 7 presents a session with the simulator. Section 8 presents some conclusions. 2 P Systems versus Production Systems In this section we will discuss some analogies between Production Systems and P systems. Basically, a Production System consists in tree components: •Working Memory: A set of “facts” consisting of positive literals defining what’s known to be true about the world. •Rules: An unordered set of user-defined “if-then” rules of the form: if P1∧... ∧Pmthen Action1, ..., Actionn where the Pis are facts that determine the conditions when this rule is applicable. Each Action adds or deletes a fact from the Working Memory. •Inference Engine: Procedure for inferring changes (additions and deletions) to Working Memory. Usually a cycle of three phases takes place: match, conflict resolution, and action (in that order). 1. Match the current Working Memory with the rule-base (Rete algorithm): Construct Conflict Set, the set of all possible (rule,list-of-facts) pairs such that rule is one of the rules and list-of-facts is a subset of facts in Working Memory that unify with the antecedent part (i.e., Left-hand side) of the given rule. If Conflict Set is empty then Halt else Go to 2 388 2. Conflict Resolution: Instead of trying all applicable rules in the Conflict set, select one for execution using a conflict resolution strategy. 3. Act/Fire: Execute the actions associated with the RHS part of the selected rule, after making the substitutions used during unification of LHS part with the list-of-facts. In P systems we have rules that are applicable only under certain conditions (as in Production systems). The application of a rule in P systems implies the evolution of elements and/or membranes, that is a change in the current “configuration of the world”. This is the case in Production Systems where the application of a rule implies changes in the Working Memory. P systems are in general non deterministic, so they have some kind of mechanism, similar to the conflict resolution phase in Production Systems, that chooses which rules from the set of applicable rules are actually applied. Because of all the analogies mentioned above it seems natural to think of P systems as rule-based systems within the framework of Production Systems and to try to represent and simulate them in a straightforward way using Production Systems techniques. 3 Recognizer P systems with Active Membranes, Input Membrane and External Output Recall that a decision problem, X, is a pair (IX, θX) such that IXis a language over a finite alphabet (whose elements are called instances) and θXis a total boolean function over IX. Definition 3.1 AP system with input is a tuple (Π,Σ, iΠ), where: •Πis a P system, with working alphabet Γ, with pmembranes labelled by 1, . . . , p, and initial multisets M1, . . . , Mpassociated with them. •Σis an (input) alphabet strictly contained in Γ. •The initial multisets are over Γ−Σ. •iΠis the label of a distinguished (input) membrane. Definition 3.2 Let (Π,Σ, iΠ)be a P system with input. Let Γbe the working alphabet of Π,µthe membrane structure and M1, . . . , Mpthe initial multisets of Π. Let mbe a multiset over Σ. The initial configuration of (Π,Σ, iΠ) with input mis (µ0, M0), where µ0=µ,M0(j) = Mj, for each j6=iΠ, and M0(iΠ) = MiΠ∪m. The computations of a P system with input m∈M(Σ), a multiset over Σ, are defined in a natural way. The only novelty is that the initial configuration must be the initial configuration of the system associated with the input multiset m∈M(Σ). In the case of P systems with input and with external output, the concept of computation is introduced in a similar way but with a small change. In the configurations, we will not work directly with the membrane structure µbut with another structure associated with it including, in some sense, the environment. 389 Definition 3.3 Let µ= (V(µ), E(µ)) be a membrane structure. The membrane structure with environment associated with µis the rooted tree Ext(µ)such that: (a)the root of the tree is a new node that we will denote env;(b)the set of nodes is V(µ)∪ {env}; and (c) the set of edges is E(µ)∪ {{env, skin}}. The node env is called the environment of the structure µ. Note that we have only included a new node representing the environment which is only connected with the skin, while the original membrane structure remains unchanged. In this way, every configuration of the system informs about the contents of the environment. Definition 3.4 Alanguage accepting P system is a P system with input, (Π,Σ, iΠ), and with external output, such that the output alphabet contains only two elements: Y es and No. This definition is stated in a general way, but in this paper P systems within the active membrane model will be used. We refer to [2] (see chapter 7) for a detailed definition of evolution rules, transition steps, and configurations in this model. Now let us define the Output function for our P systems. Given a computation C= {Ci}i<r, we will denote by Mj env the content of the environment in the configuration Cj. Definition 3.5 The output of a computation C={Ci}i<r is: Output(C) =    Y es, if Cis halting, Y es ∈Mr−1 env and No /∈Mr−1 env , No, if Cis halting, No ∈Mr−1 env and Y es /∈Mr−1 env , not defined, otherwise. If Csatisfies any of the two first conditions, then we say that it is a successful computation. Definition 3.6 A language accepting P system is said to be valid if for every halting computation, and only for them, one symbol Y es or one symbol No (but not both) is sent out (in the last step of the computation). Definition 3.7 We say that Cis an accepting computation (respectively, rejecting computation) if the object Y es (respectively, No) appears in the environment associated with the corresponding halting configuration of C; that is, Output(C) = Y es (respectively, Output(C) = No). Definition 3.8 Alanguage recognizer P system is a valid language accepting P system such that all its computations halt. This recognizer systems are specially suitable when trying to solve decision problems. In this paper we will deal with recognizer P systems with active membranes, input membrane, and external output. We recall the fact that a P system with active membranes is a tuple Π = (Σ, H, µ, ω1, . . . , ωm, R), where: 1. m≥1, is the initial degree of the system; 390 2. Σ is the alphabet of symbol-objects; 3. His a finite set of labels for membranes; 4. µis a membrane structure, of mmembranes, labelled (not necessarily in a one-to-one manner) with elements of H; 5. ω1, . . . , ωmare strings over Σ, describing the initial multisets of objects placed in the mregions of µ; 6. Ris a finite set of evolution rules, of the following forms: (a) [ a→ω]α hfor h∈H,α∈ {+,−,0},a∈Σ, ω∈Σ∗,object evolution rules: This is an object evolution rule, associated with a membrane labelled with hand depending on the polarity of that membrane, but not directly involving the membrane. (b) a[ ]α1 h→[b]α2 hfor h∈H,α1, α2∈ {+,−,0},a, b ∈Σ, communication rules (send in rules): An object from the region immediately outside a membrane labelled with his introduced in this membrane, possibly transformed into another object, and simultaneously, the polarity of the membrane can be changed. (c) [ a]α1 h→b[ ]α2 hfor h∈H,α1, α2∈ {+,−,0},a, b ∈Σ, communication rules (send out rules): An object is sent out from membrane labelled with hto the region immediately outside, possibly transformed into another object, and simultaneously, the polarity of the membrane can be changed. (d) [ a]α h→bfor h∈H,α∈ {+,−,0},a, b ∈Σ, dissolving rules: A membrane labelled with his dissolved in reaction with an object. The skin is never dissolved. (e) [ a]α1 h→[b]α2 h[c]α3 hfor h∈H,α1, α2, α3∈ {+,−,0},a, b, c ∈Σ, division rules for elementary membranes: An elementary membrane can be divided into two membranes with the same label, possibly transforming some objects and their polarities. These rules are applied according to the following principles: •All the rules are applied in parallel and in a maximal manner. In one step, one object of a membrane can be used by only one rule (chosen in a non deterministic way), but any object which can evolve by one rule of any form, should evolve. •If a membrane is dissolved, its content (multiset and internal membranes) is left free in the surrounding region. •If at the same time a membrane his divided by a rule of type (e) and there are objects in this membrane which evolve by means of rules of type (a), then we suppose that first the evolution rules of type (a) are used, and then the division is produced. Of course, this process takes only one step. •The rules associated with membranes labelled with hare used for all copies of this membrane. At one step, a membrane labelled with hcan be the subject of only one rule of types (b)-(e). 391 4 CLIPS as a Programming Language for Production Systems CLIPS is the tool we have chosen to developed a simulator of this variant of P systems. Here we present a short introduction to this programming language; for more information, tutorials, user guide, etc., visit the CLIPS Web Page at [10]. CLIPS is a productive development and delivery expert system tool which provides a complete environment for the construction of rule and/or object based expert systems. The origins of the C Language Integrated Production System (CLIPS) date back to 1984 at NASA’s Johnson Space Center. Originally, the primary representation methodology in CLIPS was a forward chaining rule language based on the Rete algorithm (hence the Production System part of the CLIPS acronym). CLIPS is now widely used throughout the government, industry, and academia. Its key features are: •Knowledge Representation: CLIPS provides a cohesive tool for handling a wide variety of knowledge with support for three different programming paradigms: rulebased, object-oriented, and procedural. •Portability: CLIPS is written in C for portability and speed and has been installed on many different operating systems without code changes. •Integration/Extensibility: CLIPS can be embedded within procedural code, called as a subroutine, and integrated with languages such as C, Java, FORTRAN, and ADA. •Low Cost: CLIPS is maintained as public domain software. 5 A CLIPS Simulator for Recognizer P Systems with Active Membranes In order to design a simulator in CLIPS for recognizer P systems with active membranes we have to give a formal representation for their basic structures, that is, for the membrane structure with the content (multiset) of each membrane and for the evolution rules. 5.1 Representation of Membranes Structures A membrane will be represented using an unordered fact in the Working Memory as follow: (deftemplate membrane (slot number) (slot father) (slot children) (slot configuration) (slot evolved) (slot label) (slot polarization) (multislot multiset)) Using this representation we have: 392 ' & $ % e1 s1s1s2 0 2 ' & $ % ]0 1 Figure 1: Example configuration •Each membrane will be identified in a one-one manner by the slot number. •The membrane structure will be represented using the slots father, which will store the number of the father membrane, and children, which will store the number of each of the child membranes. •During the simulation of a step in the evolution of a P system, we will keep two copies of the same membrane, one for the current configuration and one for the next configuration. The slot configuration will be used to differentiate between these two copies. •The slot evolved will be used to show whether or not the membrane has already evolved in the current step and so it cannot evolve anymore in this step of the computation. •The slots label,polarization, and multiset will store the label, the polarization and the multiset of the membrane. Note that the environment will be represented as the membrane number 0, which has no father, no polarization, no label and one child membrane, the skin, whose number will be 1. For example, the following unordered facts represent the configuration given above: (membrane (number 0) (children 1) (multiset)) (membrane (number 1) (father 0) (children 2) (configuration current)(evolved 0) (label 1) (polarization 0) (multiset #)) (membrane (number 2) (father 1) (children ) (configuration current)(evolved 0) (label 2) (polarization 0) (multiset e 1 , s 1 , s 1 , s 2 )) 5.2 Representation of Rules The rules are represented as facts in the Working Memory. We will represent each type of rule as an unordered fact which will store the relevant features of the rules, that is label, polarization and objects. Each type will be represented using the following templates: •Evolution rules: [a→ω]α h 393 (deftemplate rule-a (slot label) (slot polarization) (multislot left-element) (multislot right-elements)) For example, the rule [s0→S]+ 2will be represented by the following fact: (rule-a (label 2) (polarization +) (left-element s0) (right-elements S)) •Send in communication rules: a[ ]α1 h→[b]α2 h (deftemplate rule-b (slot label) (slot left-pol) (multislot left-element) (slot right-pol) (multislot right-element)) For example, the rule d1[ ]0 2→[d2]0 2will be represented by the following fact: (rule-b (label 2) (left-pol 0)(left-element d1) (right-pol 0)(right-element d2)) •Send out communication rules: [ a]α1 h→b[ ]α2 h (deftemplate rule-c (slot label) (slot left-pol) (multislot left-element) (slot right-pol) (multislot right-element)) For example, the rule [ z]+ 2→][ ]0 2will be represented by the following fact: (rule-c (label 2) (left-pol +)(left-element z) (right-pol 0)(right-element #)) •Dissolution rules: [ a]α h→b (deftemplate rule-d (slot label) (slot polarization) (multislot left-element) (multislot right-element)) 394 For example, the rule [ bn+1 ]0 2→Y ES will be represented by the following fact: (rule-d (label 2) (polarization 0) (left-element b_n+1) (right-element YES)) •Division rules: [ a]α1 h→[b]α2 h[c]α3 h (deftemplate rule-e (slot label) (slot left-pol) (multislot left-element) (slot right-pol-1) (multislot right-element-1) (slot right-pol-2) (multislot right-element-2)) For example, the rule [ en]0 2→[en+1 ]+ 2[en+1 ]0 2will be represented by the following fact: (rule-e (label 2) (left-pol 0) (left-element e_n) (right-pol-1 +) (right-element-1 e_{n+1}) (right-pol-2 0) (right-element-2 e_{n+1})) 6 The Algorithm The CLIPS algorithm to simulate a recognizer P system works in a natural way. We will briefly describe it: Step 1: Initialization. Once the initial configuration associated to the input has been constructed, a copy of each membrane with (configuration current) will be made. In this new copy we will set the slot configuration to next. With these two copies we will be able to handle the current configuration to get to the next configuration. Step 2: Transition. If there exists a membrane with (configuration current) satisfying the condition of a rule, then the rule is applied in the following way: Evolution involving only elements: At this stage, only rules of type (a) can be applied. If there exists one membrane with the (configuration current) satisfying the conditions of a rule of type (a) then the object which tiggers the rule is removed from the membrane with (configuration current) and the RHS part of the rule is added to the membrane with (configuration next). The following CLIPS rule simulates the application of a type (a) rule: (defrule elements-evolution (rule-a (label ?lb) (polarization ?pol) (left-element $?left-element) (right-elements $?right-elements)) ?membrane0 <- (membrane (configuration current) (number ?n) 395 •This stage starts with the evolution of the object dnin the skin. •In every step of this stage the object di, with n≤i≤3n−1, of the skin evolves to di+1. •This stage ends as soon as the object d3nappears in the skin, that is the moment when each internal membrane has positive charge and contains one object c1(obtained by using the first rule of (g)). Therefore, the synchronization stage needs a total of 2nsteps. The checking stage has the goal to determine how many (and which) clauses are true in every internal membrane (that is, by the assignment represented by it). This stage is controlled by the objects ci, with 1 ≤i≤m+ 1, and it starts after the presence of c1in the internal membranes. •The presence of an object ciin an internal membrane shows that the clauses C1, . . . , Ci−1are true by the assignment represented by such membrane. •From every ci(with 1 ≤i≤m) the object ci+1 is obtained in some membranes after the execution of 2 steps. •The checking stage ends as soon as the object d3n+2mappears in the skin. Therefore, the total number of steps of this stage is 2m. The output stage starts immediately after the appearance of the object d3n+2min the skin and it is controlled by the objects e1,e2, and e3. •To produce the output Y es, the object cm+1 must have been produced in every internal membrane of the configuration C5n+2m−1. Then, after 5 steps, the system returns Y es to the environment, through the evolution of objects e3present in the skin, and when it has positive charge. •To produce the output No, two cases can occur: (a) There is no internal membrane of the configuration C5n+2m−1where the object cm+1 is present; in this case, after 5 steps, the system returns No to the environment, through the evolution of the object e1present in the skin membrane and when it has negative charge. (b) There are kinternal membranes (with 1 ≤k < 2n) of the configuration C5n+2m−1where the object cm+1 is present; in this case, after 5 steps, the system returns No to the environment, through the evolution of objects e3 present in the skin and when it has negative charge. Therefore, the total number of steps in the output stage is 5. 7.2 A CLIPS Session for m=n= 2 In this section we present a session with the simulator for a instance of the problem. We consider the formula: ϕ= (x1∨ ¬x1)∧(x2∨ ¬x2). 402 CLIPS> (load ‘‘SIMULATOR.clp’’) CLIPS> (reset) CLIPS> (run) ****************************************************************************** * THIS IS PROGRAM WRITTEN IN CLIPS THAT SIMULATES COMPUTATIONS OF P-SYSTEMS. * ****************************************************************************** The P-system can be introduced using the keyboard or a file. Choose one of the following options: 1 .- If you want to introduce the P-system using the keyboard. 2 .- If you want to introduce a P-system written in a file. 2 Write the path and the file where the P-system is written: /home/Fran/validity.clp ******************************************************************* ** ** ** READ CAREFULLY THE FOLLOWING INFORMATION ABOUT THE P-SYSTEM ** ** ** ******************************************************************* This recognizer P-system with active membranes solves the VALIDITY problem. We will work with formulas in CNF. The system has two parameters: - n number of variables - m number of clauses The input must be introduced as follows: Let Form = C 1 ^ C 2 ^ ... ^ C m, a formula in CNF with n variables x 1 , x 2 , ... , x n. The input of the P-system is given by the following function: g(Form)={xij:xjinCi}U{-xij:-xjinCi} For example: Form=[x1v-x2vx3]^[x2v-x3]^[-x1vx3] g(Form)={x11,-x12,x13,x22,-x23,-x31,x33} ******************************* * P-SYSTEM SUCESSFULLY LOADED * ******************************* Write the value of the parameter n : 2 Write the value of the parameter m : 2 Write the input multiset following the instructions given above: x11,x22,-x11,-x22 Before the simulation of one computation of the P-system with the given input you can choose one of the following options: 403 1 .- If you want to save the configurations in a file. 2 .- If you don’t want to save the configurations. 2 Now you can choose one of the following options: 1.- If you want to see each configuration. 2.- If you only want to see a particular configuration. 3.- If you only want to see the answer of the system. 1 You can also choose whether or not you want to see the applied rules in each configuration: 1.- If you want to see the applied rules. 2.- If you don’t want to see the applied rules. 1 Configuration number: 0 [environment [multiset ]] [skin [children 2] [label 1] [polarity 0] [multiset , e 1 ,]] [membrane [number 2] [children ] [father 1] [label 2] [polarity 0] [multiset,d1,x11,x22,-x11,-x22,]] Above we have the initial configuration with the corresponding input. And now the generation stage begins: The applied rules are: [d1]20->[d1]2+[ d1]2- Configuration number: 1 [environment [multiset ]] [skin [children 3 4] [label 1] [polarity 0] [multiset , e 1 ,]] [membrane [number 4] [children ] [father 1] [label 2] 404 [polarity -] [multiset,d1,x11,x22,-x11,-x22,]] [membrane [number 3] [children ] [father 1] [label 2] [polarity +] [multiset,d1,x11,x22,-x11,-x22,]] The applied rules are: [x11->r11]2+ [x22->x21]2+ [-x 1 1 -> ] 2 + [-x22->-x21]2+ [-x11->r11]2- [x11-> ]2- [x22->x21]2- [-x22->-x21]2- [d1]2+->d1[]20 [d1]2-->d1[]20 Configuration number: 2 [environment [multiset ]] [skin [children 3 4] [label 1] [polarity 0] [multiset , e 1 , d 1 , d 1 ,]] [membrane [number 3] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 1 , x 2 1 , -x 2 1 ,]] [membrane [number 4] [children ] [father 1] [label 2] [polarity 0] [multiset , x 2 1 , r 1 1 , -x 2 1 ,]] The applied rules are: [r11->r12]20 [r11->r12]20 d1[]20->[d2] 20 d1[]20->[d2] 20 Configuration number: 3 405 [environment [multiset ]] [skin [children 3 4] [label 1] [polarity 0] [multiset , e 1 ,]] [membrane [number 3] [children ] [father 1] [label 2] [polarity 0] [multiset,r12,x21,-x21,d2,]] [membrane [number 4] [children ] [father 1] [label 2] [polarity 0] [multiset,x21,r12,-x21,d2,]] Until now, all the possible assignments to x1have been generated. The generation stage works in this way to generate all the possible assignments to all the variables. We skip the next configurations until the presence of the object d2(dn) shows that the synchronization stage is beginning. Configuration number: 5 [environment [multiset ]] [skin [children 5 6 7 8] [label 1] [polarity 0] [multiset,e1,d2,d2,d2,d2,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity 0] [multiset , r 2 1 , r 1 3 ,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 3 , r 2 1 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity 0] 406 [multiset , r 1 3 , r 2 1 ,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 3 , r 2 1 ,]] At the end of the synchronization stage we have the second subindexes of the objects ri k equal to 4 (2n); the checking stage begins: The applied rules are: [d4->d5,e0]10 [d4->d5,e0]10 [d4->d5,e0]10 [d4->d5,e0]10 [r23->r24]20 [r23->r24]20 [r23->r24]20 [r23->r24]20 Configuration number: 8 [environment [multiset ]] [skin [children 5 6 7 8] [label 1] [polarity 0] [multiset,e1,d5,e0,d5,e0,d5,e0,d5,e0,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 4 , r 2 4 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 4 , r 2 4 ,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity 0] [multiset , r 1 4 , r 2 4 ,]] [membrane [number 7] [children ] 407 [father 1] [label 2] [polarity 0] [multiset , r 2 4 , r 1 4 ,]] The applied rules are: [d5->d6]10 [d5->d6]10 [d5->d6]10 [d5->d6]10 e0[]20->[c1] 2- e0[]20->[c1] 2- e0[]20->[c1] 2- e0[]20->[c1] 2- Configuration number: 9 [environment [multiset ]] [skin [children 5 6 7 8] [label 1] [polarity 0] [multiset,e1,d6,d6,d6,d6,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity -] [multiset,r24,r14,c1,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity -] [multiset,r14,r24,c1,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity -] [multiset,r14,r24,c1,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity -] [multiset,r14,r24,c1,]] This stage goes on until the object c3is released into the environment and then the out stage takes place: 408 The applied rules are: d11[]2+->[d12] 2+ d11[]2+->[d12] 2+ d11[]2+->[d12] 2+ d11[]2+->[d12] 2+ [c3]10->c3[]1+ Configuration number: 15 [environment [multiset c 3 ,]] [skin [children 5 6 7 8] [label 1] [polarity +] [multiset,e1,c3,c3,c3,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] The applied rules are: [e1->e2]1+ Configuration number: 16 [environment [multiset c 3 ,]] [skin [children 5 6 7 8] 409 [label 1] [polarity +] [multiset,e2,c3,c3,c3,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] The applied rules are: [e2->e3]1+ Configuration number: 17 [environment [multiset c 3 ,]] [skin [children 5 6 7 8] [label 1] [polarity +] [multiset,e3,c3,c3,c3,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 5] [children ] [father 1] 410 [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 6] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] The applied rules are: [e3]1+->YES[]1+ Configuration number: 18 [environment [multiset c 3 , YES ,]] [skin [children 5 6 7 8] [label 1] [polarity +] [multiset , c 3 , c 3 , c 3 ,]] [membrane [number 7] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 5] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 8] [children ] [father 1] [label 2] [polarity +] [multiset , r 0 4 , r 0 4 , d 12 ,]] [membrane [number 6] [children ] [father 1] 411