Universal Computation and Optimal Construction in the
Chemical Reaction Network-Controlled Tile Assembly Model
Nicholas Schiefer and Erik Winfree
March 21, 2015
Abstract
Tile-based self-assembly and chemical reaction networks provide two well-studied models of scalable
DNA-based computation. Although tile self-assembly provides a powerful framework for describing
Turing-universal self-assembling systems, assembly logic in tile self-assembly is localized, so that only the
nearby environment can affect the process of self-assembly. This locality of control imposes a number
of fundamental constraints on the efficiency with which certain shapes can be assembled from tiles.
We introduce a new model of tile-based self-assembly in which a well-mixed chemical reaction network
interacts with self-assembling tiles to exert non-local control on the self-assembly process. Through
simulation of multi-stack machines, we demonstrate that this new model is efficiently Turing-universal,
even when restricted to unbounded space in only one spatial dimension. Using a natural notion of program
complexity, we also show that this new model can produce many complex shapes with programs of lower
complexity. Most notably, we show that arbitrary connected shapes can be produced by a program
with complexity bounded by the Kolmogorov complexity of the shape, without the large scale factor
that is required for the analogous result in the abstract tile assembly model. These results suggest that
controlled self-assembly provides additional algorithmic power over tile-only self-assembly, and that nonlocal control enhances our ability to perform computation and algorithmically self-assemble structures
from small input programs.
1
Introduction
Biological systems are capable of remarkable self-organization directed by information-carrying molecules
and the complex systems that interpret them. Even more remarkably, these systems are able to modify
themselves through feedback systems, allowing biological units such as the cell to react to changes in the
surrounding environment. In many areas of nanotechnology, we seek to emulate biological systems by
implementing self-assembly processes and dynamical systems at the nanoscale.
Because of its relatively rigid, well-understood structure and the specificity of Watson-Crick hybridization, DNA is a common substrate for work in nanotechnology. So far, work in the field has been loosely
divided into two classes: structural DNA nanotechnology, which involves self-assembly of small DNA
sub-units into larger structures [20, 14], and dynamic DNA nanotechnology, which seeks to implement
the behavior of dynamical systems through fluctuating quantities of chemical species [30]. Both classes
of DNA nanotechnology have been explored extensively, now offering scalable methods for engineering
complex nanoscale structures from small components [17, 18, 3, 26, 11] and both analog and digital
circuits for a variety of task [19, 31, 29, 15, 6]. Furthermore, both classes have well-studied theoretical
models, including a variety of self-assembly models based on Wang tiling [12, 8] and models of abstract
chemical reaction networks for chemical dynamics [23, 24, 7, 5].
Despite the well-established results in these fields, little theoretical work has considered interactions
between structural and dynamic DNA nanotechnology, suggesting that current theoretical models do not
capture the full computational power of biomolecular systems. In biological systems, structure influences
dynamics, and dynamics influences structure: the two are inextricably linked together. Recently, work
by Zhang et al. [32] proposed and experimentally demonstrated a method for controlling the formation
of DNA nanotubes from double-crossover tiles using an upstream catalytic circuit implemented as DNA
1
strand displacement system. However, there is currently little theoretical understanding of the computational power of interacting dynamic and structural biomolecular computing systems; this deficiency was
noted by Zhang et al. [32], and we hope to address it here.
Specifically, we are interested in the ability of biomolecular systems to implement computation and
construction tasks: for the former, our goal is to perform a computation and report the answer, while in
the latter, our goal is produce a particular nano-structure. Although tile self-assembly permits Turinguniversal computation [28] and Kolmogorov-optimal construction (up to scale) [22], the assembly logic
in tile self-assembly is local; only the immediate surroundings of a tile can influence its binding. The inherent locality of information flow in tile self-assembly imposes most of the restrictions on the expressive
power of the model. In contrast, chemical reaction networks are usually formulated with a “well-mixed”
assumption under which chemical species have no position within the reaction vessel. Although this
non-locality allows highly non-local information transfer, it precludes the possibility of assembling large
complexes. In fact, chemical reaction networks are unable to express error-free Turing-universal computation without the ability to form at least one-dimensional structural polymers [4, 16]. In our work,
we aim to leverage the non-local information transfer offered by chemical reaction networks to exercise
non-local control over a two-dimensional (or, in principle, three-dimensional) tile assembly process.
1.1
Our contributions
We introduce the chemical reaction network-controlled tile assembly model (CRN-TAM), a formal model
of molecular computing that uses chemical reaction networks to provide non-local control over a tile
self-assembly process. In doing so, we formalize the capabilities of the type of biomolecular computing
system demonstrated experimentally by Zhang et al. [32], allowing us to reason mathematically about
the capabilities of such a system in comparison to other models of molecular programming. We show that
the CRN-TAM subsumes models of stochastic chemical reaction networks and the abstract tile assembly
model, and establish a number of useful “building blocks” for CRN-TAM programs.
Through the Turing-universality of the aTAM, we demonstrate that the CRN-TAM is Turing-universal.
Furthermore, we show that the CRN-TAM permits the efficient construction of multi-stack machines,
proving that the CRN-TAM is also Turing-universal when restricted to unbounded space in only one
spatial dimension, unlike other models of tile-based self-assembly.
Using a natural notion of program complexity, we then turn to bounding the complexity of a minimal
CRN-TAM program that constructs an algorithmic shape. By explicit construction, we show that there
is a CRN-TAM program that constructs every shape S at scale 2, with complexity bounded by the Kolmogorov complexity of S. Furthermore, we show that this bound is tight. Using a related construction,
we prove that many shapes can be constructed by Kolmogorov-optimal CRN-TAM programs at scale 1,
and that this bound is also tight.
2
Defining the CRN-TAM
We begin by outlining a formal definition of the chemical reaction network-controlled tile assembly model
and provide a number of definitions that will be useful later.
Definition 2.1. A tile is an oriented square with a bond on each side; the bond positions are called
“north,” “south,” “east,” and “west.” Each bond has a distinct label and a strength, which is a nonnegative integer. Formally, a bond is a tuple (`, s) with label ` and strength s ∈ Z+ . For compactness,
we often express a bond (`, 1) evocatively as −` and a bond (`, 2) as =` . A tile is a four-tuple t =
(N, E, S, W ) of bonds for the north, east, south, and west sides, respectively. Throughout this paper,
tiles are denoted by symbols surrounded by boxes, as above.
Definition 2.2. An assembly is a function A : Z2 → (T ∪ {ε}) that gives the type of tile that occupies
each site of the 2D lattice. If A(x, y) = ε, then the site is said to be unoccupied, since there is no tile
there. To be a valid assembly, A must satisfy these properties:
• The origin must be occupied by a tile A(0, 0) 6= ε, which we call the seed of the assembly.
• The occupied sites of the assembly must be connected.
• The total binding strength of each tile in the assembly is at least the temperature τ .
2
Throughout this paper, assemblies are denoted by symbols surrounded by double boxes, e.g.
A
, or
shown in a different color from tiles.
The definitions given in Definition 2.1 and Definition 2.2 are identical to those in previous models
of tile-based self-assembly derived from the abstract tile assembly model [27, 12, 2]. Although it was
implicit in previous “single-crystal” models such as the aTAM, here we explicitly distinguish between
free tiles in solution and growing assemblies, even those that contain only a single tile. This allows us
to ensure formally that free tiles only attach to “activated” assemblies, and not to each other, which is
convenient for avoiding issues of spontaneous nucleation and essential for uniform treatment of “removal
strand” reactions that are described below.
In tile self-assembly, a molecular program in specified by a set T of tiles and their associated bond
strengths, an initial seed tile, and a temperature. Analogously, we can define the structural form of a
CRN-TAM program:
Definition 2.3. A program under the chemical reaction network-controlled tile assembly model is a
tuple (S, T, R, τ, I) where
• S is a finite set of identified signal species.
• T is a finite set of tuples t , t∗ , where t is a tile and t∗ is either ε or some signal species in S.
The species t∗ , if it exists, is called the removal strand for tile
one tuple.
t
. No tile may appear in more than
• R is a set of reactions, each of the form:
k
– A+B −
→ C + D for signals A, B, C, D ∈ {ε} ∪ S. These are the “normal” CRN reactions.
– A+
T
k
−
→ C + D for signals A, C, D ∈ {ε} ∪ S and tile
k
T
. These are tile deletion reactions.
k
→ T + T 0 for signals A, B, C ∈ {ε} ∪ S and tiles T and T 0 .
– A+B −
→ T + C or A + B −
These are tile creation reactions.
k
– A+ T −
→ B + T 0 for signals A, B ∈ {ε} ∪ S and tiles T and T 0 . These are tile relabelling
reactions.
k
→ X + X ∗ , where A ∈ {ε} ∪ S and X , X ∗ ∈ T . This is a tile activation reaction,
– A+ X −
that converts a free tile into the seed of a new assembly.
k
– X + X∗ −
→ A + X , where A ∈ {ε} ∪ S and X , X ∗ ∈ T . This is a tile deactivation
reaction, that converts a seed tile assembly into a free tile.
In all of these reactions, k is some rate constant. All of the constructions in this paper are independent of rate constant, and so it is often omitted for notational simplicity. In all cases where a rate
constant is omitted, it can be assumed to be 1. When any reactant or product is taken to be ε, the
k
interpretation is that the reactant or product does not exist; for example, a reaction A + ε −
→ ε+D
k
is just A −
→ D.
• τ ∈ Z+ is the temperature, or minimum binding strength.
• I is an initial state, which is a multiset of tiles and signals that are initially present. For notational
convenience, we will treat I as a function I : (S ∪ T ) → Z+ where I(z) is the count of species z in
the multiset. No assemblies are initially present.
The elements of the set S of signal species are analogous to “normal” species in a chemical reaction
network and the set T of tiles is analogous to an aTAM tile set. As in the aTAM, tiles may interact with
assemblies to form larger structures. However, in the CRN-TAM, each assembly step is accompanies
by the release of the tile’s associated removal strand, and (unless the removal strand is ε) there is a
corresponding disassembly step possible: A tile may be removed if it is bound to the assembly with a
total binding strength that is precisely the temperature τ and its removal strand is present. As a result,
the behavior of a CRN-TAM program will be dictated not only by the explicitly specified reactions R as
above, but also the tile addition and removal reactions:
3
a)
A +B
b)
C +D
A+
c)
l
o
B
C +D
m
a
A+
d
X
c
n
x
A +B
C+
w
D
l
A+
y
o
z
a
A +B
d
C
+
w
c
x
C+
m
w
D
n
x
b
B
z
y
A+
o
B
T
c
+
w
+ X*
+
b
b
c
d
T
b
b
c
c
b
D
c
n
d)
b
b
c
x
C
d
Xseed
a
d
z
m
d
a
y
a
l
D
a
b
+ T*
b
y
z
Figure 1: Example reactions for a CRN-TAM program. a) Normal chemical reaction network reactions
and tile creation reaction. b) Tile deletion and relabelling reactions. c) Tile activation, tile deactivation
reactions, tile addition reactions, and tile removal reaction.
Definition 2.4. A tile addition reaction has the form
α
+
t
1
−
→
β
+ t∗
wherever α and β are valid assemblies that differ by exactly one tile, t , that is in β but not in α,
where the tuple t , t∗ ∈ T . Note that β being valid implies that t formed new bonds with total
strength at least τ . The corresponding removal reaction
β
may occur only when
t
1
+ t∗ −
→
α
+
t
is bound by exactly strength τ .
Together, the contents of a reaction vessel—including free species and assemblies—completely specify
the state of operation for a CRN-TAM program at any point:
Definition 2.5. A state L of a CRN-TAM program P is a multiset of signals, tiles, and assemblies.
Definition 2.6. The propensity of a reaction is the product of its rate constant and the count of each
of its reactants. The possible reactions of a state L of a CRN-TAM program P = (S, T, R, τ, I) are all
of the reactions in R with non-zero propensity and all tile addition or removal reactions with non-zero
propensity.
Over time, the program evolves from the initial state according to stochastic Gillespie dynamics: that
is, reactions occur at a rate proportional to their current propensity [10]. The time evolution the state
of a CRN-TAM program therefore forms a continuous-time Markov chain.
Definition 2.7. An assembly is a terminal assembly if there are no possible reactions that involve that
assembly at any time in the future. That is, there are no valid tile addition or removal reactions involving
that assembly in the future.
Note that proving that an assembly is terminal can occasionally be done by examination of just
the assembly itself (showing that there is no location where a tile may be added, whether or not the
tile exists in solution, and showing that there is no location where a tile may be removed, whether or
not the removal strand exists in solution), but in the general case one must argue that the CRN-TAM
reactions can never produce the relevant tiles or removal strands, which (as will later become apparent)
is undecidable.
Definition 2.8. Although the time evolution of the state of a CRN-TAM system evolves stochastically,
we may speak of deterministic CRN-TAM systems: systems for which there is at most one possible
forward reaction, and at most one possible reverse reaction, for every state. That is, the system state
space is a one-dimensional line.
Definition 2.9. A chemical reaction network (or more generally, a CRN-TAM program) acting on an
initial state L stops if it is guaranteed to eventually reach a state with no possible further reactions with
probability one.
4
Definition 2.10. A CRN-TAM program constructs a shape S if the program stops with precisely one
terminal assembly, and that assembly has shape S.
To give a natural notion of the “size” of a CRN-TAM program, we introduce a notion of program
complexity. This notion is analogous to the tile set size under the aTAM, or the number of signals and
reactions in a chemical reaction network.
Definition 2.11. The complexity of an initial state I : (S ∪ T ) → Z+ is
X
|I| =
(log I(z) + 1)
z∈(S∪T )
This definition is natural since it is the same as the number of bits needed to specify a general initial
state I, up to constant multiplicative and additive factors.
Definition 2.12. Let P = (S, T, R, τ, I) be a CRN-TAM program (with unit reaction rate constants)
The complexity of P is
X
K(P ) = |S| + |T | + |R| + log τ + |I| = |S| + |T | + |R| + log τ +
(log I(z) + 1)
z∈(S∪T )
Each of the terms is related, up to logarithmic factors, to the amount of information needed to specify
a particular system.
3
Preliminary results
The CRN-TAM is based on its eponymous models: abstract chemical reaction networks and the tile
assembly model. As one would hope, it subsumes both of these models. Subsuming models of stochastic
chemical reaction networks is trivial:
Theorem 3.1. Suppose that a chemical reaction network C consists of species S and reactions R, each
of which has at most two reactants and two products. There is a CRN-TAM program P = (S, ∅, R, 0, L1 )
with dynamics identical to those of C acting on initial state L1 .
In contrast, the abstract tile assembly model requires an unbounded supply of each tile type. Thankfully, this supply is straightforward to generate with a CRN-TAM program:
Theorem 3.2. Let T be a set of tiles for the abstract tile assembly model at temperature τ , and suppose
that T0 ∈ T is the designated seed tile. There is a CRN-TAM program P that simulates the operation
of T with complexity K(P ) ∈ Θ(|T |).
Proof. For each tile
t
∈ T , we introduce the species Ct and the catalytic reaction
Ct → Ct +
t
Additionally, we add a reaction t∗ → ε that consumes the removal strand t∗ for each
state consists of one of each Ct and the seed tile
T0
t
∈ T . Our initial
.
Next, we introduce a number of basic constructions that demonstrate the flavor of CRN-TAM programs.
Lemma 3.1. For any non-negative integer k, there exists a chemical reaction network powerCounter(k, A, B)
with Θ(k) chemical species and Θ(k) chemical reactions that counts deterministically from 0 to 2k − 1
when species A is present and releases species B when it is finished.
Proof. Let #(a) be the number of molecules of species a at a specified time.
We introduce the sequences of species X0 , X1 , . . . , Xk−1 , S0 , S1 , . . . , Sk , and Y0 , Y1 , . . . Yk−1 . We
construct our counting circuit as a binary counter, where the pair (Xi , Yi ) is a dual-rail representation
of the state of the ith bit of the counter; that is, if #(Xi ) = 1, then #(Yi ) = 0, and if #(Xi ) = 0,
then #(Yi ) = 1. By convention, the value of #(Xi ) is the value of the bit. The Si species will serve as
(single-rail) digit carry markers. For k-bit counting, we produce a CRN with the following method:
5
1. For each bit i, we introduce the reactions
Si + Yi → Xi + S0
Si + Xi → Yi + Si+1
2. Add the reaction A → S0 to start the binary counting
3. Add the reaction Sn → B to indicate that the counting is finished
The initial state of our binary counting CRN is simply the full collection of species Y0 , . . . , Yk−1 ,
indicating that the initial state of the counter is 0.
Notice that the structure of the reactions ensures that the following properties hold by simple induction:
• At every time between the consumption of A and the creation of B,there is exactly one of the Si
carry species at all times, since every other reaction consumes one of these and produces one of
these.
• At any time, exactly one of (Xi , Yi ) is present, since every reaction “flips a bit” by consuming one
{Xi , Yi } and producing the other.
• The reactions implement precisely the carry behaviour of a binary counter with k bits.
• At any time, there is only one reaction that can take place, by the above properties, and so the
CRN works deterministically.
Observer that in our constructed k-bit counter, we introduce 3k + 2 ∈ Θ(k) species and 2k + 2 ∈
Θ(k) reactions. Thus, the constructed circuit—which we call powerCounter(k, A, B)—has the desired
properties.
With a slightly modified construction, we can count from 0 to any number n in Θ(log n) signals and
reactions:
Theorem 3.3. Let n be a positive integer. There exists a chemical reaction network binaryCounter(n, A, B)
with Θ(log n) chemical species and Θ(log n) bimolecular chemical reactions that counts deterministically
from 1 to n when species A is consumed and releases species B when it is finished.
Proof. By Lemma 3.1, we can construct f (A, B) that counts from 0 to 2dlog ne − 1 using Θ(dlog ne) =
Θ(log n) species and reactions. By extending this with one addition C and the reactions Sn → C, C → B
instead of Sn → B, we may have it effectively count from 0 to 2dlog ne instead.
We modify our construction from Lemma 3.1 by adding a different initial state. Let b0 b1 · · · bdlog ne
be the unique binary representation of 2dlog ne − n ≥ 0, by definition. Then, our initial state (instead of
a full sequence of off-bit Yi ) will be, for all i,
#(Xi ) = bi ,
#(Yi ) = 1 − bi
In effect, our dlog ne-bit counter starts with a value of 2dlog ne − n, which we identify as “zero”, and ends
in the state 2dlog ne , which is therefore identified as 2dlog ne − 2dlog ne + n = n.
Since this construction adds dlog ne ∈ Θ(log n) species, our program still has complexity Θ(log n)).
Although the binary counter is very simple, it is extremely powerful because it allows us to efficiently
program a certain number of initiations of a broad class of CRNs:
Definition 3.1. A chemical reaction network C evolving from a singleton state L is confluent if and
only if C stops and indicates that it has stopped with a single count of one of its species.
Corollary 3.1. Let n be a positive integer and C be a confluent CRN that is initiated by species X
and terminated by species Y . There is a CRN binaryCounter0 (n, A, B, C) with Θ(log n) + |C| chemical
species and Θ(log n) + |C| chemical reactions that counts deterministically from 1 to n, that initiates C
after every count and continues only when it has stopped.
Proof. We modify our construction from Theorem 3.3 by adding the following reactions:
• For each bit i, we have the reaction Si + Yi → Xi + X instead of reaction Xi + Yi → Xi + S0 .
• We introduce the reaction Y → S0
6
By Lemma 3.1 and Theorem 3.3, this circuit will clearly count from 1 to n, releasing X after each
count and continuing only when Y is released. Thus, the circuit is correct since C is a single-path
CRN.
It is intuitively useful to consider the initial state I of a CRN-TAM program P . However, the following
theorem shows that the addition of the initial state does not provide any additional algorithmic power
over the model with no additional state.
Theorem 3.4. Let P = (S, T, R, τ, I) be any CRN-TAM program that cannot start until some species F
is released. We define a special signal Q∗ and let fQ∗ be a function such that fQ∗ (Q∗ ) = 1 and f (s) = 0
for all s ∈ S. There exists a program P 0 = (S 0 , T 0 , R0 , τ, fQ∗ ) with K(P 0 ) ∈ Θ(K(P )) that has the same
graph of possible states after Θ(|I|) initital states.
Proof. Let Z ⊆ (S ∩ T ) be the set of s ∈ (S ∩ T ) with I(s) > 0, and let Z˜ = (z1 , z2 , . . . , z|Z| ) be an
arbitrary ordered sequence of Z. Let k = |Z|.
For each zi , let Ci be the chemical reaction network Qi → zi + Hi , and note that C is a single-path
CRN that simply creates one zi .
Let P 0 be the CRN-TAM program obtained by adding these reactions and species to P :
• Add the signal Q|Z|+1 .
• For each zi , add a new signal Qi , and a “working” binary counter binaryCounter0 (I(zi ), Qi , Hi , Ci ).
• Add the reaction: Hi → Qi+1 .
• Add the initial reaction Q∗ → Q1 .
This construction is illustrated in Figure 2.
By Corollary 3.1, each binary counter will produce precisely I(zi ) for each species zi when Qi is
present.
We can now show that when Qi+1 is released, we have the correct “initial state” counts of all species
zj , j ≤ i. In the base case, notice that the presence of Q∗ caused the release of Q1 , which correctness of
the binary counter, will cause the release of I(z1 ) of species z1 . Now, suppose that when Qk+1 is released,
we have the correct counts of all species zj , j ≤ k. Then, notice that the release of Qk+1 initiates the
release of exactly I(zk+1 ) of zk+1 , and also the release of Qk+2 .
By induction, this when species Q|Z|+1 is released, all of the species zi ∈ Z will have the correct
initial counts.
Since Ci requires a constant number of species and reactions, by Corollary 3.1, each binary counter and
the associated reactions contribute Θ(log I(zi )) complexity. Thus, by construction, P 0 has complexity:
K(P 0 ) = |S 0 | + |T 0 | + |R0 | + log τ + 1
= |S| + |{Qi }ki=1 | + |T | + |R| + O(1) + log τ +
k
X
Θ(log I(zj ))
j=1
= |S| + |T | + |R| + log τ +
k
X
Θ(log I(zj ))
j=1
= Θ(K(P ))
So long as our CRN-TAM program is deterministic at its starting state, the initial state does not
enable any reduction in program complexity. In contrast, fixed initial state provides the aTAM with
potentially very large reductions in program complexity. A careful reader will notice that the notion
of program equivalence introduced in Theorem 3.4 is a restriction of the notion of weak bisimulation,
which rigorously establishes a notion of equivalence for concurrent systems. In this paper, all of our
constructions use deterministic CRN-TAM programs, and so this theorem will always apply.
This theorem also has a very simple corollary that immediately tells us that the CRN-TAM is in
some ways more powerful than the aTAM:
Corollary 3.2. A 1 × n rectangle can be constructed by a program P with only a singleton initial state
with K(P ) = O(log n).
7
Initial state:
Q*
A
A
B
....
S1
S2
....
Binary
Counter
Binary
Counter
T
T'
Sk-1
Sk
Binary
Counter
B
T
F
Binary
Counter
T'
Figure 2: Illustration of the construction for Theorem 3.4. Starting the singleton “starter species”, we use
the binary-counting CRNs from Corollary 3.1 to produce the correct number of each initial species. When
each binary counter finishes, it starts the binary counter for the next species.
Proof. Let P = (∅, {x}, ∅, 1, I) where I(x) = n and T is simply a tile with the same strength-1 glue
on two opposite sides (say, east and west). Clearly, P assembles a 1 × n rectangle. By definition,
K(P ) = O(log n), and note that this program will not start building until a seed tile is release. By
Theorem 3.4, there exists a program P that assembles the 1 × n rectangle using only a singleton initial
state with K(P 0 ) = O(log n).
In contrast, the size of a tile set (the notion of program complexity for the aTAM) that produces a
1 × n rectangle is Θ(n) [2]. Similar bounds have been established for other models of tile self-assembly,
including the negative glues model [13].
The CRN-TAM also permits the construction of exactly m-copies of a shape that can be constructed
deterministically:
Theorem 3.5. Given a deterministic CRN-TAM program P that constructs a shape S, there is a CRNTAM program P 0 that constructs m copies of S with complexity K(P 0 ) = O(K(P ) + log m).
Proof sketch. Since P constructs S deterministically, at each time there is at most one possible tile
addition. We construct P 0 by replacing the release of a single tile by P with a binary counter that
releases m copies of that tile, and then waits for all of them to attach before continuing. To avoid having
several of these released tiles gathering together, we label all of the tiles in P with the color red, and
introduce an identical set of tiles with color black. We adjust the bonds so that red tiles may only bond
to black tiles, and black tiles may only bond to red tiles. This creates a chequerboard, and ensures proper
assembly.
Since P is deterministic, we only need a constant number of binary counters. By Corollary 3.1, this
takes O(log n) extra complexity.
4
Turing-universality
With these preliminaries, we consider the ability of CRN-TAM programs to simulate the operation of a
Turing machine—which allows it to perform arbitrary computation—under various circumstances.
Theorem 4.1. The CRN-TAM is Turing-universal at temperature τ = 2.
Proof. Given an aTAM tile set T , we may construct a CRN-TAM program P = (∅, T, ∅, 2, Iseed ) that
simulates it at temperature 2. Thus, the CRN-TAM is Turing-universal by the Turing-universality of the
aTAM [27].
Since the CRN-TAM subsumes the aTAM, Theorem 4.1 is far from surprising. However, the construction used to show the Turing-universality of the aTAM relies critically on the ability for Wang tilings
to represent computation histories: the state of the Turing machine tape at each step. Importantly, this
requires potentially unbounded space in both spatial dimensions. Through clever use of DNA strand
displacement polymers, Qian et al. [16] showed the Turing universality of polymer reaction networks
8
SS11
X
X11
...
SS11
X
X11
...
Y11
Y
Y1
Y11
Y
Y1
A
N1
N1
1*
D
A'
B
SS11
X
X11
...
SS11
X
X11
...
Y11
Y
Y1
Y11
Y
Y1
N1
A
1*
D
A'
N1
B
Figure 3: Illustrations of the push and pop operations for a stack machine. On the left, the push operation
“state A goes to state B, pushing symbol N onto stack 1” is shown. During a push operation, a stack-specific
symbol is released, along with an intermediate species A0 . The finite control waits for the stack- (but not
symbol-) specific removal strand 1∗ before continuing. On the right, the pop operation “from state A, pop
a symbol from stack 1. If it is an N , go to state B” is shown. The pop operation is basically the reverse of
the push operation.
by constructing multi-stack machines. Since each stack is one-dimensional, the construction requires
unbounded space in only one spatial dimension to provide Turing universality. A related construction
for the CRN-TAM provides an analogous result:
Lemma 4.1. Consider a (deterministic or non-deterministic) stack machine M = (Q, Σ, δ, k, q0 ), consisting of a finite set of states Q, a symbol alphabet Σ, an integer k giving the number of stacks, an initial
state q0 ∈ Q, and a set of transition rules δ where each element of δ is one of:
1. α1 → α2 for states α1 , α2 ∈ Q
σ
2. α1 + popj −
→ α2 , σ ∈ Σ for states α1 , α2 ∈ Q, corresponding to popping a symbol off of stack j.
3. α1 → pushj (σ) → α2 for states α1 , α2 ∈ Q and symbol σ ∈ Σ, corresponding to pushing a symbol σ
onto stack j.
There is a program P = (S, T, R, 1, I) that simulates M with K(P ) = O(|Q| + |Σ| + |δ|). Furthermore,
it requires unbounded space in only one geometric dimension, and runs in constant space in the other.
Proof. We show the result by construction, showing how to “compile” a stack machine M into a CRNTAM program P . Our construction, based on the one used by Qian et al. [16], is:
• For each state αi ∈ Q, we introduce the species Si and Si0 , including the initial state q0 (represented
by S0 ).
• For each stack k, we introduce:
– A “stack query species” Qk
– For each symbol σ ∈ Σ, a tile
– A tile
λk
σk
= (∅, −k , ∅, −k )
= (∅, −k , ∅, ∅) that represents the “end of stack”
• For each transition in δ:
1. Implement transitions of the form αi → αj with the reaction
Si → Sj
σ
2. Implement transitions of the form αi + pop` −
→ αj with the reactions
Si → Q` + Si0 ,
σ`
+ Si0 → Sj
3. Implement transitions of the form αi → push` (σ) → αj with the reactions
Si →
• Include as initial state one of each
λk
σ`
+ Si0 , Si0 + Q` → Sj
and one of species S0 .
9
The idea behind this construction is to represent the finite state with the presence of one of the Si
species, and use tiles to construct a physical “stack” assembly of tiles for each stack in the stack machine.
By identifying each tile with a stack’s identity, we are able to restrict the symbol to interactions wit the
desired stack. To show correctness, we demonstrate that the transitions are correct, and argue that the
possible reactions at each point are precisely the valid transitions from the current state in δ.
Clearly, reactions of type (1) are correct, since the reaction Si → Sj is a direct implementation of the
transition αi → αj .
Reactions that perform pushes and pops are somewhat more complicated. To pop a symbol from
stack `, we produce the stack query species Q` and the “state storage species” Si0 that indicates that we
are in the process of transitioning out of state αi . Since Q` is the removal species of every one of the
σ` , ∀σ ∈ Σ, this will cause the removal of the only “exposed” tile on stack `. Then, this tile σ` can
react with Si0 to produce the state transition to Sj .
Similarly, to push symbol σ onto stack `, we release
σ`
with the reaction Si →
σ`
+ Si0 , releasing
Si0
to indicate that we are in the process of transitioning out of state αi . When the tile σ` attaches to
the assembly for stack `, it will release its removal species Q` . The removal species will then react with
Si0 , which transitions to another state.
Lastly, note that at any point in time, exactly on of the Si or Si0 is present, and every reaction both
produces and consumes exactly one Si or Si0 . Thus, the progress of the CRN is deterministic, except
possibly where a single Si could transition in several ways (if the stack machine is non-deterministic).
Theorem 4.2. Let U be a Turing machine. There exists a CRN-TAM program that simulates the
operation of U , and requires unbounded space in only one geometric dimension, while running in constant
space in the other. That is, the CRN-TAM is Turing-universal when running in one spatial dimension.
Proof. It is well known that multi-stack pushdown automata are equivalent to Turing machines [21].
Observe that a multi-stack pushdown automaton can be implemented using the same construction used
in Lemma 4.1. Thus, U may be implemented by way of an equivalent multi-stack pushdown automaton.
By having the stacks grow in opposite directions, the pushdown automaton will run in constant space in
one spatial dimension.
There are two critical differences between Theorem 4.1 and Theorem 4.2. First, the aTAM is Turinguniversal only at temperature 2, since algorithmic self-assembly is required for universality. In contrast,
the CRN-TAM can simulate stack machines at temperature 1, and is thus Turing-universal at all temperatures. Second, the CRN-TAM supports Turing-universal computation using unbounded space in only
one spatial dimension, while the aTAM requires unbounded space in both spatial dimensions for universality. Interestingly, negative glues also allow for a restricted version of this result, where assemblies can
be split into one-dimensional assemblies but cannot be deconstructed completely [9].
5
Kolmogorov-optimal assembly of algorithmic shapes
We now turn our attention to the problem of constructing a geometric shape S using the CRN-TAM
program of minimal complexity.
Definition 5.1. A shape S is a connected subset of the 2-dimensional lattice Z2 under the translation
equivalence relation S = S 0 if and only if S 0 is the image of S under a function of the form t(x, y) =
(x + β, y + γ) for β, γ ∈ Z. A c-scaling of a shape S is the shape sc (S) that is obtained by replacing each
square of S with a c × c block of squares.
We follow the usual definition of the Kolmogorov complexity of a binary string x with respect to a
fixed universal Turing machine U as the minimal size of a program for U that outputs x. We extend this
notion to a shape S with the following definition:
Definition 5.2. The Kolmogorov complexity of a shape S with respect to a universal Turing machine U
is the minimal size of a program U that outputs S as a list of coordinates. We denote the Kolmogorov
complexity of S by K(S).
Definition 5.3. The CRN-TAM complexity of a shape S at temperature τ is the minimum complexity of
any CRN-TAM program that constructs S. We denote the CRN-TAM complexity of S at temperature τ
˜ τ (S).
as K
10
A
A'
2*
X2
Y1
X1
Y2
S1
S2
...
Z2
X2
T*
Y1
Start
B
...
T
C
Figure 4: Illustration of the construction of a shape S at scale 2 using a Kolmogorov-optimal CRN-TAM
program.
Theorem 5.1. For any shape S, the CRN-TAM complexity of s2 (S) at temperature 2 satisfies:
K(S)
˜ 2 (s2 (S)) ∈ Θ
K
log K(S)
We will prove this theorem as two lemmas: Lemma 5.1 for the upper bound, and Lemma 5.2 for the
lower bound.
Lemma 5.1. For any shape S, there exists a CRN-TAM program P = (S, T, R, 2, I) with
K(S)
K(P ) ∈ O
log K(S)
that constructs S at scale 2.
Proof. Our proof, inspired by Soloveichik and Winfree [22], uses a construction of a CRN-TAM program
that satisfies the desired complexity bound. Our construction will make use of a simulated Turing
machine and a finite set of “path building” tiles.
In our construction, we reduce the problem of constructing S at scale 2 to the problem of constructing
a path around the spanning tree of S. To do this, we introduce a set of tiles Tc that consists of all possible
tiles with one exactly two strength-one bonds of the same type. These tiles can produce any path in the
2D lattice, and the specific path is determined by the sequence in which tiles are released.
Let U be a universal Turing machine, and define χ to be a program for U that outputs the Z2
coordinates of each point in S. We construct a program φ for U that does the following:
1. Run χ to obtain the lattice points in S.
2. Pick some point in S, then use a depth-first search to find a spanning tree of S.
3. Construct a path W ⊂ Z2 through the (scale 2) lattice that walks around the perimeter of the
spanning tree.
11
Our CRN-TAM program uses the construction from Theorem 4.2 to simulate U running φ. We may
assume without loss of generality that U acts on a binary alphabet
Then, using the implementation of U , the CRN-TAM program begins at the start of path W and
releases appropriate tiles one-by-one to fill in the lattice sites occupied by W . This construction process
is illustrated in Figure 4.
Since every shape has a spanning tree, we may always find one with depth-first search. Furthermore,
notice that when we scale the spanning true to scale 2, there is always space for a perimeter walk W .
Thus, P will always construct c2 (S).
Now, suppose that φ is the Kolmogorov-optimal program that outputs S, so that |χ| = K(S). Since
all parts of φ other than χ are independent of the shape S and thus constant, |φ| = Θ(|χ|) = Θ(K(S)).
Using the same construction used by Soloveichik and Winfree [22], which is in turn inspired by
Adleman et al. [1], we can encode and unpack φ into an assembly with φ encoded as bonds along the
north edge with
|φ|
K(P )
O
=O
log |φ|
log K(P )
tile types in a set Tp These may be continually produced using the construction in Theorem 3.2. We may
then add an addition row to this assembly that “reads off” the bits and pushes them onto a stack of the
Turing machine to use. Lastly, we may disassemble this “unpacking” assembly by deleting the “read-off”
row using the appropriate bit-specific removal strands, and by deleting the rest of the assembly using
some shared removal strand. Thus, K(P ) ∈ O(K(S)/ log K(S)).
Lemma 5.2. For any shape S, every CRN-TAM program P = (S, T, R, τ, I) that constructs S at fixed
scale m has
K(P ) log K(P ) ∈ Ω(K(S))
Proof. First, note that there is a constant size program psim that takes a binary description of a CRNTAM program and simulates its operation. We construct our program so that it will output the coordinates of the occupied squares of the final assembly if the program constructs a shape. If the program
stops without meeting this condition, it indicates failure.
Since P constructs S, running psim on a binary encoding of P will output the coordinates of S.
Observe that we may encode P by specifying the number of signals |S|, the number of tiles |T |, the
bond types of each tile, the identities of the species in each reaction, the temperature τ , and which species
have initial state (and how much of each species we have). We encode these in binary as follows:
• |S|, |T | and τ are encoded as a binary numbers.
• The tiles and bond types are specified using the construction by Soloveichik and Winfree [22], which
takes 4|T |dlog(4|T |)e + 16|T | bits.
• The identities of the species for each reaction are encoded by their index in some canonical ordering,
taking up at most d4 log(|S| + |T |)e bits
• The initial state is encoded by specifying the initially present species and their initial counts, taking
up at most |I| + log(|S| + |T |) bits.
Thus, we have a program that outputs the coordinates of S specified in:
EP = |psim | (dlog |S|e + dlog |T |e + dlog τ e + 4|T |dlog(4|T |)e + 16|T | + d4 log(|S| + |T |)e + |I| log |I|) K(P ))
bits, and so it must be that K(S) ≤ EP . Note that since there is some c, d > 0 such that cEP + d ≤
K(P ) log K(P ), K(P ) log K(P ) ∈ Ω(K(S)).
With Theorem 5.1, we demonstrate the immense algorithmic power of the CRN-TAM over previous
models of tile-based self-assembly. Although an analogous result holds for the aTAM, it allows construction of a shape S only at a (possibly very) large scale c, which is polynomial in the runtime of U on
φ [22]. Constant-scale construction of algorithmic shapes with Kolmogorov-optimal tile sets is possible
with temperature programming; however, these results require a number of temperature changes that is
linear in the size of the shape [25]. However, the number of temperature changes is a part of the natural
definition of program complexity for temperature programming models. In contrast, the CRN-TAM
permits construction of shapes at scale 2 with a Kolmogorov-optimal program complexity.
Having shown that the CRN-TAM permits Kolmogorov-optimal construction at scale 2, we wonder
if it is possible to construct them at scale 1 (i.e. exactly) as well. We will show that this is possible for
12
an extremely broad set of shapes, which we will call “cap-able shapes.” The precise definition is implicit
in the construction below: it is those shapes for which the construction can work without any collision.
Theorem 5.2. For all cap-able shapes S, the CRN-TAM complexity of S (at scale 1) at temperature 2
satisfies:
K(S)
˜ 2 (P ) ∈ Θ
K
log K(S)
Proof. The lower bound follows immediately from Lemma 5.2.
To show the upper bound, we use a construction very similar to the construction in Lemma 5.1.
As before, let U be a universal Turing machine, and define χ to be a program for U that outputs the
coordinates of each point in S. Our program φ for U is:
• Run χ to obtain the lattice points in S.
• Pick some point in S, then use a depth-first to find a spanning tree of S. This point shall be the
“start point.”
Using the construction from Theorem 4.2, our CRN-TAM program simulates the operation of U on φ.
Our techniques from before work so long as the out-degree of every point in the spanning tree is at
most one (i.e. wherever our tree is simply a path). However, when we reach a point with out-degree
of 2 or 3—a point we will call a branching point—we need a way to build one branch deterministically
before building the other. To do this, we introduce stacks “capping tiles,” which are temporary tiles
that block the branches that are not being built immediately. As we will show later, each branch has a
unique depth of capping tiles, ensuring that it is uniquely addressable. We have separate capping tiles
for each cardinal direction, and we maintain two colors of capping tile (where each color will only bind
to the other color) to enforce one-at-a-time addition, like in Theorem 3.5.
The CRN-TAM program can execute the following logic to build S:
1. Initialize the counters nN , nE , nS , nW to zero and the boolean c = red (the other value is black).
2. Starting at the root of the directed spanning tree, perform a depth-first search of the spanning tree.
3. If the spanning tree does not branch at the current coordinate point, release the appropriate tile to
fill the current lattice point, like in Theorem 5.1.
4. If the spanning tree branches at the current coordinate point:
(a) Let the out-degree of the current point be d.
(b) For i = 1, . . . , d:
i. Release nN north capping, nE east capping tiles, nS south capping tiles, and nW west
capping tiles, all of color c. Use the Turing machine to wait for all of them to bind.
ii. Flip the color c.
(c) Add the appropriate branching tile for the current location.
(d) Release capping tiles for each direction of branching from the current point. Release one for
the first direction, two for the second, and three for the third (if d = 3). Wait for all of these
to bind. They should alternate in color.
(e) Increment the counters for the directions of the current point’s branches.
(f) For each branch growing out of the current point:
i. Release d(nN + nE + nS + nW ) capping tile-removal strands of color c. Wait for the tiles
to appear in solution, and consume with a counter on the Turing machine.
ii. Flip the color c.
iii. Decrement the counter for the direction of this branch by one.
iv. Run this procedure recursively on the branch that is now uncapped.
An example of this process is provided in Figure 5.
When a stack of capping tiles is first created, its height is unique. Then, since we always increase the
height of all capping stacks by d before creating d new capping stacks, and decrement the height of the
stacks only when we delete a capping stack, the height of every stack remains unique by induction.
Thus, only one branch has an exposed bond (without a capping stack) at any time, and so our assembly
process can proceed deterministically. Our program is guaranteed to produce exactly the shape S, at
scale 1.
13
Like in Lemma 5.1, our entire construction can be described in constant size, except for the encoding
of φ. Therefore, K(P ) ∈ O(K(S)/ log K(S)), like before.
The proof given for Theorem 5.2 works so long as we have sufficient space to build the capping
stacks, which can grow quite large: they encode a number in unary, among other problems! However,
many shapes have spanning trees with very little branching. For example, all “scale 2” shapes have nonbranching spanning tees, and many other shapes have spanning trees whose branches point “outwards”
(i.e. away from the spanning tree) so that the depth of the capping stacks does not matter. Since
our Turing machine can know from pre-planning whether a capping stack will collide with some of the
shape that is already built, the construction allows us to build and shape where there is some starting
point on the shape that permits construction. The fundamental difficulty with our attempts at scale
1-construction comes from the inability to uniquely label possible sites for tile addition in a compact
way. It is plausible that our construction can be adjusted to use binary-encoded stacks, which should
enlarge the class of cap-able shapes.
Although we do not have a more direct and intuitive characterization of the class of cap-able shapes,
it includes many shapes of interest. For example, any shapes that has a non-self-intersecting path on its
coordinates points is constructable, since such a path does not have branching points. Similarly, many
“star” shapes are constructable, even though they are non-convex.
6
Impossibility Results
Clearly, the CRN-TAM is a powerful model for computation and construction of algorithmic shapes.
However, it remains interesting to consider the limitations on the computational and constructive power
of the CRN-TAM. While negative results are often challenging to prove, we have established some limits
on the algorithmic power of the CRN-TAM.
A tile t in a CRN-TAM assembly is said to be on the interior of the assembly if there is at least
one tile sharing a bond with
t
that was added after
t
in the self-assembly process.
Lemma 6.1. A tile in the interior of an assembly cannot be removed.
Proof. Consider a tile
t
t
be a tile in the interior of an assembly and suppose that
in the assembly. Furthermore, suppose that
Suppose that
and
t
t
t
t
shared a bond with
.
is bound directly to the seed of the assembly. Then, the bond between the seed
must have strength at least τ . When
between
was added after
b
b
t
was added to the assembly, the total binding strength
and the assembly was at least τ , and so the current binding strength of
is at least τ + 1. Now, suppose that
t
t
in the assembly
was not bound directly to the seed when it was added to the
assembly, and suppose by the inductive hypothesis that
t
is bound to an interior tile that cannot be
removed. Like before, the binding strength between t and the rest of the assembly is at least τ and so
the current binding strength is at least τ + 1.
By induction, no interior tile can be removed from the assembly.
More generally, the CRN-TAM self-assembly process creates a dependency graph such an assembly
can only be disassembled in dependency-reversed order.
Definition 6.1. A tile
shares a bond with
x
x
is dependent on tile
t
if
x
was added to the assembly after
or shares a bond with a tile that is dependent on
x
x
and either
.
This recursive definition of dependency imposes an implicit directed, acyclic graph of dependencies.
To disassemble and assembly, we must recursively remove tiles from the leaves of the dependency DAG:
Theorem 6.1. If Q is the set of all tiles that are dependent on a tile
from the assembly until every tile
dependent tiles have been removed.
q
t
, then
t
cannot be removed
∈ Q is removed. That is, a tile cannot be removed until all of its
14
a)
b)
c)
d)
Tile to be
added
Figure 5: Illustration of the capping tile stack construction for scale 1 Kolmogorov-optimal assembly. In
part (a), we have just added the tile on the far right with out-degree three. Notice that the “leftover” branch
from a previous branching point is still capped with a red capping tile. In part (b), we have added the
capping tiles that protect the bonds of the tile added in part (a). Notice that we add capping tiles to all
stacks, maintaining the invariant that every stack of capping tiles has a unique depth. Note also that the
alternating color of the capping tiles ensures one-at-time addition to each stack. In part (c), we have started
to assemble the south-facing branch. We have already removed a full layer of capping tiles (one from each
capping stack); this layer can be removed without damaging the next layer because of the stripped colors.
The tile indicated can now bond to the available site. In part (d), the tile and its successor have bound to
the assembly. To continue assembly, we will remove the next layer of (red) capping tiles, exposing another
branch to construction.
15
Proof. In the base case, Q is a set of one element. In that case, t is interior, and so cannot be removed
by Lemma 6.1.
Suppose that |Q| = k, and that t cannot be removed until every tile q ∈ Q has been removed.
Furthermore, suppose that a new tile
Q0 = Q ∪ {
x
}. By definition,
cannot be removed until
removed, and so
induction.
t
x
x
x
is added to the assembly so that it depends on
must be bound to some tile
has been removed. Since
y
y
∈ Q. Since
y
∈ Q, we cannot remove
t
, and let
is an interior tile, it
t
until
y
has been
0
cannot be removed until every tile in Q has been removed. The result follows by
One (limiting) consequence of Theorem 6.1 is the impossibility of creating “temporary scaffolding”:
a CRN-TAM program cannot build permanent parts of an assembly that are dependent on parts that
are to be removed later, or it will be impossible to remove the scaffolding later.
7
Open Questions
Although we have demonstrated the power and expressiveness of the CRN-TAM for Turing-universal
computation and Kolmogorov-optimal construction, many open questions about the capabilities and
limits of the CRN-TAM remain.
One major limitation of our work is the inability to show the existence of Kolmogorov-optimal CRNTAM programs for construction at scale 1. This poses the interesting open question: is there a CRNTAM program P that can construct any shape S at scale 1 with complexity K(P ) ∈ O(K(S)/ log K(S))?
Irrespective of the answer, an answer to this question will be fascinating: if the answer is “yes,” then the
result will be an impressive demonstration of the power of the CRN-TAM. If the answer is “no,” we will
have uncovered a surprising divide between the complexity of constant scale self-assembly and unit-scale
self-assembly. In any case, this question warrants further investigation.
In our work, we have not considered the time complexity of computation or construction. In fact,
many of our constructions proceed quite slowly under Gillespie dynamics. There are therefore numerous
open questions related to the time complexity of CRN-TAM programs. Similar questions about the
volume complexity of our programs remain open.
Chemistry is an inherently parallel computational medium, yet all of our constructions have been
designed to engineer around this parallelism through carefully enforced determinism. Whether the parallelism of chemistry provides additional expressive power in the CRN-TAM remains to be seen. Preliminary results indicate that this is probably so; since our binary counting program is deterministic, the
expected time to completion for a binary counter CRN that counts to n is Θ(n). In contrast, consider
the chemical reaction network consisting of reactions Ai → 2Ai+1 for all i ≤ log n. Based on this CRN,
we can construct a counting program that (for example) executes some confluent CRN n times, but with
an expected time to completion of Θ(log n) instead.
A treatment of the robustness of CRN-TAM programs under random error is also needed. The
existence of error correcting schemes for CRN-TAM programs remains open, too. Lastly, we hope that
there are molecular motifs that can implement CRN-TAM programs, likely based on the preliminary work
by Zhang et al. [32]. In their work, they present a molecular motif for activating and deactivating tiles;
together with existing motifs for algorithmic tile self-assembly and DNA strand displacement circuity,
this motif provides most of a possible molecular implementation of the CRN-TAM. We expect that
the chief difficulty in a molecular implementation of CRN-TAM programs will be enforcing the proper
interactions between tiles and their removal strands.
References
[1] Leonard Adleman, Qi Cheng, Ashish Goel, and Ming-Deh Huang. Running time and program size
for self-assembled squares. In STOC ’01: Proceedings of the thirty-third annual ACM symposium
on Theory of computing. ACM Request Permissions, July 2001.
[2] Gagan Aggarwal, Qi Cheng, Michael H Goldwasser, Ming-Yang Kao, Pablo Moisset de Espanes,
16
and Robert T Schweller. Complexities for Generalized Models of Self-Assembly. SIAM Journal on
Computing, 34(6):1493–1515, January 2005.
[3] Robert D Barish, Rebecca Schulman, Paul WK Rothemund, and Erik Winfree. An informationbearing seed for nucleating algorithmic self-assembly. Proceedings of the National Academy of Sciences, 106(15):6054–6059, 2009.
[4] Luca Cardelli and Gianluigi Zavattaro. On the computational power of biochemistry. In K. Horimoto,
G. Regensburger, M. Rosenkranz, and H. Yoshida, editors, Algebraic Biology (Lecture Notes in
Computer Science 5147), pages 65–80. Springer-Verlag Berlin Heidelberg, 2008.
[5] Ho-Lin Chen, David Doty, and David Soloveichik. Deterministic function computation with chemical
reaction networks. Natural computing, 13(4):517–534, 2014.
[6] Yuan-Jyue Chen, Neil Dalchau, Niranjan Srinivas, Andrew Phillips, Luca Cardelli, David Soloveichik, and Georg Seelig. Programmable chemical controllers made from DNA. Nature nanotechnology, 8(10):755–762, 2013.
[7] Anne Condon, Alan J Hu, J´
an Maˇ
nuch, and Chris Thachuk. Less haste, less waste: on recycling
and its limits in strand displacement systems. Interface focus, 2(4):512–521, 2012.
[8] David Doty. Theory of algorithmic self-assembly. Communications of the ACM, 55(12), December
2012.
[9] David Doty, Lila Kari, and Benoˆıt Masson. Negative interactions in irreversible self-assembly. Algorithmica, 66:153–172, 2013. Preliminary version appeared in DNA 2010.
[10] Daniel T Gillespie. A general method for numerically simulating the stochastic time evolution of
coupled chemical reactions. Journal of computational physics, 22(4):403–434, December 1976.
[11] Yonggang Ke, Luvena L Ong, William M Shih, and Peng Yin. Three-dimensional structures selfassembled from DNA bricks. Science, 338(6111):1177–1183, 2012.
[12] Matthew J Patitz. An introduction to tile-based self-assembly and a survey of recent results. Natural
Computing, 13(2):195–224, 2014.
[13] Matthew J Patitz, Robert T Schweller, and Scott M Summers. Exact shapes and Turing universality
at temperature 1 with a single negative glue. In DNA’11: Proceedings of the 17th international
conference on DNA computing and molecular programming. Springer-Verlag, September 2011.
[14] Andre V Pinheiro, Dongran Han, William M Shih, and Hao Yan. Challenges and opportunities for
structural DNA nanotechnology. Nature nanotechnology, 6(12):763–772, 2011.
[15] Lulu Qian and Erik Winfree. Scaling Up Digital Circuit Computation with DNA Strand Displacement Cascades. Science, 332(6034):1196–1201, June 2011.
[16] Lulu Qian, David Soloveichik, and Erik Winfree. Efficient Turing-Universal Computation with
DNA Polymers. In DNA Computing and Molecular Programming, pages 123–140. Springer Berlin
Heidelberg, 2011.
[17] Paul W K Rothemund, Nick Papadakis, and Erik Winfree. Algorithmic Self-Assembly of DNA
Sierpinski Triangles. PLoS Biology, 2(12):e424, 2004.
[18] Paul WK Rothemund, Axel Ekani-Nkodo, Nick Papadakis, Ashish Kumar, Deborah Kuchnir Fygenson, and Erik Winfree. Design and characterization of programmable DNA nanotubes. Journal
of the American Chemical Society, 126(50):16344–16352, 2004.
[19] Georg Seelig, David Soloveichik, David Yu Zhang, and Erik Winfree. Enzyme-free nucleic acid logic
circuits. Science, 314(5805):1585–1588, 2006.
[20] Nadrian C Seeman. An overview of structural DNA nanotechnology. Molecular biotechnology, 37
(3):246–257, 2007.
17
[21] Michael Sipser. Introduction to the Theory of Computation. Cengage Learning, June 2012.
[22] David Soloveichik and Erik Winfree. Complexity of Self-Assembled Shapes. SIAM Journal on
Computing, 36(6):1544–1569, January 2007.
[23] David Soloveichik, Matthew Cook, Erik Winfree, and Jehoshua Bruck. Computation with finite
stochastic chemical reaction networks. Natural Computing, 7(4):615–633, 2008.
[24] David Soloveichik, Georg Seelig, and Erik Winfree. DNA as a universal substrate for chemical
kinetics. Proceedings of the National Academy of Sciences, 107(12):5393–5398, March 2010.
[25] Scott M Summers. Reducing Tile Complexity for the Self-assembly of Scaled Shapes Through
Temperature Programming. Algorithmica, 63(1-2):117–136, May 2011.
[26] Bryan Wei, Mingjie Dai, and Peng Yin. Complex shapes self-assembled from single-stranded DNA
tiles. Nature, 485(7400):623–626, 2012.
[27] Erik Winfree. Algorithmic self-assembly of DNA. PhD thesis, thesis.library.caltech.edu, May 1998.
[28] Erik Winfree. Simulations of computing by self-assembly. Technical Report CaltechCSTR:1998.22,
Department of Computer Science, California Institute of Technology, Pasadena, CA, 1998.
[29] Peng Yin, Harry MT Choi, Colby R Calvert, and Niles A Pierce. Programming biomolecular selfassembly pathways. Nature, 451(7176):318–322, 2008.
[30] David Yu Zhang and Georg Seelig. Dynamic DNA nanotechnology using strand-displacement reactions. Nature chemistry, 3(2):103–113, 2011.
[31] David Yu Zhang, Andrew J Turberfield, Bernard Yurke, and Erik Winfree. Engineering entropydriven reactions and networks catalyzed by DNA. Science, 318(5853):1121–1125, 2007.
[32] David Yu Zhang, Rizal F Hariadi, Harry M T Choi, and Erik Winfree. Integrating DNA stranddisplacement circuitry with DNA tile self-assembly. Nature Communications, 4:–, June 2013.
18