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
What do these tiles do?
Temperature = 2
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
1
1
2
N unique tile types
N-1 N-1
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…
At least two locations must share the
same tile type (pigeonhole principle)
Terminal assembly: N tiles
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…
1
s
11
1
s
s
1
c
11
11
c
11
c
11
c
11
c
11
c
1!0
00
00
c
00
z
1
0
00
01
s
11
z
c
1!0
c
00
s
2
0a
Hi
hi
hi
Hi
hi
hi
Hi
hi
hi
hi
Hi
hi
hi
BA
A
A
0
1
z
0
hi
1
0
1
A lo
lo Lo lo
BA
A lo
lo Lo lo
lo Lo lo
lo Lo lo
hi
hi
BA
A
A
lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
A
A
A lo
A
hi
hi
A
A
BA
A
A
A
A
R0+
A lo
Hi hi
hi
ba a
a
3
0 lo
lo Lo lo
ba a
a
a lo
a lo
(basically can’t do any
better than this in
either the 2HAM or
aTAM)
Not shown:
a lo
lo Lo lo
lo Lo lo
R0
z
lo Lo lo
lo Lo lo
R1+
3
lo Lo lo
0A
R1+
lo Lo lo
a
a
Yes!
lo Lo lo
a
hi
Does this work in the
2HAM?
R0+
3
a
hi
This works in the
aTAM (not obvious but
TEDIOUS to verify)
A
R1
s
A
A
R1
s
BA
A
hi
R0
z
lo Lo lo
Hi hi
R0
z
A lo
hi
R1
s
A lo
hi
R1
s
A
A
hi
R0
z
BA
A
A
hi
R0
0
2
hi
R1
s
!0
c
Hi
hi
R1
1
c
hi
R0
z
1
s
0
1
1!0
1
A
hi
R0
0
z
0
c
1
1
c
0
c
1
c
11
s
!0
c
!0
c
1
c
c
1
c
1
c
11
11
R1
s
1
c
1
c
1
c
s
1
c
1
c
11
1
s
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
lo Lo lo
1 lo
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:
N
The origin
• 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)
aTAM Loops at temperature 2
X
N-1
N-1
i+1
ii
1
S
55
1 ≤ i ≤ N-2
1
A
A
A
0
0
0
Tile complexity = N ???
+3
X
55
5
5
44
44
4
4
33
33
3
3
22
22
2
2
11
11
1
S
1
A
A
A
0
This DOES work in the 2HAM!
Temperature = 2
0
0
aTAM loops at temperature 1
CC
CC
C
BB
C
BB
B
B N-1
N-1
5
X
i+1
X
ii
44
1 ≤ i ≤ N-2
4
X
33
1
S
A
A
A
0
0
55
3
0
X
22
2
X
11
Tile complexity = N ???
+5
1
S
A
A
A
0
Does this work in the 2HAM?
Temperature = 1
NO!
0
0
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 selfassembles 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-ata-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...
C
1
R1
1
B
•
Simulate a special “Busy Beaver”
Turing machine on the empty string
input
–
–
•
Tiles non-deterministically attach to
the top row of the Turing machine
simulation
–
•
•
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
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
1
s
s
L1
L1
1
c
L1
1
c
L1
x
A
1!0
00
1
R0
R0
z
z
0
R1
!0
c
L1
1
s
1
c
L1
2N - x
11
R1
s
R1
s
s
1
R0
0
R0
L1
0c
L1
0
R$
1
0?
R?
c
L?
c
c
L?
?
_ Lh Lh qh Rh
hi
q 0_
c
0
R$
0D
Rh
R?
_
lo
hi
L B #
#
q 0_
# q 0_ R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
N = 2*T + 1
A
Can anybody see
a problem with
this?
L1
0
1
0
0
1
0
1
1
0
R$
L?
1
0?
1?
0?
0?
1?
0?
1?
1?
0?
R?
L?
_
hi
?
L _ h
L
?
h _ h
_
?
h qh h
q 1_
?
h 0 h
0
?
h 0 h
0
?
h 0 h
0
?
h _ h
_
?
h _ h
_
?
h _ R
R
hi
hi
hi
L
_
hi
_
L _ <
L
q 1_
< _ q1
_
0
q1 1 >
q 2_
0
> 0 >
0
0
> 0 >
0
_
> _ >
_
_
> _ R
R
R
R _
lo
L
_ L
hi
_
L _ <
L
q 2_
< _ q2
_
0
q2 0 >
q21
0
> 0 >
0
_
> _ R
R
R
R _
lo
L
_ L
hi
_
L _ <
L
q 21
< 1 q2
1
0
q2 0 R
R
R _
lo
hi
hi
hi
L
_ L
hi
1
L 1 Rq3
q 0_
hi
hi
hi
hi
B #
#
q 0_
# q 0_
lo
hi
hi
hi
hi
hi
hi
hi
hi
hi
hi
B #
#
hi
hi
hi
hi
hi
hi
hi
B #
#
#
# A
lo
hi
B #
#
hi
B #
#
Rq3_
lo
lo
lo
lo
lo
lo
lo
lo
lo
_
lo
lo
lo
lo
#
# A
lo
lo
lo
lo
#
# A
lo
lo
lo
lo
#
# A
lo
lo
lo
lo
#
# A
lo
lo
lo
lo
R?
R _
lo
lo
lo
lo
Rq3_
Rq3
0D
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
lo
L1
0
1
0
0
1
0
1
1
0
R$
L?
1
0?
1?
0?
0?
1?
0?
1?
1?
0?
R?
L?
_
hi
?
L _ h
L
?
h _ h
_
?
h qh h
q 1_
?
h 0 h
0
?
h 0 h
0
?
h 0 h
0
?
h _ h
_
?
h _ h
_
?
h _ R
R
R?
R _
lo
hi
L hi L
hi
L
L _ L
hi
_
L _ <
L
q 1_
< _ q1
_
0
q1 1 >
q 2_
0
> 0 >
0
0
> 0 >
0
_
> _ >
_
_
> _ R
R
R
R _ R
lo
lo
R lo R
lo
L
L _ L
hi
_
L _ <
L
q 2_
< _ q2
_
0
q2 0 >
q21
0
> 0 >
0
_
> _ R
R
R
R _ R
lo
L
L _ L
hi
_
L _ <
L
q 21
< 1 q2
1
0
q2 0 R
R
R _ R
lo
hi
L hi L
hi
L
L _ L
hi
1
L 1 Rq3
q 0_
hi
L hi L
hi
hi
L B #
#
q 0_
# q 0_ R
lo
A
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
hi
L hi L
hi
hi
L hi L
hi
hi
L hi L
hi
hi
L B #
#
hi
L hi L
hi
hi
L B #
#
hi
L hi L
hi
hi
L B #
#
hi
L B #
#
#
# A R
lo
#
# A R
lo
lo
R lo R
lo
Rq3_
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
Rq3_
Rq3
0D
_ R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
lo
R lo R
lo
Together at last…
C
1
R1
1
C
1
1
B
1
s
s
L1
L1
1
c
L1
A
s
1
c
L1
1
11
s
1!0
z
z
!0
1
1
L1
R0
L1
0
1
R1
L1
R1
L1
1
1
1
0?
1
L?
?
_ Lh Lh qh Rh
hi
q 0_
R$
Rh
1
R0
R$
L?
B
L1
!0
s
B
R1
L1
s
C
L1
00
c
B
R1
L1
c
C
D
D
A
A
s
s
11
R1
s
s
1
c
c
1!0
R0
z
z
c
00
0
R1
!0
c
1
R0
R1
s
s
1
R0
0
R0
L1
0c
L1
0
R$
1
0?
R?
c
c
c
R?
L?
R?
_
lo
L?
?
_ Lh Lh qh Rh
hi
q 0_
c
0
R$
0D
Rh
R?
_
lo
hi
L B #
#
q 0_
# q 0_ R
lo
lo
R lo R
lo
hi
L B #
#
q 0_
# q 0_ R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
Together at last…
C
1
R1
1
C
1
1
B
1
s
s
L1
L1
1
c
L1
A
s
1
c
L1
1
11
s
1!0
z
z
!0
L1
1
1
R0
L1
R0
L1
0
1
R1
L1
R1
L1
1
1
!0
R$
1
0?
1
L?
L?
?
_ Lh Lh qh Rh
hi
q 0_
s
R$
Rh
1
R1
L1
s
B
L1
00
c
B
R1
L1
c
C
D
D
A
A
s
s
11
R1
s
s
1
c
c
1!0
R0
z
z
c
00
0
R1
!0
c
1
R0
R1
s
s
1
R0
0
R0
L1
0c
L1
0
R$
1
0?
R?
c
c
c
R?
L?
R?
_
lo
L?
?
_ Lh Lh qh Rh
hi
q 0_
c
0
R$
0D
Rh
R?
_
lo
hi
L B #
#
q 0_
# q 0_ R
lo
lo
R lo R
lo
hi
L B #
#
q 0_
# q 0_ R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
#
# A R
lo
lo
R lo R
lo
lo
R lo R
lo
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:
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
0,A,L
1,B,R 0,E,L
1,D,L
• 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
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
B
3
4
It’s clear that this tile set produces
one assembly…
2
A
B
3
… in the aTAM!
What about in the 2HAM?
C
??
C
4
1
2
B
C
A
S
C
??
B
4
B
4
A
B
3
1
Temperature τ = 1
A
S
3
1
1
2
2
aTAM as 2HAM example
B
3
4
B
2
A
B
3
A
B
B
C
??
C
4
1
2
A
B
B
B
A
S
1
A
B
B
A
B
Temperature τ = 1
B
A
B
“aTAM as 2HAM” does
not automatically work.
In the 2HAM: cannot
(easily) enforce
sequential tile additions
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)