Implementing a Theoretician’s Toolkit for Self-Assembly with DNA Components

Abstract

A diverse array of theoretical models of DNA-based self-assembling systems have been proposed and studied. Beyond providing simplified abstractions in which to develop designs for molecular implementation, these models provide platforms to explore powers and limitations of self-assembling systems “in the limit” and to compare the relative strengths and weaknesses of systems and components of varying capabilities and constraints. As these models often intentionally overlook many types of errors encountered in physical implementations, the constructions can provide a road map for the possibilities of systems in which errors are controlled with ever greater precision. In this article, we discuss several such models, current work toward physical implementations, and potential future work that could help lead engineered systems further down the road to the full potential of self-assembling systems based on DNA nanotechnology.

1 Introduction

Beginning as a branch of mathematics, computer science is fundamentally focused on understanding the process of “computing” and how it can be embodied in physical systems. Mainstream studies largely focus on digital computers, composed of electronic circuits operating on Boolean logic. However, the underlying concepts of processing and transforming information via specified rules, or algorithms, can also be realized in many other formats (e.g., analog computing devices [1], quantum computers [2], etc.), including natural systems that provide continued inspiration for novel directions in engineering (such as information processing networks in cells [3]).

At the foundation of computational theory is the existence of “universal computers,” which are computing devices capable of running any possible program. These allow for the design of systems which can be given input in the form of an arbitrary program along with arbitrary data to be given to that program and which output the result of running the input program on the input data. This is in contrast to having to design a specific computer for each program that one wants to run and provides for an immense diversity of programmable behavior for such systems.

Relatively quickly after the structure of DNA was revealed [4] and its basic properties began to be understood, computer scientists started to see its potential as a programmable substrate [5,6,7] which could yield additional directions in computing. Harnessing the combinatorial powers of DNA molecules opened the door for engineered computing at the nanoscale. While biology utilizes DNA as an information storage medium, scientists and engineers began to see its potential as a structural component (e.g., [8,9,10,11]) and a platform for computing (e.g., [12,13,14]). This has enabled the design of systems whose target behaviors and outputs include structure building and computing, and through a combination of those, interfacing with chemical and biological systems to process information about them and/or to generate output that becomes integrated within them [15,16,17].

Self-assembling systems are systems composed of relatively simple components which begin in a disorganized state and autonomously combine to form more complex structures. There are already many different approaches to realizing DNA-based self-assembling systems as platforms for structure building guided by computation, and one job of theoreticians has been to abstractly model them and to determine, in their mathematical limits, the strengths and weaknesses of each, especially as compared to each other. This includes an emphasis on those which may have more viable molecular implementations, and an additional aim has been to search for techniques which can be used to circumvent or at least minimize errors that occur in physical implementations (i.e., behaviors that deviate from those predicted by the high-level mathematical abstractions). In this paper, we seek to outline several of the key aspects of various abstract models of DNA-based self-assembling systems that have been studied and discuss the theoretical pros and cons they provide as well as the current, and potential future, development of DNA-based systems capable of implementing them. The continued growth of both the theoretical and experimental sides of DNA nanotechnology, with each relying upon the other for insights and direction, can lead to the implementation of more complex and diverse systems that more fully realize the theoretical potential of self-assembling systems.

To cover the wide diversity of models and techniques that have been explored, this paper is organized as follows. In Sect. 2, we cover some preliminary definitions, and in Sect. 3, we define some of the main metrics often used for comparison across models and systems. In Sect. 4, we discuss one spectrum across which systems may vary, that of how many times copies of each individual component type appear in a self-assembled structure, and demonstrate ways in which trade-offs in different metrics occur across that spectrum. In Sect. 5, we discuss a wide variety of methods that can be used to provide the input to a self-assembling system and direct its output and demonstrate ways in which those methods have been implemented and their corresponding trade-offs as well as current technical limitations. In Sect. 6, we cover a set of varying dynamical behaviors that systems and/or individual components of systems may have, and how those behaviors can influence the powers and limitations of the systems, as well as current experimental implementations and potential future implementations that may more fully realize the powers provided those dynamical behaviors. Finally, in Sect. 7 we provide a brief summary and our optimism for the future of this area.

2 Definitions and Notation

In this section, we introduce a few basic definitions and some of the notation used throughout the following sections.

Fig. 1

Schematic depiction of an example (square) tile. Each glue (a.k.a. binding domain) is represented by the text label and black rectangle(s) on one side. The number of black rectangles corresponds to the integer-valued strength of the glue. The north (i.e., top) side has a strength 1 glue of type a, the east (i.e., right) side has a strength 2 glue of type b, the south (i.e., bottom) side has no glue (or the null glue), and the west (i.e., left) side has a strength 2 glue of type $c'$. The entire tile has the label D

An individual building block of a self-assembling system will be referred to as a tile, or sometimes as a monomer. Although a tile actually represents a component made out of one or more strands of DNA, for most of the theoretical models we will be discussing they will be abstractly represented as two-dimensional squares (or three-dimensional cubes in a few cases). An example schematic depiction of a tile can be seen in Fig. 1.

Tiles are able to attach to each other via glues on their sides. A glue is an abstraction of a binding domain, which is typically a single-stranded portion of DNA that is free to bind to a strand containing the complementary sequence. Although the overall strength of binding of two complementary strands of DNA is highly dependent upon several factors (e.g., the specific sequences, their lengths, and the number of Gs and Cs as opposed to As and Ts), a common design goal is to create categories of binding domains which have very similar attachment strengths to all other binding domains within the same category. For this reason, it is possible in the abstract, mathematical models to instead refer to glues by their categories. Therefore, we will equate each strength category with a natural number and call a glue a “strength 1,” or “strength 2” glue, for instance. Strength 1 glues can be thought of as those whose binding strengths (with their complementary domains) are approximately equivalent to some system-specific basic, standard value. Strength 2 glues can be thought of as having approximately double that binding strength. As an additional abstraction, rather than referring to specific DNA sequences for glues, we will give each glue a text label. (e.g., in Fig. 1, the north glue has label a and strength 1.) A glue binds to its complement, and the complement of a glue label is represented with the prime character, e.g., the complement to a is $a'$.

