The selfassembly of paths and squares at temperature 1
Abstract
We prove that the number of tile types required to build squares of size , in Winfree’s abstract Tile Assembly Model, when restricted to using only noncooperative tile bindings, is at least , which is also the best known upper bound. Noncooperative selfassembly, also known as “temperature 1”, is where tiles bind to each other if they match on one or more sides, whereas in cooperative binding, some tiles can bind only if they match on multiple sides.
Our proof introduces a new programming technique for temperature 1, that disproves the very intuitive and commonly held belief that, in the same model, assembling paths between two points and cannot be done with less tile types than the Manhattan distance between them. Then, we prove a necessary condition for these “efficient paths” to be assembled, and show that this necessary condition cannot hold in completely filled squares.
This result proves the oldest conjecture in algorithmic selfassembly, published by Rothemund and Winfree in STOC 2000, in the case where growth starts from a corner of the square. As a corollary, we establish as a lower bound on the tile complexity of the general case. The problem of determining the minimal number of tile types to selfassemble a shape is known to be complete.
1 Introduction
Selfassembly is the process through which unorganized, simple, components automatically coalesce according to simple local rules to form some kind of target structure. It sounds simple, but the end result can be extraordinary. For example, researchers have been able to selfassemble a wide variety of structures experimentally at the nanoscale, such as regular arrays [28], fractal structures [20, 10], smiling faces [18, 26], DNA tweezers [30], logic circuits [21, 16], neural networks [17], and molecular robots[12]. These examples are fundamental because they demonstrate that selfassembly can, in principle, be used to manufacture specialized geometrical, mechanical and computational objects at the nanoscale. Potential future applications of nanoscale selfassembly include the production of smaller, more efficient microprocessors and medical technologies that are capable of diagnosing and even treating disease at the cellular level.
Controlling nanoscale selfassembly for the purposes of manufacturing atomically precise components will require a bottomup, handsoff strategy. In other words, the selfassembling units themselves will have to be “programmed” to direct themselves to assemble efficiently and correctly. Molecular selfassembly is rapidly becoming a ubiquitous engineering paradigm, and we need to develop a theory to inform us of its algorithmic capabilities and ultimate limitations.
In 1998, Erik Winfree [27] introduced the abstract Tile Assembly Model (aTAM), a simplified discrete mathematical model of algorithmic DNA nanoscale selfassembly pioneered by Seeman [22]. The aTAM is an asynchronous nondeterministic cellular automaton that models crystal growth processes. Put another way, the aTAM essentially augments classical Wang tiling [25] with a mechanism for sequential growth of a tiling. This contrasts with Wang tiling in which only the existence of a valid mismatchfree tiling is considered, and not the order of tile placement. In the aTAM, the fundamental components are translatable but unrotatable square or cube tiles whose sides are labeled with colored glues colors, each with an integer strength. Two tiles that are placed next to each other interact if the glue colors on their abutting sides match, and they bind if the strengths on their abutting sides match and sum to at least a certain (integer) temperature. Selfassembly starts from a seed tile type and proceeds nondeterministically and asynchronously as tiles bind to the seedcontainingassembly. Despite its deliberate simplification, the aTAM is a computationally expressive model. For example, by using cooperative binding (that is, by having some of the tiles bind on two or more sides), Winfree [27] proved that it is Turing universal, which implies that selfassembly can be directed by a computer program. Here, we study noncooperative binding.
Tile selfassembly in which tiles can be placed only in a noncooperative fashion is colloquially referred to as “temperature1 selfassembly”. Despite the esoteric name, this is a fundamental and ubiquitous form of growth: it refers to growth from growing and branching tips where each new tile is added if it can match on at least one side.
It has been known for some time that a more general form of growth where some of the tiles must match on two or more sides, i.e. cooperative growth, leads to highly nontrivial behavior: arbitrary Turing machine simulation [19, 11], efficient production of squares and other simple shapes using tile types [1], efficient production of arbitrary finite connected shapes using a number of tile types that is within a log factor of the Kolmogorov complexity of the shape [24], and even intrinsic universality: the existence of a single tile set that simulates arbitrary tile assembly systems [7].
However, the capabilities of twodimensional noncooperative selfassembly remain largely unknown: several generalizations and restrictions of this model have been studied, that conjectured in all cases that noncooperative binding could not be as powerful as cooperative binding [19, 9, 4, 5, 13, 15]. The first fully general separation results were only proven recently [14], in the context of intrinsic universality [8, 7, 6]. However, the computational capabilities, in the Turing sense, of this model, remain largely unknown.
The conjecture that we prove in this paper was first stated by Rothemund and Winfree [19]^{1}^{1}1In Figure 2 of that paper: the minimal number of tile types to assemble squares is . A restriction of this result, where it is required that all the tiles be assembled with all their neighbors, appeared in the same paper. Moreover, computing the minimal number of tile types required to deterministically assemble a shape from a seed of size one is known to be NPcomplete [2], and complete in the nondeterministic case [3].
1.1 Main results
Although a number of terms have not been formally defined, we give an overview of our two main results now. See the definitions in section 2. Our ultimate goal is to prove Rothemund and Winfree’s conjecture [19] that a tile assembly system assembling only squares of size , from a seed of size , has at least tile types. Our first result disproves a statement stronger than this conjecture; namely, that the tile complexity of a square is the same as the tile complexity of its diagonal. Although widely believed, this statement is false:
Theorem 3.1.
Let be an integer. There is a tile assembly system , and two points , such that , the terminal assemblies of are all finite, they all include a path from to , and .
The fact that the constructions of this theorem are possible, even though they are quite elementary, is not obvious at all; indeed, the intuition from words and automata theory is that any attempt to “reuse” tile types will enable us to “pump” the path, as in the pumping lemma of finite automata [23], and thus any tile assembly system that can produce paths repeating tile types will also be able to produce ultimately periodic, infinite paths. This intuition is valid in a restricted setting where two adjacent tiles always agree on their abutting sides [13, 9].
Then, we will prove the following theorem, which gives the optimal lower bound on the tile complexity of squares, when growth starts from a corner:
Theorem 4.2.
Let be a temperature 1 tile assembly system, with a single tile at , and an integer. If all terminal assemblies producible by are of domain , then .
2 Definition and preliminaries
We begin by defining the twodimensional abstract tile assembly model. A tile type is a unit square with four sides, each consisting of a glue label and a nonnegative integer strength. We call a tile’s sides north, east, south, and west, respectively, according to the following picture:
We assume a finite set of tile types, but an infinite supply of copies of each type. An assembly is a positioning of the tiles on the discrete plane , that is, a partial function .
We say that two tiles in an assembly interact, or are stably attached, if the glue labels on their abutting side are equal, and have positive strength. An assembly induces a weighted binding graph , where , and there is an edge if and only if and interact, and this edge is weighted by the glue strength of that interaction. The assembly is said to be stable if any cut of has weight at least .
A tile assembly system is a triple , where is a finite tile set, is called the seed, and is the temperature. Throughout this paper, we will always have and . Therefore, we can make the simplifying assumption that all glues have strength one without changing the behavior of the model.
Given two assemblies and , we write if we can get from by the binding of a single tile, , and . We say that is producible from , and write if there is a (possibly empty) sequence such that .
A sequence of assemblies over is a assembly sequence if, for all , .
The productions of a tile assembly system , written , is the set of all assemblies producible from . An assembly is called terminal if there is no such that . The set of terminal assemblies is written .
An important fact about temperature 1 tile assembly, that we will use heavily, is that any path of the binding graph can grow immediately from the seed, independently from anything else. Formally, a path is a sequence of tile types along with positions, that is, of elements of , such that no position occurs more than once in , and for all , the positions of and are adjacent in the lattice grid of .
For any path and integer , we write the coordinates of ’s position. Moreover, if , we say that the output side of is the side adjacent to , and if , that its input side is the side adjacent to . This means that the first tile of a path does not have an input side, and the last one does not have an output side. Remark that this definition of input/output sides is only relative to a path, and not to the tiles themselves; indeed, the tiles, including the first and last ones, may have other glues, not used by the path.
Also, for any path , and any integer , we call the righthand side (respectively lefthand side) of the side of that is between its input and output sides, in counterclockwise (respectively clockwise) order. When there is no ambiguity, we will say “the righthand side (respectively lefthand side)” of itself to mean “the righthand side (respectively lefthand side) of some tile of ”.
Finally, for (respectively for ), we use the notation to mean “the vector from to ” (respectively from the position of to the position of ), and the Manhattan distance between and , written , is . We also call the origin on , i.e. the point of coordinates .
2.1 The known upper bound
3 Building efficient paths
A major obstacle in proving the claimed lower bound for squares, is that building only a square’s diagonal can require less tile types than building the whole square. In this section, we show the following result:
Theorem 3.1.
There is a tile assembly system , such that for all terminal assembly , is finite and of width .
Proof.
Since a path of height that is monotonic in the ydimension, and has less than tile types with input side south, can be “pumped”, our path will need to have “caves”, or nonmonotonic subpaths, and reuse them several times. Moreover, in order for all the assemblies of to be finite, the caves must be exited by a different path every time; however, since we want the caves to “save” tile types, these “exit paths” cannot all be new tile types. Therefore, one possible way to solve these constraints is to grow a regular monotonic path first, then build a cave , and reuse a part of as its exit path. The next time we want to reuse , we can use another part of as its exit path.
If the exit paths used in previous instance of a cave are all blocked in new instances, we will get only finite assemblies. Figure 2 is an example of such a path.
This figure, however, is not a terminal assembly; since our caves, and their exit paths, are used several times, the same assemblies can grow from all their repetitions. Fortunately, we can arrange the shape of our main path so that no collision ever happens between these repetitions, like on Figure 3. Now, this figure has 38 tile types, and is of width 27; it does not yet save tile types. But by inserting:

