Comparison of airflow and particulate matter transport in multi-room buildings for different natural ventilation patterns

全文

(1)Fundamenta Informaticae 73 (2006) 133–152 IOS Press. On the Computational Power of 1-Deterministic and Sequential P Systems . Oscar H. Ibarra , Sara Woodworth Department of Computer Science, University of California Santa Barbara, CA 93106, USA ibarra@cs.ucsb.edu; swood@cs.ucsb.edu . Hsu-Chun Yen. Department of Electrical Engineering, National Taiwan University Taipei, Taiwan 106, R.O.C. yen@cc.ee.ntu.edu.tw . Zhe Dang. School of Electrical Engineering and Computer Science Washington State University Pullman, WA 99164, USA zdang@eecs.wsu.edu. Abstract. The original definition of P systems calls for rules to be applied in a maximally parallel fashion. However, in some cases a sequential model may be a more reasonable assumption. Here we study the computational power of different variants of sequential P systems. Initially we look at cooperative systems operating on symbol objects and without prioritized rules, but which allow membrane dissolution and bounded creation rules. We show that they are equivalent to vector addition systems and, hence, nonuniversal. When these systems are used as language acceptors, they are equivalent to communicating P systems which, in turn, are equivalent to partially blind multicounter machines. In contrast, if such cooperative systems are allowed to create an unbounded number of. A preliminary version of this paper was presented at the 11th International Computing and Combinatorics Conference. Research supported in part by NSF Grants CCR-0208595, CCF-0430945, and CCF-0524136. Address for correspondence: Department of Computer Science, University of California, Santa Barbara, CA 93106, USA Research supported in part by NSC Grant 93-2213-E-002-003, Taiwan. Research supported in part by NSF Grant CCF-0430531.. 133.

(2) 134. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. new membranes (i.e., with unbounded membrane creation rules) during the course of the computation, then they become universal. We then consider systems with prioritized rules operating on symbol objects. We show two types of results: there are sequential P systems that are universal and sequential P systems that are nonuniversal. In particular, both communicating and cooperative P systems are universal, even if restricted to 1-deterministic systems with one membrane. However, the reachability problem for multi-membrane catalytic P systems with prioritized rules is NP-complete and, hence, these systems are nonuniversal. Keywords: Sequential P system, 1-deterministic P system, communicating P system, catalytic system, vector addition system, partially blind counter machine.. 1. Introduction Initiated five years ago by Gheorghe Paun [16] as a branch of molecular computing, membrane computing identifies an unconventional computing model, namely a P system, from natural phenomena of cell evolutions and chemical reactions. A P system abstracts from the way the living cells process chemical compounds in their compartmental structure. Thus, regions defined by a membrane structure contain objects that evolve according to given rules. The objects can be described by symbols or by strings of symbols, in such a way that multisets of objects are placed in regions of the membrane structure. The membranes themselves are organized as a Venn diagram or a tree structure where one membrane may contain other membranes. By using the rules in a nondeterministic, maximally parallel manner, transitions between the system configurations can be obtained. A sequence of transitions shows how the system is evolving. Various ways of controlling the transfer of objects from a region to another and applying the rules, as well as possibilities to dissolve, divide or create membranes have been studied. Membrane computing has been quite successful: many models have been introduced, most of them Turing complete and/or able to solve computationally intractable problems (NP-complete, PSPACEcomplete) in a feasible time (polynomial), by trading space for time. (See the P system website at

(3) for a large collection of papers in the area, and in particular the monograph [17].) Due to the built-in nature of maximal parallelism inherent in the model, P systems have a great potential for implementing massively concurrent systems in an efficient way that would allow us to solve currently intractable problems (in much the same way as the promise of quantum and DNA computing) once future bio-technology (or silicon-technology) gives way to a practical bio-realization (or chip-realization). In fact, the Institute for Scientific Information (ISI) has recently selected membrane

(4)

(5) computing as a fast “Emerging Research Front” in Computer Science ( erf/october2003.html). In the standard definition of a P system, the computation is carried out in a maximally parallel and nondeterministic manner [16, 17]. However, an interesting class of P systems with symport/antiport rules was studied in [3] where each system is deterministic in the sense that the computation path of the system is unique; i.e., at each step of the computation, the maximal multiset of rules that is applicable is unique. It was shown in [3] that any recursively enumerable unary language can be accepted by a deterministic 1-membrane symport/antiport system. Thus, for symport/antiport systems, the deterministic and nondeterministic versions are equivalent. The construction of the deterministic system in [3] is such that the size of the maximal multiset of rules that is applicable at every step of the computation is either 1 or 2. We refer to this system.

(6) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 135. as -deterministic. In general, a -deterministic system is one in which the maximal multiset of rules applicable at each step is at most . An interesting case is when , i.e., the system is 1-deterministic. A concept, which is more general than 1-determinism, is that of sequential mode of computation in P systems; i.e., at every step, only one nondeterministically chosen rule instance is applied. Clearly, when a P system is 1-deterministic, then the system (which, by definition, is still maximally parallel) can be treated as a sequential system. So if a class of systems is nonuniversal under the sequential mode, then any 1-deterministic such system in the class is also nonuniversal. Sequential P systems (also called asynchronous P systems) have been studied in various places in the literature (see, e.g., [5, 1, 2, 10]). Here, we present results that complement these earlier results. In particular, we show the following: 1. Any sequential P system with cooperative rules (i.e., rules of the form , where are strings of symbols) with rules for membrane creation and membrane dissolution can be simulated by a vector addition system (VAS), provided the rules are not prioritized and the number of membranes that can be created during the computation is bounded by some fixed positive integer. Hence the reachability problem (deciding if a configuration is reachable from the start configuration) is decidable. It follows that 1-deterministic such systems have a decidable reachability problem. Interestingly and somewhat surprisingly, if such cooperative systems are allowed to create an unbounded number of new membranes during the course of the computation, then they become universal. 2. A sequential communicating P system language acceptor (CPA) is equivalent to a partially blind multicounter machine (PBCM) [6]. Several interesting corollaries follow from this equivalence; for example: (a) The emptiness problem for CPAs is decidable. (b) The class of CPA languages is a proper subclass of the recursive languages..

