Notes on the optimal encoding scheme for self-assembly Days 10, 11 and 12 Of Comp Sci 480

Question How do you encode an n-bit binary string?

Answer Have a unique tile type to encode each bit separately, so we represent 1 bit per tile. We’ve seen this before. Is this optimal? NO!

A brief history Rothemund and Winfree (2000): 1 bit per tile Adleman, et. al. (2002): > 1 bit per tile (an optimal number of bits per tile) – Works at temperature 3 Soloveichik and Winfree (2004): Modified optimal encoding scheme of Adleman, et. al. to work at temperature 2 – Encodes n bits using O(n/log n) tile types

Basic idea Start with a binary string x = x n-1 x n-2 ∙∙∙x 0 Choose k such that it is the smallest number satisfying n/log n ≤ 2 k More math later… Break w up into n/k k-bit substrings and store each substring in a unique tile type Extract the bits from all the substrings until you have 1 bit per tile Use the value to start a binary counter, or something else…

An example (some details missing)…

For the sake of example, let k = 4 for the binary string x = L 0 $ $ R R R R 01 R R R R L 1 1R R L Can use the bits encoded in the north glues of the topmost row as the start value for a binary counter (or an input to a Turing machine)! 0101 R R L R R 0101 R R L L R L R R

The general construction…

The general construction Unpacking tiles broken down into several logical groups 1.Seed row 2.Extract a bit 3.Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

The seed row w m-1 L 2m-1 + 2m-22m-1 w m-2 2m-32m-2 + 2m-42m-3 w0w0 01 R 0 Since x = x n-1 x n-2 ∙∙∙x 0, we let m =  n/k , i.e., the number of k-bit substrings in x. Create these tile types: Write x = w m-1 w m-2 ∙∙∙w 0 as the concatenation of m k-bit binary substrings, with w m-1 padded to the left with leading 0’s if needed.

The general construction Unpacking tiles broken down into several logical groups Seed row 2.Extract a bit 3.Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Extract bit For all x {0,1} j where 0 < j ≤ k-1 and b {0,1}, create the following tile types: Notation: {0,1} j means “the set of all length j binary strings” 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L bL x bxL b x bx

The general construction Unpacking tiles broken down into several logical groups Seed row Extract a bit 3.Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Copy substring being extracted For all x {0,1} j where 1 < j ≤ k-1, create the following tile types: 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L x + + x x R R x

The general construction Unpacking tiles broken down into several logical groups Seed row Extract a bit Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Initiate unpacking of a new substring For all x {0,1} k-1 and b {0,1}, create the following tile types: 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L b x bx $

The general construction Unpacking tiles broken down into several logical groups Seed row Extract a bit Copy substring being extracted Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Copy substring not being extracted For all x {0,1} k, create the following tile types: 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L x x + x + + x x R R x

The general construction Unpacking tiles broken down into several logical groups Seed row Extract a bit Copy substring being extracted Initiate unpacking of a new substring Copy substring not being extracted 6.Copy a bit 7.The right side

Copy bit For all b {0,1}, create the following tile types: 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L bL b b b $ + b

The general construction Unpacking tiles broken down into several logical groups Seed row Extract a bit Copy substring being extracted Initiate unpacking of a new substring Copy substring not being extracted Copy a bit 7.The right side

The right side Create the following tile types: 0110L R 1 0L L 0101 R R R R 0L 0101 R R R R L $ $ R R R R 01 R R R R L 1 1R R L R R 0 R R 1R R 1

Tile complexity (math)

Setup For an arbitrary length n bit string w, represented as  n/k  k-bit substrings, how many tile types do we need to extract w? Reminder: n is the number of bits in the input binary string. Reminder: k chosen such that it is the smallest number satisfying n/log n ≤ 2 k

A key fact 2 k < 2n/log n Assume otherwise… 2 k ≥ 2n/log n  2 k-1 ≥ n/log n – Contradiction to the definition of k being the smallest such number with n/log n ≤ 2 k

Seed row has 2*  n/k  unique tile types We know 2 k ≥ n/log n by our choice of k Therefore: k ≥ log(n/log n) ; take the log of both sides of the previous inequality Then we have, for “large” values of n: 2*  n/k  ≤ 2*  n/log(n/log n)  = 2*  n/(log n - log log n)  ; log (a/b) = log a - log b < 2*  n/(log n - 0)  ; 0 < log log n for n ≥ 4 ≤ 2n/log n + 1 ;  x  ≤ x + 1 for any x ≤ 2n/log n + n/log n ; n/log n ≥ 1 for n ≥ 2 = 3n/log n = O(n/log n) The seed row