An entire tile may also be assigned a label (e.g., D for the tile in Fig. 1). Such a label is non-functional as far as the tile’s binding to other tiles, but can be used to categorize the tile and potentially represent some sort of marking on, or functionalization of, the tile. For example, tiles labeled with a 1 could have an attached molecule that makes them distinguishable during imaging from tiles labeled with 0 that have no such attached molecule. In this way, a readable pattern may be formed in an assembly by tiles labeled 1 and 0.

Since we are focusing on systems which build structures, we will call the desired output of a system the target structure (or target assembly). Typically, there is a target shape that defines the two- or three-dimensional shape of the target structure.

3 Metrics

If models, and systems within them, are to be measured against each other, there must be metrics on which to base the comparisons. There are several such metrics by which self-assembling systems can be measured. While accuracy in producing the desired output and robustness to environmental conditions are of great importance, several other metrics may influence important aspects, such as the feasibility of implementation.

We now define four metrics that we will focus on during our comparisons of models:

• 1. Tile complexity: the number of unique tile types required, i.e., the number of unique kinds of monomers that serve as building blocks in a particular system. This is a measure of the amount of monomer reuse that is achieved and is discussed at greater length in Sect. 4.

• 2. Monomer complexity: in general, the (maximum) size of individual monomer types. This is based upon the length and number of strands composing a single monomer type. Complexity may also more generally be derived from requirements for complex shapes, rigidity, or dynamic behavior, as well as the difficulty of fabrication (i.e., the number of experimental steps required for their production).

• 3. Resolution: the physical dimensions of a single coordinate location in the target shape (i.e., given the set of coordinates for the target shape’s voxels, how large is the volume of each in the actual target structure). It is often the case that, somewhat counterintuitively, constructions in theoretical models can be shown to be more efficient (sometimes even achieving mathematically provably the greatest possible efficiency) in tile complexity by generating “scaled up” versions of 2D (resp. 3D) target shapes in which each pixel (resp. voxel) is replaced by a square (resp. cube) of potentially many tiles. (See Fig. 2 for an example.)

• 4. Addressability: the ability to uniquely address locations in the target structure with specific binding domains. For many applications, greater specificity in the ability to address unique locations of the target structure is desired, since such locations can be used to precisely place molecules linked to the DNA strands.

4 Monomer Reuse: Hard-Coded Versus Algorithmic

A major design consideration for self-assembling systems deals with monomer reuse. For instance, in a system of self-assembling tiles, given the set of tile types, how many times does a tile of each type appear in the target structure? In this section, we investigate theoretical models and experimental implementations that vary greatly in monomer reuse and discuss related trade-offs and potential future directions.

Fig. 2

(Left) Example shape S, (middle) S pixelated and at scale factor 1, (right) S at scale factor 2

On one end of the spectrum, each type appears only one time in the target structure. We refer to such structures as hard-coded, a.k.a. uniquely addressed, and note that this paradigm has been successfully experimentally employed in both DNA origami [9] and DNA bricks [8]. (See Fig. 3a for an abstract example.) The advantages of such systems include excellent addressability as well as robustness to some of the types of errors seen with monomer reuse (see Sect. 6.1). Disadvantages include maximal tile complexity and that the size of a target assembly is limited by the number and size of unique monomer types which can be created and utilized. For instance, in DNA origami one long DNA strand, referred to as the scaffold strand, winds through the entire structure and is bent into the target shape by many short staple strands that each bind to approximately two or three short sections of the scaffold strand, bringing and holding these distant parts closer together to eventually form the final shape. With the size of a DNA origami structure determined by the length of its scaffold strand, the design of custom scaffold strands (as opposed to the original standard scaffold strand, the M13mp18 bacteriophage’s genome) becomes important. Much progress is being made in this area [18,19,20], allowing for both smaller scaffolds, with only a few hundred nucleotides, and much larger scaffolds, with over 50,000. Continued improvements to allow greater diversity in scaffold sequences and lengths will further increase the range of structures producible via DNA origami.

Fig. 3

Depiction of hard-coded assembly versus algorithmic assembly

Fig. 4

Examples of periodic structures, including a a grid of square tiles and b, c lattices formed by abstract non-square monomers

One alternative to hard-coded structures is the generation of (theoretically) unbounded periodic structures. In this case, each monomer type is reused arbitrarily often in a repeating pattern (see [21, 22] for experimental examples and Fig. 4 for abstract examples). Advantages of such systems include theoretically unbounded sizes for target structures, potentially low tile complexity, and robustness to nucleation errors (since it is valid for growth to begin from any location, see Sect. 6.1) and growth errors (see Sect. 6.1). However, disadvantages include limited addressability (restricted to periodically repeating locations) and growth of uncontrolled numbers of copies relatively simple structures.