(7) (c) The language cannot be accepted by a CPA. (d) For every , there is an and a language that can be accepted by a quasirealtime CPA with membranes that cannot be accepted by a quasirealtime CPA with membranes. (In a CPA, we do not assume that the CPA imports an input symbol from the environment at every step. Quasirealtime means that the CPA has to import an input symbol from the environment with delay of no more than time steps for some nonnegative integer independent of the computation.) (e) A quasirealtime CPA is strictly weaker than a linear time CPA. (Here, linear time means that. the CPA accepts an input of length within time for some constant .) (f) The class of quasirealtime CPA languages is not closed under Kleene + and complementation. We note that the relationship between PBCMs and sequential symport/antiport P systems (similar to communication P systems) has been studied recently in [5], but only for systems with symbol objects and not as language acceptors. Thus, the results in [5] deal only with tuples of nonnegative integers defined by P systems and counter machines. For example, it was shown in [5] that a set of tuples of nonnegative integers that is definable by a partially blind counter machine can be defined by a sequential symport/antiport system with two membranes. Our new results above cannot be derived from the results in [5]..

(8) 136. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 3. The results for CPA above generalize to cooperative system acceptors with membrane dissolution and bounded creation rules. Hence, the latter are also equivalent to PBCMs. 4. Any recursively enumerable unary language can be accepted by a 1-deterministic 1-membrane CPA with prioritized rules. 5. The reachability problem for sequential catalytic systems with prioritized rules (hence, for 1deterministic such machines as well) is NP-complete. It follows from this result that a 1-deterministic catalytic system with prioritized rules can only accept recursive languages. Note that from items 4 and 5 above, when the rules are prioritized, there are 1-deterministic systems that are universal and 1-deterministic systems that are not universal. In contrast, from item 1, without prioritized rules, 1-deterministic systems are not universal.. 2. P Systems Without Prioritized Rules Operating in Sequential Mode In this section, we consider the general definition of a P system as given originally by G. Paun in [16, 17], but with unprioritized rules. However, we allow rules for membrane dissolution and membrane creation. We look at systems that operate in sequential mode, i.e., exactly one rule instance is applied at each step (unless the system halts).. Before proceeding further, we need the definition of a vector addition system. An -dimensional. , where is called the start point (or start vector addition system (VAS) is a pair. vector) and is a finite set of vectors in , where is the set of all integers (positive, negative, zero).

(9)

(10) , The reachability set of the VAS is the set for some . . where, for all

(11) , each and . The halting reachability set

(12) . for every in . An -dimensional vector addition system with states (VASS) is a VAS together with a finite set of transitions of the form , where and are states and is in . The meaning is that such a transition can be applied at point in state and yields the point in state , provided that . The VASS is specified. by , where is the starting state. It is known that -dimensional VASS can be. effectively simulated by -dimensional VAS [7]. The reachability problem for a VAS (VASS) is to determine, given a vector , whether is in . Similarly, one can define the reachability problem for halting configurations. It is known that the reachability problem for VASS (and hence also for VAS) is decidable [12]. It is also known that VAS, VASS, and Petri net are all equivalent. First, we study P systems with membrane dissolution but without rules for membrane creation. Clearly, for sequential computations, it is sufficient to only have cooperative rules of the form or. of the form , where and are strings of objects (symbols) where each symbol in has a. designation or target, i.e., it is written , where can be ! !, ", or . The designation ! ! means. that the object remains in the membrane containing it (we usually omit this target, when it is understood). The designation " means that the object is transported to the membrane directly enclosing the. membrane that contains the object. The designation means that the object is moved into a membrane, labelled

(13) , that is directly enclosed by the membrane that contains the object. The attached to the rule means that after the application of the rule, the membrane and the rules it contains are dissolved and.

(14) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 137. the objects in the membrane become part of the membrane that enclosed the dissolved membrane. We will show that these types of P systems can essentially be simulated by a VASS. Hence the reachability problem is decidable. Theorem 2.1. A sequential P system with unprioritized cooperative rules (possibly with membrane dissolution rules) can be simulated by a VASS. Hence its reachability problem is decidable. Proof: Let be a system with cooperative rules which operates in sequential mode (one rule is nondetermin

(15)

(16) istically chosen and applied per step). Let be the set of objects in , with . The rules of. can have the form or , where is the membrane dissolution indicator. We can label the membranes in from , where is the skin membrane. Also, without loss of generality, label the membranes containing dissolution rules from (where obviously , since the skin membrane cannot be dissolved). Label the (distinct) rules in the system from (note the rule number uniquely defines the membrane each rule is associated with).. We construct a VASS to simulate . has dimension such that for and

(17) , position

(18) corresponds to the multiplicity of object in membrane . The start vector of is given by the initial configuration of . In what follows, we let . The states in are defined as follows:.

(19) : denoting the starting state of the system. In this state all membranes are intact..

(20) (for every and ): denoting the fact that rule has been selected to be applied..

(21) (for every

(22) the number of objects in rule and ): denoting that rule is currently being applied to the system. At state , the

(23) th object in the rule is being processed..

(24) (for every ): denoting that the computation has halted. Starting in state

(25) , the transitions of VASS. are created as follows:. Create the transitions

(26)

(27) . for all . This selects the next rule to apply by nondeterministically moving to state

(28) without changing any component.. Create the following transitions for each rule in :. Case 1. (of the form ) is a nondissolving rule. For all : 1. Starting in state

(29) , (using intermediate states

(30) ) sequentially subtracts 1 from the coordinates corresponding to symbols (in this order) in the membrane where. rule appears, and then sequentially adds 1 to the coordinates corresponding to . (in this order) in the membranes targeted in the ’s. (If there are not enough objects in the current membrane to apply rule , will become negative and hence will not lead to a valid computation.). 2.. nondeterministically moves to either

(31) or

(32) for some such that is a rule not yet been dissolved. If transitions to

(33) , the computation is in a halting state; otherwise, rule

(34) is applied..

