A Time Lower Bound for Multiple Nucleation on a Surface
Abstract
Majumder, Reif and Sahu have presented a stochastic model of reversible, errorpermitting, twodimensional tile selfassembly, and showed that restricted classes of tile assembly systems achieved equilibrium in (expected) polynomial time. One open question they asked was how much computational power would be added if the model permitted multiple nucleation, i.e., independent groups of tiles growing before attaching to the original seed assembly. This paper provides a partial answer, by proving that if a tile assembly model uses only local binding rules, then it cannot use multiple nucleation on a surface to solve certain “simple” problems in constant time (time independent of the size of the surface). Moreover, this time bound applies to macroscale robotic systems that assemble in a threedimensional grid, not just to tile assembly systems on a twodimensional surface. The proof technique defines a new model of distributed computing that simulates tile (and robotic) selfassembly. Keywords: selfassembly, multiple nucleation, locally checkable labeling.
1 Introduction
1.1 Overview
Nature is replete with examples of the selfassembly of individual parts into a more complex whole, such as the development from zygote to fetus, or, more simply, the replication of DNA itself. In his Ph.D. thesis in 1998, Winfree proposed a formal mathematical model to reason algorithmically about processes of selfassembly [21]. Winfree connected the experimental work of Seeman [16] (who had built “DNA tiles,” molecules with unmatched DNA base pairs protruding in four directions, so they could be approximated by squares with different “glues” on each side) to a notion of tiling the integer plane developed by Wang in the 1960s [20]. Rothemund, in his own Ph.D. thesis, extended Winfree’s original Tile Assembly Model [14].
Informally speaking, Winfree effectivized Wang tiling, by requiring a tiling of the plane to start with an individual seed tile or a connected, finite seed assembly. Tiles would then accrete one at a time to the seed assembly, growing a seed supertile. A tile assembly system is a finite set of tile types. Tile types are characterized by the names of the “glues” they carry on each of their four sides, and the binding strength each glue can exert. We assume that when the tiles interact “in solution,” there are infinitely many tiles of each tile type. Tile assembly proceeds in discrete stages. At each stage , from all possibilities of tile attachment at all possible locations (as determined by the glues of the tile types and the binding requirements of the system overall), one tile will bind, with tile type and location “chosen” nondeterministically from possible legal bonds at that stage. (Later, we will generalize this so multiple tiles can bind concurrently, at a given stage.) Winfree proved that his Tile Assembly Model is Turing universal.
The abstract Tile Assembly Model (aTAM) is errorfree and irreversible—tiles always bind correctly, and, once a tile binds, it can never unbind. Adleman et al. were the first to define a notion of time complexity for tile assembly, using a onedimensional errorpermitting, reversible model, where tiles would assemble in a line with some error probability, then be scrambled, and fall back to the line [1]. Adleman et al. proved bounds on how long it would take such models to achieve equilibrium. Majumder, Reif and Sahu have recently presented a twodimensional stochastic model for selfassembly [11], and have shown that some tiling problems in their model correspond to rapidly mixing Markov chains—Markov chains that reach stationary distribution in time polynomial in the state space of legally reachable assemblies.
While the aTAM is nondeterministic, realworld chemical reactions are probabilistic, and discrete molecular interactions are often modeled stochastically. We will define a class of stochastic selfassembly models that contains the model of Majumder et al., and prove a lower bound about any model in that class.
The tile assembly systems analyzed in [11] had the property that their equilibrium assemblies were identical (allowing for small error) with their terminal or complete assemblies, i.e., assemblies that cannot legally evolve further, given the rules of the system. This identity does not, however, hold in general. In a closed chemical system, where equilibrium may be achieved, it is possible that the system at equilibrium might consist almost entirely of large, undesirable assemblies that do not perform the desired computation. In these cases, correct assembly occurs when the system is out of equilibrium, and can be maintained because there is a large kinetic energy barrier to forming undesired structures. Therefore, when we discuss the “solution to a problem” in this paper, we identify that with the notion of a complete assembly.
We will prove a time complexity lower bound on the solution of a graph coloring problem for a class of selfassembly models, including, but not limited to, a generalization of the model of [11]. The tile assembly model in [11], like the aTAM, allows only for a single seed assembly, and one of the open problems in [11] was how the model might change if it allowed multiple nucleation, i.e., if multiple supertiles could build independently before attaching to a growing seed supertile. The main result of this paper provides a time complexity lower bound for a class of tile assembly models that permit multiple nucleation on a 2D surface or a 3D grid: there is no way for those models to use multiple nucleation to achieve a speedup to tiling a surface in constant time (time independent of the size of the surface) in order to solve a graph coloring problem, even though that graph coloring problem requires only seven tile types to solve in the aTAM. This result holds for tile assembly models that are reversible, irreversible, errorpermitting or errorfree. In fact, a speedup to constant time is impossible, even if we relax the model to allow that, at each step , there is a positive probability for every available location that a tile will bind there (instead of requiring that exactly one tile bind per stage).
To our knowledge, the method of proof in this paper is novel: given a tile assembly model and a tile assembly system in that model, we construct a distributed network of processors that can simulate the behavior of as it assembles on a surface. Our result then follows from the theorem by Naor and Stockmeyer that locally checkable labeling (LCL) problems have no local solution in constant time [12]. This is true for both deterministic and randomized algorithms, so no constanttime tile assembly system exists that solves an LCL problem with a positive probability of success. We consider one LCL problem in specific, the weak coloring problem, and demonstrate a tile set of only seven tile types that solves the weak coloring problem in the abstract Tile Assembly Model, even though that same problem is impossible to solve in constant time by multiple nucleation on a surface, for a broad class of selfassembly models. Intuitively, this demonstrates that even a problem that can be solved in polynomial time by using a few local rules when starting from a single point, cannot necessarily be solved in constant time when starting from multiple points, regardless of the rule set used. (The abstract Tile Assembly Model can weakly color an surface in steps, yet none of the multiple nucleation models we consider can solve the weak coloring problem in constantmany steps.)
The results of Naor and Stockmeyer we apply are more powerful than needed to obtain the time complexity lower bound for a system in which the selfassembling agents are as simple as DNA tiles. Our lower bound actually demonstrates that constanttime speedup to solve LCL problems is impossible via multiple nucleation, even for selfassembling modular robots capable of forming physical bonds in a threedimensional grid, and, in addition, of sending messages to their neighbors once they have bonded, and potentially deciding to break bonds they previously formed.
1.2 Background
In the abstract Tile Assembly Model, one tile is added per stage, so the primary complexity measure is not one of time, but of how much information a tile set needs in order to solve a particular problem. Several researchers [1] [3] [4] [15] [17] have investigated the tile complexity (the minimum number of distinct tile types required for assembly) of finite shapes, and sets of “scaleequivalent” shapes (essentially a analogue of the Euclidean notion of similar figures). For example, it is now known that the number of tile types required to assemble a square of size (for any natural number) is [15]. Or, if is the set of all discrete equilateral triangles, the asymptotically optimal relationship between triangle size and number of tiles required to assemble that triangle, is closely related to the Kolmogorov Complexity of a program that outputs the triangle as a list of coordinates [17].
Despite these advances in understanding of the complexity of assembling finite, bounded shapes, the selfassembly of infinite structures is not as well understood. In particular, there are few lower bounds or impossibility results on what infinite structures can be selfassembled in the Tile Assembly Model. The first such impossibility result appeared in [10], when Lathrop, Lutz and Summers showed that no finite tile set can assemble the discrete Sierpinski Triangle by placing a tile only on the coordinates of the shape itself. (By contrast, Winfree had shown that just seven tile types are required to tile the first quadrant of the integer plane with tiles of one color on the coordinates of the discrete Sierpinski Triangle, and tiles of another color on the coordinates of the complement [21].) Recently, Patitz and Summers have extended this initial impossibility result to other discrete fractals [13], and Lathrop et al. [9] have demonstrated sets in that are Turing decidable but cannot be selfassembled in Winfree’s sense.
To date, there has been no work comparing the strengths of different tile assembly models with respect to infinite (nor to finite but arbitrarily large) structures. Since selfassembly is a process in which each point has only local knowledge, it is natural to consider whether the techniques of distributed computing might be useful for comparing models of selfassembly and proving impossibility results about them. This paper is an initial attempt in that direction.
Aggarwal et al. in [3] proposed a generalization of the standard Tile Assembly Model, which they called the Tile Assembly Model. This model permitted multiple nucleation: tiles did not need to bind immediately to the seed supertile. Instead, they could form independent supertiles of size up to some constant before then attaching to the seed supertile. While the main question considered in [3] was tile complexity, we can also ask whether multiple nucleation would allow an improvement in time complexity. Intuitively, Does starting from multiple points allow us to build things strictly faster than starting from a single point?
As mentioned above, Majumder, Reif and Sahu recently presented a stochastic, errorpermitting tile assembly model, and calculated the rate of convergence to equilibrium for several tile assembly systems [11]. The model in [11] permitted only a single seed assembly, and addition of one tile to the seed supertile at each stage. Majumder, Reif and Sahu left as an open question how the model might be extended to permit the presence and binding of multiple supertiles.
Therefore, we can rephrase the “intuitive” question above as follows: Can we tile a surface of size in a constant number of stages, by randomly selecting nucleation points on the surface, building supertiles of size or smaller from those points in stages, and then allowing additional stages for tiles to fall off and be replaced if the edges of the supertiles contain tiles that bind incorrectly? (The assembly achieves equilibrium in constant time because and do not depend on .) The partial answer obtained in this paper is that locally checkable labeling problems cannot be solved in constant time, if we limit ourselves to selfassembly on a surface.
Limiting ourselves to selfassembly on a surface is significant, because we are requiring that agents adhere to a substrate and then never move again, unless they dissociate completely from the larger assembly. When assemblies multiply nucleate in solution, however, they form disjoint supertiles that can float independently until potentially becoming aligned, with some probability. A selfassembly model that made this rigorous might be strictly stronger than the selfassembly models we consider in this paper, as it is not clear how to simulate floating supertiles within our distributed computing models without introducing slowdown, as processors simulating locations of the surface would have to “pass along” information from one processor to the next, to simulate elements of the moving supertile. We leave the possibility of simulating floating supertiles to future work.
Another limitation to our results is that our proof technique applies only to selfassembly models whose binding rules are completely local. One could imagine models in which supertiles combine (or separate) based on simultaneous interactions at several locations, instead of the models we consider in this paper, in which the system’s behavior at each location depends only on the properties of that location’s immediate neighbors. The selfassembly literature, to our knowledge, contains little regarding selfassembly models with nonlocal binding rules, and this could be a fruitful area to investigate.
Klavins and coauthors have modeled selfassembly phenomena—and programmed selfassembling modular robots—using graph grammars [6] [8]. Klavins in [7] informally compares the limitations of the “distributed algorithms” of graph grammars (used to program selfassembling robots) to impossibility results in distributed computing. Recently, we have shown connections between selfassembly and the waitfree consensus hierarchy [18], and we have embedded the “graph assembly systems” of Klavins into a known graph grammar characterization of distributed systems [19]. The present paper, to the best of our knowledge, is the first to construct a formal reduction from selfassembly models to models of distributed computing.
Section 2 of this paper describes the abstract Tile Assembly Model, and then considers generalizations of the standard model that permit multiple nucleation. Section 3 reviews the distributed computing results of Naor and Stockmeyer needed to prove the impossibility result. In Section 4 we present our simulation technique and lower bound results. Section 5 concludes the paper and suggests directions for future research.
2 Description of SelfAssembly Models
2.1 The abstract Tile Assembly Model
Winfree’s objective in defining the Tile Assembly Model was to provide a useful mathematical abstraction of DNA tiles combining in solution [21]. Rothemund [14], and Rothemund and Winfree [15], extended the original definition of the model. For a comprehensive introduction to tile assembly, we refer the reader to [14]. In our presentation here, we follow [10], which gives equal status to finite and infinite tile assemblies.
Intuitively, a tile of type is a unit square that can be placed with its center on a point in the integer lattice. A tile has a unique orientation; it can be translated, but not rotated. We identify the side of a tile with the direction (or unit vector) one must travel from the center to cross that side. The literature often refers to west, north, east and south sides, starting at the leftmost side and proceeding clockwise. Each side of a tile is covered with a “glue” that has a color and a strength. Figure 1 shows how a tile is represented graphically.
If tiles of types and are placed adjacent to each other, then they will bind with the strength shared by both adjacent sides if the glues on those sides are the same. Note that this definition of binding implies that if the glues of the adjacent sides do not have the same color or strength, then their binding strength is 0. Later, we will permit pairs of glues to have negative binding strength, to model error occurrence and correction.
One parameter in a tile assembly model is the minimum binding strength required for tiles to bind “stably.” This parameter is usually termed temperature and denoted by , where .
As we consider only twodimensional tile assemblies, we limit ourselves to working in . is the set of all unit vectors in .
A binding function on an (undirected) graph is a function . If is a binding function on a graph and is a cut of , then the binding strength of on is
The binding strength of on is then . Intuitively, the binding function captures the strength with which any two neighbors are bound together, and the binding strength of the graph is the minimum strength of bonds that would have to be severed in order to separate the graph into two pieces.
A binding graph is an ordered triple where is a graph and is a binding function on . If , a binding graph is stable if .
Recall that a grid graph is a graph where and every edge has the property that . We write for the set , i.e., the twoelement subsets of .
Definition 1.
A tile type over a (finite) alphabet is a function . We write , where , and are defined by for all .
Definition 2.
If is a set of tile types, a configuration is a partial function .
Definition 3.
The binding graph of a configuration is the binding graph , where is the grid graph given by