An additional alternative is algorithmic growth in which individual monomer types may be used arbitrarily often (even in a possibly aperiodic manner) in each target assembly, as the attachment of each implicitly follows the rules of a designated algorithm. (See Fig. 3b for a basic example and Fig. 5 for a more complex example.) Advantages include the ability to (theoretically) create assemblies of arbitrary but bounded size using mathematically optimal tile complexity. Using information theoretic and computational complexity arguments, it has been proven that algorithmic self-assembly systems in the aTAM are capable of universal computation [6], can achieve mathematically optimal tile complexities for systems constructing squares [23] and scaled versions of arbitrary finite shapes [24], and even include systems capable of universally simulating all other systems [25]. For instance, Fig. 3c shows a zoomed out image of a $100 \times 100$ square which self-assembled using an efficient algorithm for counting and filling. The green row is made up of 7 unique tile types, the yellow portion of only another 14, and the entire gray portion of only 6 unique tile types. The algorithm used to create the system can take an arbitrary positive integer n as input and output a system that self-assembles an $n \times n$ square using $\log (n) + 14 + 6$ tile types, where the same 14 yellow and 6 gray tiles are used for all values of n, and an n-specific set of $\log (n)$ green tiles are used to encode a number related to n. The green tiles assemble into a row to which the 14 yellow tiles attach and execute the binary counting algorithm to grow to the necessary height, allowing the 6 gray “filler” tiles to fill in the rest of the square to precisely the dimensions $n \times n$. While this construction uses approximately $\log (n)$ tile types for arbitrarily large n, in [26] it was shown that this can be improved to $\Theta \left( \frac{\log (n)}{\log (\log (n))}\right)$, which was also shown to be the mathematical lower bound [23] for almost all values of n. Note that this is an exponential improvement over a hard-coded assembly, which even in the case of the $100 \times 100$ square, for example, would require 10, 000 unique tile types, rather than the 27 used here.

Disadvantages of algorithmic self-assembly include restricted addressability and, quite importantly, the potential for various types of errors to occur. It has been shown that for algorithmic growth to occur, some form of cooperation (see Sect. 6.1) is required, and this can lead to errors like those discussed in Sect. 6.1. Furthermore, several theoretical results require large scaling of shapes (see Sect. 3 for the definition, and an example, of a scaled shape). In some constructions, the scale factor is quite large, so each point of the shape requires a relatively large volume and is filled by a large number of tiles, with that number often depending upon, and growing with the size of, the specific target shape. This can also require tile sets that are significantly larger than can be currently successfully implemented.

Developing large tile sets which self-assemble with few errors requires the design of large sets of orthogonal glue domains (i.e., sets of domains such that each has a strong affinity for its complementary domain, but very weak affinity with all others). The number of possible domains of any given length n (i.e., composed of n bases) is bounded by $4^n$ (since there are 4 bases to choose from in each location), but only a subset of those can be selected so that (1) they are orthogonal, and (2) the binding affinities of all complementary pairs are very nearly equivalent. The second condition is important so that all glues have similar behaviors and becomes even more important if glues in different theoretical strength categories are to be implemented (see Sect. 6.1). Additionally, as glue domains are forced to become longer to accommodate larger sets of glues, the potential for non-orthogonal interactions increases (i.e., glue domains may have positive binding affinities for domains other than their complements). Other commonly considered criteria include ensuring that sequences have minimal “self-structure” (i.e., they do not have a tendency for some subsequences to bind to other subsequences on the same strand), avoiding G-tetraplexes (i.e., sequences of 4 Gs in a row), etc. Work has been done to create models that predict domain interactions and software that can perform automated design and theoretical testing of glue sets based on mathematical models of DNA strand interactions [27,28,29,30,31,32]. However, additional enhancements and extensions to this so-called sequence design process for glue domains has the potential to greatly improve the size and quality of glue domain sets and therefore the sizes of tile sets which can be successfully implemented.

5 Inputs

In this section, we discuss various methods of providing input to self-assembling systems and theoretical models and experimental implementations that utilize them. The goal is to understand different ways of controlling self-assembling systems and how we can improve that control in the future.

We can think of the monomers of the system as representing the instructions of the program to be executed. On the one hand, we can design deterministic systems which are non-programmable, in which we mean that (within a valid range of environmental parameters) the system is designed to always produce the same output, i.e., structure, regardless of any (reasonable) variations in the environment. That is, the environment does not provide meaningful input to the system and the same “program” is always “executed”. On the other hand, systems may be designed so that there is some environmental variable which can be tuned, with each setting yielding a distinct output. There are many techniques for providing input to self-assembling systems, and we now describe a few of them.

5.1 Seed Assemblies

A frequently utilized input technique is the use of a seed assembly. A seed assembly is a variable, preformed structure that is added to the system in addition to a constant set of monomer types. In theoretical models such as the abstract Tile Assembly Model (aTAM) [6], there are computationally universal systems each consisting of a single, constant set of “universal” tile types such that for every possible program and input data pair, a seed assembly encoding that program and input data can be added to a solution containing those universal tiles, causing the system to build a representation of the computation of that program on that input data. Furthermore, that computation can also determine the resulting shape of the self-assembled structure. In such a scenario, the seed assembly is incorporated into the target assembly and provides the input that determines its resultant shape and/or pattern. As an example, see Fig. 5 where an aTAM tile set is shown, as well as assemblies that self-assemble from two different seeds. In this aTAM example, the binding threshold (a.k.a. temperature) parameter is set to 2, meaning that tiles only attach to the seed, or the assembly containing the seed, if they can bind with at least one strength 2 glue, or two strength 1 glues. (See Sect. 6.1 for additional details.) Due to the binding threshold and the glue patterns, the assemblies that grow from each seed vary in size.

Current methods of experimentally implementing seed assemblies include using DNA origami as seeds with the tiles being either single-stranded or multi-stranded complexes that attach to, and grow away from, the origami seed [10, 28], or even just a single strand which serves as the seed for nucleation of growth [33].

Fig. 5

Example aTAM systems that use the same tile set but different seeds to provide inputs which yield differing assemblies

Variants on the use of a seed assembly are also possible. For instance, a seed assembly could instead serve as a template to be filled in by the tiles (which later detach from it), or as a template of a shape to be replicated. However, using seed assemblies in such ways requires additional dynamics by which the target structures can be separated from the seed assemblies (see Sect. 6).