(35) 138. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. Case 2. (of the form ) is a dissolving rule. Let be in membrane . For all :. 1. Same as case 1 step 1. (Each is consumed and each is created sequentially.) 2. To dissolve membrane , each object in the membrane must be sent " into the surrounding membrane. This is done as follows. For each symbol , subtracts 1 from the coordinate corresponding to in membrane and adds 1 to the coordinate corresponding to in the membrane enclosing . This process is iterated a number of times, where the number of times is chosen nondeterministically (i.e., when guesses that has been exhausted from membrane ). Then does the same thing for each symbol in . (The goal is to expel all objects from membrane . If done correctly, all positions in should be 0. If the nondeterministic choices of repeats made were wrong, the vector will become negative causing an invalid computation. After we reach a final state, the symbol counts in all dissolved membranes must be checked to guarantee all objects were expelled from the dissolved membranes.) 3. nondeterministically moves to state

(36) or

(37) for some such that is a rule which has not yet been dissolved. Again, if transitions to

(38) , the computation is in a halting state; otherwise, rule

(39) is applied.. At this point, the system has halted in a state

(40) . To determine if this state is indeed reachable, we must verify that case 2 step 2 released all objects in the dissolved membranes. For notational conve nience, write

(41)

(42) , etc. by

(43)

(44) , etc. respectively, where . If is a state, let be the set of all vectors that reach state from the initial vector starting in state

(45) . Now the reachability set of the P system corresponds to the following: The union over. all permutations of of the following:

(46)

(47) .

(48)

(49) . , where is the set of all -dimensional vectors with zeros in positions corresponding to the symbols in membranes not in .. Since it is decidable to determine, given an -dimensional vector, whether it is in the set above, we have shown that any sequential P system with dissolving rules and no priority rules can be simulated by a VASS. Another type of P systems (called active P systems) introduced in [14] allows rules to create new membranes during the computation. The objects of an active P system consist of passive objects which do not create new membranes and active objects which do create new membranes. A membrane creation rule is written as

(50) . If a rule of this form is applied in membrane , this rule consumes from , creates a new membrane within , and creates the string . Membrane creation changes how the degree of a system is defined. In a P system without membrane creation, its degree is the number of membranes in the initial configuration. A P system which allows membrane creation must take into consideration the membranes that may be created. Hence, the degree of a system of this type is an ordered pair where the first component consists of the number of membranes in the initial configuration and the second component consists of the maximum number of membranes at any given time in the system during computation. The concept of membrane creation in a P system has a biological basis. In biology, reproduction is a fundamental function of most cells. Including this function in the definition of a P system is a natural generalization of the model. If we allow membrane creation in our model but bound the total number of membranes that can be created (independent of the computation), we can extend our previous result to incorporate this new functionality. This gives us the following result..

(51) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 139. Theorem 2.2. A sequential P system with unprioritized rules and with both membrane dissolution and creation rules, where the total number of membranes that can be created during the computation is at most " (for some positive integer "), can be simulated by a VASS. Hence its reachability problem is decidable. Proof: The structure of this proof follows the structure of the proof of Theorem 2.1 with a few minor changes. One change that needs to be made is the vector size we are working with. For P systems with membrane creation we need to account for the maximum number of membranes that may be needed. For a P system. which uses a total of " membranes with objects, we need a VASS with dimension " . The initial vector will contain all zeros for each membrane which does not yet exist. The set associated with each state changed to represent all membranes which are will need to be . currently alive. Let and " . The states of this system are

(52) ,

(53) , and

(54) with and

(55) the number of objects in rule . The initial state of the system is

(56) . The transitions are the same as in the previous proof with one additional case:.

(57) ( is a creation rule). Let be in membrane . Case 3. is of the form . Then for all "

(58) : 1. Starting in state

(59) , (using intermediate states

(60) ) sequentially subtracts 1 from the coordinates corresponding to symbols (in this order) in membrane . Then sequentially. adds 1 to the coordinates corresponding to (in this order) in membrane

(61) . 2. nondeterministically moves to either

(62)

(63) or

(64)

(65) for some such that is a rule in in membrane such that

(66) .. The rest of the construction follows from the proof of Theorem 2.1.. . The key reason why Theorem 2.2 works is the bound " of the total number of membranes created during any computation. What if we remove this condition? That is, suppose the number of times membrane creation rules are invoked during the computation is unbounded (i.e., it is a function of the computation). In this case, the sequential P system in Theorem 2.2 becomes universal. More precisely, we have the following. Theorem 2.3. Sequential P systems with unprioritized rules and with both membrane dissolution and creation rules can simulate two-counter machines (and hence are universal). Proof: Let be a (nondeterministic) two-counter machine with nonnegative integer counters and . For this proof, it is convenient to have each instruction in to be in one of the following forms:. (on state , increment counter by one and move to state ); . (on state , decrement counter by one and move to state . The machine crashes when it attempts to decrement a counter with value 0);. (on state , if counter stores a positive value, move to state . If, however,. . . counter is with value 0, the machine crashes);.

(67) 140. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. . . . (on state , if counter stores 0, move to state . If, however, counter is positive, the machine crashes),. where are states (there are only finitely many states in ) and is one of the two counters. Initially, starts with a designated initial state with both counters 0. halts when it enters a designated accepting state with both counters 1. We now construct a P system to simulate . operates in the sequential mode and uses two membranes and which are directly inside the skin membrane. The membrane (resp. ) in is to simulate the counter (resp. ) in . uses symbols and , along with a number of other “state symbols” (each state in is treated a symbol in ). In our construction, the multiplicities of symbols (resp. ) in membrane (resp. ) correspond to the counter value (resp. ) in . We now describe how each instruction in is simulated in . We only describe instructions concerning ; instructions for can be handled similarly. We have following cases to consider:. if the instruction is , we add the following rule to membrane : . That is, a new copy of symbol is added in membrane , and symbol is removed from the membrane while a copy of symbol is sent out into the skin membrane;. . . . if the instruction is , we add the following rule to membrane : . That is, the symbol and a copy of symbol are removed from the membrane while a copy of symbol is sent out into the skin membrane;. . . . . if the instruction is , we add the following rule to membrane : . That is, the symbol and a copy of symbol are removed from the membrane, and then the copy of is added back (to ensure that in ) while a copy of symbol is sent out into the skin membrane;. if the instruction is , we add the following rule to membrane : . That is, the symbol is removed from the membrane, and then a copy of symbol and a copy of “membrane creation” symbol are sent out into the skin membrane. As a result of this dissolving rule, the membrane disappears and all the objects in the membrane are now moved into the skin membrane. Notice that, according to the instruction, we expect that the number of symbols in the membrane before its dissolution be 0 – we will see how to handle this “zero-test” in a moment. The membrane creation symbol is to create an empty