new tile types in place of glue 6,

new tile types in place of glue 14,

new tile types in place of glue 24, and

new tile types in place of glue 26
Zooming in may be needed to read these numbers on Figures 2 and 3. Printable versions are included, in Appendices A and B.
We add only tile types, but the assembly is now wider, and the result follows. An example of path that actually saves tile types is given on Figure 4.
∎
4 Building filled squares requires tile types
In this section, we prove that if a tileset has less than tile types and all its terminal assemblies are of domain then one of its productions is a path that does not “save” tile types. Our technique to prove this will be the following: assuming we are given such a tileset, we will first choose, using Algorithm 4.1, the assembly sequences that “lose” as much information as possible about their past, so as to “confuse” the tileset; then, if these assembly sequences can still build efficient paths, we will prove a necessary condition on these (this is Lemma 4.4), that cannot hold in completely filled squares (Theorem 4.5).
4.1 A pathbuilding algorithm
We first define the algorithm we use to find assembly sequences that suit our purposes. There are two possible “priority modes” for this algorithm, namely rightpriority and leftpriority:
Algorithm 4.1.
Let be a tile assembly system, be an ordering on , and be a nonempty subset of the set of paths producible by . Let be the initial path, with just . For any , if several tiles can bind to , let be the one such that:

If is of the same type as a previous tile on , with , whose output side is distinct from ’s input side, then grow , on side of .