5.2 Tile Subsets

The variable input to a system could instead be the selection of only a specific subset of tile types from a larger set. In this case, a large set of tile types is designed and synthesized, and then for each particular target assembly, a specific subset is selected and added to the solution. This technique can be utilized to make target structures which are subsets of a larger structure, as in the DNA brick technique [8], or to select specific sequences of program instructions to be carried out from a generic set [28]. A disadvantage of this approach is the potential for large tile complexity, and an advantage is that simple selection and mixing of the necessary subset of types is sufficient to produce any of the potential systems.

5.3 Monomer Concentrations

Rather than strictly varying the monomers in a system in a binary way (i.e., they are either present or not), instead their relative concentrations can be varied. This technique, known as concentration programming, has been shown to allow for great tuning in a set of theoretical results [34, 35], so that by only varying tile concentrations, any finite shape can be targeted while using a constant tile set. However, not only does this require scaling of the target shape and thus a loss in resolution, a source of great difficulty with experimental implementations of this approach is the precision required for very fine-tuned relative concentrations of tiles. Modern equipment capable of mixing nanoliters of fluid is allowing finer control of concentrations, and it may be feasible in the future to realize more of the potential of concentration programming.

5.4 Programmed Temperature Fluctuations

In systems of tile-based self-assembly where each tile is composed of multiple strands of DNA, common laboratory protocol involves a single-pot system with annealing, where the individual strands are put into a solution that is first brought to a high enough temperature to ensure complete dissociation of strands. Then, the solution is cooled to a temperature where the bonds between the individual strands comprising each tile are strong enough to allow for the formation of the tile complexes, but the binding domains that would bind tiles to each other are not strong enough to form long-lasting bonds. After holding at that temperature for a period of time that ensures most strands will be incorporated in tiles, the temperature is further lowered to a point at which tiles can bind to each other.

Another theoretically powerful method of supplying input to a self-assembling system is to vary the temperature of the system through a series of prescribed temperatures, both raising and lowering it multiple times. This can allow periods of growth followed by periods of melting, which may remove some tiles and create favorable locations for different types of tiles in the same locations during periods of lowered temperatures. Theoretical modeling of this procedure, known as temperature programming [36], has been shown to allow for a constant tile set that can be programmed, via only temperature change sequences, to form any finite shape [37]. Trade-offs can be made between the number of temperature changes required to direct growth of a target shape versus the resolution of the shape. However, physical implementations have not yet been achieved due to the difficulty of designing binding domains and systems with enough granularity to correctly bind and/or dissociate across a wide enough set of temperature levels.

Future advancements in sequence design that allow for the development of glue domains that exhibit fine enough granularity in binding strengths to support multiple discrete levels of binding and melting (possibly combined with novel tile designs) may allow temperature programming to become a useful tool.

Fig. 6

Example staged assembly system. Individual tiles are added to the top tubes in the first stage, then assemblies from the top tubes are mixed for the next stage, etc.

5.5 Staged Assembly

The number of experimental steps required to implement a self-assembling system can vary greatly. Single-pot single-stage systems exist where a set of strands is added to solution, all in one test tube, which is first heated and then annealed, and the target structures completely form during that process. Alternatively, systems exist in which multiple products are made in different tubes, then the products of subsets of those tubes are combined together (with each mixing process and then the simultaneous self-assembly processes in the separate tubes considered a “stage”), and the number of stages can be quite large. (A simple example is shown in Fig. 6.) The simplicity of single-pot single-stage systems is beneficial from an experimental perspective, but in the theoretical Staged Tile Assembly Model [38, 39] it has been shown that tile complexity can be exchanged for stage complexity. That is, the number of tile types required to build shapes can be dramatically reduced (even down to a constant tile set for an infinite set of shapes) by increasing the number of stages. Experimental work which combines staged assembly and hierarchical growth (see Sect. 6.2) has also demonstrated the great power of this paradigm [40].

Combined with methods that cause tile detachments as well (see Sect. 6.4), theoretical results in staged assembly have shown the possibility for new system behaviors such as the replication of input shapes or patterns [41,42,43] or the marking of input assemblies that match specific shapes [44].

The theoretical benefits of staged assembly come with a high cost on the experimental side. First, there is the additional work of carefully, uniquely mixing the inputs to each tube of each stage. Although this can be made much easier by automation, it then becomes difficult to first know how long the self-assembly at each stage should be allowed to proceed and second to extract only the correctly completed products of each tube of each stage for further mixing. Theoretical work has been done to study staged assembly systems in which the correctly completed products of each tube have maximal size difference from all others [45], but this technique (and those which effectively realize the tile complexity benefits of staged assembly) requires use of hierarchical assembly (see Sect. 6.2). Future work that realizes the full theoretical benefits of staged assembly would require improvements in purification techniques to make it easier to select only correctly completed products from each stage, as well as improved design and control of hierarchically self-assembling systems.

6 Dynamics

In this section, we investigate the consequences of a variety of changes to the dynamical behaviors allowed by different models and/or tile designs. By categorizing a variety of dynamical behaviors and demonstrating their powers in theoretical models, and also discussing experimental work that has begun to implement several, we hope to provide a road map for future work that can further realize the powers offered by these behaviors while effectively balancing the trade-offs.

6.1 Cooperativity

It was long speculated [23, 46] and recently proven [47] that algorithmic self-assembly cannot occur in the aTAM without behavior known as cooperation. Typically, we say a tile attaches to an assembly using cooperation when its initial binding to that assembly requires it to form bonds with more than one tile that is already part of that assembly. Note that biochemistry literature sometimes uses the term avidity to refer to the same concept. We can consider the binding domains which initially bind when a tile attaches as its “input” domains and the remaining domains (which may later serve to allow for the binding of additional tiles) as “output” domains. Intuitively, cooperation forces the attaching tile to “read” information from two separate tiles via their output domains, and careful design of the tile types of a system can ensure that the information encoded in the output domains of tiles represents specific logical transformations of the input information (e.g., the output domains could encode the bit resulting from the logical AND operation performed on the bits represented by the input domains, as shown in Fig. 7). It has been shown that for an arbitrary program, it is possible to design a set of tile types such that they are forced, in the theoretical setting, to self-assemble in a pattern that follows the execution of that program [6].