(68) membrane using the following rule in the skin membrane:

(69) .. . . . . . . . In the skin membrane, there are the following additional rules that move a state symbol object into (labelled with 2) or (labelled with 3): and , for each state in . Initially, starts with three membranes: in the skin membrane, it has one copy of the symbol , and and are empty membranes. Notice that, during any sequential execution of , there is exactly one copy of a state symbol in all the three membranes. ends when the following configuration is reached: membrane object, membrane contains exactly one object, and the skin membrane contains exactly one contains exactly one object. The latter condition ensures that there is no and object in the skin membrane; i.e., all the zero-tests are handled correctly. Clearly, has a halting computation iff has. The result follows. .

(70) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 141. Notice that, in the proof of Theorem 2.3, objects can move in and move out a membrane (e.g., the object of a state symbol). This move-in/out is essential in simulating the state transitions in a two-counter machine. We do not currently know whether the P systems in the theorem become nonuniversal when, in addition to membrane creation and dissolution rules, we only allow local rules in the form of where the target of every object in is ! ! (i.e., no move-in/out). This will be left as a topic for further investigation.. 3. P Systems and Partially Blind Multicounter Machines In this section, we show that unprioritized cooperative P systems with dissolution rules and bounded membrane creation rules used as language acceptors are equivalent to partially blind multicounter machines (PBCMs). First we show that the equivalence holds for a special class, called communicating P system acceptors. In a communicating P system CPS (with multiple membranes) [18], each rule is of one of the fol. lowing forms: (1) , (2) , and (3) , where are objects, . (which indicate the directions of movements of and ) can be ! !, ", or (see Section 2 for their meanings). The ! can only occur within the outermost region (i.e., skin membrane), which brings in symbol from the environment. Here, we consider a variant of the CPS which is used as a language acceptor. Consider a CPS with input alphabet . Let be a new symbol not in .We assume that only and the symbols in occur abundantly in the environment. Let . Thus, the CPS can import an unbounded number of symbols in from the environment. We assume that no symbol in occurs in the initial configuration. We can view the CPS above as a language acceptor, which we call a CPA. accepts a string if it constitutes all the symbols over imported from the environment during the computation, in the order given in , when the system halts. Thus, is built up as follows. At the start of the computation, (the null string). Symbols from are appended to as they are imported into the skin membrane during the computation. The CPA need not import a symbol (from ) at every step. Note that in the “maximal parallelism” operating mode, an unbounded number of symbols from can enter the skin membrane in one step since several rules of type (3) in the definition of may be. applicable to an unbounded number of pairs in the skin membrane. If the input symbols (i.e., from ) that enter the membrane in the step are (note that is not fixed), then is the string appended to , where is some nondeterministically chosen permutation of . Actually, it can be shown [8] that, in fact, we can assume without loss of generality that (i.e., at most one symbol enters the membrane in each step). A string is accepted if has a halting computation after importing symbols from the environment. It follows from the result in [18] that every recursively enumerable language can be accepted by a CPA under the maximal parallelism semantics, and vice-versa. In the rest of the paper, CPAs are assumed to operate in sequential mode, unless otherwise noted. It turns out that such a CPA is equivalent to a partially blind multicounter machine (PBCM), which is a oneway nondeterministic finite automaton augmented with blind counters [6]. At every step, each counter can be incremented/decremented by 1 or not changed, but it cannot be tested for zero. When there is an attempt to decrement a zero counter, the machine gets stuck and the computation is aborted. The machine does not have to read an input symbol at every step (i.e., it can have moves). An input string is.

(71) 142. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. accepted if, when the machine is started in a distinguished initial state with all counters zero, it processes all the input symbols in and eventually enters an accepting state with all the counters zero. Note that if in a computation, a zero counter gets stuck (because of an attempt to decrement it), the computation is aborted and the input is not accepted. It is well known that if “testing for zero” is allowed (i.e., the counters are not partially blind), such a machine can accept every recursively enumerable language, even when there are only two counters [13]. However, PBCM’s are strictly weaker than TM’s – its emptiness problem (Is the accepted language empty?) and, hence, also the membership problem are decidable. This follows from the decidability of the reachability problem for VAS [12]. Clearly, we can assume that when a PBCM reads a new input symbol, it does not change the value of any counter. However, it can change the state in the transition. So the counters can only be updated during a non-reading step. We may also assume that at most one counter can be updated at each step. Finally, we may assume that instead of “reading ” an input from the one-way input tape, the PBCM has an input terminal from which it can request an input symbol, e.g., an instruction like: From state , get ‘’ and go to state . This means the environment delivers input ‘’ to the system. Formally, an atomic move of a PBCM consists of one of the following labelled instructions (the labels are states): (1) Get ‘’ and go to ( or . . . or ); (2) Increment counter by 1 and go to ( or . . . or ); (3) Decrement counter by 1 and go to ( or . . . or ). Note that ( or . . . or ) allows a nondeterministic choice for the next state. Also note that a move of the machine without reading an input and without updating a counter but changing only its state can be simulated by an instruction of type 2 followed by an instruction of type 3. We assume that the machine has a unique halting accepting state.. . . . Theorem 3.1. Language is accepted by a CPA if and only if it can be accepted by a PBCM. Proof: from accepting Suppose that is accepted by a CPA with membranes. We construct a PBCM. . has finitely many counters. For each object and membrane of , we associate a counter . Thus, will have

(72)

