Everybody Wants to Be a Seed: Arbitrary Single-Tile Seeds in the Abstract Tile Assembly Model
Abstract
Winfree’s abstract Tile Assembly Model (aTAM) is one of the most popular abstract models for DNA nano-computing. This papers presents a seedless version of the aTAM. Instead of a designated seed assembly, any single isolated tile can initiate the assembly. This paper shows that such system can simulate any aTAM system at constant scale and it presents a tile set to do so. All systems can be simulated at scale at most 10 and most of them can be simulated at scale 5, provided that their seeds are large enough.
Removing the need for seed in self-assembly is a new way of solving the nucleation problem, that is, the problem of controlling the initialisation of any self-assembly process. It also allows for a convergence of the aTAM towards other classical tiling models, such as Wang’s.
The systems presented are based on independent modules made of tiles. The modules are carefully designed so they act kind of like stem cells. When a module self-assembles from an isolated tile, it grows a pseudo-seed which represents the seed of the simulated system with a Hamiltonian cycle along the borders of the corresponding macrotiles. The other modules, which appear later on during the simulation as components of the “regular” macrotiles, depend on each other to self-assemble. In such cases, the assembly is synchronised in a way so that the growth of any pseudo-seed is blocked. This ensures that a macrotile self-assembles only when interacting either with the pseudo-seed or with previously completed macrotiles.
Keywords and phrases:
DNA origami, self-assembly, kinetic modeling, computational modeling, cellular automataCategory:
Track B: Automata, Logic, Semantics, and Theory of ProgrammingCopyright and License:
2012 ACM Subject Classification:
Theory of computation Models of computationarchived at
swh:1:dir:72a3a175c59387141e3c76ee14e7c41c216a0327
archived at
swh:1:dir:59706d65ba40d55deb385105a853b5e36198946f
Funding:
Research funded by CNRS through the projet à risque “CalcADN”.Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele PuppisSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
In DNA based nanotechnology, complex nanostructures can be assembled from simple nano-tiles made out of DNA strands. In 1998, Winfree introduced the abstract Tile Assembly Model (aTAM) in his Ph.D. thesis [18] and experimentations showed that despite being very abstract, the model was relevant to represent the experimental assembly of complex nanostructures [13, 8]. Self-assembly of tiling patterns has been an ever expanding field of research ever since. From a theoretical point of view, the aTAM proved computationally expressive. It is Turing universal [18] as well as intrinsically universal [6] – with proper initialisation, a single set of tiles is capable of simulating any arbitrary aTAM system. The aTAM extends classical Wang tilings [17] by adding a time dimension. The base components remains the same: un-rotatable, translatable square tile types whose sides are adorned with colours. However, instead of considering only full, valid, tilings aTAM systems start from a seed assembly and add tiles to it asynchronously according to a strength associated with each colour.
Among the variants of Wang tiles, self-assembly stands out because it is seeded. On the theoretical side, the seeded domino problem is far simpler than the general problem because the proof of undecidability does not require aperiodic tile sets [17]. The addition of a seed removes the singularity of Wang tiling compared to Turing machines. On the experimental side, controlling the nucleation through seed assembly have been a major subject focus of experimental work [15, 20, 14, 4, 21, 12, 7, 16, 8], as this control is crucial in getting a good reaction yield in experimental settings.
This paper presents a variant of aTAM systems, with no pre-defined seed: Omni-nuclear Tile Assembly Systems (OnTAS). Instead of a designated seed assembly, any tile of the system can initialise the self-assembly. In particular, this paper studies OnTAS with behaviours depending as little as possible on the type of the initial tile. They are “robust” in the sense that at some distance of the origin, their behaviour does not depend on which tile has initiated the nucleation of the assembly. Such systems are aTAM system which recover from nucleation by any of their tiles.
Although the control of nucleation has been extensively studied in experimental settings [15, 20, 14, 4, 21, 12, 7, 16, 8], works on that subject in a purely abstract setting are much more scarce. [1] is one such recent study. It shows that any aTAM system, even with a complex seed, can be simulated at constant scale with a system whose seed is reduced to a single tile from which all the information necessary to initiate the assembly unfolds. The present paper goes a step further, as the single tile that serves as the seed is not specified beforehand. Here, it is not enough to embed the nucleation process in a single tile because all tiles must embed it. Hence, this paper uses the ideas from [1] as a starting point for the construction of the seed representation.
Beyond the aTAM, the 2-Handed Assembly Model (2HAM) is another take on modelling self-assembly processes in which there are no seeds [3]. In the 2HAM, any two assemblies can bind to each other to form a larger assembly, starting from the base tile types, thus enabling “spontaneous” nucleation. The 2HAM is not the aTAM and while the former can simulate the latter, the converse is not true. Cannon et al. [3] showed how to simulate the aTAM with the 2HAM despite its spontaneous nucleation by representing the tiles away from the seed with blocks that fully self-assembles only if they are interacting with the seed or with a previously completed neighbour. This paper builds upon that idea to ensure a controlled nucleation.
At first glance, the idea of growing the whole assembly from any single tile is reminiscent self-healing tile sets: Winfree’s [19] and those of Chen et al. [5]. Self-healing systems are systems that can recover (or “heal”) from an arbitrary loss of tiles provided that some large enough piece remains intact. Winfree’s construction required the seed to be part of the remaining part, but later works such as [5] developed systems that can heal even if they lose the seed. The point of self-healing systems is to be able to self-assemble the exact same tiles that were lost. Here, the setting is different: isolated tiles start over a whole new assembly. In general, the systems presented in this paper cannot recover from chunks larger than a single tile. It is a question for further research whether the two properties can be combined in a single construction.
The interest of the construction of this paper is that it explores a new field of solutions to the nucleation problem by simply removing the need for seed – at least, the need for a distinguished seed assembly. The implications are both theoretical, since it allows for a convergence of the aTAM towards classical Wang tiling and other similar models, and practical, since it removes the problem of selecting the right seed assembly in experimental settings. However, in experimental settings, a kinetic barrier on nucleation is useful to limit the quantity of parallel self-assemblies. Indeed, as opposed to what happens in the abstract model, actual samples do not contain an infinite amount of tiles and parallel assemblies are at risk of competing for the supply of tiles. OnTAS nucleation can happen from any tile without limitation, so there is a priori no such kinetic barrier. It seems sensible to suppose that further developments can be made towards adding one, particularly since after a few steps, the assembly of the seed representation from an arbitrary tile always follows the same steps, sequentially (see Section 4.2).
Section 2 presents and defines the notions used throughout the paper. Section 3 gives an overview of the result and outlines its main features: in general, any aTAM TAS can be simulated at scale 10 by an OnTAS (Corollary 9). Thus, removing the need for a distinguished seed ensures only a moderate, constant cost in the form of a scale factor. Then, Section 4 details a construction to simulate a mostly arbitrary TAS with an OnTAS at scale 5 and Section 5 proves that it works as intended.
At https://self-assembly.net/software/WebTAS/WebTAS-latest/ you will find a simulator which can be used to visualise systems in the aTAM as well as the OnTAM. The examples of this paper are available under “File/Open Example”. It also allows running the construction of Theorem 8, by selecting “Simulate current system in the OnTAM” in the OnTAM menu. The simulation uses the current assembly as the seed of the system to be simulated, so before starting the simulation, it may be necessary to add tiles until it contains square, either by running the simulation for a few steps () or by manually adding tiles (🖉). The “System/Reset To One Random Tile” menu item restarts the simulation from one random tile, as suits the omni-nuclear model.
2 Definitions
2.1 The abstract Tile Assembly Model
This section reproduces the brief informal sketch of the abstract Tile Assembly Model (aTAM) from [1] and [11], originally formulated in [6].
A tile type is a unit square with four sides, each consisting of a glue label, often represented as a finite string, and a nonnegative integer strength. A glue that appears on multiple tiles (or sides) always has the same strength . An aTAM system has a finite set of tile types, but an infinite number of copies of each tile type, with each copy being referred to as a tile. An assembly is a positioning of tiles on the integer lattice , described formally as a partial function . Let denote the set of all assemblies of tiles from , and let denote the set of finite assemblies of tiles from . Write to denote that is a subassembly of , which means that and for all points . Two adjacent tiles in an assembly interact, or are attached, if the glue labels on their abutting sides are equal and have positive strength. Each assembly induces a binding graph, a grid graph whose vertices are tiles, with an edge between two tiles if they interact. The assembly is -stable if every cut of its binding graph has strength at least , where the strength of a cut is the sum of all of the individual glue strengths in the cut.
A tile assembly system (TAS) is a triple , where is a finite set of tile types, is a finite, -stable seed assembly, and is the temperature. An assembly is producible if either or if is a producible assembly and can be obtained from by the stable binding of a single tile. In this case write ( is producible from by the attachment of one tile), and write if ( is producible from by the attachment of zero or more tiles). An assembly is terminal if no tile can be -stably attached to it. Let be the set of producible assemblies of , and let be the set of producible, terminal assemblies of . A TAS is directed if .
An assembly sequence in a TAS is a (finite or infinite) sequence of assemblies in which each is obtained from by the addition of one tile, i.e. . A set of locations depends upon some other set if, for every valid assembly sequence in , if a tile is placed in some location in , a tile was previously placed in some location in . In an assembly , a tile at location blocks a tile if there exists a valid assembly sequence which begins with and results in one or more tiles adjacent to which did not require glues of to bind to the assembly and to which a tile of a type different than could bind with strength in location if was removed.
2.2 Simulation of tile assembly systems
This section defines the notion of simulation of a TAS by another. The following definitions are those either from [11] for the “standard” ones or from [1] for those that take into account the assembly of the seed representation from a single initial tile. For more in-depth discussions, see those papers.
Intuitively, simulation of a system by a system requires that there is some scale factor such that squares of tiles in represent individual tiles in , and there is a representation function capable of inspecting assemblies in and mapping them to assemblies in .
From this point on, let be a tile set, and let . An -block macrotile over is a partial function , where . Let be the set of all -block macrotiles over . The -block with no domain is said to be empty. For a general assembly and , define to be the -block macrotile defined by for . For some tile set , a partial function is said to be a valid -block macrotile representation from to if for any such that and , then .
For a given valid -block macrotile representation function from tile set to tile set , define the assembly representation function111Note that is a total function since every assembly of represents some assembly of ; the functions and are partial to allow undefined points to represent empty space. such that if and only if for all . For an assembly such that , is said to map cleanly to under if for all non empty blocks , for some such that .
In other words, may have tiles on macrotile blocks representing empty space in , but only if that position is adjacent to a tile in . Such growth “around the edges” of is called fuzz and it is restricted to be adjacent to only valid macrotiles, but not diagonally adjacent (i.e. no diagonal fuzz).
In the following definitions, let be a tile assembly system, let be a tile assembly system, and let be a valid -block representation function .
Definition 1.
and have equivalent productions modulo (under ), and we write if the following conditions hold:
-
1.
.
-
2.
.
-
3.
For all , maps cleanly to .
Definition 2.
follows modulo (under ), written if , for some , implies that .
Definition 3.
models (under ), written , if for every , there exists where and for all , such that, for every where , (1) for every there exists where and , and (2) for every where , , , and , there exists such that .
The previous definition essentially specifies that every time simulates an assembly , there must be at least one valid growth path in for each of the possible next steps that could make from which results in an assembly in that maps to that next step.
The following definition is one of the definitions of simulation that are relevant to use when simulating systems with multi-tile seeds with systems with single-tile seeds. It comes from [1].
Definition 4.
seed-first-simulates (under ) if (they have equivalent productions modulo the seed of ), and (they have equivalent dynamics).
2.3 Omni-nuclear systems
This section defines a new type of tile assembly systems, whose seed is a single tile chosen at assembly time. Those are the systems that this paper is interested in.
An Omni-nuclear Tile Assembly System (OnTAS) is an ordered triple where is a finite set of tile types, is the temperature and is a function that associates a position in the plane to each tile type. Intuitively an OnTAS is a TAS whose seed is a single tile that can be be arbitrarily chosen from its tile set at execution time. Then, indicates the coordinates where a tile is placed whenever it is used as the seed. The OnTAS are collectively known as the Omni-nuclear Tile Assembly Model or OnTAM.
Formally, an OnTAS represents the class of all aTAM TAS with tile set and temperature and whose seed is a single tile from whose position depends on the tile type:
For any , is the unique function whose domain and image set are the singletons and , respectively.
This paper focuses on OnTAS with a behaviour that depends as little as possible on the type of the initial tile. Then, some properties concerning TAS can be intuitively extended to OnTAS if those properties are followed by all the TAS of the corresponding set:
-
A set of locations depends on another one if the former depends on the latter whichever the type of the initial tile.
-
A subassembly is said to be producible by a given OnTAS if it is producible whichever the type of the initial tile.
Moreover, the notion of simulation can be extended as follows:
Definition 5.
seed-first-simulates a TAS under if, for all TAS , seed-first-simulates under .
This leads to the following definition, which formalises the intuitive notion of what is a “robust” OnTAS, with a consistent behaviour:
Definition 6.
An OnTAS is robust (at distance ) if there exists a connected set of locations (with radius at most ) that is closed in terms of dependence and so that all TAS of the corresponding set behave identically outside of . That is, they have the same productions and the same dynamics.
Since the set of images of is included in the set of ignored locations of a robust OnTAS, no location further than from the initial tile is ignored, whichever the type of . All locations further than from the initial tile have “forgotten” the type of the initial tile.
The definition of shows that the behaviour of an OnTAS amounts to choosing non-deterministically among a set of TAS. A disjoint union of OnTAS with the same temperature implements this operation of non-deterministic choice: whenever starts with a tile from , it will behave like , since the union is disjoint. Hence, being able to simulate an arbitrary TAS with an OnTAS is enough to be able to reproduce the behaviour of a non-deterministic selection among a fixed set of TAS of same temperature with an OnTAS. This in turn, precisely characterises OnTAS as “equivalent” to a non-deterministic selection within fixed sets of TAS. The following sections are dedicated to constructing an OnTAS that simulates an arbitrary TAS. Note that the OnTAS presented there is robust: its behaviour precisely matches that of the TAS and the choice of seed tile does not affect the shape or behavior shown in the resulting assembly sequence.
3 Overview of the results
3.1 Basic illustrating example
This section considers an illustrating example: the task of self-assembling a ray. In the aTAM, a TAS with 2 tile types at temperature is sufficient for this (Figure 1(a)). One of the tile types corresponds to the single-tile seed (in red). It has a single glue to which the tiles of the other type (in blue) can bind. Those have glues on 2 opposite sides so that the assembly grows in a line. An OnTAS with the same tile types and temperature does not have the same productions. If the first tile is of the non-seed type, the assembly can grow to the left as long as it keeps adding non-seed tiles at each step. Thus, the left end of the ray can be arbitrarily far from the actual initial tile, or fail to exist at all. While in this case, in a probabilistic setting with a constant probability of choosing the red tile at each step, the full line assembles with probability zero. For a richer TAS , the OnTAS with the same tile set can be completely unable to assemble the same final assemblies as .
Consider an OnTAS , , with 11 tile types. The tiles are those represented on Figure 1(b).
Lemma 7.
seed-first simulates at scale 4.
The proof of the lemma is easy; it features here with all details in order to demonstrate the articulation of the concepts involved, and to serve as a canvas for the proof of the main result. It details the producible assemblies from any single tile, and shows that the tiles that represent the seed of are always at a known, bounded, distance of the initial tile.
Proof.
Four of the tiles self-assemble into a Z-shaped module and four others self-assemble into an S-shaped module (Figure 1(c)). Assembled together, they represent the non-seed tile of . The three last tiles self-assemble into a structure that represents . The modules fully self-assemble through strength-2 glues from any of their tiles when it is placed. Their respective rightmost tiles expose glues that cooperate with a neighbouring module to assemble the first tile (either or ) of a new module (ⓐ on Figure 1(c)). Their leftmost tiles expose a special strength-2 glue to which a tile representing the seed can bind (ⓑ on Figure 1(c)). The system self-assembles 2 adjacent rows, made out of “S” and “Z” module respectively.
The assembly goes as follows (Figure 1(d)): if the initial tile is from a Z or a S module, that module fully self-assembles. Since it has no adjacent module, no new module can attach to it. On its left-hand side, the pseudo-seed grows from the exposed glue. Once the pseudo-seed has fully self-assembled, the complementary module to the initial one self-assembles on the opposite end of the pseudo-seed. At that point, both rows have a module. They cooperate to assemble a S module, which in turn cooperates with the existing Z module to assemble a new one, and so on. If the initial tile is from the pseudo-seed, the pseudo-seed fully self-assembles, then it assembles a module on each row and the rest of the assembly goes as before.
When a module self-assembles in the “regular” way, that is, with the cooperation of adjacent, previously assembled, modules, the glue is blocked (edges marked in red on Figure 1(e)). On the contrary, when the module self-assembles spontaneously from one of its tiles, which is used as the actual seed for the whole assembly, the glue is exposed and the seed representation assembles from it (ⓓ on Figure 1(e)). Whichever the initial module (S or Z), once the pseudo-seed is fully assembled it assembles the complementary module, and only then.
The alignment function of is defined to map each tile type to its position in the fourth step of Figure 1(d).
In the end, the representation function is so that the tile at coordinates in any scale 4 square determines the tile that the macrotile represents (magenta circles on Figure 1(e)). If is part of the pseudo-seed, then the macrotile represents the seed tile of , else it represents a non-seed tile.
Consider an assembly of and a representation in . If tiles are added to to form an assembly , they assemble on the right of the ray, extending it. can assemble modules (, depending on the alignment of the macrotiles) and the resulting assembly represents . Reciprocally, if assembles modules, the resulting assembly represents an assembly with (, depending on the alignment of the macrotiles) more tiles compared to . Thus, and . Starting from any tile, first assembles the seed representation before any further growth. and have equivalent initial productions and equivalent dynamics, they have equivalent productions.
3.2 Main result
Theorem 8.
Let be a TAS. If contains a square of tiles, there exists an OnTAS at temperature that seed-first simulates at scale 5.
Proof.
The detailed proof is in Section 5.
Corollary 9.
Let be a TAS. There exists an OnTAS that seed-first simulates at scale 10.
Proof.
Let be an aTAM TAS whose seed has no 2-tile wide square within itself. Then, the IO version of can be simulated at scale 2 by a system , as detailed below. In this simulator, all tiles of are represented by -tiles squares. Theorem 8 states that there is an OnTAS that seed-first simulates at scale 5, and then seed-first simulates at scale 10.
To construct a scale-2 simulator of , let be the input-output version of . Its glues are marked with directions: a glue marked “North” is an input glue of a tile which features it on its South side, and an output glue of a tile which features it on its North side. Moreover, the set of input sides of each tile can be assumed to form an inclusion-minimal set, i.e. to have no proper subset summing to or more.
Then define the simulator as follows. It has the glues of , plus for each non-null glue marked “East”, an additional glue with strength (also marked “East”); likewise for the other directions. Then for any tile with a non-null output glue, replace the glue there with . For each “East” glue , add a “messenger” tile type with glue to the west and to the East; likewise for the other directions.
The seed is made of full squares. Its glues are:
-
where the seed of has a South facing glue at position , the seed of has glue at position (facing South),
-
where the seed of has a West facing glue at position , the seed of has glue at position (facing West),
-
where the seed of has a North facing glue at position , the seed of has glue at position (facing North),
-
where the seed of has an East facing glue at position , the seed of has glue at position (facing East).
Then simulates at scale , using the contents of the top-right cell of each square as the representation of the macro-tile: in each such square, the top-right cell contains a modified tile of (or is empty), the top-left and bottom-right cells each contain a messenger tile (or are empty), and the bottom-left cell is empty.
Competition can only happen between messenger tiles for opposite outputs on abutting macro-tiles. When it does happen, both involved macro-tiles are already mapped by the representation function.
Theorem 8 is proven for an arbitrary TAS by constructing an OnTAS that seed-first simulates . That construction relies heavily on cooperation between tiles. In the rest of this paper, all systems have temperature . There is no loss of generality because TAS with temperature are trivially simulated with temperature 2 systems.
Following [1], a more precise definition of simulation avoids cheating fuzz. Cheating fuzz is defined as fuzz that grows into a macrotile region which maps to a location in the simulated system in which there is never an incident glue (other than the null glue) from any adjacent tile. The construction presented here does not grow cheating fuzz (see Section 4.1.2).
When taking kinetic considerations into account, the benefit of the OnTAM is that “correct nucleation” is trivially verified, because any single-tile assembly can be considered correct nucleation. The drawback is that there is no kinetic barrier on the beginning of the self-assembly and there is a risk of too many independent assemblies taking place simultaneously and competing with each other. Since the self-assembly of the seed representation is done sequentially from a single starting point, it seems reasonable to think that a kinetic barrier of some sort could be added at that step in experimental implementations.
3.3 Overview of the construction
Construction 10.
Let , , be an aTAM TAS, where contains a -tile square . Consider that has its upper-left corner at coordinates , if necessary by translating the plane. Define the OnTAS , where is the set of tile types defined in the next sections and is the seed-positioning function defined in Section 4.2. verifies Theorem 8 regarding . Let be the representation of in .
This construction is to be used to seed-first simulate any arbitrary aTAM TAS with a corresponding OnTAS. In it, most tiles belong to modules that self-assemble from any of their tiles. Once a module has self-assembled, the next steps depend on its environment: it acts kind of as a stem cell. If the module is isolated, it grows a pseudo-seed from which a representation of the seed of self-assembles sequentially. Otherwise, it interacts with its neighbours to form the macrotiles of the actual simulation which starts from the complete seed representation.
The productions of are made of 2 parts: the seed representation, that assembles before anything else from any tile of , and the actual simulation. The tile set simulates for the latter part. It assembles modules that cooperate to form the macrotiles. A macrotile is composed of a central brick module (green tiles in the following figures), which represents the tile being simulated, of tenon modules (red and blue tiles in the following figures), which represent the glues, and of mortar modules (yellow tiles in the following figures) that connect the components together and with the neighbouring macrotiles (Figure 3(b)). The assembly of the seed representation follows from the initial tile. That initial tile grows a subassembly of bound size. The tile set grows an arm from there (orange tiles in the following figures) then assembles a barrier (cyan tiles in the following figures) around that subassembly and along the border of the macrotiles of the seed representation. That barrier represents the seed, it separates the initial assembly and the rest of the simulation while being the interface between them. When it is complete, some modules bind to it. Those modules can only assemble either from the complete seed representation or from a previous module. Their assembly enables the start of the actual simulation (Figure 4).
All modules carry special glues that allows isolated modules to initiate the nucleation process. These glues serve as an interface with the tiles of when they are exposed. After the nucleation, the modules assemble in a sequence so that no glue is ever exposed. Proving that invariant is an important part of the proof of Theorem 8. The rest of the proof consists in the one hand in showing that the simulation itself is correct and that the modules always interact with each other correctly. The macrotiles are designed so that whatever competitions between tiles happen locally, the resulting assembly exposes the right glues. In the other hand, the proof that the nucleation process always has the same outcome relies on showing that in all the possible cases, the initial subassembly fits within the core of .
4 Construction of the tileset of the simulator
This section details the set of tile types for the OnTAS of Construction 10.
4.1 Simulating the assembly: construction of
To derive from , the first step consists in generating . It is a standard process used and described in [1] as well as in [3]. Each glue is marked with a direction, so that the glues of each tile type are either input or output glues. A subset is a set of input directions for a tile type if the sum of the strength of the glues on the sides of in is at least , and no proper subset of is a set of input directions for . Then the tiles of are all tiles with input glues on their input sides and output glues on their output sides. In particular, if a side of a tile of has an input glue of strength , it is its only side with an input glue.
is a scale-5 version of . The idea is to have a single point of cooperation and/or competition on the central tile of each macrotile. The existing adjacent macrotiles grow fuzz towards that point. The tile that attaches there determines which tile is being represented and the rest of the macrotile assembles from it. The macrotile can then grow fuzz itself, on its empty sides with output glues, for new macrotiles to self-assemble.
The precise construction is inspired by the construction used in [3] to simulate the aTAM with thekeeps no memory of the choice of seed. 2HAM. The key takeaway is the use of modules so that a macrotile is able to fully assemble only if its neighbours are themselves sufficiently assembled. A macrotile is made up of 3 types of modules (Figure 2):
-
The tenon modules assemble from adjacent macrotiles towards the centre of the macrotile. Symmetrically, they assemble from the core of the macrotile towards the adjacent empty areas. The tile in the centre of the module is called its core tile.
-
The central brick module (which corresponds to the brick in [3]) self-assembles from the tile that binds to the input tenons. That tile is called the core tile of both the brick and any macrotile it belongs to.
-
The mortar modules bind themselves to the other modules of both the current macrotile and the existing adjacent ones. They allow for the growth of the output tenons on the empty output sides.
Each module can fully self-assemble without external help through strength- glues, but their first tiles depend on other module types. Each brick depends on one orkeeps no memory of the choice of seed. more tenons, each tenon depends on the cooperation of a brick with a mortar module and each mortar module depends on the cooperation of a tenon with either a brick or a mortar module.
During the assembly of a macrotile, the tenons shared with its input neighbors assemble first, then the brick assemble from the centre of the macrotile (Figure 3(a)). On tiles with 4 input glues, no brick binds and the macrotile is complete when all the input tenons self-assembled (see Section 4.1.1). The mortar modules bind both to the mortar modules of the adjacent macrotiles and to the input tenons, with glue pairs of strengths respectively. From there, in clockwise order, an output tenon binds both to the brick and to the previous mortar module with a -strengths glue pair, then a mortar module binds both to that tenon and to the brick, and so on until all sides of the macrotile have a tenon, either input or output (Figure 3(b)).
Each module has a single glue, where is the identifier for the module type ( corresponds to brick modules, etc.) and is the direction that the glue is facing. The identifiers of the mortar modules depend on their chirality: is the identifier for mortar modules that goes from the bottom to the left and is the identifier for their counterparts. That way, all modules of each one of the 5 module types (the fifth one is described below in Section 4.1.2) in each one of the 4 possible orientation share a unique glue. The glue is the one that serves as an interface from isolated modules to the tiles used to assemble the representation of the seed, as detailed in Section 4.2. The only exceptions are the brick modules with a strength- input glue. They do not have a glue at all because they can attach to the tenons with the corresponding strength- glue and the latter do have a glue.
4.1.1 Macrotiles with 4 input sides
The previous construction would not allow bricks to have 4 input sides as well as a glue. Instead, macrotiles whose sides are all input sides have no brick module and they are characterised in the representation function by their input tenons. To distinguish between different tiles with the exact same 4 input glues, northern input tenons have specific markings, which are chosen arbitrarily during their assembly. More precisely, each tenon that represents a glue that outputs on the south of a tile exists in different versions. Each version corresponds to a dictionary which matches all the sets of input glues of 4-inputs tiles that have on their northern side with one of the tile with the said input glues. Every pair of a 4-input tile and its input glues exists in at least one such dictionary. When a tenon outputting in the south of a macrotile assembles, its core tile is chosen arbitrarily among the variants, with no consequences on any of its glues. Then, if it happens to be part of a 4-input macrotile, the corresponding dictionary looks up the inputs glues of the macrotile in order to determine which tile is being represented. Otherwise, the marking is simply ignored.
4.1.2 Output sides with strength-0 glue
On output sides with strength glues of strength 0 (ie. no glue at all), there are no output tenons. What would be the first tile of the tenon, bound to the brick and to the previous mortar module, is instead merged in the next mortar module, thus making it “longer”. That way, nothing ever grows on the sides of the macrotiles that have no glue and there is no cheating fuzz. During the actual assembly it may be the case that the said “next mortar module” is blocked by the input fuzz of an adjacent macrotile. Then, the long mortar module would not be able to completely self-assemble but it has no consequences.
The special module naturally has a different identifier on its glue compared to those of the regular mortar modules. It is the identifier in the set previously defined.
On Figure 3(b), if the eastern side of the simulated tile had no output glue, the eastern blue tile would have no glue on its eastern side and a strength- glue on its southern side. That glue would be mirrored on the north of the mortar tile below it, so that they bind together.
4.2 Representing the seed: construction of
The purpose of the tileset is to assemble a scaled representation of , , as a descendant of any isolated tile of , the whole OnTAS tileset.
A first subset does not depend on . Consider any of the module types of the macrotiles in any of the 4 possible orientations (grey tiles on Figure 4). That module may attach to other modules. The resulting assembly has a single glue from which tiles from self-assemble an arm (orange tiles on Figures 4 and 5). grows to an edge of the rectangle area that encloses the initial module and any other modules that bind to it, where it places a final tile, . The variant of that grows from brick modules is designed so that it crashes into any input tenon module attached to the adjacent tile to the glue. That way, can only ever grow if the brick module self-assembled by itself and not as a part of a macrotile even when the glue itself is not blocked. Similarly, the long mortar modules grow their arm towards their first tiles.
The second subset actually assembles the representation of . That tileset corresponds to in [1]. It takes over to continue the assembly of with the same process as described in [1]: it assemble an inner path (blue tiles on Figure 4) that goes through the macrotiles representing . That path continues in an outer path made out of mortar modules and tenons (resp. yellow and blue tiles on Figure 4). The outer path self-assembles along the inner path, on the border of . The paths go along the border of without crossing it and self-assembles within that empty space.
The inner path plays the same role as the bricks and tenons regarding . It exposes the same glues as “standard” macrotiles would, so that the mortar modules and the output tenons assemble correctly on the outer path. The first module on the outer path binds to both the first and the last tile of the inner path. Then, the outer path assembles so that the structure of the outputs of the macrotiles of the seed representation is the same as for the other macrotiles, detailed in the previous section. Following the first one, each module depends on a previously assembled module (either mortar or tenon) and on the inner path.
The mortar modules on the outer path do not assembles their last few tiles, depending on the angle between the edges of the macrotiles they are part of (Figure 6). Their first tiles expose the glue that are necessary for the simulation to move on and the last ones are blocked by the inner path.
Each tile of the “main” tile set is part of a unique module to which corresponds a unique . Each tile of corresponds to a unique position in the representation of . Hence is defined so that the centre of the centres of the macrotiles of are aligned at scale 5 with corresponding tiles of . In particular, the tile is always placed at coordinates , as in Figure 4.
Lemma 11.
Let be an aTAM system with IO markings. Suppose it has glues, tile types with at least one output, tile types with input sides and a seed of size . Then has at most tile types.
Proof.
In T’:
-
for each tile type with at least one output, there is a brick with at most 6 new tile types, for a total of brick tile types
-
for each glue and rotation direction (cw or ccw), there is a mortar with 5 tile types, which may come in up to variants (accounting for tiles with no output), for a total of mortar tile types
-
there are 8 normal and 4 long tenons, with 3 and 4 tile types respectively.
For the arms, there are 5 module types, 4 directions and up to 8 tiles for each arm, for a total of no more than 160 tile types; the actual value is 61.
Finally, the inner perimeter of the pseudo-seed is made of unique tiles (less than of them). The outer perimeter uses the same pieces as mortars and tenons.
Thus, the total size of is less than: .
5 And yet it works: detailed proof of the result
This section shows that the construction presented above can actually be used to seed-first simulates any given arbitrary aTAM TAS .
Recall Theorem 8:
Theorem 8. [Restated, see original statement.]
Let be a TAS. If contains a square of tiles, there exists an OnTAS at temperature that seed-first simulates at scale 5.
The theorem is proven as follows: first by showing that the simulated systems and the corresponding OnTAS from Construction 10 have equivalent dynamics (Lemma 14), then by showing that they start from the same initial productions. Showing that any assembly starts by growing a seed representation before anything else takes the largest part of the proof. The proof shows that from a tile of any type, grows a tile (as defined in Section 4.2) with by-products that fit within the core of (Lemma 15) and that from that tile, the system self-assembles a full representation of the seed before any other assembly (Lemma 16).
The following definitions are useful to refer to precise parts of square areas such as the macrotiles, for instance within the seed representation.
Definition 12.
Every scale- square made of tiles, , contains a scale- square that is 2 tiles away from the edges. This sub-square constitutes the core tiles of the larger square.
Definition 13.
Around the core tiles of any macrotile there is a 2-tiles wide path that constitutes its border. The outer 1-tile-wide path is the perimeter, while the inner part of that path is the inner border. More generally, the perimeter of any macrotile assembly is the union of the 1-tile-wide paths along the edges that face regions which do not belong to the assembly.
For instance, the core of , the -macrotile square area within , is the -tile square area with upper-left corner at coordinates and bottom-right corner at coordinates (grey stripes on Figure 4).
Lemma 14.
Let be an aTAM TAS and the corresponding OnTAS from Construction 10. models (every assembly sequence of can be simulated in ) and follows (every assembly sequence in simulates an assembly sequence in ).
Proof.
See Section 5.2
Lemma 15.
Let be a TAS and the corresponding OnTAS from Construction 10. From any isolated tile placed at position , the producible assemblies have exactly one tile at position . Provided that no tile binds to it, no tile is placed outside the core of . No core tile of a brick module from is ever placed in the centre of a seed macrotile.
Proof.
See Section 5.3
Lemma 16.
Let be a TAS and , the corresponding OnTAS from Construction 10. From a tile at coordinates , assembles a complete scaled representation of before any other growth away from the seed.
The tile is the only one to interact both with tiles in the core of and tiles on its border.
Proof.
See Section 5.4
Proof of Theorem 8.
From Lemma 15, from any tile of used as a single-tile seed, self-assembles a structure with an arm that ends with a tile at coordinates . That structure fits within the core of .
Lemma 16 states that as long as that tile is correctly placed, self-assembles a complete scaled representation of from it. The assembly does not interfere with the initial structure.
If the tile that serves as the seed is from , the whole inner path of self-assembles and both of its ends have to be assembled before the outer path starts its assembly (see proof of Lemma 16). At its “inner” end, a tile can bind and the previous arguments apply.
From Lemma 14, have the equivalent dynamics as . Then, starting from a complete representation of the seed, they have the same productions and simulates . Therefore, from any tile of , simulates .
is an OnTAS that seed-first simulates at scale 5.
5.1 Representation function
Now that the producible assemblies are precisely described, the representation function can be easily derived. Formally, the representation function from an OnTAS to the simulated TAS is defined as follows:
-
The presence of any tile of within an (aligned) -tiles square area indicates that the macrotile represents the corresponding tile in
-
The presence of the core tile of a brick module from in the centre of an (aligned) -tiles area indicates that the macrotile represents the corresponding tile of .
-
Given a macrotile with four input tenons facing its core, if the combination of glues they represent exists with no mismatch on at least one tile of , then the northern tenon indicates which tile of the macrotile represents.
The following sections show that these conditions cannot interfere with each other.
5.2 Assembly simulation
This section proves that from “correct” macrotiles, only “correct” macrotiles can be assembled and from that the Lemma 14 can be deduced.
Lemma 17.
Let be an assembly of and consider a place where a tile can be added. Let be an assembly of that represents and to which a tile can be added in the square area that corresponds to , to represent the addition of a tile to . Let and be the assemblies formed by adding these tiles respectively to and . represents . For all assembly sequences from , at some point there is an assembly that represents an assembly of and which exposes the output glues of to the cores of the corresponding adjacent square areas with no macrotile, that is to the cores of the square areas that correspond to empty spots adjacent to in .
Intuitively, that means that from a valid assembly representation of in , on all empty spots of where a macrotile can be added that corresponds to a valid tile in and that eventually exposes the right output glues towards its empty neighbours.
Proof.
Suppose that the tile has 4 input glues and no output glue. Then, if three of the input tenons face the central tile of , adding a tile so that the fourth tenon also face the core of simulates the addition of . has no output glue to expose to the adjacent areas and the lemma is verified.
Henceforth, consider with at least one output glue. When enough input tenons expose their glues to the centre tile of , the core tile of a brick can bind and it determines which tile is being represented. From that tile, the brick grows in all directions where there are no adjacent macrotiles. If its glue is not blocked by a mortar module, then the first tile of the corresponding can bind to it but it crashes into the neighbouring input tenon, since the brick depends on it.
On the directions where there are adjacent macrotiles whose exposed glues are not input glues, the “tip” of the tenon and those of the mortar modules might be replaced by tiles from the brick. On those sides, if the mortar on the previous side in clockwise order self-assembles its glue, there might be a competition between the core tile of the input tenon, that binds to the adjacent macrotile, and the first tile of the corresponding output tenon, that binds to the mortar module and to the brick (Figure 7). If the input tenon “wins”, no tile blocks it from assembling a mortar module next to it in clockwise order (Figure 7(b)). Its first tile binds to the strength-1 glue exposed by the adjacent macrotile and to the strength- glue from the tenon. That latter glue also determines the shape of the mortar module. The first tiles of all mortar modules depend on a tile that eventually block their respective glues.
On the first side without an input tenon, in clockwise order starting from any input tenon, there is a mortar module from the previous side which exposes a strength-1 glue. The first tile of the output tenon of binds to the brick and to the said glue (Figure 7(a)). If there is no output glue at all on that side, the output tenon is replaced by a tile with a single strength- output glue facing the remaining direction, which is the first tile of the special mortar module described in Section 4.1.2. Then, if no mortar module grew from the next side towards the output tile, the first tile of a new mortar module can bind to the glue of the output tenon and to the brick (alternatively it binds to the initial tile of the long mortar module). If no input tenon assembled its core tile on , the mortar module that would flank it did not assemble either, since the latter depends on the former. Then, the mortar module that grows from the brick on towards is not blocked and it self-assembles completely (see for example the eastern side of the macrotile on Figure 3(b)).
The same process happens on all sides with no input tenon, initiated each time by a mortar module that grew either from an input tenon or from the brick. In the end there are two mortar modules on each side, one on each end of the edge, and they both expose a glue. On all of these sides, there is either the first tile of an output tenon or a tile that exposes no glue. That tile depends on its predecessor along the edge in clockwise order, which in turn blocks the glue of the tenon.
On sides with no macrotile, the corresponding tenon grows towards the central tile of the adjacent square area and mortar modules assembles along it. Neither tenons nor mortar modules from other macrotiles can prevent the tenon from growing all the way to the central tile because the former do not grow further than 2 tiles away from the macrotile they grew from, so they cannot block the way in front of the tenon.
On sides with an adjacent macrotile, since the output tenons of one macrotile are the input tenons of one another, the assembly goes as described on the beginning of the proof.
Locally, the assembly remained a valid representation of the corresponding assembly in , with no tile addition to apart from .
The representation function is correctly defined outside of the seed representation: a macrotile that represents a tile of either assembles 4 input tenons or a brick but not both. No tile of ever appears outside of the seed representation.
Proof of Lemma 14.
Lemma 17 holds for any arbitrary position on an assembly of , so it holds for all of them. For all assembly of , if , for all representations of in , the necessary macrotiles can be assembled incrementally to form an assembly that represents . .
Reciprocally, for all assemblies of that represents assemblies of , all that can be added to are macrotile with the same glues as the tiles they represent, both on input sides and on output sides. Hence, for all assemblies producible from , they represent assemblies of producible from . .
5.3 Initiating the seed
To prove Lemma 15, the idea is to show that there is a finite number of producible subassemblies, that their sizes are bounded and that they always expose a glue.
Proof of Lemma 15.
Let be the initial tile, ie. the actual seed of the assembly. If (i.e. if it is part of an arm between an initial subassembly and the inner perimeter), it has exactly 2 strength- glues and it will grow the rest of its variant of from both of them. One end of this arm will present a glue and the corresponding tile from will attach to it. Then, can be taken in without loss of generality.
The glues of strength on the tiles from are the internal glues of the modules, the glues and the glues of strength from the system being simulated. From any single tile of , a full module assembles thanks to its internal glues. The shapes of the modules prevent glues of strength less than of a single modules from cooperating to assemble new tiles.
Consider to belong either to a mortar module or to a tenon whose output glue is of strength strictly lower than . Besides the internal glues, the glue is the only strength- glue and no tile can bind to the module if not to the glue. The only tile that can attach there is the first end of a arm. The shapes of the modules allow for an arm to grow in a straight line along its shorter dimension towards an edge of the enclosing rectangle area. Then the arm can grow along that edge and reach any other edge and a tile can be placed. The size of that assembly is at most the size of the module plus one tile in each dimension. The size of a single module is at most tiles, so and the assembly is small enough to fit in the core of . It has exactly one tile which can be placed anywhere on its perimeter, so it can be placed at coordinates in particular.
Consider to belong to a brick with input glues of respective strengths strictly lower that . Just as before, grows from the only glue. It grows along the edge of the brick towards its core tile, as described in Section 4.2. When it reaches the opposite edge, it grows an arm along that edge. A brick is at most a -tiles rectangle, so the assembly is 4-tiles wide and it fits within the core of with additional empty space around it. That additional space allows for the arm to be shaped in a way so that the core tile of the brick is not aligned in the centre of the macrotile.
Otherwise, belongs either to a tenon with a strength- output glue or to a brick with a strength- input glue. Because the simulation goes through , such an input glue must be the only one of its tile. Then, the module can attach to another module and form a brick-tenon pair. The brick has no glue, so the only exposed strength- glue is the glue of the tenon. By construction, both modules cannot cooperate to assemble new tiles on any other place. The rest of the construction goes as before. By growing along the longest edge of the enclosing area, the produced assembly is at most by tiles wide and it fits within the core of with empty space around it (see Figure 5). The 2 tiles of additional space along the longer side of the enclosing rectangle area allow for the arm to be shaped in a way so that the core tile of the brick is not aligned in the centre of the macrotile.
Whichever module the initial tile belongs to (or even if it belongs to ), the produced assembly fits within the core of . It is at most 5-tiles wide, so there is an at least 1-tile wide “free” row on each dimension and is always able to grow towards any position on the edge of the core . The assembly has a tile at coordinates and it has no other arm. Brick modules are always assembled so that they aren’t aligned within a macrotile.
5.4 Completing the assembly of the seed representation
The statement of Lemma 16 is largely inspired by Theorem 5.1 from [1] and the proof follows roughly the same ideas, with some key differences.
Proof of Lemma 16.
The assembly of the rest of from the tile goes in 2 steps. First it assembles an inner path that goes through all macrotiles of the seed (in blue on Figure 4), then it assembles an outer path that goes all around the edges of (yellow and blue on Figure 4). Both paths follow an Hamiltonian cycle in clockwise order through the macrotiles that represent the seed. The cycle can be generated by following the procedure from [9]. The first step of that procedure is to generate a spanning tree. The vertices that correspond to in are merged in the initial graph from which the tree is generated. The Hamiltonian cycles followed by both paths go around the spanning tree along the borders of the macrotiles. is viewed as a single node of the tree and the paths go around it without crossing it (striped area in Figure 4).
The position of the first tile of the inner path is chosen so that it is aligned with the position of the first tile of an eventual outer path module, as described in Section 4.2. The first tile of the inner path binds atop the tile, hence the choice of position for . From there, the tiles of bind from neighbour to neighbour with strength- glues along the cycle to complete the inner path. The last tile of the inner path is placed on the perimeter of . It binds to the tile that closes the inner cycle and its position corresponds to the tile between both ends of the outer path. That tile has a strength-1 glue facing the next tile on the border of in clockwise order.
The outer path follows the inner path. Its first module binds to the last tile of the inner path with a strength-1 glue and to the first tile of the inner path with a strength- glue. Therefore, the inner path has to be complete before the outer path begins self-assembling and at that point, the representation of is complete. The other modules follow, one after the other, their first tiles binding to the inner path and to the last tile of the previous module.
The glues of the modules are blocked just as they would be during the “regular” simulation. The mortar modules that fully-self-assembles are those on convex edge of the path and their glues are blocked by the inner path. The glues of the tenons are still blocked by the mortar modules they depend on, as they would if they were not part of the outer path.
The inner path also ensures that macrotiles assembled away from the seed cannot grow more than 1 tile deep within the area of because it is adjacent to the outer path. Macrotiles assembled away from the seed that crash into the inner path do not block the assembly of the outer path. The structure of the outer path is the same as the structure of the output sides of “regular” macrotiles, so a macrotile assembling tiles on the corresponding output side of a macrotile does not prevent the assembly of any other macrotile adjacent to . Indeed, the tiles assembled by expose the glues necessary for the outer path to continue its assembly, and the inner path ensure that the right tiles are assembled. Note that it means that the assembly of the outer path is not necessarily sequential: a macrotile assembled away from could initiate the assembly of a part of the outer path before the previous parts in clockwise order, with no other consequences than that early assembly.
The representation function is correctly defined within the seed representation: the inner path goes through each macrotile and Lemma 15 states that the modules from cannot assemble in a way that would follow the other parts of the definition in Section 5.1.
References
- [1] Andrew Alseth and Matthew J. Patitz. The need for seed (in the abstract tile assembly model). In Nikhil Bansal and Viswanath Nagarajan, editors, Proceedings of the 2023 ACM-SIAM Symposium on Discrete Algorithms, SODA 2023, Florence, Italy, January 22-25, 2023, pages 4540–4589. SIAM, 2023. doi:10.1137/1.9781611977554.CH172.
- [2] Florent Becker and Marie de Sainte Marie. OnTAS simulator. Software, swhId: swh:1:dir:59706d65ba40d55deb385105a853b5e36198946f (visited on 2026-06-19). URL: https://gitlab.aliens-lyon.fr/atam-omninuclear-plr-2025-2026/ontas-simulator, doi:10.4230/artifacts.26763.
- [3] Sarah Cannon, Erik D. Demaine, Martin L. Demaine, Sarah Eisenstat, Matthew J. Patitz, Robert T. Schweller, Scott M. Summers, and Andrew Winslow. Two hands are better than one (up to constant factors): Self-assembly in the 2HAM vs. aTAM. In Natacha Portier and Thomas Wilke, editors, 30th International Symposium on Theoretical Aspects of Computer Science, STACS 2013, Kiel, Germany, February 27 - March 2, 2013, volume 20 of LIPIcs, pages 172–184. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2013. doi:10.4230/LIPIcs.STACS.2013.172.
- [4] Ho-Lin Chen, Rebecca Schulman, Ashish Goel, and Erik Winfree. Reducing facet nucleation during algorithmic self-assembly. Nano letters, 7 9:2913–9, 2007. URL: https://api.semanticscholar.org/CorpusID:14512210.
- [5] Holin Chen, Ashish Goel, Chris Luhrs, and Erik Winfree. Self-Assembling Tile Systems that Heal from Small Fragments. In Preliminary Proceedings of DNA Computing 13, pages 30–46, 2007.
- [6] David Doty, Jack H. Lutz, Matthew J. Patitz, Robert T. Schweller, Scott M. Summers, and Damien Woods. The tile assembly model is intrinsically universal. CoRR, abs/1111.3097, 2011. arXiv:1111.3097.
- [7] Constantine G. Evans, Angel Cervera Roldan, Trent A. Rogers, and Damien Woods. Tile blockers as a simple motif to control self-assembly: Kinetics and thermodynamics. In DNA, 2025. URL: https://api.semanticscholar.org/CorpusID:280692785.
- [8] Constantine G. Evans and Erik Winfree. Physical principles for DNA tile self-assembly. Chemical Society Reviews, 46(12):3808–3829, 2017. doi:10.1039/C6CS00745G.
- [9] Saul Thomas Griffith. Growing Machines. Thesis, Massachusetts Institute of Technology / Massachusetts Institute of Technology, 2004.
- [10] Daniel Hader. DanielHader/WebTAS. Software, swhId: swh:1:dir:72a3a175c59387141e3c76ee14e7c41c216a0327 (visited on 2026-06-19). URL: https://github.com/DanielHader/WebTAS, doi:10.4230/artifacts.26762.
- [11] Jacob Hendricks, Matthew J. Patitz, and Trent A. Rogers. Universal simulation of directed systems in the abstract tile assembly model requires undirectedness. In Irit Dinur, editor, IEEE 57th Annual Symposium on Foundations of Computer Science, FOCS 2016, Hyatt Regency, New Brunswick, New Jersey, USA, October 9-11, 2016, pages 800–809. IEEE Computer Society, 2016. doi:10.1109/FOCS.2016.90.
- [12] Dionis Minev, Christopher M. Wintersinger, Anastasia Ershova, and William M. Shih. Robust nucleation control via crisscross polymerization of dna slats. bioRxiv, 2019. URL: https://api.semanticscholar.org/CorpusID:213909869.
- [13] Paul W. K Rothemund, Nick Papadakis, and Erik Winfree. Algorithmic self-assembly of DNA sierpinski triangles. PLOS Biology, 2(12):e424, December 2004. doi:10.1371/journal.pbio.0020424.
- [14] Rebecca Schulman and Erik Winfree. Programmable control of nucleation for algorithmic self-assembly. SIAM J. Comput., 39:1581–1616, 2004. URL: https://api.semanticscholar.org/CorpusID:204116.
- [15] Rebecca Schulman and Erik Winfree. Synthesis of crystals with a programmable kinetic barrier to nucleation. Proceedings of the National Academy of Sciences, 104(39):15236–15241, September 2007. doi:10.1073/pnas.0701467104.
- [16] Tristan Stérin, Abeer Eshra, Janet Adio, Constantine Glen Evans, and Damien Woods. A thermodynamically favoured molecular computer: Robust, fast, renewable, scalable. bioRxiv, 2025. doi:10.1101/2025.07.16.664196.
- [17] Hao Wang. Proving theorems by pattern recognition I. Communications of The Acm, 3(4):220–234, 1960. doi:10.1145/367177.367224.
- [18] Erik Winfree. Algorithmic Self-Assembly of DNA. PhD thesis, California Institute of Technology, June 1998.
- [19] Erik Winfree. Self-healing Tile Sets. In Junghuei Chen, Nataša Jonoska, and Grzegorz Rozenberg, editors, Nanotechnology: Science and Computation, pages 55–78. Springer, Berlin, Heidelberg, 2006. doi:10.1007/3-540-30296-4_4.
- [20] Erik Winfree and Renat Bekbolatov. Proofreading tile sets: Error correction for algorithmic self-assembly. In Junghuei Chen and John H. Reif, editors, DNA Computing, 9th International Workshop on DNA Based Computers, DNA 2003, Madison, WI, USA, June 1-3, 2003, revised Papers, volume 2943 of Lecture Notes in Computer Science, pages 126–144. Springer, 2003. doi:10.1007/978-3-540-24628-2_13.
- [21] Yingwei Zhang, Aleks Reinhardt, Pengfei Wang, Jie Song, and Yonggang Ke. Programming the nucleation of dna brick self-assembly with a seeding strand. Angewandte Chemie, 2020. URL: https://api.semanticscholar.org/CorpusID:211080237.