Fig. 7

Example of cooperative tile attachment: On the left is an assembly consisting of three tiles that make a “corner” which allows for cooperative attachment of a tile that matches the two glues labeled “1” and “0”. On the right, four tiles implementing AND logic (with input glues on the left and bottom and outputs on the top and right). Only the tile labeled “10” can cooperatively attach to the assembly

In the aTAM [6], the requirement for cooperative binding is captured by a system parameter called the temperature, which is physically based upon factors such as the temperature of the system as well as the concentration of tile monomers. This temperature parameter is also commonly referred to as the binding threshold, and in the discrete formalization of the aTAM, it is commonly set as either 1 or 2. A value of 1 means that the binding of a single input domain is always sufficient to allow a tile to “permanently” attach to a growing assembly. A value of 2 means that either at least two input domains must correctly bind, or a single input domain of at least double strength (i.e., a strength 2 glue) must bind for a tile to attach. The theoretical power of aTAM systems with the temperature parameter equal to 2 has been proven to be quite impressive, including algorithmic self-assembly capable of the natural simulation of any possible program, the self-assembly of structures using mathematically minimal tile complexity, etc.

Fig. 8

Example of a tile binding with a glue mismatch, leading to an algorithmic error. On the left, a set of “computing” tiles. On the right, an assembly to which the green tile (but no other) can bind with strength 2 (which happens on the bottom path). On the top path, the yellow tile binds with strength 1 and a mismatched glue. Before it detaches (due to weak binding), another tile may bind and “lock in” the algorithmic error

Unfortunately, the physical reality (as it often does) differs from the theoretical model and sometimes experimental systems designed to behave as temperature 2 aTAM systems do not behave as such. In some cases, tile attachments occur in which tiles “temporarily” bind via a single strength 1 glue and the glue in the location intended to be the second input has an incorrect, “mismatching” glue domain which does not bind (or does so only partially, with low strength). (See Fig. 8 for an example.) Although such attachments are not expected to last long, with some nonzero probability a neighboring location may receive a tile which binds to the “erroneous” tile with one of its input domains, causing both tiles to be attached to the assembly and each other with enough binding strength to be “permanent”. We will call this a growth error, and in such a case, the erroneous tile may corrupt the computation being performed and cause the algorithmic growth to proceed incorrectly. This type of behavior is captured in the more physically realistic kinetic Tile Assembly Model [6], a.k.a. kTAM, and kTAM modeling has helped lead to several proofreading and error suppression techniques (where errors are considered to be tile attachments that differ from the expected tile attachments in the aTAM) that have been developed to reduce the prevalence of such errors [48,49,50,51,52]. It is notable that aTAM behavior can be approximated arbitrarily closely by the kTAM, and careful control of temperature and tile concentrations along with proofreading can help to the extent that the incidence of such errors in experimental systems has been decreased to around $0.017\%$ [53] (or to $0.03\%$ for larger tile sets [28]). However, even those seemingly excellent rates are still be too high for accurate algorithmic growth of even moderately complex (from a theoretical perspective) systems.

Cooperation has been shown to be necessary for algorithmic self-assembly, but it has also been proven that there are methods of cooperation other than the specific “glue cooperativity” already discussed. Other ways of causing the attachment of a tile to depend on two or more others, called weak cooperativity [54], have been shown in theoretical results using geometric hindrance [55, 56] and repulsive forces [57, 58]. To utilize geometric hindrance, theoretical systems with the parameter temperature set to 1 can be designed where tiles have shapes other than squares [55, 59, 60] (or in addition to squares [56]) so that the tiles that can correctly bind into a location are selected by matching a single glue for binding as well as having a complementary geometric shape (serving as the second input) that matches the second input location. To utilize repulsive forces, instead of relying on a complementary geometry as the second input, tile design can include the specific placement of a tile element which will experience a repulsive force when adjacent to another instance of that element on a neighboring tile. In this way, only a tile of a type which does not cause repulsive elements to align will be able to bind into a new location.

While the aforementioned methods of weak cooperation provide a perhaps stronger barrier to growth errors that can occur using glue cooperation, by actively preventing incorrect tile binding rather than simply not favoring it, another problem arises in temperature 1 systems. This problem, known as spurious nucleation, stems from the fact that in a temperature 1 system, all glue bonds are individually enough to cause two tiles to bind. Algorithmic self-assembly requires growth to begin from a very particular state, usually from either a seed assembly (see Sect. 5.1) which is large enough to provide a location where one or more tiles can bind via two attachments to it, or a set of “hard-coded” input tiles that can bind to each other via sufficiently strong bonds to form an assembly that can then function like a larger seed assembly. From a carefully defined input and using cooperative attachments, tiles of relatively few different types can combine in complex algorithmic patterns with many copies of each tile type appearing throughout the growing assembly. However, in a temperature 1 system, growth can be initiated apart from any seed assembly with pairs of tiles “nucleating” growth that can then proceed to follow patterns corresponding to arbitrary subsets of algorithmic growth continuing from random inputs. This spuriously nucleated, unstructured algorithmic growth leads to the formation of “junk” structures and is therefore a fatal flaw for such systems. Great experimental work using cooperativity to control nucleation has been done in [61], and a schematic representation of their results (using both single-stranded DNA tiles and DNA origami-based tiles) is shown in Fig. 9. By using two planes in the third dimension, the “crisscross slat” tiles are able to extend further than square tiles and bind to a greater number of neighboring slats when attaching. Future work leveraging such expanded cooperative growth to prevent spurious nucleation, especially across wider temperature ranges, may improve the ability to control seeding in algorithmic systems.

