DNA Self Assembly

Document Sample
DNA Self Assembly Powered By Docstoc
					DNA Self-Assembly

The complexity of
self-assembled shapes
Self-Assembly
 “The process by which an organized
  structure can spontaneously form from
  simple parts”
 Tile Assembly Model
     2-D   self-assembly of square units called tiles.
   Promising applications
     Nanofabrication
Self-Assembly & Computation
 Self-assembled “shape” = Output of
  computational process.
 We are interested in shape complexity
  (defined later on):
     Kolmogorov  Complexity
     Tile Complexity
Tile Assembly Model
Grid of unit square locations
jZ




             (i, j)




                            iZ
Directions: d  D = {N,E,S,W}
jZ




             N          N (i, j) = (i, j+1)
                        W (i, j) = (i-1, j)
                        S (i, j) = (i, j-1)
        W         E     E (i, j) = (i+1, j)


                        N = S-1, S = N-1
             S
                        W = E-1, E = W-1


                               iZ
Bond types: σ  Σ
   A bond type describes a „side‟ of a tile
    (in terms of interaction with adjacent).

    σ1 :   σ2 :   σ3 :




   Special bond type for no interaction:   null:
Tile types: t = (σN, σΕ, σS, σW)  Σ4

   Defined by its four bonds

     t1 = (σ1, null, σ1, null) =

                                                             tT

     t2 = (null, null, σ2, σ3) =



   Special tile:              empty = (null, null, null, null)
    Tile (instance) t = (t, (i, j))  TZ2

       A tile t is defined by its type t and its
        position (i, j) in the grid.
j
                                   Example:
                                   t = (t2, (2, 2))
                   t
                                   u = (t2, (3, 1))
                                   v = (t1, (1, 1))
              v         u




                                   i