(73) counters. These counters are used to keep track of the multiplicity of each symbol in each membrane. Since no symbol in appears in the initial configuration, all counters are initially zero. The symbols that appear in the initial configuration and their distributions are recorded in the finite-state control of . Every step of the simulation starts with nondeterministically selecting a rule in some membrane. Suppose is a read-rule. There are two cases. If imports a symbol in from the environment, gets symbol from its input terminal. If imports , does not execute a get instruction. Instead, it . increments the counter (i.e., the counter associated with the symbol in the skin membrane) by 1.. Simulation of a rule of the form or is easy, since it only involves decrementing. some counters (corresponding to or and ) by 1 and incrementing the target counters by 1. At some point during the simulation (chosen nondeterministically), guesses that has reached a halting configuration. verifies for each membrane that no rule is applicable. constructs a set for each membrane . The purpose of is to gather all symbols that are no longer in membrane . First puts all symbols in the initial configuration that are no longer in membrane to (this is easily done since there are only a finite number of such symbols, and has kept track of their distribution during the computation). then proceeds as follows. It looks at each rule of the form in membrane , and stores in if it is not already there (thus is “guessing” that this rule is not applicable). Next,.

(74) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 143. looks at each rule of the form or . Clearly, this rule is not applicable if either . there is no or no in membrane . If or is already in , looks at another rule. Otherwise, nondeterministically chooses one of these, say , and puts it in , and then proceeds to look at another rule. When has processed all the rules in membrane , it examines . Let be the symbols in but not in . For each , decrements the counter in membrane corresponding to (by 1) nondeterministically many times (including zero time), after which it guesses that there is no more , and puts in . The process above is done for all membranes. At this point, enters an accepting state. It is easily verified that accepts (= language accepted by ). The converse (i.e., constructing a CPA to simulate a PBCM) follows directly from the construction in [18]. Due to space limitations, the details are omitted here.. In what follows, we let CPA( ) (resp., CPA(linear)) denote the class of languages accepted by CPA. in quasirealtime (resp., linear time), and PBCM( ) (resp., PBCM(linear)) denote the class of languages.

(75) accepted by PBCM in quasirealtime (resp., linear time). We also write COUNTER( ) to denote is accepted by a multicounter machine in quasirealtime . It is obvious from the construction described in Theorem 3.1 (see [18]) that a quasirealtime (linear time) PBCM can be simulated by a quasirealtime (linear time) CPA. However, the simulation of a quasirealtime (linear time) CPA by a PBCM described in Theorem 3.1 does not quite yield a quasirealtime (linear time) PBCM. This is because after guesses that has halted, the symbols which are not in must have their counters decremented to zero. Clearly, the values in the counters (the multiplicities of the ’s) are unbounded. However, we can modify the construction of so that at the beginning of the simulation, nondeterministically guesses the symbols . If these symbols are known from the beginning, the computation can decrease the counter for each sporadically throughout the computation and hence spread the decreasing steps throughout the whole computation. During the simulation, nondeterministically chooses the times to decrement the counter corresponding to (in fact, it can choose to decrement it directly after incrementing it). If decrements each too little, then at the end the counter will not be zero and hence will not accept. If decrements each too much, the counter will become negative at some point during the computation. When the computation halts, if the the instances (nondeterministically chosen) the counters are decremented are correct, the counters corresponding to each will be zero and no extra processing will be done at this point. This allows to run in quasireal time. We omit the details. The following theorem follows from similar results for PBCM [6].. Theorem 3.2.. 1. CPA has a decidable emptiness problem.. 2. CPA is a proper subset of the family of recursive languages..

(76) 3. CPA does not contain the language . and is not closed under Kleene +.. 4. CPA( ) is not closed under Kleene +.. 5. CPA( ) is not closed under complementation.. 6. CPA( ) is a proper subset of COUNTER( ).. 7. CPA( ) is a proper subset of CPA(linear)..

(77) 144. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 8. CPA(linear) – COUNTER( ) is not empty.. Lemma 3.1. (from [6]) For every , there is a language that can be accepted accepted by a quasirealtime PBCM with counters but not by any quasirealtime PBCM with counters. We can now show the following result. Theorem 3.3. For every , there is an and a language that can be accepted by a quasirealtime CPA with membranes but not by any quasirealtime CPA with membranes. Proof:

(78)

(79)

(80)

(81) Without loss of generality consider only languages over a binary alphabet . Then . Suppose there is an such that any language language accepted by a quasirealtime CPA can be accepted by a quasirealtime CPA with membranes. Let . From Lemma 3.1, there is a language that can be accepted by a quasirealtime PBCM with counters but not with counters. By Theorem 3.3, this language can be accepted by a quasirealtime CPA. Then, by hypothesis, can also be accepted by a quasirealtime CPA with membranes. From the construction in the first part of the proof of Theorem 3.1, we can construct from this CPA, a quasirealtime PBCM with at most counters. Hence, can be accepted by a quasirealtime PBCM with counters, a contradiction. A cooperative P system acceptor with dissolution rules and bounded membrane creation rules can be defined in the usual manner (as in a CPA). Clearly, a CPA is a special case of a cooperative P system acceptor. Hence, a PBCM can be simulated by a cooperative system. For the converse, the constructions in Theorems 2.1, 2.2, and 3.1 can be implemented on a PBCM. Hence, Theorems 3.1, 3.2, and 3.3 hold when CPA is replaced by PBCM. We have: Corollary 3.1. The following are equivalent: CPA, PBCM, cooperative P system acceptors with dissolution and bounded membrane creation rules. In Theorem 3.1, the model of the CPA has a sequence of input symbols coming in from the environment, and this sequence constitutes the (one-way) input to the PBCM. Nowsuppose we modify the way the input is given to . As before, let and , where is a distinguished symbol. At the start of the computation, is given a multiset in its input membrane, where is some fixed multiset from an alphabet disjoint from , and each

(82) . The environment only contains an abundance of . Initially, there are no symbols from in the environment, and only symbols from this set that are exported to the environment (during the computation) can be imported from the environment. Thus, the multiplicity of each symbol in in . . the system (including the environment) remains the same during the computation. We say that . is accepted if , when given in its input membrane, halts. We denote the language accepted by . We call the new model NCPA. Like CPAs, the language accepted by an NCPA can also be accepted by a PBCM. Hence, the following holds. Theorem 3.4. We can effectively construct, given an NCPA , a PBCM emptiness problem for NCPAs is decidable.. accepting . . Hence, the.