Fig. 9

Crisscross slat tiles (green and blue rectangles) assembling with a binding threshold of 6, which enforces high levels of cooperativity. Binding domains are shown as small colored squares (and although they are actually on the side of the green slats facing the blue slats, they are shown for clarity). Each attaching slat must bind to at least 6 others. The empty horizontal outline shows where the next slat attachment is possible, and the vertical outline shows where there will then be 6 domains allowing for the attachment of the following slat, leading to a new location for a horizontal slat, etc.

Although “temperature 2” growth in experimental systems using glue cooperation helps restrict algorithmic growth to beginning from designated seeds, it requires careful design of glue domain strengths and careful control of actual system temperature and tile concentrations. Even so, these systems still suffer from growth errors, even after previously mentioned proofreading techniques are incorporated. Additionally, while weakly cooperative temperature 1 systems also allow for algorithmic growth and have the potential for reducing growth errors by more actively preventing attachments of incorrect tiles, they instead suffer more greatly from the problem of spurious nucleation. In order to realize the full potential of algorithmic self-assembly, systems designed to incorporate both types of cooperative behavior may be useful. For instance, if tile motifs could be designed such that geometric hindrance occurs in the case of glue mismatches while also providing glues to be used for glue cooperation enforced by temperature 2, future designs utilizing DNA origami-based tiles (e.g., [62]), or perhaps clever designs of smaller complexes, may have the potential to move forward the state of the art in algorithmic self-assembly. Additionally, experimental implementation of temperature 2 growth requires either “double-sized tiles” (such as in [10] where double-sized tiles are effectively two square tiles permanently bound together, allowing growth to extend outward from one row of growth into a new row) or the design of sets of glues with carefully separated groups representing strength 1 and strength 2 glues (as previously discussed in Sect. 5.1), and advances in sequence design would help in this effort. Yet another potential direction for advancement may come from further development of proofreading techniques and error suppression mechanisms, which have already proven to be very useful.

6.2 Single Tile or Hierarchical Growth

The aTAM and models derived from it are based on dynamics of single-tile attachment, i.e., at each step of the assembly process, a single-tile monomer attaches to a growing assembly. An alternative to this allows assemblies of arbitrary size (i.e., composed of arbitrary numbers of individual tiles) to combine with each other. This is often modeled as hierarchical assembly in which a system begins self-assembly from a collection of individual “singleton” tiles which can combine with each other in pairs, and then those assemblies can combine with each other, etc., allowing up to a doubling of assembly size with each combination. A commonly studied theoretical model of this process is called the Two-Handed Assembly Model (2HAM) as it is based upon the intuition that one already produced assembly could be taken in each hand, and the pair could then be combined to form a new, larger assembly.

Hierarchical assembly occurs in biology (i.e., the constituent pieces of amino acids combine, then those amino acids are combined to form proteins, and the proteins then combine to form cellular structures) and has even been cleverly demonstrated in DNA-based experimental systems (e.g., [40, 63, 64]). Theoretical work has shown that, in general, 2HAM systems are capable of making a greater diversity of structures and utilizing lower tile complexity than systems in the aTAM [65]. However, somewhat counterintuitively, in [66] it was proven that (under physically realistic assumptions based on molecular counts applied to the abstract 2HAM) no asymptotic speedup is actually achievable over single-tile growth. Nonetheless, the 2HAM remains a very interesting model in which the dynamics allow for the theoretical designs of systems which efficiently (in terms of tile complexity) produce complex shapes. System design in these theoretical constructions tends to make heavy use of geometric hindrance, where the interfaces along which pairs of assemblies may bind have carefully designed patterns of “bumps” and “dents” that allow for great discrimination between which pairs of assemblies can bind to each other, while allowing the numbers of unique glue domains to remain very low (often a relatively small constant number across constructions capable of targeting any particular structure among an infinite collection). This has been demonstrated in theoretical results [67,68,69] as well as experimentally [62, 63, 70] (Fig. 10).

Fig. 10

Abstract example of hierarchical assembly (showing a portion of the infinite Robinson tiling pattern). From left to right, smaller assemblies combine to form larger assemblies, which then combine with each other to form the next hierarchical level

For future experimental work to implement additional theoretical constructions, a wide variety of improvements will most likely be necessary. To leverage the use of geometric hindrance, it will be necessary for assemblies to remain rigid, at least along binding surfaces, but in many constructions those interfaces may be quite long. Without sufficient rigidity, portions of the assembly which should block the attachment of incorrect assemblies may bend to allow those attachments. Prior experimental work with hierarchical assembly [40] showed a relatively sharp drop-off of the rates of correct completion of steps of the assembly process. This seriously restricts the potential complexity of designed systems and efforts to improve that would be valuable. For instance, as the previously mentioned theoretical work of [66] showed, a roadblock to the assembly of later steps can be the multitude of assemblies of earlier steps (complete and/or incomplete) that simultaneously exist in solution. As steps progress, the number of assembly types, or species, quickly grows since not all growth progresses at the same rate, and this makes the likelihood of a pair of complementary assemblies of a later step encountering each other drop precipitously. Future improvements in the ability to relatively quickly, easily, and correctly purify the products of various steps may allow for a higher concentration of correctly matching assemblies from the same step and allow assembly to progress correctly at higher rates.

6.3 Activatable/Deactivatable Glues