Else, if it is possible, let be the tile such that:

binds to the first side of from its input side, in clockwise order if we are building a leftpriority path, and in counterclockwise order if we are building a rightpriority one.

There is at least one path in , of which is a prefix.

If there are several such choices, we choose the smallest tile with respect to .


Finally, if none of the previous cases is possible to follow (for instance, because following case 1 resulted in a collision with a previous part of the assembly), but a new branch can still grow from the existing assembly, and produce a path of , then follow it. Else, the algorithm halts.
We call the last tile that was placed before the present case the collision tile. In the special case that the current assembly before applying this case is already in , we will adopt the convention that the empty branch can start.
Remark that this algorithm does not guarantee that the final path will be in . If all producible paths end up being paths of , it will be the case. But else, it means that we can “prevent” paths of from growing. We will use this property heavily in the rest of our proof: will be the set of all paths that reach some point in the square, and by definition, all the points in a completely filled square must be covered.
4.2 Building filled squares from a seed in a corner
We begin by showing that a “path editing” operation is possible on the paths, built by Algorithm 4.1, that save tile types.
Definition 4.2.
A lefttentacular (respectively righttentacular) path is a path such that the following conditions all hold:

at least two tiles of are of the same type. Let and be the indices of two tiles of of the same type.

This same branch can also start and completely grow from tile , after is itself completely grown.
Moreover, we call a contraction vector of , and tentacles the early restarts of .
We say that a path is twoway tentacular if it is both left and righttentacular.
Definition 4.3.
Let be a tile assembly system. A path is said to be fragile if:

a tile type is repeated on , at positions and (), and , translated by , can also start growing from immediately after .

and cannot grow completely from the resulting assembly.
In the rest of the proof, we will call breaking , the choice to start growing , translated by , immediately after before growing . Moreover, the smallest suffix of that can branched earlier than its original first point on is called the breaking branch.
See Figure 6 for an example of a fragile path (at this point, though, the colors of that figure are not yet defined).
Lemma 4.4.
Let be a point of , and be a tile assembly system such that the following conditions all hold:

.

All assemblies can reach , that is, .

There is a path from to , built using Algorithm 4.1 with parameter of the algorithm being the set of all producible paths of from to , and has strictly less than tile types.

is such that for all , .
Then is either fragile or twoway tentacular.
Proof.
Let be a path from to , built using Algorithm 4.1. Without loss of generality, we assume that and (we get other cases by rotating or flipping the argument).
We first introduce the idea of visible glues: we say that a glue between two tiles of is visible from the east (respectively from the south) if interacts with on its north face (respectively on its east face), and the glue between them is the rightmost (respectively lowest) one, on an infinite horizontal (respectively vertical) line between and . Moreover, we adopt the convention that the rightmost tile on row has its north glue visible from the east, and its east glue visible from the south (even if this tile has 0strength glues on these sides).
Let us call the tiles of that have their north glue visible from the east, and the tiles of that have their east glue visible from the south. First, there are at least tiles in , and tiles in . We prove this now for : indeed, for all , the visible tile of on column has output side east. To see this, suppose, for the sake of contradiction, that some tile is visible from the south, and has output side . Then, draw an infinite horizontal halfline from the east side of to the south. Along with and a horizontal infinite line at , it partitions the plane into two connected components, by Jordan’s curve theorem (see Figure 7).
Therefore, because does not intersect itself, and for all , , it must necessarily cross the vertical line at the east of again before reaching . Thus, cannot be visible from the south, since has at least one tile below .
The same argument, rotated by , shows that has at least tiles. Furthermore, except possibly for the last tile of , and are disjoint, because each tile has at most one output side: , and therefore .
Now, because was grown using Algorithm 4.1, if a tile type is repeated in , say at positions and , with , then the translation of by started growing immediately after , by case 1 of Algorithm 4.1, ultimately crashing into something, possibly after several repetitions (because we assumed that all productions of are finite). We call this collision “collision ”. The next step of the algorithm after this happened was thus necessarily by case 3 (because only that case handles collisions), and a new (possibly empty) branch was started from the existing assembly, and reached (because of our hypothesis that all terminal assemblies have in their domain).
Therefore, an early restart of this branch can also grow from . There are two cases:

If it can grow completely from , it means that is righttentacular, by definition of righttentacular.

Else, this new branch crashes into something. We call this crash “collision ”. There are two cases, according to where it crashes:

Either it crashes into a part of grown before . In this case, first observe that the north glue of is still visible from the east after this operation: indeed, the north glue of was visible from the east before, so no , for , is on the right of on a horizontal line at . And since we only translated these tiles by , these translated tiles are not on the right of on a horizontal line at either (see for instance Figure 6).
We now prove that is fragile. Indeed, grow it until index . Then, grow a translation by of , as long as it can possibly grow. We call the resulting subpath (the longest prefix of the translation of that can grow). We claim that the original cannot grow anymore from this new assembly , and this is the definition of being fragile.
This is because of the definition of and : we first argue that collision encloses a portion of the plane: this is indeed an application of Jordan’s curve theorem, because a collision between two connected paths closes a curve in the plane. But then, since is still visible from the east or from the south in , and the side of exposed to the south or the east is its righthand side (this follows from the fact that ’s output side is its north side if visible from the east, and its east side if visible from the south, and the definition of the left and righthand sides of a tile on a path), the breaking branch starts from some (for ), and branches from its righthand side.
Therefore, if we grow this branch early, at position , and it crashes into a previous part of the assembly, then by Jordan’s curve theorem, we enclose the lefthand sides of its tiles; but since this branch forks from the righthand side of , the enclosed region is the region in which grew (because is then a “left turn” from ). Therefore, since for all , , cannot grow strictly higher than ; thus, cannot reach anymore from this assembly, which means that it cannot grow to its original endpoint, and therefore, it is fragile.

Or it crashes into a part of grown after , in which case we also choose to grow it before that part. Since is a sequence of points, it will not be able to grow completely after that, since a tile will already be present next to the collision tile of collision .

Finally, the same argument on the tiles of and (the tiles with their north glue visible from the left, and their east glue visible from the north, respectively), proves that is also lefttentacular or fragile. Remark that is not necessarily disjoint from (in the case where has at most tile types, these two sets may even be equal). ∎
Remark.
We can now prove the claimed result:
Theorem 4.5.
Let be a tile assembly system whose terminal assemblies’ domains are all , and such that . Then:
Proof.
Let , , and be the following points of a square that can assemble:
Since can fill this square, it must contain in particular a path from to , that we can build in the rightpriority mode of Algorithm 4.1.
We define a sequence of assemblies, being the assembly where only has grown. For any , let be the leftmost point on the righthand side of , and not in . If there are several such points, let be the highest one. Now, let be a rightpriority path from to , built using Algorithm 4.1. Moreover, let be the prefix of that stops at the last occurrence of ’s highest point.
There are three main cases:

If is fragile, we break it. Let be the assembly resulting from that operation. In the case where shares parts with some other paths of , this operation may also break these paths. Let be the assembly containing and all the parts of that can regrow from it.

If is righttentacular, there are two subcases:

One of its contraction vectors is to the left, i.e. . In this case, we can do the same as in case 1 above. Indeed, since the last point of is next to the leftmost point on the right of , contracting it to the left will necessarily end in a collision with , before the end of .
Indeed, this is clear in the case of , i.e. is the highest point of , as well as in the case where is on the left of .
Else, is longer than , and the subpath grows after , by definition of being a prefix of . Therefore, is on the right of : indeed, by Jordan’s curve theorem, on the closed curve pictured on Figure 8 (the curve defined by , two horizontal lines, immediately above and below , and a vertical line on the right of the square), is inside a closed region of the plane, including a point on the right of (for instance the first point of ).
Therefore, is necessarily already in , because was chosen as the leftmost point on the right of . Thus, there is an such that is the highest (and last) point of , and we can apply the same argument as in the case where , proving that is fragile.

Else, all its contraction vectors are strictly to the right. It is not possible that , for else would also be in (indeed, by definition of , it includes the last occurrence of the highest point on ) and then one of the tentacles, when grown alone, would grow out of , contrarily to our hypothesis that all the productions of stay within . Therefore, in this case, we let the tentacle grow as long as it can, until it reaches its highest point or else crashes into something.
We continue this process with being the union of , , and the longest prefix of the tentacles that can grow).