(83) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 145. Proof: (Idea) The operation of when given input is similar to the construction in the first part of the proof of Theorem 3.1. We just show how makes sure that the during the simulation, the total. number of (which initially is ) in the system is always the same during computation, for

(84) . Initially, the PBCM reads and stores in counter (for

(85) ). For each

(86) , we also use another counter (initially zero) to represent the number of ’s in the environment. Whenever an is exported into the environment, we increment by 1. When an is imported into the skin membrane from the environment, we decrement by 1. Note that we do not have to worry about checking the multiplicities of the ’s in the skin membrane and in the other membranes. . 4. 1-Deterministic P Systems with Prioritized Rules Now let us look at P systems which allow rules to be prioritized, meaning that a rule of lower priority can only be used when rules of higher priority are no longer applicable. Previously we showed that sequential cooperative P systems without priority rules are equivalent to VASS and hence nonuniversal. Allowing priority rules increases the power of these systems causing them to be universal. In fact, even cooperative P systems with the restriction of 1-determinism with only one membrane are already universal. We have the following result. Theorem 4.1. A prioritized 1-deterministic 1-membrane cooperative system (COS) with rules of the

(87)

(88)

(89)

(90) form , where , and 1 or 2, can simulate a 2-counter machine (hence, it is universal). Proof: be a (deterministic) 2-counter machine. We first construct a normalized 2-counter machine Let that simulates . The construction follows the idea in [13]. Suppose the two counters of have values.

(91) . These values can be represented in one counter of by the number . To increment

(92) by uses a second counter, which is initially zero, one, the number is multiplied by 2, 3, respectively. for this purpose. The second counter is incremented by 2, 3, respectively for every decrement of 1 in the first counter. When the first counter becomes zero, the second counter has value respectively. Similarly, decrementing

(93) by one corresponds to incrementing the second counter by one for every. decrement of 2, 3, in the first counter (i.e., is divided by 2, 3, respectively), after checking that is divisible by 2,3, respectively. The state of is stored in the finite control of . To determine the next move, has to determine. which, if any, of

(94) are zero. By passing from one counter to the other, the finite control of can. determine if is divisible by 2, 3, respectively. We modify the above construction slightly by adding the. factor to . Thus, . The purpose of the factor is so that is always positive. Using the above description of how operates, we see that the counters behave in a regular pattern. operates in phases in the following way. Let and be its counters. ’s operation can be divided into phases where each starts with one of the counters equal to some positive integer and the other counter equal to zero. During the phase, the first counter is nonincreasing and the other counter is nondecreasing. The phase ends with the first having value zero and the second counter having a positive value (note that the positiveness is guaranteed by the factor ). This value is. . equal to (i.e., no change), , , , , where is the value of the first counter before the start of the phase. Thus, a sequence of configurations corresponding to the phases above will be of the form:.

(95) 146. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. , where the are states and are positive integers. Note that the second component of the configuration refers to the value of counter , while the third component refers to the value of counter . Moreover, the state determines which of the five case ( ) applies. We may assume that the state names of the 2-counter machine when it is operating in odd phases are different from the state names when it is operating in even phases . We use ’s for states in the odd phases ’s for states in the even phases. Clearly, an instruction of the 2-counter machine has one of the following forms:. 1. " ! (i.e., in the odd phases).. 2. " ! (i.e., in the even phases).. ! " ! (i.e., switching from odd phase to even phase). 4. " ! ! (i.e., switching from even phase to odd phase). where (respectively, ) is the current state, positive means that the first (respectively, second) counter is positive, na means that the value of the second (respectively, first) counter does not matter, (respectively, ) is the next state, means decrementing the first (respectively, second) counter by 1, and means incrementing the second (respectively, the first) counter by . (Note that 0 or 3.. . . . 1 when division by 2, 3, is being simulated.) Let be the states the counter machine uses in the odd phases and be the states it uses in the even phases. As already stated, we assume that the ’s are different from the ’s. Assume that is the state of the machine when the first counter has value and is about to begin phase . We construct a prioritized 1-deterministic 1-membrane cooperative P system with symbols to simulate the normalized counter machine. The symbols and represent the two counters. The initial configuration is

(96) . (This means that the first counter has value 5 and the second counter is zero.) The rules are defined according to the type of rules above. 1. For a transition of form 1, define the rule . . 2. For a transition of form 2, define the rule . . 3. For a rule of form 3, define the rule . 4. For a rule of form 4, define the rule . . Rules of the form and are of higher priority than rules of the form . and . It is clear that the system described above simulates the computation of the two-counter machine. Note that the rules above can be simplified, e.g., a rule of the form can be simulated . . . by the rules:

(97)

(98)

(99)

(100)

(101)

(102) , where

(103)

(104)

(105) are new symbols.. . The above result applies to a 1-deterministic 1-membrane symport/antiport system (SAS) [11, 15].. This system has rules of the following forms: " which is an antiport rule, and " or.

(106)

(107)

(108)

(109) which is an symport rule, where

(110)

(111) are strings of symbols. The radius of an antiport rule is . For a symport rule, the radius is . Corollary 4.1. A prioritized 1-deterministic 1-membrane symport/antiport system (SAS) whose rules are antiport of radius (2,1) or (2,2) can simulate a 2-counter machine..

(112) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 147. Looking at the class of communicating P systems, we find similar results. The class of 1-deterministic 1-membrane CPS with priority rules can also simulate a 2-counter machine using a technique similar to the proof of Theorem 4.1. Theorem 4.2. A prioritized 1-deterministic 1-membrane CPS can simulate a 2-counter machine. Proof: We need only show that the rules in the COS constructed above can be implemented in a 1-membrane CPS with priority rules. We construct a CPS with priority rules which simulates a COS. has one membrane (the skin membrane) and a distinguished symbol . Initially, contains symbols . We describe how the rules of are constructed. Note that in the COS constructed above, its rules are of the form ", where " are states, is. a symbol (either or ), and is (a unary string) of the form , where is a symbol (either. or ). The rules of the CPS are defined by cases:. . Case 1. If the rule is ", then the following rules are in. . . . . ". . . "

(113) "

(114) "

(115) "

(116) "