In the aTAM and many similar models, the tiles are “static,” meaning they can be thought of as components whose properties do not change once they bind to an assembly or at any time afterward. However, many DNA-based nanotechnologies are based largely upon dynamic reactions such as strand displacement [71,72,73]. When strand displacement mechanics are incorporated into tile-based self-assembly, it is possible to make tiles whose binding domains turn “on” and “off.” This has been experimentally prototyped [74] and theoretically modeled [75,76,77], with tiles developed such that the binding of one glue on a tile can cause other glue domains on that tile to either become “active” (i.e., they were previously sequestered but then uncovered) or “inactive” (i.e., they go from either bound or able to bind to being sequestered such that they can no longer bind and any bond they previously formed with another tile is broken). See Fig. 11 for an example.

Fig. 11

Example of a “signal-passing” tile in two levels of abstraction. Assembly proceeds from the bottom to the top. On the left, the green tile initially has its left glue partially sequestered, but the unpaired $c'$ domain provides an additional matching domain that allows it to bind more favorably with the glue on the yellow tile. That causes the previously bound strand to detach, which is then able to bind with the top strand on the right side, exposing the right-side glue. On the right, a further abstraction depicts the same process: The e glue of the green tile is initially “inactive”. When the $c'$ glue binds, it causes the “firing” of the signal which eventually “activates” the e glue

Theoretical constructions with so-called signal-passing tiles have shown that not only can they self-assemble structures whose shapes are impossible to self-assemble with static tiles (e.g., the discrete self-similar fractal called the Sierpinski triangle cannot self-assemble in the aTAM [78], but it can self-assemble using signal-passing tiles [75]), but they can also perform universal computation without requiring the assembly to be as large as the product of the time and space requirements of the computation. That is, with static tiles, all steps of the computation must be permanently represented within the final assembly, so an assembly in which a computation occurs using n bits in each of m computation steps requires $n \cdot m$ tiles to be permanently attached. However, with signal-passing tiles it is possible for the glues of tiles to deactivate after they have participated in a step of a computation and thus for tiles to detach after facilitating a computational step and for assemblies to remain smaller while performing computations. The demonstrated theoretical power of systems of signal-passing tiles is in several ways greater than that of the aTAM, and although many constructions make use of tiles which have high signal complexity (i.e., many signal pathways across the same tile), theoretical work has also shown that by scaling up target shapes [79], signal complexity can often be brought down to only 2 signals, allowing for relatively simple tiles to exhibit the greatly enhanced power of signal passing.

Although some experimental work has been done with signal-passing tiles [74], in that work, only a single signal passed across each tile and glue deactivations were not used. In order to expand the use of signals, larger tile motifs will likely be required, but (small) DNA origami structures could potentially provide a good platform. The process of passing signals from one glue to another when the first binds could be implemented using techniques similar to those of “surface chemical reaction networks” [80,81,82] where strand displacement cascades are used to transmit the signals. Although the complexity of individual tiles implemented in this way would be much greater than simple single-stranded tile (SST) motifs (i.e., tile designs which use a single strand of DNA per tile), if even an additional fraction of the algorithmic control possible with signal-passing tiles could be realized that increased complexity has the potential to be justified. Furthermore, using DNA origami as the tile body also provides the potential for integrating geometric hindrance as a tool, adding even more control and error suppression to algorithmic growth.

6.4 Tile Removal and Breaking of Assemblies

The ability for tiles that previously joined together in an assembly to detach from each other at designated points allows for not only new dynamics but also for new categories of targeted behaviors. For instance, it becomes possible to develop theoretical systems which take as input a structure that already has the desired shape and then to produce assemblies having that same shape [41, 43], or to replicate patterns encoded into assemblies [42, 53]. It also becomes possible to design theoretical systems capable of attaching to the perimeters of input assemblies if and only if they match a particular shape [44]. Experimental work has even succeeded in showing how the fracturing of assemblies can serve as the basis for the replication of patterns [53].

Theoretical models that allow for glue detachment include signal-passing tiles (see Sect. 6.3), the melting of subsets of weaker glue bonds via increased temperatures (see Sect. 5.4), and the dissolution of a subset of tiles within an assembly (for instance, in systems with tiles made of both DNA and RNA, the RNA-based tiles could be dissolved via an RNase enzyme [43]).

Development of systems leveraging the additional possibilities enabled by tile detachment and the breaking apart of assemblies will require overcoming the hurdles discussed for robustly implementing signal-passing tiles or temperature programming, or techniques such as incorporating RNA-based tiles into systems with DNA tiles and successfully dissolving them while leaving the DNA tiles intact. Also, for many of the theoretical constructions, greater control of hierarchical self-assembly will be required.

6.5 Reconfiguration Via Flexibility

When cellular machinery builds the wide variety of proteins encoded by genes, even though only a small number of amino acids are used as the building blocks, the diversity of protein shape and functionality that results are astonishing. Since we know the sequences of the genes and their mappings to the amino acid sequences, it may seem that it should be easy to predict those properties of proteins. However, as amino acids are attached one at a time, the forming chain folds upon itself in a complex three-dimensional pattern influenced by several types of molecular interactions. This process turns out to be computationally intractable to predict in general [83]. In contrast, DNA origami utilizes a rational design approach toward folding which starts with the desired shape to self-assemble and then develops a routing path for a scaffold strand that can then be folded into that path by staple strands.

Fig. 12

Example of an oritatami system, where a chain of “beads” is transcribed, one at a time. (In this case, from a to f.) Each bead type can be designed to be able to form bonds with some subset of other bead types. As beads are transcribed, the chain folds (on the triangular grid, a portion of which is shown in red) to form a maximal number of bonds (shown here as dashed green lines). On the left, the chain has not folded to maximize bonds, but on the right it has

Following nature’s example, a cotranscriptional approach to utilizing folding with tiles based on RNA has been developed [84, 85]. A generalization of this process has been captured in the theoretical model called oritatami [86] (see Fig. 12 for an example), which has been shown to allow for universal computation [87] and have strong shape-building abilities [88]. While RNA seems to be the natural medium for such systems, perhaps some future DNA-based work could use related techniques.

