Asynchronous Signal Passing for Tile Self-Assembly: Fuel Efficient Computation and Efficient Assembly of Shapes
In this paper we demonstrate the power of a model of tile self-assembly based on active glues which can dynamically change state. We formulate the Signal-passing Tile Assembly Model (STAM), based on the model of Padilla, et al. to be asynchronous, allowing any action of turning a glue on or off, attaching a new tile, or breaking apart an assembly to happen in any order. Within this highly generalized model we provide three new solutions to tile self-assembly problems that have been addressed within the abstract Tile Assembly Model and its variants, showing that signal passing tiles allow for substantial improvement across multiple complexity metrics. Our first result utilizes a recursive assembly process to achieve tile-type efficient assembly of linear structures, using provably fewer tile types than what is possible in standard tile assembly models. Our second system of signal-passing tiles simulates any Turing machine with high fuel efficiency by using only a constant number of tiles per computation step. Our third system assembles the discrete Sierpinski triangle, demonstrating that this pattern can be strictly self-assembled within the STAM. This result is of particular interest in that it is known that this pattern cannot self-assemble within a number of well studied tile self-assembly models. Notably, all of our constructions are at temperature 1, further demonstrating that signal-passing confers the power to bypass many restrictions found in standard tile assembly models.
The abstract Tile Assembly Model (aTAM)  created a paradigm for computation to be carried out by a physical assembly process that captured the essence of the Wang tiling model . Turing machine simulation within the aTAM demonstrated its capacity for universal computation, and many subsequent assembly programs shifted focus to patterns, shapes and structures as the output of tile computation [24, 25, 29, 13]. Many modifications to the standard aTAM have been investigated, including several variants that capture the notion of hierarchical assembly [5, 7, 2, 3, 4, 20]. Previous work introduced the notion of using signaled glue activation [20, 18], in particular to guide hierarchical assembly, enabling recursive self assembly . Here we develop a general model of signaled tile self-assembly to enrich the tile assembly paradigm with greater capabilities that anticipate advancing techniques in the field of DNA nanotechnology and allow tile assembly to more closely emulate biological and natural processes.
Signaled glue activation was introduced in  for the purpose of establishing communication inside an assembly so that by activating glues at the exterior of the assembly it may take on new identities or roles. Interactions between assemblies, as described in hierarchical models such as the 2-HAM [1, 5], can simulate the interactions of individual tiles, coordinated in the STAM by the introduction of signals. In particular, recursive assembly results when supertiles simulate the original tiles of the tile set , a strategy outlined here in section 4 in a scheme for efficient line assembly.
Cooperativity, where more than one tile must be in place to determine which tile may be added next, is an important aspect of tile assembly systems. A binding threshold is included in the aTAM, given as the temperature, of the system. Tiles can bind only if the sum of glue interactions at a particular site meet or exceed , thus a system at temperature 2 readily includes cooperativity, whereas it is not as readily achieved at temperature 1. In the STAM, cooperativity can occur at temperature 1 via a query process, where a tile binds to an assembly at one edge, then queries a neighboring tile by turning on a set of glues. Information about the neighboring tile is gained based on which of these glues binds to its match. This cooperative effect differs from the aTAM in that STAM tiles may also respond to the identities and binding events of more distant tiles, enabling the constructions given in this paper to operate at temperature 1. Though the constructions here do not demonstrate a full simulation of the aTAM at temperature 2 by the STAM at temperature 1, the results here are significant given the known and conjectured limitations to temperature 1 computation in the aTAM and its variants [6, 12].
We expect glue deactivation to be as easy to implement as glue activation based on plausible DNA strand displacement mechanisms. Therefore, we utilize this new capability to design a Turing Machine that is fuel efficient (Section 5), and to implement the strict self-assembly of the Sierpinski triangle (Section 6). While on first consideration, glue deactivation might be thought to be on par with negative glues, it never requires repulsive forces between tiles, a necessity for negative glues that to our knowledge has yet to be implemented. Glue deactivation serves here to produce a fuel efficient Turing Machine that does not need to copy the state of unchanged positions on the tape. A halting computation produces an output tape, not a transcript of the computation as in the traditional aTAM simulation of a Turing Machine. Strict self assembly of the Sierpinski triangle is achieved by releasing tiles that are not part of the target structure.
The addition of signaled glue activation and deactivation to tile assembly brings it one step closer to emulating biological processes of self assembly, where communication within a developing and growing living organism are crucial to its survival and success. In this construction, it becomes easier to view the Turing Machine plus its tape as a developing entity, that by following its input instructions, much as a cell follows its genetic recipe, goes through a metamorphosis and emerges from a halting computation as a new entity. The asynchronous growth process of the strict Sierpinski triangle in this model resembles the growth of something such as coral, where the “living” functional part of the system inhabits the growing frontier of the structure, laying down an enduring structure before dying and being washed away. The constructions presented in this paper demonstrate not only a more efficient use of materials (Table 1) in certain cases, but also serve to make the model more relevant in a biological context. The STAM anticipates the increasing sophistication of molecular computation systems, as described in the next section.
|Lines||Tiles||Signals||Temperature||Glue Activation||Glue Deactivation|
|Turing Machine||Space||Fuel||Temp||Tiles||Signals||Glue Act.||Glue Deact.|
|3D aTAM ()||1||-||-||-|
|Negative Glues ()||2||-||-||-|
|Negative Glues ()||8||-||-||-|
|Sierpinski Triangle||Strict||Tiles||Signals||Temp||Scale||Glue Act.||Glue Deact.|
2 Physical Basis for the Model
The generalized model presented here has been designed to take into consideration a DNA implementation of all aspects of signaled assembly. We envision a physical implementation where Watson-Crick DNA base pairing provides specific glue interactions as it has done before for DNA implementations of the aTAM [32, 25]. Additionally, we suggest that toehold-mediated DNA strand displacement reactions  may be the basis for the new elements of our model: binding-induced signaling, and glue activation or deactivation. The physical body of a tile might be composed entirely from a DNA origami structure [26, 16] in order to provide more room for signal pathways than the smaller DNA structures that have been used to implement the passive tiles of the aTAM . Many known and tested DNA strand exchange mechanisms [34, 36, 23], cascades , and walkers [19, 17, 34, 31] suggest possibilities for implementing the signal pathway, including logic gates for responding to multiple inputs and transducers for ensuring that the activated glue can have a different sequence from the glues on the input edges . Details of a plausible DNA origami tile construction are given in .
Details of our model come from a consideration of possible DNA strand displacement mechanisms that might be used to implement signal-passing tiles. The physical basis of the three glue states are illustrated in Figure 1, where a glue may be considered ‘latent’ or ‘off’ (Figure 1c) if enough of its DNA sticky end, including the toehold, is blocked by being bound to a complementary DNA protection strand. Activation of a latent glue involves the toe-hold mediated removal of that strand as a result of a signal cascade (Figure 1d). The difference between the ‘on’ state (Figure 1a) and the ‘latent’ or ‘off’ state (Figure 1c) is based on the availability of toeholds and whether or not there could be any opportunity for them to initiate binding to another tile in the system. Deactivation is merely a reversal of this process, making it just as feasible as activation.
The limitation to pass a given signal only once, and to activate and deactivate a specific glue on a single tile only once comes from the inherent consumption of “DNA fuel” associated with DNA strand displacement cascades, where the production of more DNA base pairs in the products drives the process forward. Thus, the model is designed to emphasize this fuel-consumption aspect by making each use of a signal count as another signal path. The asynchronous nature of our model reflects the likewise asynchronous nature of the molecular events we envision for the physical implementation. In particular, DNA strand displacement reactions proceed via a branch migration resembling a random walk at a rate that can vary widely depending on toehold length and composition . We allow for the time taken by these signaling or glue activation events by storing actions triggered by various events in STAM assembly in a queue for asynchronous processing. Together, these model details capture to the best of our ability and in the most general way possible the capabilities reported in the field of DNA nanotechnology that we see as plausible additions to the molecular implementation of tile assembly, particularly if DNA continues to play a significant role in these implementations.
3 STAM Notation and Model
In this section we define the Signal-passing Tile Assembly Model (STAM), an extension of the 2-Handed Assembly Model (2HAM) [5, 7, 3, 4], which itself is an extension of the Tile Assembly Model (TAM) . The STAM is a refined version of the model presented in , in which the basic tiles of the TAM are augmented with the ability to receive information, in the form of signals, from neighboring tiles in an assembly, and to pass signals to neighboring tiles. A very important feature of signals is that each signal can only move across any given tile one time - they are not reusable.
The STAM that we define is a highly generalized model which imposes minimal restrictions on aspects such as the speed of signals and orderings of events. This generalized version, while perhaps difficult to create well-behaved constructions within, provides a framework that is intended to be maximally independent of the specific details of potential physical implementations of actual signal tiles, such as those using mechanisms suggested in . Valid constructions within this model, such as all of the constructions presented within the following sections of this paper, will therefore also work correctly within more restricted versions of the model (for instance, where signal timing or ordering can be guaranteed).
3.1 Informal Description of the 2HAM
Since the STAM is an extension of the 2HAM, we now give a brief, informal description of the 2HAM.
A tile type is a unit square with four sides, each having a glue consisting of a label (a finite string) and strength (a positive integer value). We assume a finite set of tile types, but an infinite number of copies of each tile type, each copy referred to as a tile. A supertile (a.k.a., assembly) is a positioning of tiles on the integer lattice . Two adjacent tiles in a supertile interact if the glues on their abutting sides are equal (in both label and strength) and bind with that shared strength. Each supertile induces a binding graph, a grid graph whose vertices are tiles, with an edge between two tiles if they interact and where the weight of that edge is the strength of their bond. The supertile is -stable if every cut of its binding graph has strength at least . That is, the supertile is stable if at least energy (i.e. a cut across bonds whose strengths sum to at least ) is required to separate the supertile into two parts. A tile assembly system (TAS) is a pair , where is a finite tile set (or more generally a finite set of supertiles) and is the temperature, a parameter specifying the minimum binding energy required for a supertile to be stable. Given a TAS , a supertile is producible if either it is an element of , or it is the -stable result of translating two producible assemblies without overlap or rotation. A supertile is terminal if for every producible supertile , and cannot be -stably attached. A TAS is directed (a.k.a., deterministic, confluent) if it has only one terminal, producible supertile. Given a connected shape , a TAS strictly self-assembles (also produces uniquely) if every producible, terminal supertile places tiles exactly on those positions in (appropriately translated if necessary). Given a pattern (which must not necessarily be connected), a TAS weakly self-assembles if every producible, terminal supertile places a subset of tiles exactly on those positions in (appropriately translated if necessary). Weak self-assembly can be thought of as using a subset of tile types to “paint a picture” of on a possibly larger canvas of tiles composing a terminal assembly.
3.2 Informal Description of the STAM
In the STAM, tiles are allowed to have sets of glues on each edge (as opposed to only one glue per side as in the TAM and 2HAM). Tiles have an initial state in which each glue is either “on” or “latent” (i.e. can be switched on later). Tiles also each implement a transition function which is executed upon the binding of any glue on any edge of that tile. The transition function specifies a set of glues (along with the sides on which those glues are located) and an action for each: 1. turn that glue on (only valid if it is currently latent), or 2. turn that glue off (valid if it is currently on or latent). This means that glues can only be on once (although may remain so for an arbitrary amount of time or permanently), either by starting in that state or being switched on from latent, and if they are ever switched to off then no further transitions are allowed for that glue. This essentially provides a single “use” of a glue (and thus the implicit signal sent by its activation and binding). Note that turning a glue off breaks any bond that the glue may have formed with a neighboring tile. Also, since tile edges can have multiple active glues, when tile edges with multiple glues are adjacent, it is assumed that all glues in the on state bind (for a total binding strength equal to the sum of the strengths of the individually bound glues). The transition function defined for each tile type is allowed a unique set of output actions for the binding event of each glue along its edges, meaning that the binding of any particular glue on a tile’s edge can initiate a set of actions to turn an arbitrary set of the glues on the sides of the same tile either on or off. As the STAM is an extension of the 2HAM, binding and breaking can occur between tiles contained in pairs of arbitrarily sized supertiles. In order to allow for physical mechanisms which implement the transition functions of tiles but are arbitrarily slower or faster than the average rates of (super)tile attachments and detachments, rather than immediately enacting the outputs of transition functions, each output action is put into a set of “pending actions” which includes all actions which have not yet been enacted for that glue (since it is technically possible for more than one action to have been initiated, but not yet enacted, for a particular glue).
An STAM system consists of a set of tiles and a temperature value. To define what is producible from such a system, we use a recursive definition of producible assemblies which starts with the initial tiles and includes any supertiles which can be formed by doing the following to any producible assembly: 1. executing any entry from the pending actions of any one glue within a tile within that supertile (and then that action is removed from the pending set), 2. binding with another supertile if they are able to form a -stable supertile, or 3. breaking apart into two separate supertiles along a cut whose total strength is less than .
As an overview, tiles in the STAM pass signals to neighboring tiles simply by activating glues which can bind with glues on adjacent edges of neighboring tiles. The information content of a signal is dependent upon the transition function of the receiving tile, that is, by what glue actions the receiving tile initiates upon the binding of its glue. By subsequently activating and deactivating its own glues, the receiving tile can propagate the signal to any of its neighbors. Solely by utilizing the mechanism of glue activation and deactivation initiated and carried out on individual tiles but chained together through series of glue bindings, a global network which is capable of passing information across entire assemblies (and also of allowing them to selectively enable sites for further growth or to discard arbitrary portions of the assembly), is created. However, an important restriction is the “fire once” nature of the signals, meaning that each glue can only transition to any given state once, and therefore the number of signals which a tile can process is a constant dependent upon the definition of the tile type.
The STAM, as formulated, is intended to provide a model based on experimentally plausible mechanisms for glue activation and deactivation, but to abstract them in a manner which is implementation independent. Therefore, no assumptions are made about the speed or ordering of the completion of signaling events (i.e. the execution of the transition functions which activate and deactivate glues and thus communicate with other tiles via binding events). This provides a highly asynchronous framework in which care must be made to guarantee desired results, but which then provides robust behavior independent of the actual parameters realized by a physical system. Furthermore, while the model allows for the placement of an arbitrary number of glues on each tile side and for each of them to signal an arbitrary number of glues on the same tile, this would obviously be limited in physical implementations. Therefore, each system can be defined to take into account a desired threshold for each of those parameters, not exceeding it for any given tile type, and we have also defined the notion of signal complexity, as the maximum number of glues on any side of any tile in a given set, to capture the complexity of a tile set.
3.3 Formal Definition of the Signal Passing Tile Assembly Model
This section presents a formal definition of the STAM. In order to help clarify many aspects, a consistent example is provided and referenced throughout.
3.3.1 Basic Notation
Let denote the set of labels , or .
Active Glues and Glue States
Let denote a set of glue types. A glue is an ordered pair where is the glue type and is the glue strength. Note that throughout the remainder of this paper, unless specifically stated, all glues will have strength and as shorthand will be denoted simply by their glue types with the strength omitted.
Let be the set of possible states for a glue. Intuitively, on is the “normal”, active state of a glue, meaning that it is either able to bind or currently bound. A glue in the latent state is inactive (and therefore unable to bind), and also has never been on (or off). A glue in the off state is also inactive and unable to bind, but can never be (re)activated. We define an active glue as an ordered pair where is a glue type and is a state.
As in the original TAM, we define a label as an arbitrary string over some fixed alphabet and labels will be used as non-functional (i.e. they don’t participate in tile bindings) means of identifying tile types. Denote as the set of all valid labels. For the self-assembly of patterns (e.g. the weak self-assembly of the Sierpinski triangle), tile labels are the mechanism used for distinguishing between groups of tiles, i.e. those “in” the pattern and those “outside” it. Experimentally, labels can be implemented as DNA loops which protrude above the surfaces of tiles for imaging purposes , and thus the motivation exists to allow for the modification of tile labels along with glues. Therefore, we define an active label is an ordered pair where and .
Active Tiles and Transition Functions
A generalized active tile type is a unit square defined as a -tuple where is a function specifying the set of all active glues present on a given side, is the set of all active labels, is the transition function and is a multiset over . A generalized active tile type is an active tile type if, for all and for all active glues , . In other words, while a tile side may have multiple glues, there cannot be multiple copies of the same type of glue on a single side.
A transition function takes as input a direction and a glue type (i.e. we say that it is “fired” by the binding of glue type on side of ), and outputs a (possibly empty) set of glue or label actions, i.e., elements of . Consider an active tile type and suppose that for some and . Intuitively, if (i.e., the multiplicity of ) before “fires,” then after executing . We assume for the sake of convenience that outputs the empty set for any pair of direction and glue on which is not explicitly defined. In other words, the binding of a glue on fires the transition function, which can result in a set of “requests” for specific active glues and labels on to transition into specified states.
As shorthand, let “” represent “latent”, “” represent “on”, and “” represent “off”. Let be an active tile type. For notational convenience, we will denote as the active glue of satisfying, for some , . We purposely omit the direction from our shorthand notation because it will always be clear from the context. Note that, in our notation, the superscript specifies its current state (e.g. if the active glue is on, we write ), and the subscript represents its set of pending state transitions (i.e., the set of all glue actions ). For example, if , then we write . If there are no pending state transitions for in , then we omit a subscript. Figure 2 shows the valid state transitions for active glues, which is restricted to latent being able to transition to either on or off, and “ being able to transition to “. Note that once a glue is in the off state, there is no valid transition out of that state. Also, the only valid initial states for an active glue are latent or on since a glue which started in the off state could never interact and therefore could simply be removed.
Figure 3 shows an example active tile type with , , , and . Note that for the sake of convenience, in figures we tend to omit superscripts unless the glue state is off, so a glue with no superscript and a rectangular tab next to it represents that the glue is on, and with no such a tab is latent. Glues which are off will contain the “” superscript, or be removed completely, to remove ambiguity. Figure 3 also includes two depictions of the tile’s transition function. In this example, when the glue on the North side of the tile binds, the tile’s transition function specifies that glues on the West side and on the East side are requested to turn on.
An active tile is an instance of an active tile type which has its own pending sets for each of its active glues and labels–all of which sets must be initially empty.
Active supertiles in the STAM are defined similarly to supetiles in the 2HAM. Note that only glues which are in the on state can bind, and only those which are bound contribute to the -stability of a supertile. When two -stable supertiles can be translated so that they are non-overlapping and the abutting on glues can bind to create a cut strength of at least , we say that they are -combinable. A supertile is said to be -breakable into supertiles and if there exists a strength strength cut of the stability graph that separates the tiles of into supertiles and .
Active Supertile Combination
Two active supertiles and may combine into active supertile if the underlying supertiles for and are -combinable into the underlying supertile for . When supertiles combine, all matched glues in the on state on the boundary between and are said to bind, and thus fire the transition functions of their respective tiles, causing the necessary states to be added to the pending sets of the targeted tiles.
Active Supertile Breaking
An active supertile can break into active supertiles and if the underlying supertile for has a cut of less than -strength dividing into the underlying supertiles for and .
An STAM system is a tuple where is a set of initial active supertiles referred to as the initial assembly set of the system, and is a positive integer referred to as the temperature of the system. We further restrict that the initial assembly set only contains active super tiles such that . For some problems such as the unique assembly of shapes and lines (see section 4), is further restricted to contain only active supertiles that consist of singleton active tiles.
3.3.2 Producible Assemblies
The signal passing tile assembly model is defined in terms of the set of producible active supertiles . is defined recursively as follows:
- Base Set of Assemblies
- Combination Transition
For any 2 active supertiles , if and are -combinable into active supertile , then .
- Break Transition
For any supertile , if is -breakable into active supertiles and , then .
- Active Glue Transition
Consider an active supertile . For each active tile with , for all , for all and for all , there is a supertile such that and differ only at location as follows: satisfying
if and or and or and , then for all , , and for all , .
(This simply says that any supertile which can be created from another producible supertile by simply executing one of ’s pending actions is also producible.)
- Active Label Transition
Active label transitions are defined similar to active glue transitions.
3.3.3 Terminal Assemblies
The set of producible assemblies of an STAM system defines the collection of active supertiles that can occur throughout the assembly process. The terminal set of assemblies of an STAM system defines the subset of producible assemblies for which no combination, break, glue transition, or label transition is possible. Conceptually, the terminal assembly set represents the sink state of the assembly system in which the system has been given enough time for all assemblies to reach a terminal state. The terminal set of assemblies is considered the output of an STAM system. In our constructions we are interested in designing systems that will have either 1) a unique terminal assembly that has a desired shape or 2) has a collection of terminal assemblies in which the desired target assembly is the largest or 3) the desired target assembly is the only assembly which contains a specially designated marker tile.
Please see Section 3.4 for an example STAM system and several transitions and producible assemblies.
3.4 Example STAM System
Here we give a small example STAM system along with descriptions of several transitions and producible assemblies.
3.4.1 Example tile types
Figure 4 shows a tile set that will be used for the following example. We will refer to active tiles by their labels for convenience. The “Bot” tile has four glue actions defined for its transition function, all of which turn on glues. The “MM” tile includes two glue actions which turn off glues: when glue on the North binds, both that glue and glue on the South get off transitions placed into the multiset of the active tile, which will eventually cause them to be turned off. The transition function for the “MR” tile contains a label action, namely when the glue on the South binds.
3.4.2 Example STAM transitions
Define an STAM system where is the tile set shown in Figure 4. Figure 5 shows a set of transitions and producible assemblies within that system. Figure 5(a) shows a “Top” and “MM” tile in their initial configurations (with empty sets for all active tiles as required, and all superscripts explicitly shown for reference). Figure 5(b) shows the supertile resulting from a combination transition performed on one “Top” and one “MM” tile. Note that the binding of the two glues causes four glues to have state transitions added to the multisets the belong to their respective active tile. Figure 5(c) shows the supertile resulting from a glue flip transition performed on the supertile in Figure 5(b), namely the glue on the West side of the “Top” tile transitioned to state on and that pending transition was removed from the multiset belonging to its active tile. Figure 5(d) shows the supertile resulting after two glue flip transitions are performed on the supertile in Figure 5(c), namely glue on the East of “Top” is turned on and on the North of “MM” is turned off.
3.5 STAM Metrics
Within this paper we consider the problem of assembling precise shapes, simulating Turing machines, and the strict self-assembly of infinite fractals. To measure how efficiently we can solve these assembly problems within the STAM model, as opposed to alternate models, we consider a number of natural metrics designed to measure experimental feasibility with respect to likely STAM implementations, the most important being DNA origami based tiles which implement glue actions through DNA strand displacement.
3.5.1 Tile Complexity
The tile complexity of an STAM system is , the number distinct active supertiles that serve as the initial set of assemblies for the system. In the case that is restricted to contain active supertiles consisting of only singleton active tiles, this metric denotes the number of distinct tile types that must be engineered to implement the STAM system. In general, the metric describes the number of distinct assemblies that must be engineered to implement the system.
3.5.2 Signal Complexity
The signal complexity of an STAM system is the maximum number of glues that occur on the face of any tile from . Within the STAM system, each glue along a tile face is potentially set up to fire a transition function that triggers a set of local glue actions upon binding. In practice, such transition triggers can be set up through a sequence of DNA strand displacements. Setting up a small network of such displacement chains on the face of a DNA origami tile is experimentally quite feasible. However, the cost and complexity grow substantially as the number of distinct displacement reactions grows, making the signal complexity a key metric for experimental feasibility.
3.5.3 Fuel Efficiency
Fuel efficiency is a metric that is considered in the context of simulating a Turing Machine and denotes the number of tiles that are used up (and cannot be reused) per computation step of the Turing machine being simulated. Our result constitutes the first Turing simulation self-assembly system that achieves fuel efficiency.
3.5.4 Space Complexity
Space complexity is a metric that is considered in the context of simulating a Turing Machine and denotes the size of the assembly that represents the current tape and state of the Turing machine after a given computation step.
For an STAM system , the temperature value denotes the number of glue bonds required for two assemblies to combine. Higher temperature systems realize finer grained bonding strength differences than lower temperature systems and may be comparably harder to implement in practice. One of the most straightforward class of systems to implement may be temperature systems in which any single bond is sufficient to cause two assemblies to attach. In particular, strength systems do not require the implementation of error prone cooperative bonding in which attachment may be based on 2 or more glues spread across 2 or more distinct tiles.
4 Efficient Construction of Linear Assemblies
In the aTAM, lines are inherently inefficient to self-assemble, requiring the worst possible tile complexity of . However, using signal-passing tiles it is possible to create lines using no more than tile types, regardless of the value of . Of course, the value of must some how be encoded in the system, but rather than requiring tile types as in the aTAM, in the STAM the value of can be efficiently encoded using bits to require tile types with signal complexity. The construction we use makes use of a recursive doubling strategy where random tile binding events randomly assign the fate of each supertile at each stage, and is of independent interest in terms of using signal-passing tiles to perform recursive assembly of structures.
We first state our result for the special case where is a power of 2 and provide a detailed construction. The exact tile set is given in Figure 9. A high-level description of the recursive doubling technique is given in Figure 8, and a small example of the assembly process for a length line is given in Figures 10-11. This result can be generalized to work for any positive integer by increasing the glues on the tile types of the powers of construction and adding more tile types, while keeping the signal complexity at , yielding the final result stated in Theorem 4.2.
For every , there exists an STAM system which uniquely assembles a line. Moreover, contains tiles, has signal complexity , and does not use glue deactivation.
4.1 Proof of Theorem 4.1
Define as a naming function that takes as input a supertile and returns a string . For an arbitrary input , if the height is 1 and the width is for some , returns if has active glues labeled and on its eastern edge, if has active glues labeled and on its eastern edge, if has active glues labeled and on its western edge, and if has active glues labeled and on its western edge. Otherwise, returns .
Initially, the system consists only of copies of tiles from , namely the four singleton tiles whose names correspond to their identities as defined by : and . Assembly proceeds by recursive combination of these tiles into larger supertiles. Figure 8 shows how producible assemblies can join; for example, can attach to the western edge of either or , producing and , respectively. For a detailed view of the internal signal structure of the tiles that allows for this behavior, see Figure 9. Note that each assembly possesses two exposed external glues which allow non-deterministic binding to occur, a critical aspect of the construction.
The binding event that joins two assemblies together will propagate a signal either left or right (via or glues), depending on what identity the newly formed assembly is supposed to take on. For example: if tile attaches to tile , it can only do so by virtue of glue . At this point, the assembly “knows” that it is now supposed to be , and activates a glue on its right face: . Each tile in the assembly can receive on its left edge (because it is already activated), and activate it on its right edge, effectively propagating a signal across multiple tiles. When the rightmost tile (in this case, ) receives the signal, it activates glues corresponding to the appropriate identity, i.e., and . At this point, the assembly can properly be called . The tileset is designed in such a way that the external edge tiles in any particular assembly are known. For example, it can be observed that the leftmost and rightmost tiles in any will be and , respectively. This fact allows a simple signal transduction: when an edge tile receives a particular signal, there is exactly one identity that particular assembly can adopt via glue activation.
The assembly process can be thought of as being isomorphic to a staged assembly process, where at every stage such that , four new assemblies are formed from assemblies produced at stage . These can combine with one another in four ways, and so on. This process terminates at the final mixing, when , because the final binding event does not trigger signal propagation, resulting in terminal lines. Note that there are unique terminal assemblies, all of which are lines.
4.2 Proof of Theorem 4.2
For every , there exists an STAM system , with , which uniquely assembles an line. Moreover, the signal complexity of is and does not use glue deactivation.
Let be an arbitrary positive integer. Note that can be written as a sum of powers of , i.e. where is the th bit of the binary representation of . Just as can be written this way, the line of length can be composed of segments with power of lengths, each composed during the construction of the line of length where , as described in the previous section. The joining of line segments corresponding to the powers of that sum to is shown in Figure 12.
The tiles from the previous section are modified to include more glues each that direct the assembly of the powers of shown in Figure 12. The resulting tile set still has signal complexity and is shown in Figures 13-14. Depending on the specific bit sequence of , the tile types , , and may or may not be included in the tile set for that . For each power of which is a component of the binary representation of , there is an assembly which stops doubling at that length and exposes a glue on its eastern edge that allows it to bind to the bar of length corresponding to the next lower power of . If is odd, then the tile is the only tile with an initially exposed glue (namely, ) on its west side. If is even and (the second bit in its binary representation is ), then tile is used in the construction and will present the first west facing glue, namely . If neither or are , then tile type is used to ensure that there will be lines of length equal to the smallest included power of two which will expose a glue on the west and will stop any continued doubling. For all other included powers of (assuming that is not a power of ), the tile will be included in the tile set and will ensure that bars of lengths corresponding to each such power of will stop doubling at those lengths and present glues on their east side.
Once a bar binds via a glue on its east, it sends a signal to the west side to open the next glue and allow subsequent attachment. Finally, the bar of the largest power of will also stop doubling and send a signal (starting from either an or tile) to the east allowing for the attachment of the line consisting of all smaller powers of .
5 Fuel Efficient Turing Machines
Showing that the original abstract Tile Assembly Model is computationally universal is a simple matter of designing a tile assembly system which can simulate a universal Turing machine, as originally shown in , and later expanded upon in [22, 8, 6, 11]. While displaying the computational power of the aTAM (and variants prior to the STAM), a common drawback of the constructions has been the number of tiles utilized during the formation of the assembly which simulates the computation, which, in this paper, is referred to as the fuel efficiency of the simulation.
For prior constructions, it has been necessary to make a new copy of the entire tape of the Turing machine between each computational step, with the new copy identical to the original except for the slight difference of a mere two tape cells indicating: 1. the output value in the tape cell left by the tape head, and 2. the tape cell marking the current location of the tape head. This full-scale copying of the tape, including the vast majority of cells which are unchanged, is wasteful in terms of the number of tiles required, experimentally very error prone due to the huge number of tile attachments required, and results in enormous assemblies. In this section, we exhibit a construction which is capable of simulating a universal Turing machine in the STAM, but while doing so only requires a small constant number of tiles (never more than ) as fuel for each computational step and maintains an assembly which consists of a number of tiles which is only twice the total number of tape cells used by the Turing machine up to that step. It is possible that with significantly fewer binding events in the STAM construction than in those of previous models (even taking into account those used for signaling), it may be the case that the number of errors which occur could decrease, assuming, of course, that the mechanism which carries out the transition function is sufficiently error-free.
Throughout this paper, and without loss of generality, we define Turing machines as follows. Let be an arbitrary single-tape Turing machine, such that with state set , input alphabet , tape alphabet , transition function , start state , accept state , and reject state . Furthermore, begins in state on the leftmost cell of the tape, expects a one-way infinite-to-the-right tape, and is guaranteed to never attempt to move left while on the leftmost tape cell.
Theorem 5.1 (Fuel efficient Turing machines).
For any Turing machine with input , there exists an STAM system with tile complexity , signal complexity , and fuel efficiency , which simulates on in the following way:
contains an active supertile consisting of active tiles representing and ’s start state.
If halts on , then contains exactly one supertile with tiles and that supertile contains exactly one () tile if accepts (rejects) .
If does not halt on , then contains exactly (terminal) supertiles with tiles.
Our proof of Theorem 5.1 is by construction. Here, we provide a brief overview.
Our construction works by utilizing a set of tile type templates that, along with the definition of a Turing machine , are used to generate the set of active tiles which are specific to . The construction uses a pair of tiles to represent each tape cell, with one tile representing the value (, , or ) of that cell and one tile providing a “backbone” which the other attaches to and which also attaches to the backbone tiles of the cells to its left and right. Additionally, there is a special tile for the tape cell representing the rightmost end of the tape, and also, at any given time, exactly one tape cell which also represents one state of along with the tape cell value. The location of the tape cell with that information denotes the location of ’s tape head at that point, and the value of the state tells what state is in. Transitions of occur in a series of main steps in which tiles bind to the north of the tape cell denoting the head location, then to the north of the tape cell to the immediate left or right (depending on whether or not ’s transition function specifies a left or right moving transition from the current state while reading the current tape cell value), and along the way cause the dissociation of the tiles representing the tape cell values in both locations and their replacement with tiles which represent the correct output tape cell value of the transition and correctly record the new state and head location at the tape cell immediately to the left or right. Due to the asynchronous nature of glue deactivations, and also the necessity that any “junk” assemblies produced (i.e. those assemblies which break off from the assembly representing the Turing machine tape and which don’t contribute to the final “answer”) must not be able to attach to any portion of any supertile which represents any stage of the computation, junk assemblies are produced as size or so that any activated glues which would otherwise be able to bind to another supertile are hidden between the tiles composing the junk assembly. In such a way, is correctly simulated while requiring only a constant number of new tiles per simulated transition step, and all junk assemblies remain inert and at size either or . If halts, there will be one unique, terminal supertile which represents the result of that computation and is of size . If does not halt, only the junk assemblies will be terminal.
Our proof is by construction. Let be a Turing machine and be the input. We define the finite set of tile types in relation to as shown in Figure 17. Note that the tile types presented are generic templates applicable for generating the tile types specific to a given (with the exception of the “tape extension tile type”, “backbone tile type”, and the left “tape cell tile type” which are used for all ). Also note that the tile type templates provided for the “Turing machine head tile types” are specific to transitions which move the tape head to the right, and those for left-moving transitions are simply mirror images with a unique set of glues (e.g. every glue is prefixed with “-”) defined specifically for those transitions. The actual tile types that would be generated for a specific can be determined by substituting each valid variable value (as specified below each tile type template) into glue labels, and potentially consist of a large number of actual tile types generated by each template definition.
The tiles in the “Tape cell tile types” and “Backbone tile type” sections of Figure 17 are used to compose the tape. The tape itself, as shown in Figure 18, consists of a row of east-west connected “backbone” tiles, each of which is connected on its north to a tile representing a tape cell. The backbone is used to keep the entire assembly connected during the process of tape cell replacement. The possible values for tape cells are: (1) “”, (2) “”, (3) “_” (a blank), (4) “*” (which represents the currently rightmost tape cell), or (5) where (at any point there is exactly one such tape cell which represents the location of the head and ’s current state along with the contents of the tape cell that the head is currently reading. The tiles in the “Turing machine head tile types” group are used to simulate the actions of the head, which can be understood as four high-level steps (,,, and - to be explained shortly). The “Tape extension tile type” is used to extend the tape by one additional blank symbol (“_”) if and when the head reaches the rightmost end of the tape, thus allowing the assembly to simulate a one-way infinite-to-the-right tape.
The easiest method of explanation of this construction is to step through an example transition, which we now do. The specific example is depicted in the series of Figures 18, 19 and 20. Assume that is currently in state “” and reading symbol “”, the output symbol is “”, the next state should be “”, and the head should move right (i.e. the simulated transition is ). Glues which are currently on are shown as black, glues which have just been turned on or connected in the current step are shown as bright blue, glues which are queued to turn off are shown as red, and glues which are currently off or latent have been hidden. Triggered actions have been depicted by arrows.
The transition begins from the glue on the tile. As depicted in Figure 19(a), the - tile encodes the information to read a while in state , change it to a , move the head to the right, and change to state . The values , and “move to the right” are implicitly stored by - as shown in Figure 19(b). - then connects to the tape cell tile below to read the symbol on that cell (a here), and sends a message back to - which causes - and the now obsolete tape cell beneath it to dissociate as a pair, as shown in Figure 19(c)-Figure 19(f). When - connected with -, - didn’t know what the tape cell value beneath it was, so it had to activate all four possible glues, which are , , , and . Since only the binds, - can pass along the value of in its next glue to a tile of type -. Here the means the next state will be , the tape cell of the current head position will change to , and the symbol of next head position is . Then, in Figure 19(h)-Figure 19(l), the - tile causes a new tile representing a tape cell value of to fully bind to the backbone and activate its glue, which completes the transition of that tape cell. After that tile is connected to the backbone, it sends a message to - that allows it to dissociate, as shown in Figure 19(l)-Figure 19(o). Finally, the - tile binds to -’s glue, allowing it to facilitate the binding of the where the previously was, and eventually dissociate along with the - once the is fully connected, as shown in Figure 19(p)-Figure20(w). At this point, the tape is ready for next state transition, in a configuration similar to that at the beginning of the transition but with the correct output from the transition which is now complete, and the head in the correct position while representing the new state.
5.1 Growing the tape
In order to simulate a one-way infinite-to-the-right tape with a finite assembly, we simply design the tape so that the rightmost cell always represents a special value, namely . Whenever a transition begins which needs to move the tape head to the right, and the destination location of the head currently contains the symbol, that situation is “read” by the - tile which forces a tile to bind to its right, which itself ensures that a new tape cell location with the symbol as well as a new backbone tile to hold it in place at the end of the tape both firmly bind. Additionally, the - tile “fakes” the situation of having read a blank () symbol so that the location previously occupied by the is treated as though it was occupied by a , which - coupled with the new symbol one location to the right - is logically identical to adding a blank tape cell on the right end of the tape. Since this occurs whenever the head tries to move to the end of the tape, it simulates an infinite tape.
5.2 Junk assemblies
During each transition of , several junk assemblies are created when they dissociate from the main assembly representing the tape. These can be seen in Figure 19(f), Figure 19(o), and Figure 20(w), and are also shown in Figure 21. In order to guarantee correctness of the construction and thus the underlying simulation of , it is necessary that these junk assemblies cannot interfere with any version of the computation (keeping in mind that many such simulations would be occurring in parallel). To ensure this, we have carefully designed the junk assemblies so that every glue on their perimeter must be either latent or off, with the notable exception of the glues and on the west side of the - tile of the middle junk assembly shown in Figure 21. The method of ensuring that specific glues are actually deactivated in a temperature system is to (1) only send deactivation signals to glues which must be bound at the time the signal is sent and (2) to only send deactivation signals to glues on one side of a bond (i.e. if two tiles are bound together by glue , only one of those tiles sends a signal to deactivate its copy of ). In this way, despite the fact that signals are processed asynchronously, it must be the case that if a supertile is going to detach, all glues on the boundary of (whether on or the supertile that is bound to) which have been sent a deactivation signal have actually already turned that glue off. Furthermore, since it is often the case that sets of glues must be turned on with the expectation that only one of them will ever bind (e.g. as in the case when the - tile activates one glue for each potential tape cell value to its south), in order to follow (1) above, it is necessary to conceal the unused on glues from any potential interactions. This need to segregate such glues is the reason for creating junk assemblies of size (and ) rather than of size , and is a technique utilized in all of the constructions which make use of glue deactivation within this paper.
Following the above design techniques makes it necessary that for the leftmost and rightmost junk assemblies to detach, they must be completely inert and unable to bind to any other supertiles in the system. The middle supertile, with the and glues still active, on the other hand, ensures that it cannot bind to any other supertile by utilizing a form of geometric hindrance. Essentially, the - tile can only ever dissociate if it does so with a tape cell tile attached to its south. While the glue on its west would otherwise be able to attach to a - tile that is currently bound to the tape using the eastern (in this case ) glue, an tile can only ever attach to a tape cell tile after an tile dissociates from its north. The dissociation of the can only happen if it does so while connected to an tile, and the tile could only dissociate along with the tile after “filling in” the new tape cell tile. Thus, for the western facing glue on an tile to be available for binding, it can never be the case that a junk supertile like that pictured in the middle of Figure 21 would be able to bind: it is too tall (the necessary space for the southern tile would already be occupied by a tape cell tile).
Finally, in the case where the tape is grown one cell to the right there is a fourth type of junk assembly. This junk assembly is simply the middle junk assembly of Figure 21 with a tile bound to the east of the - tile by both and glues (for a total size of tiles). However, the southern glues of the tile must be deactivated before dissociation of the junk assembly, and therefore no new glues in the on state are added. As this is the only other producible type of junk assembly, this means that all junk assemblies are fully inert and unable to bind to any other supertiles, and thus maintain the correctness of the simulation while also never growing larger than size .
5.3 Correctness of Theorem 5.1
It has been shown that the STAM system which simulates correctly simulates the behavior of TM on input . If halts, special - tiles for (previously undiscussed) will attach in the head location which halt further assembly (by containing no other on or activatable glues), thus creating a terminal assembly of size (since there must be at least one tape cell tile representing a , , or and the tape cell tile representing , along with their backbone tiles). If does not halt, the supertile representing the tape will never be terminal - only the junk assemblies will be terminal - and thus there will be no terminal supertiles of size . Furthermore, it is a temperature system, all junk assemblies remain at size either or , the signal complexity is (specifically, due to the maximum number of glues on a tile side being the on the west side of -), the fuel efficiency is as every transition produces exactly junk assemblies, each with size , and adds at most new tiles to the tape assembly (the two new tiles for the tape cells which have swapped the head position, plus possibly two more tiles if the tape was grown by one symbol to the right), and tile complexity since the tape alphabet and all other glue values are a constant size set and each tile template can be used to generate at most a constant number of tiles for each transition in and there can be at most transitions in . ∎
6 Self-Assembly of the Sierpinski Triangle
Discrete self-similar fractals are defined as sets of points in , and consist of infinite, aperiodic patterns. It is difficult, if not impossible, for them to strictly self-assemble in the aTAM, as is shown in [14, 21] where the impossibility of a class of discrete self-similar fractals, including the Sierpinski triangle, strictly self-assembling in the aTAM is proven. The impossibility of strictly self-assembling the Sierpinski triangle in the 2HAM was shown in . Additionally, Doty  has shown a generalization of the impossibility proof from  which applies to, among other things, scaled versions of the Sierpinski triangle for any scaling factor. Thus, any method of strictly self-assembling the Sierpinski triangle, scaled or not, is of interest.
In this section, we show that weak self-assembly of the Sierpinski triangle is possible in the STAM with fewer tile types (4 versus 7) and lower temperature (1 versus 2) than existing TAM constructions, and we also show that strict self-assembly at scale factor is possible in the STAM at temperature 1, a first for any model at any temperature.
6.1 The discrete Sierpinski triangle
Here we use the definition of . Let . Define the sets by the recursion , , where and . Then the (standard) discrete Sierpinski triangle is the set . See Figure (a)a for a depiction of the first five stages (i.e. through ).
Our Sierpinski triangle constructions are as stated in the following two theorems. Additionally, in the next section we provide a high-level sketch of the more technically challenging construction for Theorem 6.2.
There exists an STAM system that weakly self-assembles the Sierpinski triangle. The system has 5 unique tiles, signal complexity , assembles at temperature , and does not utilize glue deactivation.
There exists an STAM system that strictly self-assembles the discrete Sierpinski triangle at temperature , with tile complexity , scale factor , signal complexity , and which makes use of glue deactivation, producing terminal junk assemblies of size .
6.2 Weak Self-Assembly of the Sierpinski Triangle
Here we describe an STAM system that weakly self-assembles to prove Theorem 6.1 by construction. Of note is that this construction works at temperature 1, thus using no cooperative binding, and does not utilize glue deactivation. Further, the tile complexity and signal complexity are small constants of 5 tiles and 4 signals per tile face. This construction is an example of a more general technique for simulating any rectilinear aTAM system (rectilinear systems grow from south to north, west to east) with a temperature STAM system. The general simulation of any aTAM system with a temperature system STAM system is direction for future work.
The weak Sierpinski STAM tile set is given in Figure 23. The construction is very similar to standard aTAM constructions for weakly self-assembling the Sierpinski triangle (e.g. ), with the main difference being that the aTAM construction works at temperature , by having each tile (which is not on an axis) attach with two input sides. Each input side receives as input either a or a , and the value for both output sides is the xor of the input bits. Those tiles which output a are colored white and considered outside of the Sierpinski triangle, and those which output a are colored black and considered within it. Since our construction works at , one input direction - in this case the west - is chosen to be the first to bind. Then, signals cause glues for either possible value of the second input to be turned on, allowing the tile to query the tile to its south for its value of 0 or 1. Whichever of the glues answers that query then binds and activates the correct output glues as well as turning on the correct label value which identifies the tile as being either white or black. This general signaling mechanism of recruiting a new tile to the complex, activating query glues on edges that are adjacent to tiles already bound to the complex, and then responding to the results of the query is used throughout the temperature 1 STAM constructions given in this paper, and suggests the basis for simulating rectilinear systems.
6.3 Strict Self-Assembly of the Sierpinski Triangle
Our proof of Theorem 6.2 is by construction. Here, we provide a brief overview.
Define as the function which takes as input a point and which returns the set of points which correspond to at a scale factor of , that is, the square of points . (For instance, ). For notation, we will refer to the points in the set as , , , and with subscripts corresponding to the values for and , given as , , , and , respectively. See Figure (b)b for a clarification of this notation.
Let be the Sierpinski triangle at scale factor , i.e. where each point in the original Sierpinski triangle is replaced by a square of points, which we will refer to as a block. To prove Theorem 6.2, we now present an STAM system, which strictly self-assembles . At a high-level, it does so by weakly self-assembling by treating each block as a single tile which receives one input each from the block to its south and the block to its west. Each input is either a or , and the block performs the equivalent of an operation on those inputs and outputs the result to its north and east. A block which outputs a corresponds to a point and thus a location which must remain tiled in the final assembly (shown as grey locations in Figure (a)a). A block which outputs a instead corresponds to a point and must eventually be removed from the final assembly (shown as white locations in Figure (a)a). Whenever a white region is completely tiled and completely surrounded by blocks corresponding to grey positions (note that all white regions in are surrounded by grey positions), glue deactivation is used to “eject” the blocks of that white region as a set of “junk” supertiles. Those junk supertiles are then broken down into constant sized terminal supertiles (of sizes 3, 4, and 6) which are unable to attach to any portion of the infinitely growing assembly, and thus remain inert junk assemblies.
The active tile types which compose are depicted in Figures 24, 25, and 26. The tiles of Figures 24 and 25 form 2 2 blocks (Figure 27) that function like individual tiles in the aTAM construction and the above construction. Each block responds to the inputs from the south and west, yielding an output that is the xor of the binary inputs. The tiles of Figure 26 form the 2 2 seed block, and the horizontal and vertical blocks along the axes, with the exception of tile Ev-2 which only binds to junk assemblies after they are ejected from the construction, initiating the signals that further break down these junk assemblies into smaller pieces. The seed, horizontal and vertical blocks are shown as part of the assemblies in Figures 28-30. Initially, based on the glues that begin in the on state, only tiles of type can bind to tiles of type and , to begin building the seed block. These initial bindings initiate a series of glue activations which can, using tiles of the types shown in Figure 26, tile each of the blocks corresponding to the points of the positive and axes in , namely the points . Arbitrarily large portions of the axes can form without the need for any tiles filling in the “interior” 0- and 1-blocks (in positions where and ). However, no interior block can be fully tiled until blocks and have received tiles. In fact, the first tile placed in is always , and for interior blocks this tile always attaches first to (that is, the north-west tile of the block immediately to its south). For the rest of the discussion, we will only be referring to interior blocks unless explicitly stated.
The first tile to attach in a 0- or 1-block is either or depending on whether or not the output from the block to the south is a or , respectively (Figure 27). (An example of the assembly process can be seen in Figures 28-30.) Once it also binds to the block to its west to receive its second input, it is able to determine the correct output for that block and activate binding glues on its north which specify the identity of that entire block as either (in a white position) or (in a grey position). If it is a -block (-block), the rest of the block fills in with the , , and (, , and ) tiles, in order. Note that either type of block can have either a or tile in its southwest position (the and merely corresponding to the identity of the first input), since the first input is not sufficient to determine the identity of the block. The 0- and 1- blocks produce the weak Sierpinski pattern at scale factor 2 until glue deactivations begin to occur.
Next, we describe the dissociation process that removes the -blocks from a region of the produced assembly once that region is fully enclosed by -blocks. After blocks determine their identity as - or -blocks, they presenting that output to their north and east, allowing further block assembly. -blocks display glues to their south or east, while -blocks also activate glues on their output (north and east) sides which are used to detect that they are bordered by a -block and begin the dissociation process. When a -block forms in the block , it must be the case that one of the inputs to the tile in position is a . If is of type , that input was to the south, and if it is then that input came from the west. Once both inputs have been determined, such a () tile will activate a glue which initiates a () signal to the south (west). This signal will be received by the bordering -block and cause it to dissociate from the -block and pass the signal further into the block and the entire white region. The combination of and signals which pass through -blocks in a white region bounded by -blocks (note that they must be completely surrounded by -blocks since the order of block growth is strictly up and to the right and those signals are only initiated from the south and east sides of -blocks) cause them to separate into vertical chunks which can each dissociate as single supertiles. The design of the signal propagation and glue deactivation is such that the junk supertiles can only dissociate as supertiles which are bounded on both the north and south by -blocks (although they may only be block wide and thus bounded on the east and west by -blocks). This fact is extremely important to the process which further breaks apart those junk supertiles into constant sized pieces but also ensures that they will always be broken apart and never interfere with further growth of the assembly representing the Sierpinski triangle.
The first phase of dissociation breaks the white regions into vertical columns which were previously bounded above and below by grey portions. (The process by which some example junk assemblies are broken down - including some partial re-growth with the addition of singleton and tiles - into latent, constant sized junk, is shown in Figure 31.) This means that the bonds between the white and grey regions are broken on the north and south, and also the bonds on the left and right of each column of blocks (both with white and grey blocks) are broken. The careful design of the signals which cause the dissociation of the white regions, always beginning from grey regions to the north and east and initially only causing dissociation with bordering grey blocks to the north and south (and not other white blocks to the north and south of blocks in potentially large white regions), ensures that when junk assemblies are able to dissociate that the glues on their borders which remain active do not allow them to re-attach to any other portion of the growing assembly except for those which have no blocks formed to the north of them. Additionally, if they are larger than tiles they are guaranteed to have an tile in the northwest corner of each block in their northernmost row, and that tile will have an active glue on its north. Since any position in which these junk assemblies can re-attach cannot have blocks to their north, the glue will allow an tile to attach, and this attachment will initiate the second phase of dissociation in which a chain of signals cause the junk assembly to break up into fixed height portions. Any re-attachment of the junk assemblies to the growing structure will therefore be temporary and also not able to cause incorrect growth by initiating invalid signals. Thus the junk assemblies are broken into fixed width and height portions in two phases.
It is notable that junk assemblies can allow singleton and tiles to attach at some point during their break up into constant sized pieces, but that only these single attachments are possible and no additional signal activation is possible which would allow the junk assemblies to make further attachments. Another interesting aspect of the dissociation process is that white blocks which have grey blocks bordering them on their west side will cause a single tile of those grey blocks to dissociate with them. The newly formed hole in the grey block will be re-filled by either an or a - tile. The reason for this is to “hide” the active glue between the original tile and the tile to its east, which could allow incorrect binding of the junk assembly. In fact, the need to hide active bonds which cannot be guaranteed to be deactivated in this asynchronous model is the reason for the complexity of the dissociation process and the size of the final, terminal junk assemblies.
Through this process in which weak self-assembly of the Sierpinski triangle proceeds until white regions are surrounded by grey blocks, and then those white regions are forced to dissociate as arbitrarily large junk assemblies which are then further broken down into constant sized junk assemblies, all the while being guaranteed not to cause incorrect assembly by binding to the still growing structure, provides the correct strict self-assembly of the Sierpinski triangle at scale 2.
The authors would like to thank Nataša Jonoska and Daria Karpenko for fruitful discussions and comments on this work.
-  L.M. Adleman, Q. Cheng, A. Goel, M-D.A. Huang, D. Kempe, P. Moisset de Espanés, and P.W.K. Rothemund, Combinatorial optimization problems in self-assembly, Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, 2002, pp. 23–32.
-  F. Becker, Pictures worth a thousand tiles, a geometrical programming language for self-assembly, Theoretical Computer Science 410 (2009), no. 16, 1495–1515.
-  Sarah Cannon, Erik D. Demaine, Martin L. Demaine, Sarah Eisenstat, Matthew J. Patitz, Robert Schweller, Scott M. Summers, and Andrew Winslow, Two hands are better than one (up to constant factors), Tech. Report 1201.1650, Computing Research Repository, 2012.
-  Ho-Lin Chen and David Doty, Parallelism and time in hierarchical self-assembly, SODA 2012: Proceedings of the 23rd Annual ACM-SIAM Symposium on Discrete Algorithms, SIAM, 2012, pp. 1163–1182.
-  Qi Cheng, Gagan Aggarwal, Michael H. Goldwasser, Ming-Yang Kao, Robert T. Schweller, and Pablo Moisset de Espanés, Complexities for generalized models of self-assembly, SIAM Journal on Computing 34 (2005), 1493–1515.
-  Matthew Cook, Yunhui Fu, and Robert Schweller, Temperature 1 self-assembly: Deterministic assembly in 3d and probabilistic assembly in 2d, Proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms, 2011.
-  Erik D. Demaine, Martin L. Demaine, Sándor P. Fekete, Mashhood Ishaque, Eynat Rafalin, Robert T. Schweller, and Diane L. Souvaine, Staged self-assembly: nanomanufacture of arbitrary shapes with glues, Natural Computing 7 (2008), no. 3, 347–370.
-  Erik D. Demaine, Matthew J. Patitz, Robert T. Schweller, and Scott M. Summers, Self-assembly of arbitrary shapes using rnase enzymes: Meeting the kolmogorov bound with small scale factor (extended abstract), Proceedings of the Twenty Eighth International Symposium on Theoretical Aspects of Computer Science (STACS 2011) (Dortmund, Germany), 2011, to appear.
-  R.M. Dirks and N.A. Pierce, Triggered amplification by hybridization chain reaction, Proceedings of the National Academy of Sciences of the United States of America 101 (2004), no. 43, 15275.
-  David Doty, personal communication, 2012.
-  David Doty, Lila Kari, and Benoît Masson, Negative interactions in irreversible self-assembly, Algorithmica, to appear. Preliminary version appeared in DNA 2010.
-  David Doty, Matthew J. Patitz, and Scott M. Summers, Limitations of self-assembly at temperature 1, Theoretical Computer Science 412 (2011), 145–158.
-  M.Y. Kao and R. Schweller, Randomized self-assembly for approximate shapes, Automata, Languages and Programming (2008), 370–384.
-  James I. Lathrop, Jack H. Lutz, and Scott M. Summers, Strict self-assembly of discrete Sierpinski triangles, Theoretical Computer Science 410 (2009), 384–405.
-  F. Liu, R. Sha, and N.C. Seeman, Modifying the surface features of two-dimensional DNA crystals, J. Am. Chem. Soc 121 (1999), no. 5, 917–922.
-  W. Liu, H. Zhong, R. Wang, and N.C. Seeman, Crystalline Two-Dimensional DNA-Origami arrays, Angewandte Chemie International Edition 50 (2011), no. 1, 264–267.
-  K. Lund, A.J. Manzo, N. Dabby, N. Michelotti, A. Johnson-Buck, J. Nangreave, S. Taylor, R. Pei, M.N. Stojanovic, and N.G. Walter, Molecular robots guided by prescriptive landscapes, Nature 465 (2010), no. 7295, 206–210.
-  U. Majumder, T.H. LaBean, and J.H. Reif, Activatable tiles: Compact, robust programmable assembly and other applications, Proceedings of the 13th international conference on DNA computing, 2007, pp. 15–25.
-  T. Omabegho, R. Sha, and N.C. Seeman, A bipedal DNA brownian motor with coordinated legs, Science 324 (2009), no. 5923, 67.
-  J.E. Padilla, W. Liu, and N.C. Seeman, Hierarchical self assembly of patterns from the Robinson tilings: DNA tile design in an enhanced tile assembly model, Natural Computing 11 (2012), 323–338.
-  Matthew J. Patitz and Scott M. Summers, Self-assembly of discrete self-similar fractals, Natural Computing 9 (2010), 135–172.
-  , Self-assembly of decidable sets, Natural Computing 10 (2011), 853–877.
-  L. Qian and E. Winfree, A simple dna gate motif for synthesizing large-scale circuits, Journal of The Royal Society Interface 8 (2011), no. 62, 1281–1297.
-  Paul W. K. Rothemund and Erik Winfree, The program-size complexity of self-assembled squares (extended abstract), STOC ’00: Proceedings of the thirty-second annual ACM Symposium on Theory of Computing (Portland, Oregon, United States), ACM, 2000, pp. 459–468.
-  Paul W.K. Rothemund, Nick Papadakis, and Erik Winfree, Algorithmic self-assembly of DNA Sierpinski triangles, PLoS Biology 2 (2004), no. 12, 2041–2053.
-  P.W.K. Rothemund, Folding DNA to create nanoscale shapes and patterns, Nature 440 (2006), no. 7082, 297–302.
-  Robert Schweller and Michael Sherman, Fuel efficient computation in passive self-assembly, Proceedings of the 24th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2013) (New Orleans, Louisiana), 2013, to appear.
-  G. Seelig, D. Soloveichik, D.Y. Zhang, and E. Winfree, Enzyme-free nucleic acid logic circuits, science 314 (2006), no. 5805, 1585.
-  D. Soloveichik and E. Winfree, Complexity of self-assembled shapes, SIAM Journal on Computing 36 (2007), no. 6, 1544–1569.
-  H. Wang, Proving theorems by pattern recognition II,, AT&T Bell Labs Tech. J 40 (1961), 1–41.
-  S.F.J. Wickham, M. Endo, Y. Katsuda, K. Hidaka, J. Bath, H. Sugiyama, and A.J. Turberfield, Direct observation of stepwise movement of a synthetic molecular transporter, Nature Nanotechnology 6 (2011), no. 3, 166–169.
-  E. Winfree, Algorithmic self-assembly of DNA, Ph.D. thesis, California Institute of Technology, June 1998.
-  E. Winfree, F. Liu, L.A. Wenzler, and N.C. Seeman, Design and self-assembly of two-dimensional DNA crystals, Nature 394 (1998), no. 6693, 539–544.
-  P. Yin, H.M.T. Choi, C.R. Calvert, and N.A. Pierce, Programming biomolecular self-assembly pathways, Nature 451 (2008), no. 7176, 318–322.
-  B. Yurke, A.J. Turberfield, A.P. Mills, F.C. Simmel, and J.L. Neumann, A DNA-fuelled molecular machine made of DNA, Nature 406 (2000), no. 6796, 605–608.
-  D.Y. Zhang and G. Seelig, Dynamic DNA nanotechnology using strand-displacement reactions, Nature Chemistry 3 (2011), no. 2, 103–113.