(117) "

(118) "

(119) "

(120) "

(121) "

(122) " Priority: . Case 2. If the rule is " , then the following rules are in . . :. :. . . . . . . . . . , then the following rules are in : "

(123) "

(124) "

(125) "

(126) "

(127) "

(128) "

(129) "

(130) "

(131) "

(132) "

(133) "

(134) "

(135) "

(136) "

(137) "

(138) "

(139) " Priority: Case 4. If the rule is " , then the following rules are in : "

(140) "

(141) "

(142) "

(143) "

(144) "

(145) "

(146) "

(147) "

(148) "

(149) "

(150) "

(151) "

(152) "

(153) "

(154) Case 3. If the rule is " . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

(155) 148. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. "

(156) "

(157) "

(158) "

(159) "

(160) "

(161) "

(162) "

(163) "

(164) " Priority: . . . . . . . . Clearly these rules use a 1-membrane CPS with priority rules to simulate a 2-counter machine. Hence a 1-membrane CPS with priority rules is universal. The above theorem is in contrast to a result in [10] that a sequential multi-membrane CPS whose rules are not prioritized is equivalent to a VAS. Finally, consider the model of a sequential multi-membrane CS where the rules are prioritized. Specifically, there is a priority relation on the rules: A catalytic rule of lower priority than cannot be applied if is applicable. We refer to this system as prioritized CS. We know that the reachability set of a sequential multi-membrane CS is semilinear and, hence, its reachability problem is NP-complete. In [9], the status of the reachability problem for systems with prioritized rules was left open. Here we show that the reachability problem is also NP-complete. Taking advantage of the equivalence between sequential multi-membrane CS and communicationfree VAS1 [9], we first show the reachability problem for prioritized communication-free VAS (which will be defined in detail below) to be NP-complete, which immediately yields the mentioned complexity result for prioritized sequential multi-membrane CS. Given a communication-free VAS , a priority relation over is an irreflexive, asymmetric, and transitive relation such that takes precedence over if ( , ) , meaning that cannot be applied if is applicable. Due to the nature of communication-freeness, we further assume to satisfy a property that if and subtract from the same coordinate, neither nor is in

(165) ; otherwise, one of the two could never be applied. Let denote and .. In this paper, is assumed to be an equivalence relation. Given a vector , an addition vector can be applied at under priority relation if and no other of higher priority has . Let (resp., ) denote the reachability of from through transition sequence under the unprioritized (resp., prioritized with priority relation ) semantics. The following result plays a key role in our analysis.. and a priority relation , if ( , for ) and for every applicable at , is in the lowest priority class induced by , then . Lemma 4.1. Given a communication-free VAS some permutation. . . of .. Proof: Along , let be the leftmost vector at which the priority requirement is violated. Let be the addition vector applied at , and be one of the highest priority applicable at . We claim that there exists a , and is present in the segment from to ; otherwise, would still be applicable at (due to the communication-freeness nature of ) – violating the assumption of the 1. A communication-free VAS is a VAS where in every transition, at most one component is negative, and if negative, its value is ..

(166) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 149. lemma. Since and do not subtract from the same coordinate, applying at followed by remains a valid computation. By repeatedly applying such a rearrangement to the remaining sequence, a computation meeting the priority requirement can be constructed. For related results concerning other types of prioritized concurrent models, the reader is referred to, e.g., [20]. Based upon the above lemma and the fact that the binary reachability relation of communication-free VAS can be characterized by integer linear programming [4, 19], we have the following result. Theorem 4.3. The reachability problem for prioritized communication-free VAS is NP-complete. Proof: The lower bound follows immediately from the NP-hardness of checking reachability for the basic model of communication-free VAS, as they are special cases of their prioritized counterparts (with an empty priority relation). First we recall the following result (referred to as ‘Fact A’ in our subsequent discussion) from [4, 19], indicating that the binary reachability relation of communication-free VAS can be characterized by integer linear programming:. Given a communication-free VAS , there exists a system of linear inequalities of polynomial size such that iff has an integer solution. Furthermore, remains linear even if and are replaced by variables.. . . that is an equivalence relation, which partitions into a number of equivalence classes Recall , for some (

(167)

(168) ). Intuitively, each represents a set of vectors having the same priority. For every and (

(169) ), either or (but not both); we we write (resp., ) if (resp., ). Without loss of generality, assume to be enumerated in increasing priority. Given a and a , we let if (i.e., is the index of the equivalence class containing ). To show the upper bound, suppose is a computation reaching in a prioritized communica tion-free VAS with priority relation . Listing in increasing priority, let the equivalence

(170)

(171) classes induced by be , for some . We let , be vectors and be addition vectors along satisfying the following: (We assume , , and

(172)

(173) .). 1. 2.. is the vector applied at in , and , . . ,. , ,

(174) , and applied in ( applied in . (a) . ),

