notes on the two-handed assembly model (2ham)
DESCRIPTION
Notes on the two-handed assembly model (2HAM). Days 38 and 39 of Comp Sci 480. Two hands. Two-handed assembly model (2HAM) Mmmmmmm… ham! First introduced back in 2004 by Aggarwal, et. al. A.k.a., q-tile assembly model A.k.a., hierarchical self-assembly model - PowerPoint PPT PresentationTRANSCRIPT
Notes on the two-handed assembly model (2HAM)
Days 38 and 39 of Comp Sci 480
Two hands
• Two-handed assembly model (2HAM)– Mmmmmmm… ham!
• First introduced back in 2004 by Aggarwal, et. al.• A.k.a., q-tile assembly model
– A.k.a., hierarchical self-assembly model• A.k.a., “Polyomino” assembly model
• Seedless assembly model– No seed tile is ever specified
• Models the physical reality (?) that two growing assemblies can bump into each other and bind– How likely is this to happen in “real life”?– Larger assemblies get “floppy” and are even more unlikely to
bind
Model definition
• No seed tile– Every tile is the seed tile
• Tiles NEED NOT bind one at a time, but entire assemblies can combine in pairs
• Producible assemblies (a.k.a., supertiles) are defined recursively:– Singleton tiles are producible assemblies– A producible assembly may be obtained by translating
two producible assemblies such that the sum of the binding strengths along adjacent edges is at least the temperature
A key difference
• In the aTAM, producible assemblies had to contain the seed– I.e., singleton tiles were NOT considered
producible
• In the 2HAM, singleton tiles are producible– There is no seed tile
2HAM example
Temperature = 2
What do these tiles do?
Assembly tree…
aTAM = assembly sequences
2HAM = assembly trees
Unique production
• A 2HAM tile set T is said to uniquely produce a supertile A if every supertile produced by T, say B, can grow into A– B T A
• The previous example uniquely produces the assembly A, consisting of the 4x2 rectangle
A generalization
• The 2HAM is a generalization of the aTAM• Thus, it should be more “powerful” than the
aTAM– Recall that tile complexities were reduced for certain
classes of shapes in temperature programming and tile concentration programming
• Let’s see some examples of tile complexities for some different classes of shapes in the 2HAM…
Lines
• What is the tile complexity of uniquely building a 1xN line in the 2HAM?
• Upper bound: N• Here’s the tile set (temperature 1)
– Works in the aTAM too with “0” as the seed tile
0 1 11 2 N-1N-1
N unique tile types
Lines (lower bound)
• What is the minimum number of tile types required to uniquely build a 1xN line in the 2HAM?
• N• Why?• Suppose N-1 tile types could do it…
Terminal assembly: N tiles
At least two locations must share the same tile type (pigeonhole principle)
Since this subassembly is producible, we can use it to build an infinite line (a contradiction)
Squares
• Fact: the minimum number of tile types required to build an NxN square in the 2HAM is Ω(log N / log log N)– Just like the aTAM– Can use an advanced “information-theoretic”
argument to prove this fact
• Is it possible to uniquely produce an NxN square in the 2HAM using O (log N / log log N) unique tile types?– Just like the aTAM?
Optimal square (aTAM) tile set…
0c!0
0s
1c1
!0z
0c0
0c1c
1
1c
0c0
0c1c
1
1c 0z
R0
R1hi
1sR1
R0hi1 ss
1
10c!0
0s1c
1
1c
1c1
!0z 0 zz
0
10zR0
R1hi1c
1
1c
1sR1
R0hi0c
!0
0s1c
1
1c1c
1
1c
Not shown:0 lo3
R0+
1sR1
R0+A
0 320
a0 210
1 11
a loaa
b ahia
Hi hihi
Lo lolo
1 lo3R1+
A loAA
B AhiA
a loaa
b ahia
a loaa
Hi hihi
Lo lolo Lo lolo
Lo loloLo loloLo lolo
B AhiA
B AhiA
B AhiA
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
1c1
!0z1c
1
1c1c
1
1c
Lo lolo Lo lolo Lo lolo Lo lolo Lo lolo Lo lolo
0zR0
R1hi
1sR1
R0hi1 ss
1
11 ss1
11 ss1
1
B AhiA
B AhiA
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
Lo lolo
A loAA
A loAA
A loAA
A loAA
A loAA
A loAA
Lo lolo
Hi hihi Hi hihi Hi hihi Hi hihi Hi hihi This works in the aTAM (not obvious but TEDIOUS to verify)
Does this work in the 2HAM?
Yes!
(basically can’t do any better than this in either the 2HAM or aTAM)
0zR0
R1+A
2HAM optimal encoding
• Can reduce the tile complexity of the previous (2HAM) square tile set
• Use optimal encoding scheme– It works in the 2HAM just like it works in the
aTAM
• Get O(log N / log log N) tile complexity
Separation
• So far we have NOT seen any examples of how the 2HAM can be used to reduce tile complexities for lines and squares
• Pretty much every example we’ve seen that works in the aTAM also works in the 2HAM (unmodified)
• Perhaps we should look at other classes of shapes and try to see a “separation” between the aTAM and the 2HAM– I.e., with respect to tile complexities
At the end of last class
• At the end of last class last time, I asked: does the Sierpinski triangle strictly self-assemble in the 2HAM (it doesn’t in the aTAM)
• Not in the 2HAM either– Assume T is a 2HAM tile set that uniquely builds S
– T is finite
– S is infinite
– Horizontal bars in S get longer and longer
– Eventually, T must place a duplicate tile type in some horizontal bar
– This portion of the bar must be held together “without cooperation”
Scaled Sierpinski triangle
• Does the scaled Sierpinski triangle strictly self-assemble in the 2HAM?
• Open question
• Guess: probably not
• Somebody should prove this!
Loops
• A loop of size N is the following shape:
• What is the tile complexity of loops in the aTAM/2HAM?– Trivial tile complexity for aTAM and 2HAM: 2N+2 (unique tile
type for every point in the loop)
N
The origin
aTAM Loops at temperature 2
Temperature = 2
X
1 ≤ i ≤ N-2
AA 0
ii+1
i
N-1N-1
001
S1
A
X
AA 0
12
1
55
001
S1
A
23
2
34
3
45
4
12
1
55
23
2
34
3
45
4
Tile complexity = N + 3???
This DOES work in the 2HAM!
aTAM loops at temperature 1
S A AA 0
Temperature = 1
001
ii+1
i
N-1BN-1
BC BC C
X 1 ≤ i ≤ N-2
S A AA 0 001
12
1
23
2
34
3
45
4
BC B 5B5
C C
X
X
X
X
Tile complexity = N + 5???
Does this work in the 2HAM?
NO!
A fact
• FACT: The number of tile types required to uniquely build a loop of size N at temperature 1 in the 2HAM is ≥ 2N + 2– We will not prove this fact
• Thus: “aTAM > 2HAM”, when it comes to building loops of size N– “aTAM > 2HAM” ≈ aTAM is more powerful than the
2HAM at temperature 1 – NOT in an asymptotic sense– Both models can build loops with O(N) tile types at
either temperature 1 or 2
Loops: summary• At temperature 2, loops cannot be used to show separation between
the aTAM and 2HAM– aTAM tile complexity = N + 3 ≥ 2HAM tile complexity
• At temperature 1, loops definitely cannot be used to show separation– The aTAM wins!
• Of course, loops don’t give us an “asymptotic” separation between
the aTAM and 2HAM• We need to find a class of shapes whose self-assembly exploits the
two-handed, non-local binding capabilities of the 2HAM• Is there such a shape?
– Yes…
Staircases
• Staircases are examples of shapes that can be assembled drastically more (tile) efficiently in the 2HAM than in the aTAM
• Basic idea: – Define a staircase (of size N)– Prove that a staircase of size N can be built
with very low tile complexity in the 2HAM– Prove that a staircase of size N requires a
high tile complexity in order to be built by any aTAM system
Staircase definition
• A staircase is a sequence of steps
• Set the width of a step to be N– N = 3 in this example
• Each step has a height between 1+2 and 2N+2
– There are 2N steps (8 in this example)
• Put an NxN square right below each step
• Connect each step to its neighbors at two points (two points per neighbor step)
• The end result is a staircase (of size N)
Building staircases in the aTAM
• Fact: If T is any tile set that uniquely self-assembles a staircase of size N, then |T| = Ω(N)– We will not prove this (too many details)
• Dr. Furcy can tell you about a tile set T that uniquely builds a staircase of size N, with |T| = O(N2)– Ask him about this during his office hours
Building staircases in the 2HAM
• Goal: uniquely build a staircase of size N with asymptotically fewer than N unique tile types– Actually, don’t care about building staircases for
arbitrary N– Just infinitely many values of N
• Solution: Turing machines!• Super high-level, basic idea:
– Assemble each stair step in isolation– Have two stair steps combine if they are the right size
A question
• Assume: 2N - 1 unique tile types are required to uniquely produce an NxN square in the aTAM, at temperature 1, but the seed has to be placed at the origin– This is conjectured to be true, but has not been
verified yet
• What is the tile complexity of uniquely building an NxN square, at temperature 1, in the 2HAM?– Upper bound?– Lower bound?
An answer
• Assume a 2HAM tile set T uniquely builds an NxN square with 2N-2 tile types
• Since the temperature is 1, there is a one-tile-at-a-time assembly sequence in T, starting from any point in the square, namely the origin, and fills in the square
• T would do the exact same thing in the aTAM (at temperature 1)– This contradicts the assumption from the previous
slide.
Build one stair step...• Simulate a special “Busy Beaver”
Turing machine on the empty string input
– Busy beaver Turing machines run for a long time, but in this example, the TM halts immediately
– Let T = the number of transitions the Turing machine takes to halt on input empty string
• Tiles non-deterministically attach to the top row of the Turing machine simulation
– 0/1 possible at each location, marking left and right locations (this defines the value x)
• Count up from the guessed value (x in this example) to the next highest power of two minus one
• Grow a “cap” row
0c!0
0s
1c1
!0z
1 ss1
1
00
?
1sR1
R0
0zR0
R1
1sR1
R0
1L1
L1c
1L1
L1c
1 R1C
1AL1
L?
qh RhLh?
q0__Rh
R?
lo_ Lh
L?
hi
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
2N - x
N = 2*T + 1
x 0 DR$
R?
0cR0
R$0 cc0
c1L1
L1c
1 sBL1
1 Rq3L1
q0_
A##
lo
B #hi
#
q0_#
q0_
lo
lolo
lo
0 Rq2
0
Rq3_
1 q2<
q21
1_ <L_
L
0 >q2
0
q210 >>0
0_ R>_
R_ q2<
q2_
__ <L_
L
1 >q1
0
q2_0 >>0
00 >>0
0_ >>_
__ R>_
R_ q1<
q1_
__ <L_
L
qh hh?
q1__ hL?
L_ hh?
_0 hh?
00 hh?
00 hh?
0_ hh?
__ hh?
__ Rh?
R
_Rq3
Rq3_
lo
_RR
lo
_RR
lo
_RR
lo
_RR?
lo_
L?
hi
_L
hi
_ LL
hi
_ LL
hi
_ LL
hi
hihi
hi
A##
lo
B #hi
#
A##
lo
B #hi
#
A##
lo
B #hi
#
A##
lo
B #hi
#
hihi
hi
hihi
hi
hihi
hi
hihi
hi
hihi
hi
hihi
hi
hihi
hi
lolo
lo
lolo
lo
lolo
lo
lolo
lo
lolo
lo
lolo
lo
lolo
lo
lolo
lo
lolo
lololo
lololo
lololo
lololo
lololo
lololo
lololo
lololo
lololo
lo
0 DR$
R?00
?1AL1
L?11
?11
?00
?11
?00
?00
?11
?00
?
Can anybody see a problem with this?
1 Rq3L1
q0_
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
0 Rq2
0
Rq3_
1 q2<
q21
1_ <L_
L
0 >q2
0
q210 >>0
0_ R>_
R_ q2<
q2_
__ <L_
L
1 >q1
0
q2_0 >>0
00 >>0
0_ >>_
__ R>_
R_ q1<
q1_
__ <L_
L
_ RRq3
Rq3_
lo
_ RRR
lo
_ RRR
lo
_ RRR
lo_ LLL
hi
_ LLL
hi
_ LLL
hi
_ LLL
hi
hi LLhi
hi
A R##
lo
B #Lhi
#
A R##
lo
B #Lhi
#
A R##
lo
B #Lhi
#
A R##
lo
B #Lhi
#
hi LLhi
hi
hi LLhi
hi
hi LLhi
hi
hi LLhi
hi
hi LLhi
hi
hi LLhi
hi
hi LLhi
hi
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lolo RRlo
lo
0 DR$
R?00
?1AL1
L?11
?11
?00
?11
?00
?00
?11
?00
?
More steps for the Turing machine means wider steps
Wider steps means more steps in the staircase!
NOTE: The same Turing machine is simulated in every step, so every step is the same width
qh hh?
q1__ hL?
L_ hh?
_0 hh?
00 hh?
00 hh?
0_ hh?
__ hh?
__ Rh?
R_R
R?
lo_
L?
hi
Together at last…
0c!0
0s
1c1
!0z
1 ss1
1
00
?
1sR1
R0
0zR0
R1
1sR1
R0
1L1
L1c
1L1
L1c
1 R1C
1AL1
L?
qh RhLh?
q0__Rh
R?
lo_ Lh
L?
hi
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
0 DR$
R?
0cR0
R$0 cc0
c1L1
L1c
1 sBL1
1c1
!0z
1 ss1
11sR1
R0
0zR0
R11L1
L1c
1 R1C
1AL1
L?
qh RhLh?
q0__Rh
R?
lo_ Lh
L?
hi
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
0!0
?1 DR$
R?
1sR1
R$0c!0
0s1
L1
L1c
1 sBL1
AD
BC BC
Together at last…
1c1
!0z
1 ss1
11sR1
R0
0zR0
R11L1
L1c
1 R1C
1AL1
L?
qh RhLh?
q0__Rh
R?
lo_ Lh
L?
hi
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
0!0
?1 DR$
R?
1sR1
R$0c!0
0s1
L1
L1c
1 sBL1
AD
0c!0
0s
1c1
!0z
1 ss1
1
00
?
1sR1
R0
0zR0
R1
1sR1
R0
1L1
L1c
1L1
L1c
1 R1C
1AL1
L?
qh RhLh?
q0__Rh
R?
lo_ Lh
L?
hi
A R##
lo
B #Lhi
#
q0_ R#
q0_
lo
lo RRlo
lo
lo RRlo
lo
lo RRlo
lo
0 DR$
R?
0cR0
R$0 cc0
c1L1
L1c
1 sBL1
BC
Tile complexity
• Let M be any Turing machine that runs for T steps when given the empty string as input
• Assume M has k states and a constant number of input/tape alphabet symbols
• 2HAM tile complexity for building a staircase of size 2T + 1: O(k)
• Can’t use this procedure to assemble staircases of any size– But can always assemble arbitrarily large staircases with
a number of unique tile types asymptotically less than the width of a stair step
Busy beaver separation
• Let M be the following (“busy beaver”) Turing machine:
• Running time of M on empty string as input: T = 47176870 steps(Thanks: http://en.wikipedia.org/wiki/Busy_beaver)
• Let N = 2T + 1 • Desired size of staircase: N
– aTAM: at least c* 47176870 unique tile types needed, for some constant c
– 2HAM: < 100 unique tile types needed
A B C D E
0 1,B,R 1,C,R 1,D,R 1,A,L 1,H,R
1 1,C,L 1,B,R 0,E,L 1,D,L 0,A,L
The 2HAM is better
• Why is the 2HAM so much better at building staircases (of size N) than the aTAM?
• One possible answer: cooperation in the 2HAM does not need to be local, like it always is in the aTAM
• Geometry of assemblies can be used to hinder/help assembly
Is the 2HAM better?
• Is the 2HAM really better than the aTAM?• Can the 2HAM literally do anything that the
aTAM can do?• Example: take an aTAM tile set T and pretend
it’s a 2HAM tile set• Does T produce exactly the same assemblies in
the 2HAM as it does in the aTAM?• Intuitively: an assembly sequence in the aTAM
can be carried out by the 2HAM…
aTAM as 2HAM example
3
2
S 1
A
B
C
3
43
2It’s clear that this tile set produces one assembly…
… in the aTAM!
What about in the 2HAM?21
21
3
2
A
B
B
B
A
B
B
B
B
C
3
4
Temperature τ = 1
??4
C
??4
C 21
3
4
??4
C
B
C
A
B
B
B
S 1
A
aTAM as 2HAM example
3
2
B
C
3
43
2
21
A
B
B
B
A
B
B
B
??4
C 21
3
4
??4
C
B
C
A
B
B
B
A
B
B
B
A
B
B
B
A
B
B
B
A
B
B
B
“aTAM as 2HAM” does not automatically work.
In the 2HAM: cannot (easily) enforce sequential tile additions
S 1
A
Temperature τ = 1
Simulation
• Fact: the 2HAM can “simulate” the aTAM– “simulate” specifies that single tiles in an aTAM tile set must be
treated as producible assemblies
• That is, for each aTAM system T, there is a 2HAM system S satisfying the following:– Every assembly tree of S represents one assembly sequence of
T (OR just a single tile type of T)– Every assembly sequence of T is represented by one assembly
tree of S
• Key detail: the producible assemblies of S are scaled up versions of producible assemblies of T– The scale factor is 5!
The basic idea
• Start with an aTAM tile system as input
• Represent each aTAM tile type as a 5 x 5 supertile
• Bricks: 3 x 3 supertiles that map to aTAM tiles
• Mortar: 1 x 3 (or 3 x 1) supertiles and singleton tiles that hold bricks together
• Simulate dynamics and production (not connectivity)
• Too many details!
S
Simulation: generalizations
• Any aTAM system at temperature 1 or 2 can be simulated by a 2HAM system at temperature 2
• Any aTAM system at temperature 3 can be simulated by a 2HAM system at temperature 3
• Any aTAM system at temperature ≥ 4 can be simulated by a 2HAM system at temperature 4
Verification
• Verifying unique production in the aTAM (in 3D) can be done by an efficient algorithm– O(“size of the assembly”2)
• Verifying unique production in the 2HAM (in 3D) probably cannot be done by any efficient algorithm– Very complicated, but very COOL, proof of this!– The complexity of verifying unique production in the 2HAM in 2D
is not known and currently under investigation
• Verifying producibility in the 2HAM can be done by an efficient algorithm– Doty (2013): O(|A|*log2|A|)
Summary
2HAM = Ω(aTAM)