Else, by Lemma 4.4, has at least tile types. There are two subcases:

if , we let , and resume the construction.

if , the construction is over. Indeed, in this case , and is a path from to , with at least distinct tile types.

In order to conclude the proof, we need to argue that this construction halts, even though cases 1 and 2a seem to make the assembly smaller. First, all the paths we grow in this construction are rightpriority paths. Therefore, after these two cases happen, the same points will appear again as , for , but in this case, the path that we can build from to will necessarily be “less rightpriority” than the original ones, meaning that they will turn left earlier than . Indeed, in both case 1 and 2a, we break , and add the resulting assembly to .
To justify this implication, we need to examine what can possibly happen to these “broken paths” in greater detail. When a path is broken, and we branch and grow a new one to reach , one of two things could happen:

Either is fragile or righttentacular with a contraction vector to the left, in which case nothing can happen to earlier broken parts. The assembly sequence that we use to prove this is the following: First grow all the parts that can grow on the left of , then the broken . Then, grow the earlier broken parts on its right. Either these parts are on the left of ’s breaking branch, in which case they are also enclosed, or they are on its right, but in this case, even if a collision happens between the breaking branch of , and these parts, this collision is either with the original fragile path – which still keeps it broken – or with an earlier breaking branch – which still keeps the original path enclosed, and therefore broken.
Remark.
A fundamental thing about this process, that we are using here, is that breakings always happen between a breaking branch on the right of the path, and the path itself.
This argument would fail in the case where collisions between and an earlier broken part could “open” an earlier enclosed part, that would “free” a formerly broken path. Indeed, because of the very fact that these parts are broken, there is always the possibility to regrow a breaking branch until rebreaking the path.