and
and the binding function is given by for all .
Definition 4.
For a set of tile types, a configuration is stable if its binding graph is stable. A assembly is a configuration that is stable. We write for the set of all assemblies.
Definition 5.
Let and be configurations.

is a subconfiguration of , and we write , if and, for all , .

is a singletile extension of if and is a singleton set. In this case, we write , where and .

The notation means that and is a singletile extension of . (The “1” above the arrow is to denote that a single tile is added at this step.)
Definition 6.
Let .

For each , the frontier of is the set

The frontier of is the set
Definition 7.
A assembly sequence is a sequence in , where and, for each with , .
Definition 8.
The result of a assembly sequence is the unique configuration satisfying: and for each .
Definition 9.
Let . A assembly sequence from to is a assembly sequence such that and . We write to indicate that there exists a assembly from to .
Definition 10.
An assembly is terminal if .
Intuitively, a configuration is a set of tiles that have been placed in the plane, and the configuration is stable if the binding strength at every possible cut is at least as high as the temperature of the system. Informally, an assembly sequence is a sequence of singletile additions to the frontier of the assembly constructed at the previous stage. Assembly sequences can be finite or infinite in length. We are now ready to present a definition of a tile assembly system.
Definition 11.
Write for the set of configurations, stable at temperature , of tiles whose tile types are in . A tile assembly system is an ordered triple where is a finite set of tile types, is the seed assembly, and is the temperature. We require to be finite.
Definition 12.
Let be a tile assembly system.