A different approach has been taken by theoretical models [89, 90] which have been developed to at least partially mimic and capture similar folding behaviors, and unsurprisingly, it is intractable to compute most interesting properties of systems in these models, even despite their more discrete nature. For instance, tiles in the Flexible Tile Assembly Model (FTAM) [89] are considered to be rigid bodies, but they are allowed to have flexible bonds with their neighbors. The physical inspiration for the theoretical FTAM is the way that protein folding can allow chains of amino acids to rapidly explore possible configurations and adopt those that are (relatively) optimal. For reconfigurations that are not excessively large, it seems likely that this process of reconfiguration and exploration can proceed more quickly than bimolecular reactions which require the diffusion of new monomers for attachment, and that perhaps even displacement and reconfiguration of previously bound subassemblies may be possible to engineer, enabling shape-changing assemblies (Fig. 13).

Fig. 13

Example of a reconfigurable assembly in the flexible tile assembly model. The glues between square tiles are flexible, similar to hinges, and allow the flat structure on the left to fold into the hollow box on the right

A potential DNA-based implementation could achieve flexible bonds between tiles by including unpaired nucleotides on one or both sides of glues which have bound (with the bound portions forming rigid helices). This could allow for bound tiles or even subassemblies to change positions relative to other portions of an assembly, and thus, it may be possible to design algorithmic self-assembling systems which form reconfigurable assemblies that can be designed to first take one shape and can then reconfigure into a differently shaped assembly by the addition of just a few strands that displace targeted glue strands, or different environmental signals such as the concentration of a particular molecule (like MgCl$_2$ as was demonstrated experimentally in [91]) or pH (as shown experimentally in [92]) (Fig. 14).

Fig. 14

Example CRN whose input is a set of A and B molecules. Each molecular species is denoted by a different letter. Each reaction is specified by a different line. For example, in the first reaction one copy of an A molecule combines with one copy of a B molecule to produce two copies of the X molecule. This CRN computes which input is in the majority. The system evolves to its output by increasing the count of the majority input while decreasing that of the minority input, since the reactant in the majority will be more likely to interact with both the Xs and the other reactant

6.6 Assembly Growth Controlled by CRNs

Chemical reaction networks (CRNs) are composed of sets of reactions, each of which has a set of reactant chemical species that react to produce a set of product chemical species. A set of such reactions which are chained together by having the outputs of one reaction act as the inputs of another can define a network capable of complex behaviors. Theoretical work has shown that arbitrary CRNs can be implemented as sets of DNA complexes [93] and that has led to an entire branch of DNA nanotechnology based upon the design of artificial CRNs, including programming languages that compile digital circuits into DNA complexes [94]. While the goal of such systems is typically centered around the integration of computing logic with chemical and/or biological systems rather than structure building, there has also been research which ties the two together. Although tile assembly can also be described by chemical reactions that model the combination of an assembly and a tile to form a larger assembly, the geometry of the forming structure helps define which tiles may attach. Also, tiles are neither transformed or consumed (at least in models such as the aTAM). More general CRNs do not consider geometry of structures and also allow for reactants to be consumed and/or converted into other species (while perhaps also consuming “fuel” species and creating “waste” species). The combination of DNA-based implementations of these more general CRNs with tile assembly systems (theoretically [95,96,97] and experimentally [98]) provides the ability to have the growth of assemblies controlled by computations performed by a set of general CRN reactions that can be based upon time delays, the presence or lack of specific inputs, or even feedback based on the growth of assemblies themselves by adjusting concentrations and/or counts of tiles used during the assembly process. The “signals” produced by a CRN in this case are global in nature, potentially influencing any or all of the assemblies growing in parallel, while the control provided by the signals of signal-passing tiles (see Sect. 6.3) is local in nature, impacting only the growth of the assembly on which a signal is initiated.

As the development of both DNA-based CRNs and tile-based self-assembly systems continues to mature, there is great potential for control of structure-forming systems by CRNs whose input can be delivered by a wide array of mechanisms, including (but not limited to) the presence of targeted molecules in the environment. Combined with reconfigurable assemblies (see Sect. 6.5), systems could be designed to release cargoes, expose previously sequestered functionalized surfaces, or perform other environmentally responsive behaviors.

7 Conclusion

We have summarized a wide variety of theoretical models of self-assembling systems that were primarily developed to provide high-level mathematical abstractions and give insights into the effects of varying aspects of components (e.g., sizes, shapes, rigidity, binding affinities, etc.) and model dynamics (e.g., methods of growth and/or breaking of assemblies, cooperativity, etc.). Some of these insights have already provided guidance to experimental designs, and we hope the models will continue to evolve and mature alongside the design and engineering techniques of DNA nanotechnology. Theoretical modeling can provide a framework that shows which properties of components and systems are needed for desired resultant behaviors and guide researchers in the right direction as they work to develop new molecular components and techniques. Additionally, it can serve as a foundation to categorize potential behaviors of newly developed components and dynamical behaviors made possible in the laboratory.

There is a symbiotic relationship between theory and experiment, and thus it also remains important that theory incorporates up-to-date knowledge of experimental roadblocks and challenges, which can then be used for the development of new models and theoretical studies. The rapid growth and great success of DNA nanotechnology have been achieved in part due to strong ties between theory and experiment, and conferences like the “International Conference on DNA Computing and Molecular Programming” [99] have been integral in building and maintaining this connection. We look forward to seeing where future developments will lead and are optimistic that many of the powers of self-assembling systems displayed within the theoretical domain will be realized in physical systems, and this theoreticians’ toolkit for building self-assembly systems will come closer to reality.