Else, the construction will continue. If ’s eventual tentacles crash into something, then this crash does not affect any of the arguments, since we only let them grow until their first collision.
∎
Corollary 4.6.
Let be a tile assembly system whose terminal assemblies are all of domain , and such that . Then .
Proof.
Let be the position of the seed. We can use the technique of Theorem 4.2 on all the rectangles with diagonals , , and . At least one is of width and height at least , and verify the assumptions of Lemma 4.4, and the proof of Theorem 4.5 can be applied, either directly, or by “turning in the other direction”, i.e. looking for a nonlefttentacular path. ∎
5 Future work
The next step, in proving the fully general conjecture, is to extend Lemma 4.4 to the case where the seed can be anywhere in the square. The reason why it does not apply to that case, is that a “lower restart” is not necessarily an “early restart”; indeed, let be a path from to , and be a path from to . If and are of the same type for some and , then restarting from does not result in a competition for growth between this “lower branch” and , since the tiles of , to the north of , were grown before .
Therefore, despite Corollary 4.6, the general question remains open:
Open Problem 1.
Is there a tile assembly system with less than tile types, that can assemble a filled square at temperature 1, starting from a single tile anywhere in the square?
Even though the recent results about its intrinsic universality [14], and the present paper, have made significant advances in that direction, the exact computational power of temperature 1 systems is still completely unknown. Moreover, the existence of single tileset simulating, at temperature 1, any other temperature 1 tile assembly system, is still open. The following open problem is particularly puzzling, especially in regard of the impressive results of [5], showing that threedimensional temperature 1 tile assembly are capable of Turing computation:
Open Problem 2.
Is is decidable whether two tile assembly systems have the same terminal assemblies?
Moreover, Theorem 3.1 is the first twodimensional construction at temperature 1, with less tile types than its Manhattan diameter, in the general aTAM. On the other hand, our solution to the original conjecture relies heavily on the fact that our squares need to be completely filled. This leaves the following question open:
Open Problem 3.
For all , is there a tile assembly system , with and , whose terminal assemblies all contain at least a square frame, that is, such that for all , ?
The initial construction of a square with tile types, by Rothemund and Winfree, used a fairly simple design. Our result shows that this is optimal, but it does not discard the possibility of other designs:
Open Problem 4.
Is there a way to selfassemble a square of size at temperature 1 with tile types, that is not a trivial variation of Rothemund and Winfree’s “comb” design (Figure 1)? How many are there?
6 Acknowledgments
I thank David Doty and Damien Woods for friendly support and discussions, Erik Winfree and his group for hosting me during this research, and Paul Rothemund for encouragements. I am especially grateful to Damien Woods, for all the comments that helped me unshuffle a previous, particularly tortured, version of this paper, and more generally for taking me with him on the journey [29]. Section 1 of this paper is partially taken from [14], I would like to thank my coauthors on that paper. Also, Tom Hirschowitz and Christophe Raffalli suggested the name “tentacular”.
References
 [1] Leonard Adleman, Qi Cheng, Ashish Goel, and MingDeh Huang. Running time and program size for selfassembled squares. In Proceedings of the 33rd Annual ACM Symposium on Theory of Computing, pages 740–748, Hersonissos, Greece, 2001.
 [2] Leonard M. Adleman, Qi Cheng, Ashish Goel, MingDeh A. Huang, David Kempe, Pablo Moisset de Espanés, and Paul W. K. Rothemund. Combinatorial optimization problems in selfassembly. In Proceedings of the ThirtyFourth Annual ACM Symposium on Theory of Computing, pages 23–32, 2002.
 [3] Nathaniel Bryans, Ehsan Chiniforooshan, David Doty, Lila Kari, and Shinnosuke Seki. The power of nondeterminism in selfassembly. In Proceedings of the TwentySecond Annual ACMSIAM Symposium on Discrete Algorithms, SODA ’11, pages 590–602. SIAM, 2011. Arxiv preprint: arXiv:1006.2897.
 [4] Harish Chandran, Nikhil Gopalkrishnan, and John Reif. Tile complexity of approximate squares. Algorithmica, 66(1):117, 2013.
 [5] Matthew Cook, Yunhui Fu, and Robert T. Schweller. Temperature 1 selfassembly: deterministic assembly in 3D and probabilistic assembly in 2D. In Proceedings of the 22nd Annual ACMSIAM Symposium on Discrete Algorithms, pages 570589, 2011. Arxiv preprint: arXiv:0912.0027.
 [6] Erik D. Demaine, Matthew J. Patitz, Trent A. Rogers, Robert T. Schweller, Scott M. Summers, and Damien Woods. The twohanded tile assembly model is not intrinsically universal. In ICALP: 40th International Colloquium on Automata, Languages and Programming, volume 7965 of LNCS, pages 400412, Riga, Latvia, July 2013. Springer. Arxiv preprint arXiv:1306.6710.
 [7] David Doty, Jack H. Lutz, Matthew J. Patitz, Robert T. Schweller, Scott M. Summers, and Damien Woods. The tile assembly model is intrinsically universal. In Proceedings of the 53rd Annual IEEE Symposium on Foundations of Computer Science, pages 439446, October 2012. Arxiv preprint: arXiv:1111.3097.
 [8] David Doty, Jack H. Lutz, Matthew J. Patitz, Scott M. Summers, and Damien Woods. Intrinsic universality in selfassembly. In Proceedings of the 27th International Symposium on Theoretical Aspects of Computer Science, pages 275286, 2009. Arxiv preprint: arXiv:1001.0208.
 [9] David Doty, Matthew J. Patitz, and Scott M. Summers. Limitations of selfassembly at temperature 1. Theoretical Computer Science, 412(12):145158, 2011. Arxiv preprint: arXiv:0906.3251.
 [10] Kenichi Fujibayashi, Rizal Hariadi, Sung Ha Park, Erik Winfree, and Satoshi Murata. Toward reliable algorithmic selfassembly of DNA tiles: A fixedwidth cellular automaton pattern. Nano Letters, 8(7):17911797, 2007.
 [11] James I. Lathrop, Jack H. Lutz, Matthew J. Patitz, and Scott M. Summers. Computability and complexity in selfassembly. Theory Comput. Syst., 48(3):617647, 2011.
 [12] Kyle Lund, Anthony T. Manzo, Nadine Dabby, Nicole Micholotti, Alexander JohnsonBuck, Jeanetter Nangreave, Steven Taylor, Renjun Pei, Milan N. Stojanovic, Nils G. Walter, Erik Winfree, and Hao Yan. Molecular robots guided by prescriptive landscapes. Nature, 465:206210, 2010.
 [13] Ján Maňuch, Ladislav Stacho, and Christine Stoll. Two lower bounds for selfassemblies at temperature 1. Journal of Computational Biology, 17(6):841852, 2010.
 [14] PierreEtienne Meunier, Matthew J. Patitz, Scott M. Summers, Guillaume Theyssier, Andrew Winslow, and Damien Woods. Intrinsic universality in tile selfassembly requires cooperation. 2013. Arxiv preprint: arXiv:1304.1679.
 [15] Matthew J. Patitz, Robert T. Schweller, and Scott M. Summers. Exact shapes and Turing universality at temperature 1 with a single negative glue. In DNA 17: Proceedings of the Seventeenth International Conference on DNA Computing and Molecular Programming, LNCS, pages 175189. Springer, September 2011. Arxiv preprint: arXiv:1105.1215.
 [16] Lulu Qian and Erik Winfree. Scaling up digital circuit computation with DNA strand displacement cascades. Science, 332(6034):1196, 2011.
 [17] Lulu Qian, Erik Winfree, and Jehoshua Bruck. Neural network computation with DNA strand displacement cascades. Nature, 475(7356):368372, 2011.
 [18] Paul W. K. Rothemund. Folding DNA to create nanoscale shapes and patterns. Nature, 440(7082):297302, March 2006.
 [19] Paul W. K. Rothemund and Erik Winfree. The programsize complexity of selfassembled squares (extended abstract). In STOC ’00: Proceedings of the thirtysecond annual ACM Symposium on Theory of Computing, pages 459468, Portland, Oregon, United States, 2000. ACM.
 [20] Paul W.K. Rothemund, Nick Papadakis, and Erik Winfree. Algorithmic selfassembly of DNA Sierpinski triangles. PLoS Biology, 2(12):20412053, 2004.
 [21] Georg Seelig, David Soloveichik, David Yu Zhang, and Erik Winfree. Enzymefree nucleic acid logic circuits. science, 314(5805):15851588, 2006.
 [22] Nadrian C. Seeman. Nucleicacid junctions and lattices. Journal of Theoretical Biology, 99:237247, 1982.
 [23] Michael Sipser. Introduction to the Theory of Computation. International Thomson Publishing, 1st edition, 1996.
 [24] David Soloveichik and Erik Winfree. Complexity of selfassembled shapes. SIAM Journal on Computing, 36(6):15441569, 2007.
 [25] Hao Wang. Proving theorems by pattern recognition  II. The Bell System Technical Journal, XL(1):141, 1961.
 [26] Bryan Wei, Mingjie Dai, and Peng Yin. Complex shapes selfassembled from singlestranded DNA tiles. Nature, 485(7400):623626, 2012.
 [27] Erik Winfree. Algorithmic SelfAssembly of DNA. PhD thesis, California Institute of Technology, June 1998.
 [28] Erik Winfree, Furong Liu, Lisa A. Wenzler, and Nadrian C. Seeman. Design and selfassembly of twodimensional DNA crystals. Nature, 394(6693):53944, 1998.
 [29] Damien Woods. Intrinsic universality and the computational power of selfassembly. 2013. Arxiv preprint: arXiv:1309.1265.
 [30] Bernard Yurke, Andrew J Turberfield, Allen P Mills, Friedrich C Simmel, and Jennifer L Neumann. A DNAfuelled molecular machine made of DNA. Nature, 406(6796):605608, 2000.