A simple analysis

1
A simple analysis

• Suppose complementary DNA strands of length U
  always stick, and those of length L never stick
  (eg U20, L10)
• Suppose you have n randomly chosen DNA strands of
  length U
• Probability that there will be some undesired
  interaction of length at least L U2n24-L
• Basis of Adlemans construction and also DNA
  tiles

2
Tile Systems and Program Size

• A tile system that uniquely assembles into a
  shape is analogous to a program for computing the
  shape
• Program size The number of tile types used
• Goal Find smallest program size for interesting
  classes of shapes Adleman 99Rothemund and
  Winfree 00
• Can often derive lower bounds on program size
• Need n distinct tile types to assemble a line of
  length n (pumping lemma)
• Need Oio(log n/log log n) distinct tile types to
  construct squares of side n (Kolmogorov
  complexity)
• Also need a notion of assembly time or running
  time

3
Tile Systems and Assembly Time
t 2

• d

B
C
A
Seed
4
Tile Systems and Assembly Time
A 50, B30, C 20

• d

0.5
0.3
0.2
0.5
0.3
Assembly time Average time to go from seed to
terminal state
5
Example Assembling Lines

• Require n tiles to assemble line of length n
• Eg. suppose tiles B and F are the same
• Could pump the tiles BCDE to get infinite line
• Therefore program size is n
• For fastest assembly, all tiles must have the
  same concentration (1/n)
• Expected assembly time is n2
• Can assemble thicker rectangles (2 n, log n
  n, n n etc.) faster and with less tile types!

F
G
H
I
A
6
Self-assembling Squares

• Would like to assemble n x n squares as fast as
  possible and with as few tile types
• Kolmogorov lower bound of Oio(log n/log log n) on
  the program size (i.e. number of different tiles)
• Assembly time has to be O(n) in accretion model
• Motivation
• Simple canonical problem, leads to useful general
  techniques
• Also interesting in its own right (e.g.
  assembling computer memories)

7
Rothemund-Winfree construction

• Basic Idea Easy to extend a self-assembled
  rectangle into a self-assembled square

y
B
x
x
t2
y
z
A
w
w
z
z
C

• Inefficient to start with a 1 n rectangle
• Need W(n) tile types, W(n2) time for lines
• Solution Use counters to make rectangles

w
8
Assembly Time Analysis Technique
B
C
A
Seed
Terminal assembly
9
Assembly Time Analysis Technique

• Let L be the length of the longest path in an
  equivalent acyclic subgraph of G
• Often, much smaller than longest path in Markov
  Chain
• Let Cm be the smallest concentration Ci
• Theorem The assembly time of the given tile
  system is O(L/Cm) with high probability
• Find the right equivalent acyclic subgraph
• No Markov chains anymore, just combinatorial
  analysis
• Analysis technique is tight there always exists
  an EAG which gives a tight bound if Cis are
  identical

10
Proof for identical Cis
ti,j time for tile to attach at position (i,j)
after it becomes attachable

• ti,j exponential random variable with mean 1/C
• L length of longest path in equivalent acyclic
  graph
• Number of paths 3L
• For any path P in graph, let tP åi,j 2 P ti,j
• Assembly-time sd maxP tP
• EtP L/C also sharp concentration (Chernoff
  bounds)
• ) Expected assembly time O(L/C)

11
Squares via counters

• Self-assemble a log n n rectangle by simulating
  a log n bit counter
• Start with a seed row that has log n tiles,
  labeled 0/1
• Define an increment operation which adds one to
  the row
• Crucial step assembly must stop when all the
  tiles in a row are labeled 1
• Requires Q(log n) tile-types to make the seed and
  ?(1) other tiles
• Can be improved to the Kolmogorov optimum of
  Q(log n/log log n)
• Then, use triangulation on one side of the
  counter to covert the counter into a square

12
Counter tiles
13
Counting example
From Cheng, Moisset, Goel Optimal self-assembly
of counters at temperature 2 (basic ideas
developed over many papers)
14
Equivalent Acyclic Subgraph for Counters
1111111 .. .. 0000000
1 1 1 1
01111111
1111110 .. .. 0000000
0 0 0 0
L(n) 2 L(n/2) Q(log n) Q(n) T(n)
L(n)/Cm Q(n)
00000000
15
Constructing squares and Counters

• Can extend this basic idea to
• Assemble n n squares in time O(n), using O(log
  n/log log n) tiles (provably optimum)
• Count optimally in binary using the same assembly
  time and program size
• General design and analysis techniques
• A library of subroutines (counting,
  base-conversion, triangulating the line)
• If this is so efficient, why didnt nature learn
  to count?
• Possible conjecture Not evolvable, not robust
• Open problems general analysis techniques for
  assembly time in reversible models?