1 / 42

MEMBRANE COMPUTING

MOLECULAR COMPUTING. MEMBRANE COMPUTING. Rudolf FREUND. Faculty of Informatics Vienna University of Technology Wien, Austria. Overview. Molecular Computing. ► DNA Computing. ● Splicing, Watson-Crick complementarity ● Test tube systems (universality). ► Membrane Computing.

badru
Download Presentation

MEMBRANE COMPUTING

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. MOLECULAR COMPUTING MEMBRANE COMPUTING Rudolf FREUND Faculty of Informatics Vienna University of Technology Wien, Austria

  2. Overview Molecular Computing ►DNA Computing ● Splicing, Watson-Crick complementarity ● Test tube systems (universality) ►Membrane Computing ●P systems - a general model ●P systems - selected results ●Related Models ●Future Research

  3. Molecular Computing • one of the most emerging fields in computer science • brings together computer scientists and biologists • opens new possibilities for both fields: • computers help in decoding the sequences of • DNA in genes, • - allow for the simulation of biological • processes etc., • - computer scientists learn from nature, • face the challenge to bring back their new • achievements to allow for a better understanding • of the processes happening in nature.

  4. Watson-Crick Complementarity Adenine Cytosine Guanine Thymine DNA DeoxyriboNucleic Acid double helix 3´ … ATCG…5´ || || ||| ||| 5´ … TAGC…3´

  5. DNA Splicing 3´ … ATCC…5´ splicing 1 || ||| sticky ends 5´ … TAG G…3´ 3´ … T TCG…5´ || ||| sticky ends splicing 2 5´ … AAGC…3´ -------------------------------------------------------------------------------- 3´ … ATCG…5´ recombination 1 || || ||| ||| 5´ … TAGC…3´ 3´ … TTCC…5´ || || ||| ||| recombination 2 5´ … AAGG…3´

  6. DNA Computing - Splicing SPLICING RULE r = u1 # u2 $ u3 # u4 x = x1 u1 u2 x2 , y = y1 u3 u4 y2 , z = x1 u1 u4 y2 , w = y1 u3 u2 x2 SPLICING ( x , y )  r ( z , w ) T. Head: Formal language theory and DNA: An analysis of the generative capacity of specific recombinant behaviors.Bull. Math. Biology, 49 (1987), 737-759. E. Csuhaj-Varjú, R. Freund, L. Kari, Gh. Păun: DNA computing based on splicing: universality results. In: L. Hunter, T. Klein (Eds.): Pacific Symposium on Biocomputing '96, WSP (1996), 179-190. D. Pixton: Splicing in abstract families of languages. Theoretical Computer Science 234 (2000), 135-166.

  7. Splicing Splicing: r = u1 # u2 $ u3 # u4 , ( x , y )  r ( z , w ) z = x1u1u4y2 , w = y1u3u2x2 x = x1u1u2x2, y = y1u3u4 y2 , x1 u1 u2 x2 x y1 u3 u4 y2 y ------------------------------------------------------------------------------- z x1 u1 u4 y2 w y1 u3 u2 x2

  8. Cutting and Recombination (CR) CUTTING RULE u1 # [m] $ [n] # u2 x = x1 u1 u2 x2 , y = x1 u1 [m] , z = [n] u2 y2 CUTTING x  r ( y , z ) RECOMBINATION RULE ( [m] , [n] ) x = x1 u1 u2 x2 , y = x1 u1 [m] , z = [n] u2 y2 RECOMBINATION ( y , z )  r x R. Freund, F. Wachtler: Universal systems with operations related to splicing. Computers and Art. Intelligence 15 (4).

  9. Splicing Systems / CR Systems without any additional features: cannot even generate all regular languages computational completeness (universality): - infinite number of rules - multisets - periodic sets of rules - control mechnisms (control graphs,...) - test tube systems - membrane systems

  10. Test Tube Systems - references L. M. Adleman: Molecular computation of solutions to combinatorial problems. Science, 226 (Nov. 1994), 1021-1024. (lab solution of small travelling salesman problem) E. Csuhaj-Varjú, L. Kari, and Gh. Păun: Test tube distributed systems based on splicing. Computers and Artificial Intelligence, Vol. 15 (2) (1996), 211-232. R. Freund, E. Csuhaj-Varjú, and F. Wachtler: Test tube systems with cutting/recombination operations. In: R.B. Altman, A.K. Dunker, L. Hunter, T. Klein (Eds.): Pacific Symposium on Biocomputing'97 (1997), 163-174.

  11. Test Tube Systems - definition  = ( B , BT , n , A ,  , D , f ) • B set of objects • BT B set of terminal objects • n number of test tubes • A = ( A1 , ... , An ) Ai set of axioms in tube i •  = ( 1 , ... , n ) i set of operations in tube i • D finite set of output/input relations of the form • ( i , F , j ) ; F is a filter between tubes i and j • f  { 1 , ... , n }final test tube for results

  12. TTS – begin of computation step The computations in the system  run as follows: At the beginning of the computation the axioms are distributed over the n test tubes according to A, i.e., test tube Ti starts with Ai. Now let Li be the contents of test tube Ti at the beginning of a derivation step. Then in each test tube the rules of  operate on Li, i.e., we obtain (elements of) i*( Li).

  13. TTS - redistribution The next substep is the redistribution of the elements of i*(Li) over all test tubes according to the corresponding output/input relations from D, i.e., if ( i,F,j) is in D then the test tube Tj from i*(Li) gets i*(Li)  F, whereas the rest of i*(Li) that cannot be distributed to other test tubes remains in Ti.

  14. TTS – final result of computation The final result of the computations in  consists of all objects from BT that can be extracted from a final test tube from E. The final results of the computations in  consists could also be taken all objects from B that can be extracted from a final test tube from E thus taking B = BT . For extended test tube systems, i. e., BT B and BT B, the terminal results can be extracted from every test tube.

  15. When two tubes are enough WHEN TWO TUBES ARE ENOUGH

  16. TTS – references Rudolf Freund, Franziska Freund: Test Tube Systems or How to Bake a DNA Cake. Acta Cybernetica, Vol. 12, Nr. 4, 445-459. Rudolf Freund, Franziska Freund: Test Tube Systems: When two tubes are enough. DLT '99 and in: G. Rozenberg, W. Thomas (Eds.): Developments in Language Theory, Foundations, Applications and Perspectives. WSP, Singapore (2000), 338-350.

  17. TTS – universality with CR Theorem. Any recursively enumerable language L can be generated by a test tube system with CR rules  = (MW*M , [e]W+[f] , 2, (A1, Ø ) , (C1  R1 , C2), {(1, F1, 2) , (2, F2, 1)}, {2}) with only two tubes and the filters between the tubes being a finite union of sets of the form mW+n with markers m,n. Proof (sketch). We simulate a grammar generating L{d}. G = (N,T,P,S) with L(G) = L{d}, where d is always generated in the last step of the derivation of a terminal word in G. V = N  T {B} , W = V  {d}. A string w is represented by rotated versions [x]w2Bw1[y] , w = w1w2 . Terminal strings are of the form [e]w[f] , w  T+. The rules in P are labelled productions p:   with 1  |  | 2 and 0  |  |  2 .

  18. TTS – universality with CR (proof) M = {[e],[f],[e´],[f´], [x],[y],[x´],[y´]}  { [lp], [rp], [lp´] |pLab}  {[xc],[yc],[xc´],[yc´] |cLab} A1 = {[lp][y] |pLab, p:}  {[x]c[xc´], [yc´] [y] |cV}  {[x]BS[y]} C1 = {u#[rp] $ [lp´]#[y] | uV, pLab, p:, ||=2} {u#[rp] $ [lp´]#[y] | uV2  {B}, pLab, p:, ||=1} R1 = {([rp],[lp])|pLab}  {([xc´], [xc] ), ([yc], [yc´]) |cV} C2 = {u#[yc] $ [y´]#c[y], [x]#[x´]$ [xc]#u | u,c V} {[x]B#[e´] $ [e]#u, u#[f] $ [f´]#d[y] | uT} D = {(1, F1, 2), (2, F2, 1)} F1 = [x]W+[y] F2 =  cV [xc]W+[yc] 

  19. TTS – universality with splicing Theorem. Any recursively enumerable language L can be generated by a test tube system with splicing rules  = (W*,{E}W+{F}, 2, (A1,A2), (R1 R2), {(1,F1,2),(2,F2,1)}, {2}) with only two tubes and the filters between the tubes being a finite union of sets of the form {A}W+{B} with A,B  W. Proof (sketch). We simulate a grammar generating L{d} like in the proof before the CRTTS; as there we only cut at the ends of a string, we can construct  as follows: For a cutting rule like [x] # [r] $ [l] # u we take the axiom LZ and the splicing rule L # Z $ X # u . For a cutting rule like c # [r] $ [l] # u[y] we take the axiom ZR and the splicing rule c # uY $ Z # R . For a recombination rule like ( [r] $ [l] ) involving the axiom [l]w[y] we take the axiom ZwY and the splicing rule u # R $ Z # wY, etc. 

  20. Membrane Systems introduced by Gheorghe PǍUN (1998) • brought new impact into the area of • theoretical computer science, • especially into the area of formal languages; • incorporate several features of living cells; • allow for constructing various formal models of • universal computers, • restricted models allow for the characterization • of well-known families of languages.

  21. P Systems (Membrane Systems) (invented by Gheorghe PǍUN , 1998) membrane structure multisets of objects • evolution / communication rules applied in • the maximally parallel mode • the sequential mode dissolving / generating membranes many variants computationally complete Gheorghe Păun: Membrane Computing - An Introduction. Springer-Verlag, Berlin, 2002. The P Systems Web Page: http://psystems.disco.unimib.it

  22. Membrane structure [1[2[4 ]4 [5 ]5 ]2[3 ]3]1 elementary membrane region 4 5 2 3 1 skin membrane

  23. Grammar schemes / grammars A grammar schemeG is a construct (O,OT,P, ) where ∙ O is the set of objects; ∙ OTO is the set of terminal objects; ∙ P is a finite set of productions p O×O or Om×On; ∙ is the derivation relation of G induced by the productions in P; A grammarG is a construct (O,OT,P, ,w) where ∙ w is the axiom or the initial multiset over O. L(G) = { v  OT | w * v } or L(G) = { v  M(OT) | w * v }

  24. String grammars A string grammar G is a construct (N,T,P,S) where ∙ N is the alphabet of non-terminal symbols; ∙ T is the alphabet of terminal symbols, N ∩ T = { }; ∙ P is a finite set of productionsof the form u → v with u V* and v V+, where V := NT; ∙ S N is the start symbol. A string grammar G now is a construct (V*,T*,P, G ,S) where the derivation relation for u → vP is defined as usual by xuy u→v xvy for all x,yV*, thus yielding the well-known derivation relation G for the string grammar G. L(G) = { v  T* | w G* v } .

  25. Types of string grammars As special types of string grammars we consider string grammars with arbitrary productions, context-freeproductions of the form A → v with AN and vV*, and λ-free context-free productions of the form A → v with AN and vV*, the corresponding types of grammars denoted by ENUM, CF, and CF-λ, thus yielding the families of languages L(ENUM), i.e, the family of recursively enumerable languages, as well as L(CF) and L(CF-λ), i.e., the families of context-free and λ-free context-free languages, respectively.

  26. Matrix grammars A matrix grammar Gwith appearance checking(with ac for short) GMof type X is a construct (O,OT,P, G,w,M,F) where (O,OT,P, G ,w) is a grammar of type X, M is a finite set of finite sequences of productions (an element of M is called a matrix), and F P. For a matrix m(i) = [mi,1,…,mi,n(i)] in M and v,uO we define v m(i)u if and only if there are w0,w1,…,wn(i)O such that w0 = v, wn(i) = u, and for each j, 1 ≤ j ≤ n(i), ∙ either wj-1m(i,j) wj according to G, ∙ or m(i,j) is not applicable to wj-1 according to G, wj = wj-1, m(i,j)F.

  27. Language generated by a matrix grammar The language generated by GM is L(GM) = {v OT : wm(i,1) w1…m(i,k) wk, wk = v, wjO, m(i,j) M for 1 ≤ j ≤ k ,k ≥ 1}. The matrix grammar GM is said to be of type MATac; it is said to be of type MAT - to be without appearance checking (without ac) - if F = { }. The corresponding families of languages are denoted by L(X-MATac) and L(X-MAT), respectively.

  28. Graph-controlled grammars A graph-controlled grammar G of type X is a construct (O,OT,P, G,w,R,L(in),L(fin)) where (O,OT,P, G ,w) is a grammar of type X, R is a finite set of rules r of the form ( l(r): p(l(r)),σ(l(r)),φ(l(r)) ), where l(r)Lab(G), Lab(G) being a set of labels associated (in a one-to-one manner) with the rules r in R, p(l(r))P, σ(l(r))Lab(G) is the success fieldof the rule r, and φ(l(r))Lab(G) is the failure field of the rule r; L(in)Lab(G) is the set of initial labels, and L(fin)Lab(G) is the set of final labels.

  29. Graph-controlled grammar - languages For r = ( l(r): p(l(r)), (l(r)), (l(r)) ) and v,uO we define (v,l(r)) G (u,k) if and only if ∙ either p(l(r)) is applicable to v, vG u, and kσ(l(r)), ∙ or p(l(r)) is not applicable to v, u=v, and kφ(l(r)). The language generated by G is L(G) = {v OT : (w0,l0) G (w1,l1)… G(wk,lk), k ≥ 1, wjO and ljLab(G) for 0 ≤ j ≤ k, w0 = w, wk = v, l0L(in), lkL(fin). The graph-controlled grammar G is said to be of type GCac; it is said to be of type GC - to be without appearance checking (without ac) - if φ(l)= { } for all lLab(G). The corresponding families of languages are denoted by L(X-GCac) and L(X-GC), respectively.

  30. Graph-controlled and matrix grammars Theorem 1. For any arbitrary type X, L(X-MAT)L(X-GC) and L(X-MATac)L(X-GCac). Proof. Let G = (O,OT,P, G,w,M,F) be a matrix grammar of type X; then we construct the graph-controlled grammar G’ = (O,OT,P, G,w,R,L(in),L(fin)) with Lab(G’) = { (i,j) : 1 ≤ j ≤ n(i), 1≤ i ≤ n }, L(in) = L(fin) = { (i,1) : 1≤ i ≤ n }, R = { ( (i,j): mi,j,σ(i,j),φ(i,j) ) : 1 ≤ j ≤ n(i),1≤ i ≤ n }, σ(i,j) = { (i,j+1) }, 1 ≤ j < n(i), σ(i,n(i)) = { (i,1) : 1≤ i ≤ n } ( = L(fin) = L(in) ), 1≤ i ≤ n; φ(i,j) = σ(i,j) if mi,j F and φ(i,j) = { } otherwise, 1 ≤ j ≤ n(i), 1≤ i ≤ n . □

  31. P system - definition A P system (with priorities) of type X is a construct • =( O,OT,P,  ,μ,wμ,Rμ, ρμ)where • - ( O,OT,P,  )is a grammar schemeG()of type X; • - μis the membrane structure of ; usually, we shall • label the membranes with 1,...,n in a bijective way; the • outermost membrane is labelled by 1 (skin membrane); • wμ( = (w0,w1,...,wn) ) is a function assigning a multiset • over O to the environment (w0) and to each region • inside membrane i, 1 ≤ i ≤ n; • - Rμ ( = (R1,...,Rn) ) is a function assigning a finite set • of rules to each membrane i, 1 ≤ i ≤ n, of μ; • - ρμ( = (ρ1,...,ρn) ) is a function assigning a priority • relation for the rules in Ri to each membrane i of μ.

  32. maximally parallel derivation mode is one of the most common features of many models introduced so far in the area of P systems. A universal clock is assumed to control the parallel application of rules which may be quite unrealistic, but is relevant for many interesting theoretical results,especially when provingcomputational completenessand solving (NP-)hard problems. Applying the rules assigned to the membranes in the maximally parallel derivation mode means choosing a multiset of rules in such a way that after assigning objects from the environment and the regions to these rules not enough objects are left to add another rule which could be applied together with the chosen rules.

  33. sequential derivation mode In the sequential derivation mode, only one rule is applied in one derivation step. Biological processes in living organisms happen in parallel, but they may not be synchronized by a universal clock, insteadmany processes involve several objects in parallel, but the processes themselves are carried out in an unsynchronized or asynchronous way. Formally, this feature an be captured by letting an arbitrary number of processes happen in parallel in an unsynchronized / asynchronous way (asynchronous derivation mode).

  34. P system - derivation A derivation in the P system  works as follows: We start with the initial multisets wi in the environment and the regions inside the membranes, respectively. At any stage of the derivation, the rules assigned to the membranes are used according to the derivation mode (observe that a rule from Ri can only be applied if no other rule of higher priority according to the priority relation ρi could be applied, too, to any combination of objects inside and outside membrane i).

  35. P system - language All terminal objects from OT ever appearing at any step in any membrane contribute to the language L() generated by . The family of languages generated by X-P(pri) systems (with membrane structure μ) in the derivation mode m (sequential: m = s, maximally parallel: m = p) is denoted by L(X-mP(pri)) (L(X-mP(μ,pri)), respectively). If all priority relations in an X-P(pri) system are empty, we call it an X-P system and denote the corresponding families of languages generated by X-P systems (with membrane structure μ) in the derivation mode d by L(X-mP) ( L(X-mP(μ) ), respectively).

  36. Rules in a P system of type X A rule in a P system of type X is of the form <(x1,or1), …, (xm,orm)> → <(y1,tar1), …, (yn,tarn)> where orj (origin) and tark (target) are from {in, out} and <x1, …, xm> → <y1, …, yn> is a rule over the underlying grammar scheme G() of type X. The objects x1, …, xm to be affected as in the rule <x1, …, xm> → <y1, …, yn> are chosen according to the origins or1, …, ormand the resulting objectsy1, …, yn are released according to the targets tar1, …, tarn.

  37. P systems with splicing rules Theorem. Any recursively enumerable language L can be generated by a P system with splicing rules with only one membrane and even without priorities on the rules in the sequential derivation mode, i.e., L(splicing-sP( [1 ]1 ) = L(ENUM). in out | | skin membrane | | axioms (unbounded) axioms (unbounded) | | splicing rules | |

  38. P systems with string rewriting rules Theorem. Any recursively enumerable language L can be generated by a P system with priorities and context-free rules in a membrane structure of two membranes in the sequential mode, i.e., L(CF-MATac) = L(CF-GCac) = L(CF-sP( [1 [2 ]2 ]1 , pri ) ) = L(ENUM).

  39. P systems with string rewriting rulesbut without priorities Theorem. Without priorities, P systems with context-free rules (in a linear membrane structure of three membranes) in the sequential mode can only generate languages generated by matrix grammars without appearance checking, i.e., L(CF-MAT) = L(CF-sP( [1 [2 [3 ]3 ]2 ]1 ) ). Theorem. Without priorities, P systems with context-free rules (in a linear membrane structure of three membranes) in the maximally parallel mode can generate any recursively enumerable language, i.e., L(CF-MATac) = L(CF-GCac) = L(CF-pP( [1 [2 [3 ]3 ]2 ]1 ) ) = L(ENUM).

  40. Variants of P systems ►generate/dissolve membranes used for implementing parallel algorithms (usually linear in time, but trading time for space) for solving (NP-)hard problems ►tissue(-like) P systems arbitrary graph structure for connections between cells (not necessarily a tree as in P systems); e.g., useful for describing neural networks ►...

  41. Related models Luca Cardelli: http://www.luca.demon.co.uk Brane Calculi: process calculi with computation “on” the membranes, not inside them. BioAmbients: a stochastic calculus with compartments.

  42. Future research ►investigate the complexityof various models of P systems, especially searching for the borderline between systems that are / are not universal (or computationally complete, respectively); ►find new (parallel) algorithms for solving (NP-)hard problems based on P systems; ►investigate the potential of various models of P systems to describe biological processes; ►implement various models of P systems “in silicio” and/or “in vitro” (in the lab); ►...

More Related