Tile complexity of the general construction Unpacking tiles broken down into several logical groups Seed row: O(n/log n) 2.Extract a bit 3.Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Extract a bit We need to compute 2*(2(|{0,1} 1 | + |{0,1} 2 | + ∙∙∙ + |{0,1} k-1 |)) 2*(2(|{0,1} 1 | + |{0,1} 2 | + ∙∙∙ + |{0,1} k-1 |)) = 2*(2*(2+4+∙∙∙+2 k-1 )) = 4*(2 k - 2) < 4*2 k < 4*2*n/log n = O(n/log n) bL x For all x {0,1} j where 0 < j ≤ k-1 and b {0,1}, create the following tile types: Notation: {0,1} j means “the set of all length j binary strings” bxL b x bx

Tile complexity of the general construction Unpacking tiles broken down into several logical groups Seed row: O(n/log n) Extract a bitO(n/log n) 3.Copy substring being extracted 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Copy substring being extracted x + For all x {0,1} j where 1 < j ≤ k-1 and b {0,1}, create the following tile types: + x x R R x We need to compute 2*(2(|{0,1} 2 | + |{0,1} 3 | + ∙∙∙ + |{0,1} k-1 |)) 2*(2(|{0,1} 2 | + |{0,1} 3 | + ∙∙∙ + |{0,1} k-1 |)) = 2*(2*(4+8+∙∙∙+2 k-1 )) = 4*(2 k - 4) < 4*2 k < 4*2*n/log n = O(n/log n)

Tile complexity of the general construction Unpacking tiles broken down into several logical groups Seed row: O(n/log n) Extract a bitO(n/log n) Copy substring being extractedO(n/log n) 4.Initiate unpacking of a new substring 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Initiate unpacking of a new substring b x For all x {0,1} k-1, and b {0,1}, create the following tile types: bx $ The size of the set {0,1} k-1 is 2 k-1, and b can take on two possible values, so the total number of tile types created in this step is: 2*2 k-1 = 2 k < 2n/log n = O(n/log n)

Tile complexity of the general construction Unpacking tiles broken down into several logical groups Seed row: O(n/log n) Extract a bitO(n/log n) Copy substring being extractedO(n/log n) Initiate unpacking of a new substringO(n/log n) 5.Copy substring not being extracted 6.Copy a bit 7.The right side

Copy substring not being extracted + x For all x {0,1} k, create the following tile types: x + x + + x x R R x The size of the set {0,1} k is 2 k, so the total number of tile types created in this step is: 3*2 k < 3*2n/log n = O(n/log n)

Tile complexity of the general construction Unpacking tiles broken down into several logical groups Seed row: O(n/log n) Extract a bitO(n/log n) Copy substring being extractedO(n/log n) Initiate unpacking of a new substringO(n/log n) Copy substring not being extractedO(n/log n) Copy a bitO(1) The right sideO(1) TOTAL: O(n/log n)

Summary We can encode an n-bit binary string using O(n/log n) unique tile types

Application to squares How do we apply the optimal encoding scheme to the self-assembly of an NxN square? What is the resulting tile complexity? – n = log N – Can encode n bits using O(n/log n) tile types – Tile complexity of square: O(log N / log log N) Homework problem

Improvement I presented the construction using “spacer” tiles in between each k-bit substring Can we remove the spacer tiles? This wouldn’t give us an asymptotical improvement over O(n/log n), but it might make implementation easier Definitely worth thinking about…

Improved (?) construction Need to modify seed row: w m-1 L 2m-1 + 2m-22m-1 w m-2 2m-32m-2 + 2m-42m-3 w0w0 01 R 0 w m-1 L 2m-1 w m-2 2m-22m-1 w0Rw0R 01 Still get O(n/log n) tile types after deleting the “spacer” tile types. Need to combine “Copy substring being extracted” with “Copy substring not being extracted” groups… x y y x Among others, we will at least need these tile types… For all x {0,1} j, where 1 < j ≤ k-1, and for all y {0,1} k create the following tile types… BEFORE… x + + x x R R x + x x + x + + x x R R x Copy substring being extractedCopy substring NOT being extracted What is the tile complexity of just this group of tile types?

Tile complexity of modification Tile complexity of our previous modification: “For all x ϵ {0,1} j, where 1 < j ≤ k-1, and for all y ϵ {0,1} k create the following tile types…” | {0,1} j | 1 < j ≤ k-1 } | * | {0,1} k | = (2 k -2) 2 k = 2 k 2 k -2*2 k > 2 2k - 2*(2*n/log n) = (2 k ) 2 - 2*(2*n/log n) ≥ (n/log n) 2 - 1/2*(n/log n) 2 = 1/2*(n/log n) 2 = Ω(n 2 /log 2 n) = No good! It seems like the spacer tiles are needed, unless drastic changes are made.