(175) . (In .) words, is the rightmost occurrence among the lowest priority transitions in , is of the lowest The crux of our subsequent analysis lies in the fact that in priority in VAS with its set of addition vectors restricted to (The start (b). . .

(176) 150. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. iff in . This, in conjunction vector of is not important here.) . By Lemma 4.1, with Fact A, enables us to set up a system of linear inequalities to capture the reachability of from : We begin by guessing the following: 1. transitions with , 2.. , a set of coordinates such that subtracts from some coordinate in , for every with . ( is the set of coordinates that are zero so that no vector of higher. priority than is applicable in .. Then the system of linear inequalities is set up as follows: (A0) (A1) (A2) (A3) (A4). ,.

(177)

(178) , , — a system of linear inequalities guaranteed by Fact A, and , .. . In the above inequalities, are vector variables representing the values of markings , , , , , respectively, mentioned in our earlier discussion. (A0) is trivial. What (A1) says is that at , no vectors with priorities higher than are applicable. By Fact A, (A2) is sufficient to imply . Lemma 4.1, in conjunction with (A1) and (A2), further implies . (A3) and (A4) are again trivial. Based on our earlier discussion, it is then straightforward that the above system of linear inequalities has an integer solution iff . Hence, the reachability problem is in NP. We now have the following. Corollary 4.2. The reachability problem for sequential multi-membrane catalytic systems with prioritized rules is NP-complete. Proof: (Sketch) As shown in [10], every sequential multi-membrane CS S can be simulated by a communicationfree VAS G, and vice-versa. Consider a priority relation for multi-membrane CS such that the prioritizing is only between rules in the same membrane, and if and are rules in the same membrane, then neither the first rule takes precedence over the second rule nor the second rule takes precedence over the first rule. Examining the proof of Theorem 4.3 shows that every sequential multimembrane CS S with prioritized rules can be simulated by a communication-free VAS G with prioritized rules, and vice-versa. .

(179) O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. 151. 5. 1-Deterministic Language Acceptors with Prioritized Rules It is known that any recursively enumerable unary language can be accepted by a (deterministic) 2-counter machine with a one-way input tape which operates as follows: , starting in its start state. with both counters zero, when given a string , reads the input symbols left-to-right and halts if and. only if . Note that need not read a new input symbol at every step. We may assume that after the right delimiter is read by the counter machine, it can continue with the computation (without attempting to read another symbol on the tape). The input is accepted if eventually halts. The input is not accepted if the machine does not halt. The 2-counter machine can be normalized, with each instruction taking one of the following forms:. (1) " ! ; (2) , where or (meaning that is a reading state and the machine reads an input symbol and changes state without altering the counter. contents); (3) " ! ; (4) , where or ; (5) ! " ! ; (6) " ! ! . See the proof of Theorem 4.1 in the appendix for more details. Note that the state can also be “tagged” whether they are in a reading mode or nonreading mode. Transitions of the form 1, 3, 5, 6 are non-reading (indicated by in the second parameter) and are handled as before. Transitions 2 and 4 are reading and are translated to cooperative rules and , respectively. It follows that all the results in the previous section can be reformulated for P systems that are acceptors when the 2-counter machine is an acceptor. For example, Theorem 4.2 can be written to read: Corollary 5.1. Every recursively enumerable unary language can be accepted by a deterministic 1membrane CPS with prioritized rules.. 6. Conclusion In this paper we investigated the computational power of different types of sequential and 1-deterministic P systems. We showed that without prioritized rules, sequential P systems are equivalent to VAS, even if they are allowed to have dissolution rules and bounded creation rules. We also showed that these systems when used as language acceptors are equivalent to communicating P system acceptors which, in turn, are equivalent to to partially blind counter machines. When the rules are prioritized, there are two types of results: there are sequential P systems that are universal and sequential P systems that are nonuniversal. In particular, both communicating and cooperative P systems are universal, even if restricted to 1-deterministic systems with one membrane. However, catalytic P systems with prioritized rules have NP-complete reachability problem and, hence, nonuniversal.. References [1] E. Csuhaj-Varju, O.H. Ibarra, G. Vaszil: On the computational complexity of P automata. Proc DNA10, Milano, 2004 (C. Ferretti, G. Mauri, C. Zandron, eds.), LNCS 3384, Springer, Berlin, 2005, 76–89. [2] Z. Dang, O.H. Ibarra: On P systems operating in sequential and limited parallel modes. Pre-Proceedings of 6th Workshop on Descriptional Complexity of Formal Systems, London, Ontario, 2004, 164–177..

(180) 152. O. H. Ibarra et al. / 1-Deterministic and Sequential P Systems. [3] R.. Freund, Gh. P˘aun: On deterministic

(181) , 2003.. P. systems,. See. P. Systems. Web. Page. at. [4] L. Fribourg, H. Olsen: Proving safety properties of infinite state systems by compilation into Presburger Arithmetic. CONCUR’97, LNCS 1243, Springer, Berlin, 1997, 213–227. [5] P. Frisco: About P systems with symport/antiport. Second Brainstorming Week on Membrane Computing, Sevilla, Spain, 2004, 224–236. [6] S.A. Greibach: Remarks on blind and partially blind one-way multicounter machines. Theoretical Computer Science, 7, 3 (1978), 311–324. [7] J. Hopcroft, J.-J. Pansiot: On the reachability problem for 5-dimensional vector addition systems. Theoretical Computer Science, 8, 2 (1979), 135–159. [8] O.H. Ibarra: On the computational complexity of membrane systems. Theoretical Computer Science, 320, 1 (2004), 89–109. [9] O.H. Ibarra, Z. Dang, O. Egecioglu: Catalytic P systems, semilinear sets, and vector addition systems. Theoretical Computer Science, 11, 1 (2004), 167–181. [10] O.H. Ibarra, H. Yen, Z. Dang: On the power of maximal parallelism in P systems. Developments in Language Theory 2004, LNCS 3340, Springer, Berlin, 2004, 212–224. [11] C. Martin-Vide, A. P˘aun, Gh. P˘aun: On the power of P systems with symport rules. Journal of Universal Computer Science, 8, 2 (2002), 317–331. [12] E. Mayr: An algorithm for the general Petri net reachability problem. SIAM J. Computing, 13 (1984), 441– 460. [13] M. Minsky: Recursive unsolvability of Post’s problem of Tag and other topics in the theory of Turing machines. Ann. of Math., 74 (1961), 437–455. [14] M. Mutyam, K. Kriithivasan: P systems with active objects: Universality and efficiency. Proceedings of the Third International Conference on Machines, Computations, and Universality, Chis¸in˘au, Moldova, May 23–27 2001, 276 – 287. [15] A. P˘aun, Gh. P˘aun: The power of communication: P systems with symport/antiport. New Generation Computing, 20, 3 (2002), 295–306. [16] Gh. P˘aun: Computing with membranes. Journal of Computer and System Sciences, 61, 1 (2000), 108–143. [17] Gh. P˘aun: Membrane Computing: An Introduction. Springer, Berlin, 2002. [18] P. Sosik: P systems versus register machines: two universality proofs. Pre-Proceedings of Workshop on Membrane Computing (WMC-CdeA2002), Curtea de Arges¸, Romania, 2002. [19] H. Yen: On reachability equivalence for BPP-nets, Theoretical Computer Science, 179 (1997), 301–317. [20] H. Yen: Priority conflict-free Petri nets. Acta Informatica, 35, 8 (1998), 673–688..

(182)