Helper functions
   Let t = (t, (i, j)) = ((σN, σE, σS, σW), (i, j))

 type(t) = t
 pos(t) = (i, j)
 bondd(t) = bondd(t) = σd
 adj(t,u) = true if dD: pos(t) = d(pos(u))
    Helper functions (example)
     type(t) = t2, pos(t) = (2, 2), bondS(t) = σ2
     S(W(pos(t)) = pos(v) = (1,1)

j
                                           t = (t2, (2, 2))

                 t                         u = (t2, (3, 1))
                                           v = (t1, (1, 1))

            v         u
                                    σ1 :        σ2 :          σ3 :


                                i
Configuration
 A configuration is a set of tiles, with
  exactly one tile in every location (i, j)
 For any configuration A, notation A(i, j)
  indicates the tile at location (i, j)
 Practically, specify a set of non-empty
  tiles; all other tiles are implicitly empty.
Strength functions (definition)
   Bond strength function: g(σ, σ´) : Σ2 → Z
     Defined   for all pairs of bonds (including null)
   Tile strength function: Γ(t, u)
     Defined for adjacent tiles t and u
     Equals to g(σ, σ´) where σ and σ´ are the
      bond types of the adjacent sides of t and u
      respectively
  Strength functions (example)
            Example of g
                                               t         u
       σ1     σ2    σ3     null

σ1     1       0    0       0
                                                         v
σ2     0       7    0       0

σ3     0       0    2       0           Γ(t, u) = g(σ1, σ1) = 1

null   0       0    0       0           Γ(u, v) = g(σ2, σ2) = 7


Formally:
                g(bondd1 (t),bondd (u)), if adj(t,u) in directiond
       Γ(t,u)  
                                 0,otherwise
Strength function properties
 g is symmetric
 g(σ, null) = 0
 g is non-negative
 g is diagonal
     Diagonalmeans that only matching bond
     types can interact!
Tile system T = (T, ts, g, τ)
   A tile system T is defined by:

    A   set Τ of tile types    t1         t2   ...




    A   seed tile ts, with type(ts)  T
    A   strength function g
    A   threshold τ
Self-Assembly (definition)
 Self assembly is defined by a relation
  between configurations
 Suppose A and B are identical configs,
  except for t, which exists in B but not in A:
     A(pos(t))   = empty, B(pos(t)) = t
   Self assembly:
     A→B   if ΣdDΓ(t, A(d(pos(t)))) ≥ τ
  Self-Assembly (example)
              Contents of g

         σ1      σ2   σ3      null

σ1        1       0    0       0        x                 x       t
σ2        0       7    0       0

σ3        0       0    2       0                 y                y

null      0       0    0       0

                                     Configuration A   Configuration B


       A→B only if Γ(t,x) + Γ(t,y) = 1 + 7 ≥ τ
Transitive Closure
 The reflexive transitive closure of → is
  denoted as . (That is, we say that A  B
  if we can keep adding tiles to A and reach
  B: A → A2 → A3 → ... → B).
 We are interested in self-assemblies from
  a single seed tile ts!
Assemblies for a tile system T
   Prod(T) = {A, such that {ts}  A)
     All   the configurations reachable from ts in T.
   Term(T) = {A  Prod(T), B≠A: A  B}
     All   the terminal assemblies reachable from ts


   T uniquely produces A if Term(T) = {A}.
Threshold τ
 A common choice is τ = 2, where the
  strength function ranges over {0, 1, 2}.
 Systems with τ = 1 and a strength function
  ranging over {0, 1} are rather limited.
Example of T = (T, ts, g, τ)
                                 N    E     S    W
   Set T of tile types:                               σ1
                           ts    -     -    -    σ1
                           t1    -    σ1    -    σ2
                                                            ts
                           t2    -    σ2    σ3    -
 ts  = (ts, (2, 4))       t3    σ3    -    σ4    -
   g = I = diag{1}        t4    σ4   σ5    -     -    σ2        σ1
                           t5    -    σ6    -    σ5
   τ=1                                     σ7   σ6
                           t6    -     -                    t1
                           t7    σ7    -    σ8    -
                           t8    σ8    -    -    σ9
                           t9    -    σ9    -    σ10             σ2
                                                            σ3
                           t10   -    σ10   -     -
                                                            t2
What does it assemble to?
      N    E     S    W
                            σ1
ts    -     -    -    σ1
t1    -    σ1    -    σ2
                                 ts
t2    -    σ2    σ3    -
t3    σ3    -    σ4    -
t4    σ4   σ5    -     -
t5    -    σ6    -    σ5
t6    -     -    σ7   σ6
t7    σ7    -    σ8    -
t8    σ8    -    -    σ9
t9    -    σ9    -    σ10
t10   -    σ10   -     -
What does it assemble to?
      N    E     S    W
                            σ2        σ1   σ1
ts    -     -    -    σ1
t1    -    σ1    -    σ2
                                 t1             ts
t2    -    σ2    σ3    -
t3    σ3    -    σ4    -
t4    σ4   σ5    -     -
t5    -    σ6    -    σ5
t6    -     -    σ7   σ6
t7    σ7    -    σ8    -
t8    σ8    -    -    σ9
t9    -    σ9    -    σ10
t10   -    σ10   -     -
What does it assemble to?
      N    E     S    W
                                 σ2   σ2        σ1   σ1
ts    -     -    -    σ1    σ3
t1    -    σ1    -    σ2
                            t2             t1             ts
t2    -    σ2    σ3    -
t3    σ3    -    σ4    -
t4    σ4   σ5    -     -
t5    -    σ6    -    σ5
t6    -     -    σ7   σ6
t7    σ7    -    σ8    -
t8    σ8    -    -    σ9
t9    -    σ9    -    σ10
t10   -    σ10   -     -
What does it assemble to?
      N    E     S    W
ts    -     -    -    σ1
t1    -    σ1    -    σ2
t2    -    σ2    σ3    -
t3    σ3    -    σ4    -
t4    σ4   σ5    -     -
t5    -    σ6    -    σ5
t6    -     -    σ7   σ6
t7    σ7    -    σ8    -
t8    σ8    -    -    σ9
t9    -    σ9    -    σ10
t10   -    σ10   -     -
Shape scaling
   Coordinated* shape of assembly A:
     SA = {(i, j) such that A(i, j) ≠ empty}
     (This is a single connected component)

   For a set of locations S, and cZ+, define
    a c-scaling of S:
      Sc = {(i, j) such that  i/c  , j/c    S }
     (This   is a magnification of S by a factor of c)

                           *shape within a fixed coordinate system
Shape equivalence
 Coordinated shapes S1 and S2 are scale-
  equivalent if c,dZ+ such that S1c = S2d
 Coordinated shapes S1 and S2 are
  translation-equivalent if they can be
  made equivalent by translation.
 We write S1  S2 if c,dZ+ such that S1c
  is translation-equivalent to S2d
Shape equivalence (example)
S1 is translation-equivalent to S2
S2 is scale-equivalent to S3
S1  S3




          S1              S2         S3
Equivalence class
 Scale-equivalence, translation-equivalence
  and  are equivalence relations.
 The equivalence class of coordinated
  shapes under the relation “” is called the
  shape Ŝ. We say that Ŝ is the shape of
  assembly A if SAŜ.
Tile complexity
   The tile complexity of a coordinated
    shape S is the minimum number n of tile
    types needed by a tile system T to
    uniquely produce that shape.
     Ksa(S)   = min{n: T with |T|=n, {ts}  S*}
   Definition directly extended for a shape Ŝ

                         *Formally, {ts}  A, and S is the
                         coordinated shape of A
Tile complexity (examples)
   Let‟s examine Stanford‟s initials

                  ts




                            ts
Tile complexity (“S”)
   Minimum Solution: Ksa=11                        N    E     S    W
                                              ts    -     -    -    σ1
                                              t1    -    σ1    -    σ2
                ts                            t2    -    σ2    σ3    -
                                              t3    σ3    -    σ4    -
                                              t4    σ4   σ5    -     -
                                              t5    -    σ6    -    σ5
                                              t6    -     -    σ7   σ6

                     As complex as it can
                                              t7    σ7    -    σ8    -
                     get (need as many tile   t8    σ8    -    -    σ9
                     types as tiles)!
                                              t9    -    σ9    -    σ10
                                              t10   -    σ10   -     -
Tile complexity (“U”)
   Possible solution: n=11                          N     E    S     W
                                               ts     -    σ6    -    σ1
                                               t1    σ2    σ1    -    -
           t5        t10                       t2    σ3    -    σ2    -
                                               t3    σ4    -    σ3    -
           t4        t9
                                               t4    σ5    -    σ4    -
                                               t5     -    -    σ5    -
           t3        t8
                                               t6    σ7    -     -    σ6
           t2        t7    Can we do better?
                                               t7    σ8    -    σ7    -
                                               t8    σ9    -    σ8    -
           t1   ts   t6                        t9    σ10   -    σ9    -
                                               t10    -    -    σ10   -
Tile complexity (“U”)
   Optimal solution: Ksa=7                              N     E    S     W
                                                   ts     -    σ6    -    σ1
                                                   t1    σ2    σ1    -    -
           t5        t5                            t2    σ3    -    σ2    -
                                                   t3    σ4    -    σ3    -
           t4        t4
                          Notice that the leg
                                                   t4    σ5    -    σ4    -
                          formed by t2 to t5 is    t5     -    -    σ5    -
           t3        t3   the same as t7 to t10.
                                                   t6    σ72   -     -    σ6
                          Modify t6 by placing
           t2        t2   bond type σ2 north       t7    σ8    -    σ7    -
                          (instead of σ7).         t8    σ9    -    σ8    -
           t1   ts   t6   The assembly will        t9    σ10   -    σ9    -
                          reuse t2 to t5!
                                                   t10    -    -    σ10   -
Binary Counter
   Ksa=?
                 1   0   0   0
                 0   1   1   1
                 0   1   1   0
                 0   1   0   1
                 0   1   0   0
                 0   0   1   1
                 0   0   1   0
                 0   0   0   1
Binary Counter

                      1   0   0   0
                      0   1   1   1
                      0   1   1   0
                      0   1   0   1
                      0   1   0   0
                 U    0   0   1   1
                      0   0   1   0
                      0   0   0   1

           L     ts
Binary Counter

                 1   0   0   0
                 0   1   1   1
                 0   1   1   0
                 0   1   0   1
                 0   1   0   0
                 0   0   1   1
                 0   0   1   0
                 0   0   0   1
Binary Counter                     Assembly grows
                                   in this direction
Type of tile can be determined
by two input conditions, and can
forward two outputs
                                         1   0   0   0
 “Outputs”                               0   1   1   1
                                         0   1   1   0
                                         0   1   0   1
                                         0   1   0   0
                      Matching           0   0   1   1
                      “inputs”           0   0   1   0
                                         0   0   0   1
Binary Counter
I am the same as my
SOUTH, unless it‟s      1   0   0   0
time to FLIP!           0   1   1   1
                        0   1   1   0
But how to determine    0   1   0   1
if it‟s time to FLIP?   0   1   0   0
                        0   0   1   1
                        0   0   1   0
                        0   0   0   1
 Time to flip?
                                    1   0   0   0
Black = Same as SOUTH               0   1   1   1
Red = Different than south,
cause it‟s time to flip!            0   1   1   0
                                    0   1   0   1
FLIP up to the first 1 from the
right, therefore nice property to
                                    0   1   0   0
propagate EAST-to-WEST              0   0   1   1
                                    0   0   1   0
                                    0   0   0   1
Binary Counter
         NUM
         output

                          1   0   0   0
FLIP              FLIP    0   1   1   1
output            input   0   1   1   0
                          0   1   0   1
                          0   1   0   0
          NUM             0   0   1   1
          input
                          0   0   1   0
                          0   0   0   1
 Binary Counter
          Flip OFF   Flip ON


NUM = 0                        1   0   0   0
                               0   1   1   1
                               0   1   1   0
                               0   1   0   1
NUM = 1                        0   1   0   0
                               0   0   1   1
                               0   0   1   0
                               0   0   0   1
 Binary Counter
          Flip OFF   Flip ON


NUM = 0                        1   0   0   0
                               0   1   1   1
             0                 0   1   1   0
                               0   1   0   1
NUM = 1                        0   1   0   0
                               0   0   1   1
                               0   0   1   0
                               0   0   0   1
 Binary Counter
          Flip OFF   Flip ON


NUM = 0                        1   0   0   0
                               0   1   1   1
             0         1       0   1   1   0
                               0   1   0   1
NUM = 1                        0   1   0   0
                               0   0   1   1
                               0   0   1   0
                               0   0   0   1
 Binary Counter
          Flip OFF   Flip ON


NUM = 0                        1   0   0   0
                               0   1   1   1
             0         1       0   1   1   0
                               0   1   0   1
NUM = 1                        0   1   0   0
                               0   0   1   1
             1
                               0   0   1   0
                               0   0   0   1
 Binary Counter
          Flip OFF   Flip ON


NUM = 0                        1   0   0   0
                               0   1   1   1
             0         1       0   1   1   0
                               0   1   0   1
NUM = 1                        0   1   0   0
                               0   0   1   1
             1         0
                               0   0   1   0
                               0   0   0   1
Binary Counter
   Ksa=7
                         1   0   0   0
                         0   1   1   1
                         0   1   1   0
                         0   1   0   1
                         0   1   0   0
    0       0       U    0   0   1   1
                         0   0   1   0
                         0   0   0   1

    1       1   L   ts
Binary Counter

                 1   0   0   0
                 0   1   1   1
                 0   1   1   0
                 0   1   0   1
                 0   1   0   0
                 0   0   1   1
                 0   0   1   0
                 0   0   0   1
Variant of Sierpinski Triangle
   Ksa=7
                    0       1       0       1       0
                1       1       0       0       1       1
                    1       0       0       0       1
                        1       1       1       1
     1      1               1       0       1
                                1       1
                                    1
     0      0
Compute the tile complexity?
   Given a coordinated shape S, can I
    compute its complexity Ksa(S)?
     (Combinatorial   optimization problem)

     Yes,   but it‟s hard (NP-complete)!
Turing Machine
 A Turing Machine is a simple computation
  model which can be used to compute any
  function.
 Most common form:
     1-dimensional   infinite tape with 0s and 1s
     Head located at some position on the tape
     Internal state, program
     Can read/write tape, move head
Kolmogorov Complexity
   The Kolmogorov complexity of a binary string
    x with respect to a universal Turing machine U is
    the smallest program p that outputs x:
     KU(x)   = min{|p|: U(p) = x}
   The Kolmogorov complexity of a shape S is the
    smallest program that can output it as a list of
    locations encoded in some binary form <S>:
     K(S)   = min{|s|: U(s) = <S>} (directly extended for Ŝ)
Complexity theorem
    a0, b0, a1, b1, such that Ŝ:

      a0K(Ŝ)+b0 ≤ Ksa(Ŝ)logKsa(Ŝ) ≤ a1K(Ŝ)+b1


   Therefore K = Θ(nlogn)
Proof for first part
   Create a Turing machine that simulates
    self-assembly.
     Write a fixed-size program p0 to do the
      assembly of a tile system T that reproduces Ŝ.
     Final program p = p0 + <T>
        <T> is binary encoding of tile system T.
        What is the size of <T>?
              In other words, how many bits are needed to describe T?
Size of <T> = <(T, ts, g, τ)>
   T contains n = Ksa(Ŝ) tile types.
     Each tile type is specified by four bonds
     At most 4n different bond types
     For every tile type, 4log(4n) bits
          Therefore, T is specified in 4nlog(4n) bits
                Note: ts is included in T.

   g, τ are not directly needed; for each tile type,
    specify which of the 16 subsets of D it can bind
     Needs       16n bits
Proof (cont)
   Therefore final size of program: cnlogn+d

       K(Ŝ) = min{programs} ≤ cnlogn+d

   Thus:
            a0K(Ŝ)+b0 ≤ Ksa(Ŝ)logKsa(Ŝ)
Compute the tile complexity? (v2)

   Given a shape class Ŝ, can I compute its
    complexity Ksa(Ŝ)?

     No,   Ksa(Ŝ) is uncomputable!

        In other words, language L is undecidable:
       L = { (ℓ, n) s.t. ℓ = <S> for some SŜ and Ksa(Ŝ)≤n }

				
DOCUMENT INFO