Notes for self-assembly of thin rectangles
-
Upload
deacon-watson -
Category
Documents
-
view
47 -
download
0
description
Transcript of Notes for self-assembly of thin rectangles
![Page 1: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/1.jpg)
Notes for self-assembly of thin rectangles
Days 19, 20 and 21 of Comp Sci 480
![Page 2: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/2.jpg)
Warm-up
• (From hw3) PROVE: There exist infinitely values of N for which the tile complexity of uniquely building an NxN square is O(log log N)– This is MUCH better (asymptotically) than O(log N / log log
N)
• Consider values of N that are powers of 2: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, …
![Page 3: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/3.jpg)
NxN square for N = 1024 + 11
• Observation: 1024 = 210
• Thus, 1024 has 1 + log 1024 = 11 bits– Encode 1024 using 11 (log 1024) tile types?– NO!
• Don’t encode 1024 – just encode 10• Then build a 10x10 square• Once the “little square” is done, use its top row as the
start value of another counter (something like 8 additional tile types for this)
• The “big square” will have about 210 rows– 1024 + 10 rows
![Page 4: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/4.jpg)
1 0 0 1ABX
ABA Y
YYY
Y Y
1 0 1 0
0 0 0 0
XY
X
XY X
X X X X
Y Y Y Y
10 0 0 0 0 0 0 0 000 0 0 0 0 0 0 0 1
00 0 0 0 0 0 0 0 0
Y X
DC
CD C
X X X X X X X X
Y Y Y Y Y Y Y Y
D C
D CY
X
YY
YY
1034 x 1034
Tile complexity for this example:
“O(log 10) = O(log log 1034)”
In general (if N = 2m):
O(log m) = O(log log N)
No optimal encoding either!
We could do this for any value of N that is a power of 2!
![Page 5: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/5.jpg)
Warm-up summary
• (Hw3) Prove/disprove: There exists a positive constant c such that, for all values of N, the tile complexity of uniquely assembling an NxN square is at least c*log N / log log N.
• Disproved• For all positive constants c, there exists a value of N such that
the tile complexity of uniquely assembling an NxN square is less than c*log N / log log N
• Our “power of 2” construction had tile complexity O(log log N)
• Claim: For any positive constant c, there exists an N such that log log N < c * log N / log log N– This solves the homework problem
![Page 6: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/6.jpg)
Another warm-up
• Prove (from hw4): there is a program that can remove un-used tile types from a given tile set T
• Here’s what doesn’t work:– For each tile type t in T:
• simulate T (in TAS or some other simulator)– If there is more than one assembly sequence, then just simulate them all – If t never appears in the assembly, then remove it from T
• What can go wrong?• In fact, one can prove that there is NO program that can, in
general, remove un-used tile types from a given tile set• This doesn’t necessarily mean you should disprove the
problem on the homework
![Page 7: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/7.jpg)
Thin rectangles
![Page 8: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/8.jpg)
What is a thin rectangle?
• Rectangle: Nxk– N rows, k columns
• Thin rectangles: when k < log N / (log log N – log log log N)– “Thick” otherwise
• What does this mean?• Thin rectangles are so thin… – You can’t use the optimal encoding trick!– Why? …
![Page 9: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/9.jpg)
No optimal encoding
• For optimal encoding, we have x = xn-1xn-2 x∙∙∙ 0 that we split up into n/k k-bit substrings, where n/log n ≤ 2k < 2n/log n
• Do the math: n/k ≈ c* n/(log n - log log n), for some constant c
• If n = log N, then we need ≈ log N/(log log N - log log log N) columns just to start the encoding
• Thin rectangles do not give us enough space to do this
• Therefore: cannot use optimal encoding for thin rectangles
![Page 10: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/10.jpg)
Thick rectangles?
• If k > log N / (log log N – log log log N), then the rectangle is thick
• Can use optimal encoding to uniquely build thick rectangles– An NxN square is an example of a thick rectangle
• Tile complexities– Upper bound: O(log N / log log N) for ALL values of N
• The width doesn’t really matter– Lower bound: Ω(log N / log log N) for “almost all” N
• Infinitely many examples of N for which the bound does not hold– Hw3
• Proof uses “Kolmogorov complexity” (see me for project idea)
![Page 11: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/11.jpg)
Lower bound
![Page 12: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/12.jpg)
Lower bound for thin rectangles
• Goal: Prove that the tile complexity for building thin Nxk rectangles is at least a certain value
• First, develop sufficient conditions for when we can “pump” an assembly (up or down) – A kind of pumping lemma for self-assembly– Temperature can be arbitrary, so not really
related to pumpability
![Page 13: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/13.jpg)
Window movie lemma
![Page 14: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/14.jpg)
Windows• Let A be an assembly• A window is partitioning of A into two disjoint “subassemblies” AL and AR
– AL and AR need not be connected!– We say that w “cuts” A into AL and AR
• Technically, a window is a way to divide the 2D (3D) coordinate space into two parts
SS
SS
AL AR
The window w
A = AL U AR
Given a window w, its translation by the vector (x,y) is written as w + (x,y)
Given an assembly A, its translation by a vector (x,y) is written as A + (x,y)
w’ = w + (-1,0)
![Page 15: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/15.jpg)
Window movie
• We will now define the term “window movie”• A window movie will keep track of the order
of placement, position and glue type for each glue that appears along the window w in assembly sequence a
![Page 16: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/16.jpg)
Window movie definition• Let a = (a0, a1, …) be an assembly sequence and w be a window• A window movie is the maximal (possibly infinite) sequence of
position and glue ordered pairs, written as Ma,w = ((x0,y0),g0), ((x1,y1),g1), …, given by the order of appearance of the glues along window w– If two glues appear simultaneously along a window then the positions
and glues appear in the window movie in the order N, E, S, W– gi could be “empty”
• The translation of a window movie Ma,w = ((x0,y0),g0), ((x1,y1),g1), … by the vector (x,y), written as Ma,w + (x,y), is the window movie Ma,w’, where w’ = w + (x,y)– Each point in the sequence gets translated
![Page 17: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/17.jpg)
Window movie example
SS
SS SS
SS
NOTE: Different assembly sequences give different window movies
What is the window movie?
Ma,w = ((-1,0), green), ((0,1), yellow), ((0,1), “empty”), ((-1,1), “empty”), ((-1,1), green), ((0,2), yellow), ((-2,1), “empty”)
SS
Seed is placed at (0,0)
SS
SS
![Page 18: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/18.jpg)
Window movie lemma (setup)
• Let a = (a0, a1, …) be an assembly sequence with final result A
• Let w be a window that cuts A into AL and AR
• Let w’ = w + (x,y), for (x,y) ≠ (0,0), be a translation of w that cuts A into BL and BR
• Let Ma,w and Ma,w’ be window movies for w and w’, respectively
• Assume AL contains the seed tile
![Page 19: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/19.jpg)
Window movie lemma (setup)
A
AL AR
BL BR
w w’
![Page 20: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/20.jpg)
Window movie lemma
• If Ma,w = Ma,w’ - (x,y), for some (x,y) ≠ (0,0), then the following two assemblies are producible:– ALB’R = AL U B’R
• Where B’R = BR - (x,y)
– B’LAR = B’L U AR
• Where B’L = BL + (x,y)
• Proof idea: construct a valid assembly sequence that produces the assembly ALB’R. Further details omitted.
![Page 21: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/21.jpg)
Window movie lemma high-level example
A
AL AR
BL BR
w w’
![Page 22: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/22.jpg)
Window movie lemma high-level example
AL
B’R = BR - (x,y)
ALB’R = AL U (BR - (x,y))
![Page 23: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/23.jpg)
A better example
SS
w w’ = w + (3,0)
125
436
798
131215
101114
Ma,w = Ma,w’ + (-3,0) Window movie lemma says that we can do this…
![Page 24: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/24.jpg)
Example
SS
w w’ = w + (3,0)
125
436
798
131215
101114
This must also be producible (via Window movie lemma)…
…using a different assembly sequence
![Page 25: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/25.jpg)
Glue windows vs. tile windows
• Window movies are sequences of location-glue pairs
• What about location-tile pairs?• That is, what if we define a window movie as
Ma,w = ((x0,y0),t0), ((x1,y1),t1), …, where each ti is a tile type ???
• Let’s do some examples…
![Page 26: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/26.jpg)
“Tile window” example
Same “tile windows” (up to translation)
Try to splice…
Definitely NOT producible!
What if we require the shape to be rectangular OR the tile window to be completely filled?
![Page 27: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/27.jpg)
“Glue window” exampleBack to using glue windows (our original definition)…
There is no assembly sequence that results in equivalent (glue) window movies (up to translation) for the two windows given above…
…why?
This means we CANNOT apply the Window movie lemma to get a weird, non-producible (disconnected) assembly!
![Page 28: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/28.jpg)
Thin rectangle tile complexity
• We will prove that the tile complexity of uniquely building a thin rectangle is Ω(N1/2k/k)– For EVERY value of N and k– Only assume unique production of shape• Allows for possibility of non-determinism
• Our proof is by contradiction– Assume we can uniquely build a thin rectangle
using a tile set that is “just barely” too small
![Page 29: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/29.jpg)
Thick rectangles need not apply
• Apply the Ω(N1/2k/k) thin rectangle bound to thick rectangles…• Let k = log N• Then we have:
N1/2log N/log N = (N1/log N)1/2/log N = 21/2/log N≈ 1.4/log N,
which says that we need at least 0 tile types (as N gets bigger and bigger)
• If k = N, then we have: N1/2log N/log N = (N1/N)1/2/log N
< (N1/log N)1/2/log N≈ 1.4/log N.
![Page 30: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/30.jpg)
The setup
• Let T be any tile set that uniquely builds an Nxk (thin) rectangle
• For the sake of simplicity, assume the single seed tile type is placed at the origin
• Let G be the number of unique glues in T– Strength-label pairs
![Page 31: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/31.jpg)
The assumption
• Assume 0 < G < ((N-1)/(2k)!)1/2k
– Should still work with “N-1” replaced with “N” or “N+1” – either way, not a big deal
• Once we get a contradiction, we will know that G ≥ ((N-1)/(2k)!)1/2k
![Page 32: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/32.jpg)
Horizontal windows
• Only consider windows that cut the Nxk rectangle horizontally
• In any such window, there are 2k glue positions (see the picture…)
• There are less than (N-1)/(2k)! distinct ways to position glues in these 2k positions...
G < ((N-1)/(2k)!)1/2k
< ((N-1)/(2k)!)1/2k choices for the first position, < ((N-1)/(2k)!)1/2k choices for the second position, etc…
< ((N-1)/(2k)!)1/2k * ((N-1)/(2k)!)1/2k * ∙∙∙((N-1)/(2k)!)1/2k
= (((N-1)/(2k)!)1/2k)2k = (N-1)/(2k)!
k
![Page 33: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/33.jpg)
Order matters
• If, along a horizontal window, there are 2k positions, then how many different ways could these glues show up?
• How many different orderings?• Example: how many different ways are there
to order the numbers 1, 2, 3, 4 and 5?5!
• 2k glue positions means there are (2k)! possible ways in which the glues could show up along the window
![Page 34: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/34.jpg)
How many windows?
• In an Nxk rectangle, we have N rows of tiles
• But only N-1 internal row-to-row boundaries
• Therefore, there are N-1 ways a window can cut an Nxk rectangle horizontally
k
N
![Page 35: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/35.jpg)
Two “identical” window movies• There are less than (N-1)/(2k)! distinct ways to position glues
in 2k positions along a horizontal window• Key: In an Nxk rectangle, a positioning of glues along a
horizontal window must be repeated for more than (2k)! of the windows…– “N-1 horizontal windows” divided by “number of ways to position
glues along that window” = “number of times some positioning of glues must be repeated in Nxk assembly”…
– (N-1)/((N-1)/(2k)!) = (2k)!• But there are only (2k)! possible orderings• Thus, at least two orderings must be repeated across all
horizontal windows that cut the Nxk assembly– This gives us two windows w, w’, with w’ = w + (x,y) and (x,y) ≠ (0,0)
such that Ma,w = Ma,w’ - (x,y)
![Page 36: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/36.jpg)
Apply the Window movie lemma
• Assume this is a terminal assembly produced by T
• The window movie lemma says that T should be able to do this…
• ALB’R cannot be an Nxk rectangle– w’ = w + (x,y), where (x,y) ≠ (0,0)
• ALB’R is terminal– Otherwise the assembly before
“splicing” wasn’t terminal
w’
w
AL
B’R
ALB’R
![Page 37: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/37.jpg)
Where’s the contradiction?
• ALB’R is a contradiction
• What is the contradiction? • We originally assumed that T uniquely
produces an Nxk rectangle– Possibly many assemblies, but all must have the
same Nxk rectangle shape
• ALB’R is NOT an Nxk rectangle
![Page 38: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/38.jpg)
The math• Thus, we have:
G ≥ ((N-1)/(2k)!)1/2k
> ((N-1)/(2k)2k)1/2k ; (2k)2k > (2k)! = ((N-1)1/2k/(2k)2k/2k
= (N-1)1/2k/2k> (N/22k)1/2k/2k ; N-1 > N/22k for k > 2, and large
N= (N1/2k/2)/2k= N1/2k/4k= Ω(N1/2k/k)
• Since |T| ≥ G/4, it follows that |T| = Ω(N1/2k/k)– Note: G/4 ≤ |T| < G4
• |T| < G4 (four sides, G choices per side)• |T| ≥ G/4 (G glues, tiles have four sides, put a different glue on every side
of every tile type)
![Page 39: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/39.jpg)
Upper bound
![Page 40: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/40.jpg)
Let’s build thin rectangles!• Build a base-m counter, where m = N1/k
– Do NOT use zig-zag counter design• Start value encoded in the seed row
– Have k unique tile types• Total columns: k• How many “counter” tile types?
– O(m) • Total rows (start counting at 0): N1/kk = mk
• Can start at any number between 0 and mk – 1• North glues of seed row should represent mk – N• Tile complexity: O(m + k) = O(N1/k + k)• Observation: we never used assumption that k < log N /
(log log N - log log log N)
![Page 41: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/41.jpg)
A special case
• Upper bound is O(N1/k + k) for all N• What if k = log N– N x log N rectangle– Not thin– Tile complexity (as per above):
O(N1/log N + log N) = O(2 + log N)= O(log N)
![Page 42: Notes for self-assembly of thin rectangles](https://reader035.fdocuments.in/reader035/viewer/2022081511/56812a85550346895d8e206e/html5/thumbnails/42.jpg)
Discussion
• Upper bound is O(N1/k + k) for all N• Lower bound is Ω(N1/2k/k) for all N• Can we get the two bounds to be closer
together?– Can we lower the upper bound?– Can we increase the lower bound?• It is possible to prove a lower bound of Ω(N1/k/k) for all
N– Can’t use the Window movie lemma– Use tile windows but pump up, not down