{'fraction_non_alphanumeric': 0.031543146756768774, 'fraction_numerical': 0.008824967767749967, 'mean_word_length': 4.323275352029346, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Distributed Agreement in Tile Self-Assembly

Laboratory investigations have shown that a formal theory of fault-tolerance will be essential to harness nanoscale self-assembly as a medium of computation. Several researchers have voiced an intuition that self-assembly phenomena are related to the field of distributed computing. This paper formalizes some of that intuition. We construct tile assembly systems that are able to simulate the solution of the wait-free consensus problem in some distributed systems. (For potential future work, this may allow binding errors in tile assembly to be analyzed, and managed, with positive results in distributed computing, as a"blockage"in our tile assembly model is analogous to a crash failure in a distributed computing model.) We also define a strengthening of the"traditional"consensus problem, to make explicit an expectation about consensus algorithms that is often implicit in distributed computing literature. We show that solution of this strengthened consensus problem can be simulated by a two-dimensional tile assembly model only for two processes, whereas a three-dimensional tile assembly model can simulate its solution in a distributed system with any number of processes.


Introduction
One emerging field of computer science research is the algorithmic harnessing of molecular selfassembly to produce structures (and perform computations) at the nano scale. In his Ph.D. thesis in 1998, Winfree [20] used tiles on the integer plane to define a self-assembly model which has become an influential tool. As noted by several researchers (for example [1]), problems in algorithmic tile selfassembly share characteristics with better-studied problems in distributed computing: asynchronous computation, the importance of fault tolerance, and the limitations of local knowledge. In this paper, we formalize a connection between the two fields, by constructing models of tile assembly that simulate solutions to the wait-free consensus problem in some distributed systems.
The tile self-assembly literature has considered two main classes of models: models in which tiles bind to one another in an error-free manner, and models in which there is a positive probability that mismatched tiles will bind to one another. In an error-permitting model, if mismatched tiles bind, they can produce a blockage-an unplanned tile configuration that stops a particular section of an assembly from being able to accrete tiles.
As blockages do occur in wetlab self-assembly experiments, it is natural to ask how we could make our self-assembly computations as resilient against blockages as possible. Researchers have investigated mechanisms to limit the chance of blockages through error-correction (for example [3] [5]), or, relatedly, for a tile assembly to "heal" itself in the event of damage [15]. Like other errorcorrecting codes, these mechanisms can consume significant overhead, and only reduce without eliminating the possibility of a blockage. Our interest in this paper, therefore, is to build a framework for robust self-assembly even in the presence of one or more unhealable blockages. Of course, if we consider a situation in which multiple subassemblies grow independently, then the blockage of one subassembly will have no effect on the others. The problem arises when otherwise independent subassemblies send information to, or receive information from, one another, and need to coordinate This research was supported in part by National Science Foundation Grants 0652569 and 0728806. arXiv:0902.3631v3 [cs.DC] 16 Jul 2010 based on that information-hence our motivation to import the consensus problem into the world of tile assembly.
The most common types of processor faults modeled in distributed computing are crash failure (where a processor stops functioning) and Byzantine failure (where a processor can behave maliciously and take "worst-possible" steps). Several other types of failure have been defined; in general, their severity lies between crash failure and Byzantine failure. We will focus on shared objects that can be simulated in the presence of a tile self-assembly analogue of crash failures, to construct a theoretical foundation for synchronized fault-tolerance in self-assembly. In the long run, we believe that the combination of error-correction and distributed computing techniques (to manage a variety of failures) will produce self-assembling systems with high fault-tolerance.
The consensus problem was originally defined by Lamport for a system of distributed processors, as an abstraction of the transaction commit problem in database theory. It has since been shown to have wide application to the study of distributed systems; see, for example, Attiya and Welch [2] for a textbook introduction. In brief, given a system of n distributed processors, a solution to the consensus problem is an algorithm that ensures all nonfaulty processors agree on the same value. (There is also a "validity" condition to ensure the algorithm is not trivial.) The consensus problem for a system of n processors is called n-consensus, and a consensus algorithm is termed wait-free if up to n − 1 processors can crash in an n processor system, and even so all correctly working processors will decide on the same value.
This paper is part of a larger program to connect the fields of self-assembly and distributed computing. By reducing models of self-assembly to models of distributed processors, one can apply known distributed computing impossibility results to obtain limits to the power of selfassembly [17] [18]. The results in Section 5 of this paper make use of a three-dimensional tile assembly model. Unlike two-dimensional tiles, 3D tiles have not been implemented in the lab, and it is not clear whether they can be, given current methods. The objective of the current paper is to explore which distributed objects can (and cannot) be simulated by self-assembling systems, in order to clarify how positive results of distributed computing can apply to self-assembly.
We have organized the rest of the paper as follows. Section 2 provides further background about tile self-assembly and distributed computing. Section 3 presents a tile assembly simulation of a twoprocessor message-passing distributed system. In Section 4, we construct a tile assembly simulation of wait-free 2-consensus. In Section 5, we define a strengthening of the consensus problem, and show that two-dimensional tile assembly systems cannot simulate solutions to it for systems of three or more processes, but three-dimensional tile assembly systems can. Section 6 concludes the paper and provides suggestions for future research.

Tile self-assembly background
Winfree's objective in defining the Tile Assembly Model was to provide a useful mathematical abstraction of DNA tiles combining in solution in a random, nondeterministic, asynchronous manner [20]. Rothemund [13], and Rothemund and Winfree [14], extended the original definition of the model. For a comprehensive introduction to tile assembly, we refer the reader to [13]. Intuitively, we desire a formalism that models the placement of square tiles on the integer plane, one at a time, such that each new tile placed binds to the tiles already there, according to specific rules. Tiles have four sides (often referred to as north, south, east and west) and exactly one orientation, i.e., they cannot be rotated. A tile assembly system T is a 5-tuple (T, σ, Σ, τ, R), where T is a finite set of tile types; σ is the seed tile or seed assembly, the "starting configuration" for assemblies of T ; τ : T × {N, S, E, W } → Σ × {0, 1, 2} is an assignment of symbols ("glue names") and a "glue strength" (0, 1, or 2) to the north, south, east and west sides of each tile; and a symmetric relation R ⊆ Σ × Σ that specifies which glues can bind with nonzero strength. In this model, there are no negative glue strengths, i.e., two tiles cannot repel each other.
In this paper, we allow for the possibility of errors in binding between tiles. While, in general, binding errors can cause unplanned configurations to be built, we will make a simplifying assumption that the only binding errors that might occur are tile blockages, tile mismatches that prevent any further tiles from binding to the subassembly at which the blockage occurred. In particular, no erroneously bound tile can be enclosed by tiles that attach later in the process of self-assembly. Figure 1 shows a toy example of a tile assembly system, and a possible blockage. A configuration of T is a set of tiles, all of which are tile types from T , that have been placed in the plane, and the configuration is stable if the binding strength (from τ and R in T ) at every possible cut is at least 2. An assembly sequence is a sequence of single-tile additions to the frontier of the assembly constructed at the previous stage. Assembly sequences can be finite or infinite in length. The result of assembly sequence − → α is the union of the tile configurations obtained at every finite stage of − → α . The assemblies produced by T is the set of all stable assemblies that can be built by starting from the seed assembly of T and legally adding tiles. If α and β are configurations of T , we write α −→ β if there is an assembly sequence that starts at α and produces β. An assembly of T is terminal if no tiles can be stably added to it. We are, of course, interested in being able to prove that a certain tile assembly system always achieves a certain output. In [16], Soloveichik and Winfree presented a strong technique for this: local determinism. 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 t 0 at location l in the result of α, and t 0 and the immediate "OUT-neighbors" of t 0 are deleted from the result of − → α , then no other tile type in T can legally bind at l; the result of − → α is terminal. A tile assembly system T is locally deterministic iff every legal assembly sequence of T is locally deterministic. Local determinism is important because of the following result.
Theorem 1 (Soloveichik and Winfree [16]). If T is locally deterministic, then T has a unique terminal assembly.

Distributed computing background
Distributed computing began as the study of networks of processors, in which each processor had limited local knowledge. However, much of the distributed computing literature now speaks in terms of systems of processes, not processors, to emphasize that the algorithms or bounds obtained from the theorem apply to any appropriate collection of discrete processes, whether they are part of the same multicore chip, or spread across a sensor network. One of the most-studied distributed computing models is the asynchronous shared memory model, in which processes are modeled as finite state machines that can read and write to one or more shared memory locations called registers. The model is asynchronous because there is no restriction on when a process will execute its next computation step, except that any nonfaulty in (iii) a tile binds to the north of the seed tile for the same reason. Note that steps (ii) and (iii) could have occurred in reverse order; this is an example of the nondeterminism of self-assembly. In (iv) a tile binds because its west side (which is strength one, as represented by the single line) and south side (also strength one) bind cooperatively to the tiles already in the configuration, creating a strength two bond. Figure (v) shows an alternative to (iv), in which a tile binds incorrectly, causing a blockage that prevents the assembly from growing further.
process can delay only a finite length of time before taking its next step. We refer the reader to [2] for exposition and technical details of such a model. We now provide a formal definition of the consensus problem for a distributed system. Definition 1. Let M be an asynchronous shared memory model such that each process p i in M has two special state components: x i , the input; and y i , the decision value. Let V , the set of possible decision values, be a finite set of positive integers. We require that x i ∈ V for all i. For each i, y i starts out containing a null entry, y i is write-once, and the value written cannot be erased. A solution to the consensus problem is an algorithm that guarantees the following.
Termination Every nonfaulty process p i eventually writes a value to y i . Agreement For any i, j, if p i and p j are nonfaulty and write to y i and y j , then y i = y j . All nonfaulty processes decide on the same decision value. Validity For any i, if p i is nonfaulty, then the y i written by p i must be the input value x j for some processor p j .
We will consider fault-tolerant consensus, in which one or more processes can fail in some way. The simplest type of failure-and the only type we will consider in this paper-is crash failure, meaning that at some point a process ceases operation and never takes another step.
It is a classic result of distributed computing that there is no deterministic algorithm that solves the consensus problem in an asynchronous shared memory model, in the presence of even a single crash failure, when the only registers available to the system are read/write registers [4]. One way to overcome that impossibility result is by making the registers more powerful. These more powerful registers are often called objects or shared objects, to emphasize they might be a special process segment unto themselves, not just a single memory location. For a comprehensive introduction to the theory of shared objects with different consensus strengths, see [8]. We will use only the following key definitions in this paper.

Definition 2.
Object O solves wait-free n-process consensus if there exists an asynchronous consensus algorithm for n processes, up to n − 1 of which might fail (by crashing), using only shared objects of type O and read/write registers.
where v ∈ V is a possible decision value, and O will ack with command return(O, v out ), where v out ∈ V is a possible decision value, and O returns the same value v out to all processes that invoke it. O is an n-consensus object if O is a consensus object and n is maximal such that O solves wait-free n-process consensus.
Finally, we define the notions of configurations and execution segments of a distributed system. Intuitively, we consider the events of a system to be the read and write invocations (and acks) performed upon (and returned by) registers by the processors of the system; and configurations and execution segments are built up from the instantaneous state of the system, and events that are then applied to it. Definition 3. Let M be a distributed system with n processes and one n-consensus object O. A configuration of M is an (n + 1)-tuple q 1 , . . . , q n , o , where q i is a state of p i and o is a state of O. The events in M are the computation steps by the processes, the transmission of a consensus decision value from O, and the (possible) crashes of up to n − 1 of the processes. A legal execution segment of M is a sequence of form C 0 , φ 0 , C 1 , φ 1 , C 2 , φ 2 . . . where each C i is a configuration, φ i is an event, and the application of φ i to C i−1 results in C i .

Simulating a two-processor message-passing system in tile self-assembly
In practice, asynchronous shared memory systems are usually built on top of distributed systems in which processors interact physically by passing messages. The shared memory model is a convenience for the programmer, as shared memory is easier to reason about than message-passing. Our method of simulating shared consensus objects is conceptually similar: we will construct tile assembly machinery to simulate a two-processor message-passing distributed system, and then in the next section modify that machinery to simulate a shared 2-consensus object.
Winfree showed how to simulate the behavior of a Turing machine by means of a "wedge construction" in tile assembly [20]-essentially, the growing tile assembly grew level by level, with each level simulating one step of a Turing machine execution, the seed tile simulating the initial input, and (if needed) the level expanding one tile longer than the previous level to simulate the Turing machine head moving to a never-before-reached cell of the work tape. It is this expansion of a level (always occurring in the same direction) that gives the terminal assembly of the simulation a wedge-like appearance. Lathrop et al. [10] extended this wedge construction so that the notion of "simulate" would mean that each row of the wedge records the state of the Turing machine tape after one move of the head, and, if the Turing machine halts, a row of tiles is built along the side of the wedge, so a special "halting tile" binds to the base of the wedge, as a marker that the simulation has halted.
We now modify the construction of [10] to simulate two processors capable of sending each other messages. The intuition behind the simulation is that we add an input buffer and an output buffer to Winfree's original construction by having every other row of the wedge check to see whether a message has been received, and to incorporate the message if one has arrived; and we simulate the sending and receipt of a constant-size number of messages by using a unique tile that encodes the message to build a ray along the edge of the wedge, toward the intended destination of the message, and a ray back along the edge of the wedge to simulate the ack -the character that acknowledges receipt of the message. A high-level schematic for the construction appears in Figure 2.
Theorem 2. For any two-processor message-passing model M of distributed computing in which each process runs forever and sends messages of constant size, there is a tile assembly system T (in the standard Winfree-Rothemund Tile Assembly Model) that simulates M in two dimensions.
Proof. Fix M a two-processor asynchronous message-passing model of distributed computing, such that processors p 1 and p 2 send each other messages of size bounded by some constant k. Winfree has shown that the Tile Assembly Model is Turing Universal, and in particular can simulate a Turing Machine using a construction that grows in the shape of a "wedge" [20]. If neither p 1 nor p 2 ever sends (or receives) messages, then let T 1 and T 2 be tile assembly systems that simulate p 1 and p 2 . Then we can construct a tile assembly system T * with a seed out of which T 1 grows in one direction, and T 2 grows in another.
So assume that at least one of p 1 , p 2 sends messages to the other. To simulate processors checking their inbuffers, we modify the wedge construction, so that (1) messages sent to the processor simulated by the wedge can "crawl up" the side of the wedge until they reach the frontier; and (2) every other row of tiles in the wedge allows sent messages to bind with that row with probability bounded away from zero. Therefore, the construction remains two-dimensional, and, since both p 1 and p 2 run forever, the message will be delivered with probability one. Figures 3 and 4 illustrate how the modified wedge construction works.

Simulation of processor one, and its input buffer
Simulation of processor two, its input buffer and a message sent from processor one to processor two. Fig. 2. Schematic of how to simulate a two-processor message-passing system with two-dimensional tiling. The green tiles are the initial seed assembly, out of which the white wedges grow. The wedges simulate the processors. An additional tile is attached to each level of the wedge, to simulate the processor's inbuffer, as described further in Figure 3. To simulate sending a message from processor 1 to processor 2, the wedge on the left sends a message down the side that does not contain the inbuffer. The transmission of that message is done by the tiles colored light grey. (The black arrows indicate the order in which the tiles bind during assembly.) If processor 2 sent a message to processor 1, we could simulate this in tiles by constructing a similar "grey" transmission from the northeast edge of the wedge simulating processor 2, westward toward processor 1 (essentially a mirror image of the grey tiles in the schematic).

Seed assembly
Since there are only k-many messages, we encode each message with a unique tile. We simulate the sending of messages from p 1 to p 2 by allowing tiles to bind along one "edge" of the tile assembly, and simulate the sending of messages from p 2 to p 1 along the other "edge." It is important that the Tile Assembly Model assumes that at each stage of assembly, the tile that binds-and the location it binds to-are chosen uniformly at random. It takes several tiles to build one row of a wedge, but just one tile to propagate a message up one row, closer to the frontier. So, almost surely, the message will have unboundedly many opportunities to incorporate its information into the "inbuffer row"; hence, almost surely, the message will be delivered.

Simulating 2-consensus in two dimensions
We turn now to the simulation in tile assembly of shared objects that solve wait-free consensus problems. We will discuss in this section how to simulate 2-consensus by a two-dimensional tile assembly system, and in the next section show how to extend the simulation to more processes, and to a third tiling dimension.
Intuitively, the main objective of this section is to construct a tile assembly system that behaves as shown in Figure 5: there are three "modules" or subassemblies: one (π 1 ) to simulate p 1 , another (π 2 ) to simulate p 2 , and a third to simulate a 2-consensus object. In addition, there are "rays" of tiles built from π 1 and π 2 , to simulate the values that p 1 and p 2 are writing to the 2-consensus object; and "rays" of tiles built in response, to simulate the acks received by p 1 and p 2 after the writes conclude.
First, we define what it means for a tile assembly system to simulate a distributed system. Informally, we want to capture the following: each configuration of the distributed system is simulated by a tile configuration; all legal behavior of the distributed system is modeled by legal behavior of the tile assembly system; conversely, if it is impossible to take a step in the distributed system, the tile assembly system cannot simulate taking that step; and the tile assembly system halts, or a section of it becomes blocked, if and only if the distributed system reaches a halting configuration, or the corresponding processor crashes.
Definition 4. Tile assembly system T simulates distributed system M if: 1. There is a 1-1 mapping h from configurations of M to stable tile configurations of T .
is a legal tile assembly sequence in T . 3. If there is no legal execution segment from C 0 to C 1 in M, then there is no legal tile assembly sequence in T such that h(C 0 ) −→ h(C 1 ). 4. Let C be a configuration of M and C be a set of configurations of M. If M is such that, upon achieving configuration C, it must eventually achieve some configuration C ∈ C unless a process crashes, then T is such that, if it ever reaches h(C) then it must achieve h(C ) for some C ∈ C unless there is a tile blockage. (Note that C may be an infinite set.) 5. If C 0 , φ 0 , C 1 , φ 1 is a legal execution segment in M, and the event φ 0 is the crash failure of a previously correct process, then h(C 1 ) contains one more tile blockage binding error than h(C 0 ) contains. 6. If in configuration C of M all processes have halted, then in tile configuration h(C) of T there are no further locations to which tiles can bind stably, i.e., h(C) is terminal.  The dark grey tiles are the edge of a "wedge" that simulates processor 2 (in the simulation of a twoprocessor system). The light grey tiles represent the inbuffer of processor 2. In this diagram, every other row of the wedge is a row that is built from the inbuffer tile, to the west. The arrows show the direction that tiles bind in. More generally, the wedge construction does not need to "check" the inbuffer at every other row, as long as it checks infinitely often. Figure (i) shows how message m 1 attaches along the east side of the inbuffer, and has opportunities due to double bonds to bind to the north of the most recent inbuffer tile. In Figure (ii), m 1 is successfully transferred into the inbuffer, which then means that the next row that checks the contents of the inbuffer transmits m 1 to (potentially) all tiles in the wedge, as shown. The farthest northeast tile in Figure (ii) changes the column to an inbuffer column, in case later messages need to be transferred from the east to the wedge growing to the west.
Edge of simulation of processor 2.  Fig. 4. This figure continues the construction from Figure 3(ii), by showing how a second message, named m 2 , gets transferred to the "first message" column of the wedge simulating processor 2. The mechanism shown in Figure 3 will then transfer m 2 to the inbuffer. Note that the furthest northeast tile sets up the configuration so any further messages sent can be transferred west, as m 2 was.
Subassembly π 1 Simulation of processor one Seed assembly "2-consensus object" of Figure 2 Subassembly π 2 Simulation of processor two Fig. 5. Two (yellow) subconfigurations π 1 and π 2 growing from a common (green) seed assembly. (The arrows indicate the order in which tiles bind to the assembly.) They communicate with the configuration shown in Figure 6, by means of (grey) "message" tiles they send, and (white) "ack" tiles they receive back. Intuitively, π 1 and π 2 simulate two processes in a distributed system, communicating with a 2-consensus object.
The main objective of this section is to prove the following theorem.
Theorem 3. Let M be an asynchronous message passing model of distributed computing with two processes and one 2-consensus object O, such that p 1 and p 2 send no messages to each other, and such that each process invokes O at most once. Then there is a tile assembly system T that simulates M.
To prove Theorem 3 we first exhibit a tile configuration that can simulate a 2-consensus object. Lemma 1. Fix V any finite set. There is a tile configuration ρ that contains a binding location l with the following properties: (1) the only tiles that bind at l have nonzero glue strenghs at either the south, north and west sides, or the south, north and east sides; (2) any tile that binds at l will have a glue name taken from V on either its east or west side; (3) if glue name v ∈ V is on the tile that binds at l, then the name of the tile's north glue will be "Ackv," and ρ will build a ray transmitting the glue name Ackv to its west and east.
Let V be the set of decision values of the consensus problem we want to simulate. Then Figure 7 exhibits a tileset of 6 · |V | + 5 tile types that assembles ρ with the desired properties.
Proof (Lemma 1). Fix a finite set V and a locally deterministic tile assembly system T that builds all but the top row of the tile configuration shown in Figure 6(i). For each v ∈ V , add a tile as shown in the top row of Figure 6(i), such that v appears in each location a "0" or "1" appears in the figure. If a tile with value v ∈ V as its west glue name binds as a decision tile, as in Figure 6(ii), then ρ builds an ack as shown in Figure 6(iii). Similarly, a tile with value v ∈ V as its east glue, ρ builds an ack as shown in Figure 6(v). Without loss of generality, assume the decision tile binds with the value transmitted from the west of ρ. When tiles eventually arrive from the east, ρ will build an ack on their north sides, as shown in 6(iv). Figure 7 exhibits an explicit tileset of 6 · |V | + 5 tiles for such a tile configuration ρ.
Once the decision tile binds, the tileset for ρ is locally deterministic. Hence, unless a blockage error occurs, ρ builds appropriate acks to both east and west, regardless of the order in which the tiles bind.
Proof (Theorem 3). Fix M, a system of distributed computing per the theorem statement, let V be the set of possible input values to the consensus problem that O might be invoked to solve, and let k = |V |. We will design T so it builds the structure shown in Figure 5.
Using the machinery from the proof of Theorem 2, let T 1 be a tile assembly system that simulates p 1 , T 2 a tile assembly system that simulates p 2 , and T 3 a tile assembly system that constructs ρ, a simulator of a 2-consensus object, per Lemma 1. Without loss of generality, we can require T 1 to build in a direction opposite to T 2 (west and east), and for each to build in such a way that they simulate the growth of the Turing machine tape by extending one additional tile to the south at every other column of the construction.
Begin with tile assembly system T * as in the proof of Theorem 2: the seed assembly of T * is such that T 1 grows out of it in one direction, and T 2 grows out of it in another, as in Figure 2. We will build T by extending T * to include the simulation of communication between those two processes and the consensus object.
Extend T * to T by adding, for each of the k possible decision values, unique tiles of the form shown in Figure 6(i), so π 1 and π 2 can send rays to ρ, and receive acks as shown in Figure 6(iv). (The diagram shows a simulation of binary consensus, with only glue names "0" and "1." We replace Ray from subassembly π 1 Ray from subassembly π 2 0 (To π 1 )  Fig. 6. Diagram of the simulator of a 2-consensus object used to prove Theorem 3. At stage (i), rays from subassemblies π 1 and π 2 approach location l. At stage (ii), a tile binds at l, in this case deciding in favor of the input value of subassembly π 1 . At stage (iii), the simulator sends an ack to π 1 . At stage (iv), the simulator sends an ack to π 2 . "Stage" (v) demonstrates the alternative: a decision tile has bound in favor of the initial value of π 2 , and the simulator has acked to π 2 .
those glue names with a total of k distinct names.) We also include in T the tiles needed so that a subconfiguration that simulates a process can send, and receive, one tile's worth of information. To show T simulates M, let h 1 be a map that testifies that T 1 simulates p 1 (on all process steps except invocations to O and responses from O), and h 2 testify that T 2 simulates p 2 (similarly, without communication with O). Let α be a configuration of ρ in which the base of ρ has been completely built, i.e., everything but the top row of Figure 6(i). Then for C = q 1 , q 2 , o a configuration of M, we have the following cases.
2. If p 1 or p 2 (or both) have invoked O, but O has not responded to either yet, let h(C) = h 1 (q 1 ) ∪ h 2 (q 2 ) ∪ α ∪ β, where β is the blue tile configuration of Figure 5 that simulates the transmission of messages from p 1 or p 2 or both, as appropriate. As the messages have not arrived at O, no tiles in β reach the top of subassembly ρ. 3. If O has responded to exactly one process, say where β is a configuration as in Figure 6(iii), with the appropriate decision value replaced for glue name "0." 4. If O has responded to both processes, say in order p 1 and then where β is a configuration as in Figure 6(iv), with the appropriate decision value replaced for glue names "0" and "1." 5. If q 1 is of form return(O,v) for v ∈ V , let C be the configuration immediately preceding C in the execution segment. Define h(C) by adding tiles to h(C ) so a tile with the glue name corresponding to decision value v is stably placed at the northeast corner of π 1 , for incorporation into the simulation of p 1 . Define h(C) similarly if q 2 is of form return(O,v), except that the tile is stably placed at the northwest corner of π 2 .
Since we are assuming each of p 1 and p 2 invokes O at most once, a simple induction argument confirms that T simulates M via h.

Simulating distributed systems with three or more processes
One critical difference between "classical" distributed systems and tile assembly systems is that sending messages-and writing to shared memory locations-in a distributed system does not affect the future computation resources available to processes; whereas in a tile assembly system, the tiles placed on the plane to simulate such operations may "box in" other subassemblies, so they cannot grow beyond some point, due to tile blockages. Put another way, systems of distributed processes have multidimensional resources: each process computes using its own set of resources, and messagepassing takes place via a different set of resources. By contrast, every tile operation self-assembles using the same shared resource: the surface. It is, therefore, not surprising that to simulate this resource-independence of distributed systems, tile assembly systems require multiple surfaces, that is to say, three spatial dimensions. Formalizing that is the main objective of this section. We now generalize the "traditional" consensus problem in distributed computing, to make explicit an assumption that is perhaps universal in the distributed computing literature: invocation of a consensus object does not increase the likelihood that a processor will fail. Definition 5. Let M be a system of distributed processes such that all correctly-operating processes will run forever. A solution to the Consensus Subroutine Problem for M is an algorithm A that solves the wait-free consensus problem for M in such a way that no process increases its likelihood of crash failure by calling A as a subroutine.
If M has only two processes, then a tile assembly system of the form in Figure 5 will solve the Consensus Subroutine Problem for M, because there is enough space on the surface for π 1 , π 2 and the messages to and from ρ to assemble without interfering. For M with three or more processes, the situation is different. If we attempt to simulate processes that run forever in two dimensions, the tile configurations that simulate the processes must grow without bound. This will cause destructive collision with tiles attempting to communicate information with an n-consensus object.
Theorem 4. Let M be a system of n distributed processes (n ≥ 3) and one n-consensus object, such that all correctly-working processes will run forever. Then no two-dimensional tile assembly system can simulate a solution of the Consensus Subroutine Problem for M.
Proof. Let M be a distributed system with three processes, and otherwise as given in the theorem statement. Any T that simulates M must be able to simulate M even if any n − 1 processes of M crash. So each tile configuration that simulates a process p i ∈ M must grow independently of other such configurations, else a tile blockage simulating the crash of p i might also block p j where i = j. Let π 1 , π 2 , π 3 be the independent tile subconfigurations simulating p 1 , p 2 , and p 3 , respectively.
In order to simulate wait-free 3-consensus, there must be a particular location l on the tiling surface where two processes (WLOG say p 1 and p 2 ) agree on a common value. But then consider an execution segment of the consensus algorithm in M where O sends a common value to p 1 and p 2 , but neither p 1 nor p 2 receives that information until p 3 has decided on its own final decision value. (Without loss of generality, we can assume that l is located further from π 3 than from either π 1 or π 2 .) To simulate this in tiling, π 3 must obtain the information about the correct decision value somehow, and there is no guarantee the information is located anywhere except on the surface somewhere between π 1 and π 2 , as it has not reached either π 1 or π 2 yet. Configuration π 3 must either decide on a value without consulting either π 1 or π 2 , or obtain the information from location l. If π 3 decides independently, it could decide on the wrong value. However, to obtain the information from l, it must build a transmission ray and an ack ray to and from l, which means that the tiles it places forever limit the growth of either π 1 or π 2 , or both. (See Figure 8 for a visual representation.) Any tile assembly system that limits the growth of π 1 , π 2 or π 3 cannot solve the Consensus Subroutine Problem for M. Given a distributed system with four or more processes, we can just consider the Consensus Subroutine Problem for executions in which all but three processes crash. We have shown there is no two-dimensional tiling simulation of a solution to the Consensus Subroutine Problem for three processes. Therefore, there is no such simulation for a system with any number of processes n ≥ 3.
To focus on analysis of fault-tolerance of the consensus problem in a distributed system, models of distributed computing tend to require that the consensus object itself be nonfaulty, even though processes may fail. We will carry over that requirement into our tiling models: we do not permit tile blockages at location l in the construction ρ, nor on the "approach pad" of the three-dimensional configurations we are about to present. Therefore, our results show that if all tiles in these configurations bind correctly, they simulate objects capable of solving wait-free n-consensus for any finite n.
Kao and Ramachandran have proposed a "natural" extension of the Winfree-Rothemund Tile Assembly Model from two dimensions to three dimensions [9], in which self-assembling DNA cubes are constructed like folding boxes from two-dimensional DNA tiles. Figure 9 illustrates how such a cube could be "derived" from planar tiles. A cubic tile in this model would then be a 4-tuple T N × T S × T W × T E , where each T i (for i ∈ {N, S, E, W }) encodes the glue information needed to

Seed assembly
The black circle contains location l, where the decision value for π 1 and π 2 is reached.
Ray from π 3 Fig. 8. For π 1 and π 2 to agree on a decision value, they must agree on a value at some location l. If the information at l is tiled outside the blue area before π 1 and π 2 incorporate it into their simulation of p 1 and p 2 , it will block further progress of (at least) one of π 1 , π 2 . So to simulate an execution where p 1 and p 2 take no further steps until p 3 has decided, the decision value must lie inside the blue area. But if π 3 sends a ray into the blue area to obtain the decision value, it permanently blocks growth of π 1 or π 2 (the figure shows π 3 blocking π 1 ). However, π 3 has no other way to make progress if π 1 and π 2 agree on a value, and then no more tiles bind to π 1 or π 2 until π 3 has committed to a decision. (The point is information-theoretic. If the ray from π 3 connects to a ray from the red circle before a ray from the red circle connects to π 1 or π 2 , then π 1 or π 2 will be forever unable to send information through that tile configuration.) "sew" the cubic tile together, as in Figure 9, and also the glue type on each respective cube face, available to bind to other cubic tiles. We refer the reader to [9] for the formalisms of this model, and for discussion of algorithms and complexity measures in the model. For our purposes, it is sufficient that there is a (theoretical) way to construct self-assembling cubes whose faces carry glue information, and these cubes bind together following similar rules as in two dimensions: all binding is error-free or a blockage, and bonds are stable if they produce a binding strength of 2 or greater.  Fig. 9. Schematic for construction of a three-dimensional cube from two-dimensional tiles. This figure follows Figure 1 in [9]. Tiles floating in solution combine in a group of six, as in (a), which then folds into a box, as in (b). Each face of the cube can then bind to other cube faces, because of additional glues encoded into the faces that, for clarity, are not shown in the diagram.
Theorem 5. Let M be a system of n distributed processes (n ≥ 3) and one n-consensus object O, such that the processes do not send one another messages, each process invokes O at most once, and all correctly-working processes will run forever. There is a three-dimensional tile assembly system that simulates solution of the Consensus Subroutine Problem for M.
Proof. Let M be a distributed system as in the theorem statement. We will simulate the execution of n processes in two tiling dimensions by constructing a tile system that assembles in a "starfish" pattern, with n arms growing out from a central seed tile. Each arm simulates one process of M. We can control the direction of growth-and the rate of increase in width-of each tile configuration that simulates a Turing machine, so such starfish configurations can be tiled, for any n. (Techniques to do this are discussed in [10] [12].) The construction of Figure 5 was successful because the communication between π 1 and ρ, and π 2 and ρ, did not block the growth of either π 1 or π 2 . We duplicate that effect by placing the tile configuration that simulates n-consensus object O above the seed assembly (in the z-direction), and requiring that the tiles that simulate processes have glue names on their "tops" (their upward faces in the z-direction) that create paths for transmission of proposed decision values, and reception of acks of those transmissions. Figure 10 explicitly shows how to construct a three-dimensional tile configuration that simulates a 4-consensus object. We could simulate a 3-consensus object by blocking one of the sides of the "approach pad" of that construction. We now argue generally about how to construct such a simulating configuration for any n ∈ N. The subassembly in Figure 10 sends a ray due north, and receives an ack due south. If we want to simulate an n-consensus object for n > 4, we use the following more general tiling method: each of the n processes has an entry square to the approach pad. Once a transmission ray is incident to the approach pad, its tiles bind in a way that "floods" the approach pad-greedily binding to any location possible on the approach pad. Since we are assuming there can be no tile blockages on the approach pad, we are guaranteed that some tile from some unblocked π i will bind to the decision point. Once a tile binds to the decision point, acks are built in the z-direction above the decision point, and the correctly-labeled ack radiates along the tops of all the tiles that bound to the approach pad, and follow back the transmission rays to the π j 's that sent them. Because we have the extra z-direction to work in, it is ok if the transmission rays on the approach pad block one another: each π i will attempt to enter the approach pad at a unique location, and if its entry (or forward progress on the approach pad) is blocked, its presence nonetheless creates a "channel" for the ack information to be transferred, along the top and the sides of the transmission ray.

Conclusion
We have shown how two-dimensional tile assembly systems can simulate solution to the consensus problem for some two-process distributed systems, and how three-dimensional tile assembly systems can simulate a strengthening of the consensus problem for some n-process distributed systems, for any n. One way to extend our current results would be to consider what types of communication among processes could be simulated by tile assembly.
The error assumption in this paper-that any binding fault causes an entire subassembly to stop growing permanently-is an oversimplification that renders sophisticated error-management techniques unavailable for almost trivial reasons. One can imagine a simulation of a two-processor system in which the tile constructions that simulate each processor are interleaved somehow, with sufficient redundancy that many binding errors could be recovered, in a way analogous to the behavior of resilient cellular automata [6]. However, because those assemblies are interleaved, the assumption of blockage failure would cause them both to stop growing, as their frontiers are not independent of each other. An important area of future work will be the modeling of more realistic failures, and the development of techniques to manage such failures.  Fig. 10. Proposed values from subassemblies can approach the decision point from four sides. Whichever value binds to the decision point is the one chosen and acked to all subassemblies. This scales up to any finite n ≥ 3, by making the approach pad large enough to accomodate "transmission rays" from n subassemblies; and by sending the acks along the "tops" of the "transmission rays," as shown in the side view, Figure 11. (That way, each subassembly will receive an ack, and not be blocked out from lack of space.) Note this construction is not "fair," in the sense that the decision point is not equidistant from each subassembly, so one subassembly's proposed value may be more likely to be chosen than that of others. Fortunately, consensus only requires common agreement, not fairness.