# DNA Self Assembly

Document Sample

```					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
 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
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
Shared By:
Categories:
Stats:
 views: 12 posted: 4/24/2011 language: English pages: 58