160 likes | 256 Views
The Family of L anguages Generated by No n -co o perative Membrane Systems. Hiroshima University Higashi-Hiroshima , Japan. Chi ş in ă u , Moldova. Institute of Mathematics and Computer Science Academy of Sciences of Moldova. Technical University of Moldova. Artiom Alhazov
E N D
The Family of Languages Generatedby Non-cooperative MembraneSystems Hiroshima University Higashi-Hiroshima, Japan Chişinău, Moldova Institute of Mathematics and Computer Science Academy of Sciences of Moldova Technical University of Moldova Artiom Alhazov Constantin Ciubotaru Yurii Rogozhin Sergiu Ivanov {artiom,chebotar,rogozhin,sivanov}@math.md One-line summary:LOP*(ncoo,tar,n,n,nPri)=? (with target indications without dissolution, priorities or other ingredients)
LOP*(ncoo,tar) • We call it TheMembrane Systems Language Family • Is the family of languages generated by transitional P systems without cooperation • Easy: LOP*(ncoo,tar) = LOP1(ncoo,out) • technique of flattening the membrane structure • Arbitary P system from OP1(ncoo,out) • =(O,=[1]1,w1,R1,i0=0) • the components of the tuple are alphabet, membrane structure, starting multiset, rules and output region • Rules are of the form auoutv, aO, u,vO*
Computation: ncoo and result: L • Maximal parallelism becomes total parallelism • All objects in region 1 evolve • (unless there is no rule to rewrite them, • but such useless objects do not contribute to the result, • so we assume the system has no useless objects) • Result: the concatenation of objects sent out, in the order in which they are sent out • Sent out in the same step: taken in arbitrary order
⇒ ⇒ bcc a a bcc bcc ⇒ bcc bcc a bcc ⇒ bcc bcc bcc a bcc . bcc bcc bcc Example 1 • =({a,b,c},[1]1,aa,{a,aa(bcc)out},0) • L()=(Perm(bccbcc))*(Perm(bcc))* Result of this computation: Perm(bccbcc) Perm(bcc) Perm(bcc) .= a a ={bbcccc,bcbccc,bccbcc,bcccbc,bccccb,cbbccc,cbcbcc,cbccbc,cbcccb,ccbbcc,ccbcbc,ccbccb,cccbbc,cccbcb,ccccbb}{bcc,cbc,ccb}{bcc,cbc,ccb}
CF grammars. Time yield • The illustration of Example 1 suggests that evolutions of non-cooperative membrane systems are “like” derivation trees of context-free grammars. • We define the time yield of a derivation tree as concatenation of permutations of terminal symbols at every depth: • Lt()=Perm(yield0()) Perm(yield1()) … Perm(yieldheight()()) • Time yield of a grammar: union of time yields of its derivation trees. • Terminals collected top-down, not left-to-right
Example 2 • G=({S,A,B,C},{a,b,c},S,P) • P={SSABC,SABC,AA,BB,CC,Aa,Bb,Cc} • Lt(G)={w{a,b,c}*: |w|a=|w|b=|w|c>0} • Lt(CF) \ CF S Time yield: S A B C S A B C A B C A B C A B C A B C A b C A b C A B c Perm(bbc) A c A c A bPerm(ccb) aaaPerm(aaa)
Results Representation via grammars Comparison to Chomsky families Closure properties A more difficult example Stay tuned
LOP(ncoo,tar) via derivation trees • We proved that Lt(CF)=LOP(ncoo,tar) • inside~non-terminals, outside~terminals • extra step to produce the axiom • 1NF: • the axiom is never produced • other symbols are never erased • BinaryNF: 1NF and |right side|2 • 3NF: BinaryNF and • all non-terminals are reachable • all non-terminals are productive unless the axiom is not.
Position in Chomsky Hierarchy • LOP(ncoo,tar) REG • Simulate a complete FA; erase final states • LOP(ncoo,tar) CS • LBA simulates total parallelism for 1NF • LOP(ncoo,tar) \ CF (Example 2) • LIN \ LOP(ncoo,tar) • Example 3: {anbn|n1}LOP(ncoo,tar) • technical proof using special definitions • TheMembrane Systems Language Family contains REG, is incomparable with LIN and CF, and is contained in CS.
Closure properties - I • LOP(ncoo,tar) is closed under permutations • Idle productions scramble the order • LOP(ncoo,tar) contains REGPerm(REG) • Take regular construction for R1R2 • Permutation closure technique for R2 • Example 4: m,n1(abc)m Perm(dnenfn) LOP(ncoo,tar)
Closure properties - II • LOP(ncoo,tar) is closed under erasing/renaming morphisms • Open problem for morphisms that can lengthen • Difficult if many symbols are produced in the same step • LOP(ncoo,tar) is closed under union • Non-deterministic choice between axioms • Example 3’: {anbncn|n1}LOP(ncoo,tar) • Erasing all c’s: contradiction with Example 3 • LOP(ncoo,tar) is not closed under intersection • Intersect Example 2 with regular a*b*c* • Contradiction with Example 4 • LOP(ncoo,tar) is not closed under complement • Intersection is a complement of union of complements
Closure properties - III • Example 5:L=m,n1Perm(ambm) cnLOP(ncoo,tar) • technical proof using special definitions • LOP(ncoo,tar) is not closed under concatenation • LPerm(REG)REG( LOP(ncoo,tar) )2 • LOP(ncoo,tar) is not closed under taking the mirror image • LPerm(REG)REG( LOP(ncoo,tar) )R
aabbcc ⇒ D’D’D’D’ aabbcc c’b’a’c’b’a’c’b’a’c’b’a abccbaabccba c’c’c’c’c’c’c’b’b’b’b’b’b’b’a’a’a’a’a’a’a’a’b’c’ aabbcc c’b’a’c’b’a’c’b’a’c’b’a aabbcc c’b’a’c’b’a’c’b’a’c’b’a abccbaabccba ⇒ ⇒ ⇒ DDDDDD DDDDDDDD DD D’D’D’D’ ⇒ aabbccc’b’a’c’b’a’c’b’a’c’b’aabccbaabccbac’c’c’c’c’c’c’b’b’b’b’b’b’b’a’a’a’a’a’a’a’a’b’c’ A more difficult example • =({D,D′,a,b,c,a′,b′,c′},[1 ]1,DD,R), • R={D→(abc)outD′D′,D→(abc)out, • D′→(a′b′c′)outDD,D′→(a′b′c′)out}. • LD=L()={ Perm((abc)2k0)Perm((a′b′c′)2k1)··· • Perm((abc)2k2t)Perm((a′b′c′)2k2t+1) |k0=1,0≤ki≤2ki−1,1≤i≤2t+1,t≥0}. • Two kinds of non-context-freeness • permutations and counting.
Summary of Results • The family generated by transitional non-cooperative systems (without additional control) is reconsidered • Very simple definition. Fundamental in membrane computing? • Characterized via CFG derivation trees • Three normal forms • Compared to Chomsky families • Some closure properties are established • An example of a difficult language is given
Open questions • Is LOP(ncoo,tar) contained in MAT? • Is LOP(ncoo,tar) contained in ET0L? • Is LOP(ncoo,tar) closed under morphisms? • Can LOP(ncoo,tar) be recognized in polynomial time? • Sharpen the lower bound of REGPerm(REG) • Sharpen the upper bound of semilinear CS
Thank you • Reminder of the example illustrating the model • =({a,b,c},[1]1,aa,{a,aa(bcc)out},0) a a bcc a a bcc bcc bcc bcc a bcc bcc bcc bcc a bcc . bcc bcc bcc Result of this computation: Perm(bccbcc)Perm(bcc)Perm(bcc). foryour questions