Then the set of assemblies produced by is
where “” means that tile configuration can be obtained from seed assembly by a legal addition of tiles.

The set of terminal assemblies produced by is
where “terminal” describes a configuration to which no tiles can be legally added.
If we view tile assembly as the programming of matter, the following analogy is useful: the seed assembly is the input to the computation; the addition of tile types to the growing assembly are the legal steps the computation can take; the temperature is the primary inference rule of the system; and the terminal assemblies are the possible outputs.
We are, of course, interested in being able to prove that a certain tile assembly system always achieves a certain output. In [17], Soloveichik and Winfree presented a strong technique for this: local determinism.
Informally, an assembly sequence is locally deterministic if (1) each tile added in binds with the minimum strength required for binding; (2) if there is a tile of type at location in the result of , and and the immediate “OUTneighbors” of are deleted from the result of , then no other tile type in can legally bind at ; the result of is terminal. We formalize these points as follows.
Definition 13 (Soloveichik and Winfree [17]).
A assembly sequence with result is locally deterministic if it has the following three properties.

For all ),
where means the sides of the tile that bound at location during assembly sequence that contributed nonzero strength during the stage at which the tile bound. (Informally, these are the “input sides” of the tile at location , with respect to assembly sequence .)

For all and all , .

.
Definition 14 (Soloveichik and Winfree [17]).
A tile assembly system is locally deterministic if there exists a locally deterministic assembly sequence with .
Local determinism is important because of the following result.
Theorem 1 (Soloveichik and Winfree [17]).
If is locally deterministic, then has a unique terminal assembly.
2.2 More general selfassembly models
We move now from DNA tiles selfassembling on a twodimensional surface, to a more general setting, where selfassembling “agents” with the ability not just to bind but also to communicate after binding and potentially unbind, can assemble either in the plane or in threespace. One could think of think of these agents as (nano or macroscale) robots that interlock physically, and, after interlocking, can send their neighbors electronic messages of low complexity. Based on receipt of messages, the robots can then decide to break bonds to one or more of their neighbors. Such modular robots have already been implemented in laboratory experiments [7]. Further, these robots may be constructed so each has (at least with high probability) a unique identification code—permitting transmission of strictly more information than is possible in the setting of tile selfassembly, in which tiles do not have unique identifiers.
We will consider generalizations of the abstract Tile Assembly Model that include the following: (1) multiple nucleation; (2) assembly in which glues bind incorrectly according to some error probability; and (3) negative glue strengths, allowing incorrectly bound tiles to be released from the assembly so it is possible for a correctlybinding tile to attach in that location; (4) a third spatial dimension; and (5) tiles can now be “agents,” i.e., finite state machines with algorithms and unique identifiers. We formalize this as follows.
Definition 15.
A regular selfassembling agent type is a finite state machine of form , where is an (deterministic or probabilistic) algorithm and the ’s are finite strings over a finite alphabet (codes for the glue types associated with ) that are hardcoded into the machine. The algorithm can be null (in the case of passive selfassembly like DNA tiles), or can decide whether to transmit messages of length bounded by a constant to neighbors based on the agent’s interaction with neighboring glue types.
We will assume that all agent types have identical geometric structure, and their glues all have the same orientation. For example, in the aTAM, all agent types are unit squares, oriented north, east, south, west. Also, for simplicity of the proof, we will assume that our agents are memoryless. However, because of the generality of the results of Naor and Stockmeyer, our lower bound results would still hold if agents could make active selfassembly decisions based on a history of messages received from neighbors, not just the current messages and glue types of their neighbors.
Definition 16.
The binary relation is a set of binding rules for the (finite) set of agent types if, for any , both and are glue types that appear in elements of .
Definition 17.
The function is an assignment of binding strengths for the set of binding rules , if the domain of is , and the range of is the set of nonnegative integers.
Definition 18.
is a model of regular selfassembling agents if , where is a (finite) set of regular selfassembling agent types, is a set of binding rules for , is an assignment of binding strengths for , is the temperature of the system (the threshold binding strength for bonds to be stable), and is an initial (finite) seed assembly.
The algorithm of each agent type may include a variable MYID, and we allow the possibility that each agent in the system does, in fact, have a unique identification number. This might be appropriate when modeling robotic selfassembly. In the case of molecular selfassembly, each agent is anonymous. Assembly systems in both the aTAM and the stochastic model of Majumder et al. can be defined in this formalism, by giving each agent type an algorithm that performs no instructions, and defining (respectively deterministic or probabilistic) binding relations in a natural way.
To conclude this section, we formalize what it means for a selfassembly model to allow multiple nucleation on a surface.
Definition 19.
Let be a model of regular selfassembling agents. We say allows multiple nucleation if, in addition to the placement of the seed assembly at the initial stage of assembly, there is some probability that (at the first stage of assembly only) an agent is placed on each location of the surface with probability . Further, if an agent is placed at location because of multiple nucleation, its agent type is chosen uniformly at random from the space of possible agent types.
We could allow multiple nucleation to occur at multiple stages during the assembly, not just the first. Again, because of the generality of Naor and Stockmeyer’s results, that would not affect our lower bound proof.
3 Distributed Computing Results of Naor and Stockmeyer
In a well known distributed computing paper, Naor and Stockmeyer investigated whether “locally checkable labeling” problems could be solved over a network of processors in an entirely local manner, where a local solution means a solution arrived at “within time (or distance) independent of the size of the network” [12]. One locally checkable labeling problem Naor and Stockmeyer considered was the weak coloring problem.
Definition 20 (Naor and Stockmeyer [12]).
For , a weak coloring of a graph is an assignment of numbers from (the possible “colors”) to the vertices of the graph such that for every nonisolated vertex there is at least one neighbor such that and receive different colors. Given a graph , the weak coloring problem for is to weak color the nodes of .
In the context of tiling, to solve the weak coloring problem for an surface means tiling the surface so each tile has at least one neighbor (to the north, south, east or west) of a different color. In the next section, we will present a simple solution to the weak coloring problem in the abstract Tile Assembly Model. By contrast, Naor and Stockmeyer showed that no local, constanttime algorithm can solve the weak coloring problem for grid graphs, nor for dimensional meshes, a generalization of grid graphs which we now define.
Definition 21.
A dimensional mesh is a graph with vertex set for some , such that two vertices are connected by an edge if the distance between them is 1.
Theorem 2 (Naor and Stockmeyer [12]).
For any natural numbers , and , there is no local algorithm with time bound that solves the weak coloring problem for the class of dimensional meshes. (This remains true even if the processors have unique identifiers and can transmit them as part of the local algorithm.)
A second theorem from the same paper says that randomization does not help. The original result is stronger than the formulation here.
Theorem 3 (Naor and Stockmeyer [12]).
Fix a class of graphs closed under disjoint union. If there is a randomized local algorithm with time bound that solves the weak coloring problem for with error probability for some , then there is a deterministic local algorithm with time bound that solves the weak coloring problem for .
4 Simulation of SelfAssembly on a Surface
In order to apply the theorems of Naor and Stockmeyer to the realm of selfassembly, we build a distributed network of processors that reduces a selfassembly problem to a distributed computing problem. The motivating intuition is that each processor simulates a location of the surface, and reports to its neighbors whether there is a (simulated) agent at that location. Formally, we prove the following theorem.
Theorem 4.
Let be a model of regular selfassembling agents for any natural number , such that selfassembles on a dimensional mesh of size , and that allows multiple nucleation. Then there is a model of distributed computing that simulates using processors with the network topology of a dimensional mesh, and constantsize message complexity.
Proof.
Fix a model of regular selfassembling agents as in the theorem statement. Let be a configuration of agents on the mesh of size . Let be the set of glue types of and the set of electronic messages of . (Both and are finite sets.) The definition of the binding function induces a function
such that takes as input the (possibly empty) agent type at some location in configuration , and, based on the glue types and electronic messages received from the neighbors that could be incident to an agent at , returns, for each agent type, the probability that would contain that agent type, over the space of all legal assembly sequences that start with configuration and run for one time step. In particular, for fixed , fixed , and fixed , it is true that
We have not formally defined assembly sequences, but they are a natural extension of the assembly sequences of tile selfassembly, where the and of are used to determine whether agents bind stably to one another. Also, if an agent type lies on the edge of the size surface, so it does not have a neighbor in a particular direction, we define so that the empty set is the glue and electronic message “transmitted” from the “neighbor” in that direction.
We simulate assembly sequences of on an dimensional mesh where each of the dimensions has length by a network of processors whose network graph is also a dimensional mesh of total size . Each processor will simulate the presence or absence of an agent in the same location on the assembly surface. We interpret bonds between two agents as messages. We add on top of those messages, an additional set of electronic messages agents can send neighbors, and encode the combination as an ordered pair: glue type and electronic message. The function will be the probabilistic transition function for processors in this system.
Processors of are of the following form.
 Processor
 many input message buffers:

.
 many output message buffers:

.
 A color variable:

, a variable that can take a value from , where is a global constant.
 A local state:

Each processor is in one of different local states during a given execution stage . There is one stage to simulate each agent type , and an additional stage EMPTY, to simulate the absence of an agent from the surface location that is simulating.
 A state transition function:

This function takes the current processor state and the messages received in the current round, and probabilistically directs what state the processor will adopt in the next round.
The messages processors send on the network are of form glue type, electronic message. The input message buffers of processor simulate the glue types of the edges the agent at ’s location is adjacent to, and the electronic messages (if any) received from an agent’s neighbors. The output message buffers of simulate the glues on the edges of the tile is simulating, and the electronic messages the agent transmits to its neighbors. The purpose of is to simulate the color of the agent placed at the location simulated by .
All processors in are hardcoded with the same probabilistic state transition function, which is determined from the definition of (which we induced above from the properties of ), in the natural way: if, in round of the algorithm execution, is in state , a simulation of , and hears messages that simulate glue types and electronic messages , then at the end of round , it will transition to state with probability , where and each is a distinct element of . As explained above, we denote the state that simulates the “presence of the empty set”—i.e., the absence of any agent from the location simulated by —as EMPTY.
To simulate the process of selfassembly, we run the following distributed algorithm on .
Algorithm execution proceeds in synchronized rounds. Before execution begins, all processors start in state EMPTY. In round , (through the intervention of an omniscient operator) each processor in the locations corresponding to the seed assembly enters the stage to simulate the agent type at that location in the seed assembly.
Also in round , each processor not simulating part of the seed assembly “wakes up” (enters a state other than EMPTY) with probability , the multiple nucleation probability of . If a processor wakes up, it enters state , chosen uniformly at random from the set of nonEMPTY states. For any round , each processor runs either Algorithm 1 or Algorithm 2, depending on whether it is in state EMPTY.
The interaction between agents in is completely defined by the glues and electronic messages of an agent’s immediate neighbors, as specified in the function and the algorithm of each agent type. The processors of simulate that behavior with Algorithm 2. Since the processors of simulate empty locations with Algorithm 1, by a straightforward induction argument, can simulate all possible assembly sequences, and the theorem is proved. ∎
We obtain our time lower bound results as corollaries of Theorem 4.
Corollary 1.
If the (deterministic or probabilistic) binding rules of a multiply nucleating tile assembly system are entirely local, then is unable to solve the weak coloring problem in constant time.
Proof.
Suppose is an irreversible tiling model. If can weak color surfaces in constant time, then there is a deterministic algorithm for the distributed network that weak colors locally, and in constant time. By Theorem 2 that is impossible.
So assume is a reversible tiling model, and when assembles, it weak colors the tiling surface, and achieves bond pair equilibrium in constant time. Then there is a local probabilistic algorithm for that weak colors in constant time, with positive probability of success. By Theorem 3 that is impossible as well. Therefore, no exists that weak colors surfaces in constant time. ∎
By a similar argument, we obtain a lower bound for active selfassembling agents on a threedimensional cubic grid.
Corollary 2.
If a model of 6regular selfassembling agents has only local binding rules, then it cannot solve the weak coloring problem in constant time on a 3dimensional mesh, for any value of .
A physical interpretation of Corollary 2 would be that robots selfassembling in threespace (i.e., and, in this example, so there are six arms coming off each robot, orthogonally to one another) cannot achieve speedup to constant time by selfassembling in separate groups and then joining the groups together. This lower bound remains in effect even if the robots are designed by a method that assigns each robot a unique identifier.
We conclude this section by noting that the weak coloring problem has low tile complexity—that is, can be defined using only a few local rules—in the aTAM.
Proposition 1.
There is a tile assembly system in the abstract Tile Assembly Model that weak colors the first quadrant, using only seven distinct tile types.
Proof.
Figure 2 exhibits a tileset of seven tile types that assembles into a weak coloring of the first quadrant, starting from an individual seed tile placed at the origin. One can verify by inspection that is locally deterministic, so it will always produce the same terminal assembly. All assembly sequences generated by produce a checkerboard pattern in which a monochromatic “+” configuration never appears. Hence, it solves the weak coloring problem for the entire first quadrant, and also for all squares, for any . ∎
5 Conclusion
In this paper, we showed that if a tile assembly model has only local binding rules, then it cannot use multiple nucleation on a surface to solve locally checkable labeling problems in constant time, even though the abstract Tile Assembly Model can solve a locally checkable labeling problem using just seven tile types. In fact, we proved a more general impossibility result, which showed the same lower bound applies to selfassembling agents in a threedimensional grid that are capable of binding and subsequently sending messages to their neighbors. To the best of our knowledge, this was the first application of a distributed computing impossibility result to the field of selfassembly.
There are still many open questions regarding multiple nucleation. Aggarwal et al. asked in [3] whether multiple nucleation might reduce the tile complexity of finite shapes. The answer is not known. Furthermore, we can ask for what class of computational problems does there exist some function such that we could tile an square in time , and “solve” the problem with “acceptable” probability of error, in a tile assembly model that permits multiple nucleation. It would also be interesting to explore the possibility of modeling multiple nucleation of molecules floating in solution—instead of adhering to a surface—perhaps by using techniques from the field of ad hoc wireless networks.
We hope that this is just the start of a conversation between researchers in the fields of distributed computing and biomolecular computation.
Acknowledgements
I am grateful to Soma Chaudhuri, Dave Doty, Jim Lathrop and Jack Lutz for helpful discussions on earlier versions of this paper. I am also grateful to two anonymous referees, who suggested significant conceptual and technical improvements to my original journal submission.
References
 [1] Adleman, L., Cheng, Q., Goel, A., Huang, M.D.: Running time and programsize for selfassembled squares. In: Proceedings of the 33rd Annual ACM Symposium on the Theory of Computing, pp. 740748 (2001)
 [2] Attiya, H., Welch, J.: Distributed Computing: Fundamentals, Simulations, and Advanced Topics, second edition. Wiley Series on Parallel and Distributed Computing (2004)
 [3] Aggarwal, G., Goldwasser, M., Kao, M.Y., Schweller, R.: Complexities for generalized models of selfassembly. In: Proceedings of the fifteenth annual ACMSIAM Symposium on Discrete Algorithms, pp. 880889 (2004)
 [4] Cheng, Q., de Espanes, P.M.: Resolving two open problems in the selfassembly of squares. Technical Report 793, University of Southern California (2003)
 [5] Kao, M.Y., Ramachandran, V. DNA selfassembly for constructing 3D boxes. LNCS 2223, Proceedings of the 12th International Symposium on Algorithms and Computation (ISAAC 2001), P. Eades, T. Takaoka (Eds.), pp. 429441 (2001)
 [6] Klavins, E.: Directed selfassembly using graph grammars. In: Proceedings of the Foundations of Nanoscience: Self Assembled Architectures and Devices, pp. 4558 (2004)
 [7] Klavins, E.: Programmable selfassembly. IEEE Control Systems Magazine, 24(4), pp. 4356 (2007)
 [8] Klavins, E., Ghrist, R., Lipsky, D. A grammatical approach to selforganizing robotic systems. IEEE Transactions on Automatic Control, 51(5), pp. 949962 (2006)
 [9] Lathrop, J., Lutz, J., Patitz, M., Summers, S.: Computability and complexity in selfassembly. Theory of Computing Systems, to appear.
 [10] Lathrop, J., Lutz, J., Summers, S.: Strict selfassembly of discrete Sierpinski triangles. Strict selfassembly of discrete Sierpinski triangles, Theoretical Computer Science, 410 (2009), pp. 384405.
 [11] Majumder, U., Reif, J., Sahu, S.: Stochastic Analysis of Reversible SelfAssembly. Journal of Theoretical and Computational Nanoscience 5(7), pp. 12891305, July 2008.
 [12] Naor, M., Stockmeyer, L.: What can be computed locally? SIAM Journal of Computing, 24(6), pp. 12591277 (1995)
 [13] Patitz, M., Summers, S.: Selfassembly of discrete selfsimilar fractals. To appear in: Proceedings of the Seventh International Conference on Unconventional Computation. SpringerVerlag, Heidelberg (2008)
 [14] Rothemund, P. W. K.: Theory and Experiments in Algorithmic SelfAssembly. Ph.D. thesis, University of Southern California, Los Angeles (2001)
 [15] Rothemund, P., Winfree, E.: The programsize complexity of selfassembled squares. In: Proceedings of the 32nd Annual ACM Symposium on Theory of Computing, pp. 459468 (2000)
 [16] Seeman, N.: Denovo design of sequences for nucleicacid structuralengineering. Journal of Biomolecular Structure and Dynamics, 8(3), pp. 573581 (1990)
 [17] Soloveichik, D., Winfree, E.: Complexity of selfassembled shapes. SIAM Journal of Computing, 36(6), pp. 15441569 (2007)
 [18] Sterling, A. Distributed Agreement in Tile SelfAssembly. To appear in the Proceedings of the 15th International Meeting on DNA Computing and Molecular Programming, June 2009 (DNA 15), LNCS.
 [19] Sterling, A. SelfAssembling Systems are Distributed Systems. Tech report, July 2009. Submitted.
 [20] Wang, H.: Proving theorems by pattern recognition II. Bell Systems Technical Journal, 40, pp. 141 (1961)
 [21] Winfree, E.: Algorithmic SelfAssembly of DNA. Ph.D. thesis, California Institute of Technology, Pasadena (1998)