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

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

3. 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!

4. 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

5. 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…

6. An example (some details missing)…

7. For the sake of example, let k = 4 for the binary string x = 01100101 0L 0 $ + 0 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 0 1 1 1 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 + + 10 + + 0L 1 10 110 R R 0101 R R + + 110 + + 0L 110 0110L R 1 0101 12 + 23 0110L 3 1 1 1 0 10 R R

8. The general construction…

9. 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

10. 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.

11. 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

12. 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 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 bL x bxL b x bx

13. 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

14. Copy substring being extracted For all x {0,1} j where 1 < j ≤ k-1, create the following tile types: 0110L 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 x + + x x R R x

15. 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

16. Initiate unpacking of a new substring For all x {0,1} k-1 and b {0,1}, create the following tile types: 0110L 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 b x bx $

17. 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

18. Copy substring not being extracted For all x {0,1} k, create the following tile types: 0110L 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 + x x + x + + x x R R x

19. 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

20. Copy bit For all b {0,1}, create the following tile types: 0110L 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 bL b b b $ + b

21. 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

22. The right side Create the following tile types: 0110L 3 + 23 0101 12 R 1 0L 110 0110L 0101 R R R R 0L 0101 R R R R 110 + + 10 + + + 0101 + + + 1 10 110 0L 1 1 0 $ + 0 1 0 10 0 0101 101$ R R R R 01 R R 1 101 01 R R 0 0 0 0 1 1 1 1 0L 1 1R R 1 0 0 01 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0L 1 1 1 0R R 0 R R 1R R 1

23. Tile complexity (math)

24. 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

25. 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

26. 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

27. 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

28. 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

29. 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

30. 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)

31. 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

32. 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)

33. 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

34. 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)

35. 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)

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

37. 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

38. 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…

39. 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?

40. 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.