The non-cooperative tile assembly model is not intrinsically universal or capable of bounded Turing machine simulation
Pierre-\'Etienne Meunier, Damien Woods

TL;DR
This paper proves that the non-cooperative (temperature 1) tile assembly model cannot simulate Turing machines or be intrinsically universal, contrasting with the cooperative model's capabilities, and introduces new analytical tools for such proofs.
Contribution
The paper demonstrates the limitations of the non-cooperative tile assembly model and develops new tools for analyzing complex paths and computational power in tile systems.
Findings
Non-cooperative model cannot be intrinsically universal.
Generalizations like errors or 3D increase computational power.
Introduces a reduction technique for proving computational limitations.
Abstract
The field of algorithmic self-assembly is concerned with the computational and expressive power of nanoscale self-assembling molecular systems. In the well-studied cooperative, or temperature 2, abstract tile assembly model it is known that there is a tile set to simulate any Turing machine and an intrinsically universal tile set that simulates the shapes and dynamics of any instance of the model, up to spatial rescaling. It has been an open question as to whether the seemingly simpler noncooperative, or temperature 1, model is capable of such behaviour. Here we show that this is not the case, by showing that there is no tile set in the noncooperative model that is intrinsically universal, nor one capable of time-bounded Turing machine simulation within a bounded region of the plane. Although the noncooperative model intuitively seems to lack the complexity and power of the…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsDNA and Biological Computing · Cellular Automata and Applications · Modular Robots and Swarm Intelligence
The non-cooperative tile assembly model is not intrinsically universal or capable of bounded Turing machine simulation
Pierre-Étienne Meunier
Inria
[email protected] This work was carried out while at Inria, Paris, France, and the Department of Computer Science, Aalto University, Finland, and Aix Marseille Université, CNRS, LIF UMR 7279, 13288, Marseille, France, and LIAFA UMR 7089, Paris 7, France, and California Institute of Technology, Pasadena, CA 91125, USA. Supported in part by National Science Foundation Grant CCF-1219274.
Damien Woods
Inria
[email protected] This work was carried out while at Inria, Paris, France, as well as California Institute of Technology, Pasadena, CA 91125, USA, and during a brief visit to LIAFA (UMR 7089), Paris 7, France. Supported by National Science Foundation grants CCF-1219274, 0832824 (The Molecular Programming Project), CCF-1219274, and CCF-1162589, USA, a visiting professor award from Paris 7, and by INRIA.
Abstract
The field of algorithmic self-assembly is concerned with the computational and expressive power of nanoscale self-assembling molecular systems. In the well-studied cooperative, or temperature 2, abstract tile assembly model it is known that there is a tile set to simulate any Turing machine and an intrinsically universal tile set that simulates the shapes and dynamics of any instance of the model, up to spatial rescaling. It has been an open question as to whether the seemingly simpler noncooperative, or temperature 1, model is capable of such behaviour. Here we show that this is not the case, by showing that there is no tile set in the noncooperative model that is intrinsically universal, nor one capable of time-bounded Turing machine simulation within a bounded region of the plane.
Although the noncooperative model intuitively seems to lack the complexity and power of the cooperative model it was not immediately obvious how to prove this. One reason is that there have been few tools to analyse the structure of complicated paths in the plane. This paper provides a number of such tools. A second reason is that almost every obvious and small generalisation to the model (e.g. allowing error, 3D, non-square tiles, signals/wires on tiles, tiles that repel each other, parallel synchronous growth) endows it with great computational, and sometimes simulation, power. Our main results show that all of these generalisations provably increase computational and/or simulation power. Our results hold for both deterministic and nondeterministic noncooperative systems. Our first main result stands in stark contrast with the fact that for both the cooperative tile assembly model, and for 3D noncooperative tile assembly, there are respective intrinsically universal tilesets. Our second main result gives a new technique (reduction to simulation) for proving negative results about computation in tile assembly. However, our results leave as an open problem whether there might be other ways noncooperative systems compute.
1 Introduction
The design and laboratory fabrication of nanoscale molecular systems that implement sophisticated computation is a goal held by many. If we are to have such an engineering discipline that exploits the idea that molecules can compute, then we need a firm foundation of the kind of computational theory that is relevant to such systems. The field of algorithmic tile assembly provides one such theoretical framework targeted specifically at molecular self-assembling systems. One of most well-studied models of computation for molecular self-assembly systems is the abstract tile assembly model, put forward by Winfree [26]. The model describes crystal-like growth process where, starting from a small connected arrangement of square tiles, called a seed assembly, a growth process takes place where other unit-size square tiles stick to the ever-larger growing assembly. Local rules specify which tiles can stick at each location along the boundary of the assembly. Growth happens asynchronously and in parallel; the model is a kind of asynchronous nondeterministic cellular automaton. Winfree [26] showed that the model can simulate Turing machines, Winfree and Rothemund showed that it can efficiently self-assemble squares [24, 23], and Winfree and Soloveichik [25] used bounded-space simulation of time-/space-bounded Turing machines to exhibit for each finite connected shape a Kolmogorov-efficient tile set that assembles a scaled version of that shape. Recently, it has been shown that there is even a single intrinsically universal tile set set that faithfully simulates the geometry (shapes) and dynamics of any instance of the model, up to spatial rescaling [8].
These results were all shown for the so-called cooperative (or temperature 2) model, where tiles bind to the growing assembly if they, or at least some of them, bind on two or more sides. This provides a kind of “context sensitivity” in the growth process. What happens if we allow noncooperative (or temperature 1) growth where tiles bind if they match on at least one side? Growth like this looks like growing and branching tips in 2D. Tendrils snake out from the seed, possibly crashing into each other, and more often than not they seem to merely form simple structures (cycles and/or repeated path segments), and certainly not the kind of structures needed for computation. Putting proofs behind this intuition has been a challenge and the literature has seen a number of unproven conjectures about the limitations of temperature 1. In this paper, we settle two such questions.
Our first main result is on the topic of simulation in tile assembly. As noted, it has been shown that there is an intrinsically universal tile set for the cooperative model; that is, a tile set is capable of simulating any instance of the cooperative model [8]. More precisely, there is a tile set that given as input any instance of the tile assembly model (encoded as a seed assembly), tiles from self-assemble (at temperature 2) to simulate the geometry (shapes) and dynamics of perfectly, modulo a spatial rescaling. By spatial rescaling we mean that each unit-sized square tile in is simulated by an square block of tiles over . The result is a kind of completeness result for the abstract tile assembly model: the tile set is “hard” for all tile assembly systems in the sense it is able, via extensive use of cooperative binding, to capture all possible production and dynamics of all systems, and of course every instantiation of is itself also a valid tile assembly system. Since then, it has been shown [20] that the noncooperative tile assembly model can not simulate the cooperative model but it was left open (Conjecture 1.4 [20]) whether the noncooperative model can simulate itself. So although the noncooperative model is weak, perhaps it is just strong enough for self-simulation? In other words, is there a noncooperative tile set that is “hard” for the noncooperative model? We answer this conjecture by showing that there is no such intrinsically universal tile set for the noncooperative model.
Our second main result is on computation in the noncooperative model. We show, that it is impossible to simulate a time-bounded Turing machine in a bounded rectangular region of the plane in the noncooperative model (see Theorem 1.2 for the formal statement). Although this statement has caveats (i.e. both instances of the word “bounded”), it implies that the noncooperative model can not simulate Turing machines using any method with a geometry remotely similar to any of the known ways to simulate Turing machines in any known tile assembly model [24, 25, 3, 6, 5, 23, 22, 21, 15, 11, 14, 26, 27].111I.e. by simulating a time and space -bounded Turing machine in a region for finite functions and . It is important to note that the negative result about simulation in ref [20] does not say anything about computation in the model; in fact that particular negative result also holds in the 3D noncooperative model, despite the fact that model can simulate Turing machines. It is also important to point out that many generalisations [3, 7, 6, 13, 5, 23, 22, 1, 21, 16, 11, 15, 14] of the classical 2D noncooperative model can indeed carry out “bounded” simulation of Turing machines; thus our result formally separates these generalised noncooperative models from the classical 2D model.
New tools for noncooperative tile assembly.
Besides showing limitations on noncooperative growth in terms of simulation and computation power, we contend that this paper brings some new techniques to the table. Generally in tile assembly systems, in order to carry out nontrivial computation for finite or infinite shape-building one often has the goal of building structures that (a) are large but (b) not too large (e.g. neither hardcoding a small shape nor filling the entire plane could be reasonably regarded as interesting computation—the interesting algorithmic stuff lies in-between). In this paper we provide two tools to analyse, and prove negative results on, building such shapes in the noncooperative model. The first is a method to show that any any path of tiles that travels a long enough horizontal distance while staying above some horizontal line can be either pumped forever or else blocked by growing something else. Hence if was supposed to form part of some interesting shape, then our first tool (Lemma 5.10) makes it so that we can use to make another path that either goes outside the shape ( is pumpable), or else prevents from growing to completion ( is blocked). This contrasts with previous works, e.g. [10, 18], since here we use non-pumpable paths to prove that other “unintended” assemblies can be produced. In fact one of the main new ideas in our work is to prove strong properties about non-pumpable paths.
Our second tool (Theorem 6.1) builds on this to simultaneously block multiple paths, despite the fact they may interact with each other in very complicated ways. More precisely, given a set of paths of tiles, we define a total ordering on those paths so that we can iteratively apply the first tool to infinitely pump and/or block all of the paths. This methodology seems general enough that it might find future application. See Section 4 for a proof overview.
Another contribution of this work that might prove useful in the future is a set of definitions (Section 2.3) and lemmas (Section 5.1) that capture a number of basic properties about producible paths at temperature 1. Two properties we reason about again and again are (a) visibility of a glue from the south meaning that no glue on the path lies immediately below , and (b) the notion of one path being more right-turning, or more right-priority, than another. We often force right-priority paths to grow a branch until that branch crashes into (intersects the position of) a prefix of the path, then we embed the new crashed path in and reasoning using the visibility of some glue along to argue that the crashed path encloses a component of the plane along the left-hand side of . Our conventions and tricks for reasoning about paths of tiles via embeddings in could be applied to a variety of models. They in turn allow us to frequently use reasoning that is at the abstraction level of paths in the plane as opposed to the more low-level of individual tiles and glues. Together this collection of tools allow us to disrupt any attempt to build shapes of a certain kind, and they work whether or not nondeterminism is deployed as a tool by the ill-fated programmer. We hope these ideas may find use independently of the two main problems we solve here.
Intrinsic universality, and simulation between tile assembly systems, is giving rise to a kind of complexity theory for comparing models of self-assembly[28]. It is interesting to note that in this setting sometimes it is possible to prove negative results on the simulation power of models that are already known to be Turing universal [7, 15, 20]. Here we show that one can obtain a negative result on Turing machine-style computation itself, via a negative result on simulation between tile assembly systems. Hence we show (for the first time) that simulation between tile assembly systems is a new method to obtain negative results on Turing computation in tile assembly.
Previous and future work.
A large number of papers have conjectured or discussed that in one sense or another, sophisticated computation such as Turing machine simulation or building shapes with few tile types is impossible in the noncooperative model [24, 23, 5, 10, 4, 18, 22, 1]. Our Theorem 1.2 implies that any claimed simulator of Turing machines by noncooperative (temperature 1) systems would have to look very different from the known methods for cooperative abstract tile assembly model [26, 24, 25] and its generalizations such as the two-handed [3, 7] or polygon [6, 13] models, as well as variants of the noncooperative models, such as 3D tiles [5], probabilistic simulations [5, 23], negative glues [22], staged and stepwise assembly [1], active signals [21, 16], polyomino-shaped tiles [11, 15] and polygons [14]).
Rothemund and Winfree [24] gave the first negative result on 2D temperature 1 systems: building an square requires tile types if we insist that the square is fully connected. They conjecture this holds in the absence of that assumption. Maňuch, Stacho, and Stoll [18] show that 2D temperature 1 systems without mismatches require at least tile types to uniquely self-assemble squares. Tile assembly systems that always build a single terminal assembly are said to be directed. Doty, Patitz and Summers [10] conjecture that every directed 2D noncooperative system is pumpable meaning, roughly speaking, that every sufficiently long path of tiles has a segment that can be producibly repeated infinitely often. (They conjecture this for directed systems since by a result of Cook, Fu and Schweller [5] we know that non-directed systems simulate Turing machines, with some error.) Their paper shows that if this conjecture holds then certain forms of computation (e.g. infinite computation) are impossible for directed 2D temperature 1 systems. Proof of that conjecture would not imply our main results which are concerned with bounded (finite) computation and simulation, nor do our results imply that temperature 1 systems are pumpable (i.e. the present paper leaves the pumpability question open). Also our negative results do not make any assumptions about pumpablity, mismatches nor directedness.
As already noted, it has been shown [20] that noncooperative tile assembly can not simulate the cooperative model, here we answer the main open question from that paper (Conjecture 1.4 [20]).
Meunier [19] gives positive results for 2D noncooperative systems. First, by showing the existence of relatively simple noncooperative tile assembly systems that always build finite assemblies that contain a path where at least one tile type is repeated. A second, more general, construction gives for each real number , a tileset which, started from a single tile seed, produces only finite terminal assemblies, all of height . So although general-purpose computation seems impossible at temperature 1, we know that one form of algorithmic self-assembly is possible, namely building long(ish) paths by re-using tile types.
One of the main reasons one simulates Turing machines with tile assembly systems is to build shapes. Theorem 1.2 shows that none of the standard ways to make shapes in models that are generalisations of the noncooperative model can possibly work in the noncooperative model itself. This gives one formal sense in which shape building via computation is impossible at temperature 1. We leave (all!) others open.
Beyond self-assembly, the combinatorics of self-avoiding walks in the plane, first introduced by Flory in 1953 [12] in the context of polymer chemistry, has provided long-standing open problems attracting attention from mathematicians and computer scientists [17, 2]. Our setting and results can be interpreted as memory-bounded versions of this topic: indeed, noncooperative self-assembly is exactly the process of building self-avoiding paths in , but with a memory encoded by tile types. It would be interesting to see if our techniques could be applied to that domain to shed an algorithmic light on the problem of counting or sampling self-avoiding walks.
There are a large number of papers on temperature 1 models that are generalisations of the classical temperature 1 model that we study [5, 23, 22, 1, 21, 16, 11, 15, 14]. Since those models achieve Turing universality, naïve application of our techniques to those models is provably impossible. But often we care more about shape-building than computation and our techniques give a method to edit producible shapes, hence we ask: Can our techniques be generalised to show limitations to the classes of shapes efficiently producible in those models? Another question: Is there a non-trivial hierarchy of simulation power within the noncooperative model? We leave this as an open research direction to further clarify and investigate the power of noncooperative self-assembly,222The question is not without merit, as recently it was shown that the two-handed, or hierarchical, model of self-assembly has an infinite set of hierarchies with each level in the hierarchy more power than the one below [7]. However, the dearth of positive results for the temperature 1 abstract tile assembly model suggests positive results are unlikely to be easily found. that would certainly require new techniques beyond what we’ve seen to date.
Our results do not close the problem of determining what can be built computationally at temperature 1; there are many potential forms of computation that could in principle be exhibited by noncooperative systems beyond those formally encapsulated by Theorems 1.1 and 1.2. We close with a conjecture that attempts to eliminate many of these. All known temperature 1 tile assembly systems that reuse tile types without producing infinite terminal assemblies produce assemblies that place tiles at a small Manhattan distance from the seed. For example, using tile types to build a size square with Manhattan diameter [24], or, for all real numbers , using tile types to build finite terminal assemblies, all of height at least [19]. We conjecture that if a temperature 1 tile assembly system with tile types produces only finite terminal assemblies, then these terminal assemblies place tiles at Manhattan distance no more than from the seed. This bound is just large enough so that the techniques exploited in this paper — that require reuse of a visible glue type along a path of tiles — could potentially find application, but small enough to almost meet the lower bound in [19]. More importantly, our conjectured bound severely limits the kinds of finite computations achievable in the temperature 1 abstract tile assembly model.
1.1 Results
We give an overview of our two main results, although a number of notions have yet to be formally defined (see Section 2 for definitions). Our first main result shows that the noncooperative abstract tile assembly model is not intrinsically universal:
Theorem 1.1**.**
The noncooperative abstract tile assembly model is not intrinsically universal. In other words, there is no tileset that at temperature 1 simulates all noncooperative tile assembly systems.
The intuition behind the proof is given in Section 4, and the proof is given in Sections 5 and 6.
Our second main result, that is almost immediate from our main theorem, shows that temperature 1 systems are severely limited in their ability to simulate Turing machines. The standard published methods to simulate Turing machines in 2D in the abstract tile assembly model and its generalizations [24, 25, 3, 6, 5, 23, 22, 21, 15, 11, 14, 26, 27], are (or can be easily modified to be) such that simulation of a space bounded, and time bounded Turing machine can be achieved in a rectangle with (a) a seed assembly (encoding ) contained in the leftmost columns (coordinates), (b) an output assembly (encoding the output of on input ) that includes a unique tile type appearing on the rightmost column, and (c) no tile ever goes outside this rectangle. The following theorem states, in a formal way, that simulating Turing machines in a bounded rectangular region, without error and with the accept/reject answer given as a tile on the rightmost column is impossible for the 2D noncooperative abstract tile assembly model, for deterministic or even nondeterministic tile assembly systems. In the theorem statement it is important to note that the “bounding function” is arbitrary in the sense that it allows a potential simulator tile assembly system to use much more space than the actual running time or space usage of the Turing machine ; this generality serves to strengthen the theorem statement (e.g. bounded Turing machine simulation is impossible even if we allow the tile assembly system to use, say, exponential, or doubly exponential, or indeed any finite spatial scaling).
Theorem 1.2**.**
Let , and let such that , . Let be any Turing machine that halts on all inputs in time using space . There is no pair where is a tileset and is a function such that for all , , there is a seed assembly and tile assembly system such that:
** 2. 2.
for all , , where and has at least one occurrence of a special tile type on the rightmost column of , and nowhere else, if and only if accepts .
The formalism simply states that there is no tile set , such that when is instantiated as a noncooperative (temperature 1) tile assembly system , with an input seed assembly (that somehow encodes a Turing machine and its input ), then simulates on within a finite rectangular region, writing a yes/no answer as /“no tile” anywhere on the rightmost column of tiles. Since the “bounding function” in the theorem statement can be arbitrarily large, the theorem holds even if we allow the noncooperative system to use an arbitrarily large, but finite, rectangular bounding box for the simulation. Section 4 gives an intuitive overview of the proof, and the actual proof is given in Section 7.
2 Definitions and preliminaries
Let be the integers, and .
When referring to the relative placements of positions in the grid graph of , or in the plane , we say that a position is to the right of (respectively, to the left of, above, below) of another position if (respectively , , ). This definition should not be confused with the definitions of right and left turns, nor with the definition of right-hand side and left-hand side, all of which are defined below.
Moreover, unless stated otherwise, vectors of and are column vectors, i.e. \overrightarrow{u}=\left(\begin{array}[]{c}x_{u}\\ y_{u}\end{array}\right).
2.1 Abstract tile assembly model
The abstract tile assembly was introduced by Winfree [26]. In this paper we study a restriction of the abstract tile assembly model called the temperature 1 abstract tile assembly model, or noncooperative abstract tile assembly model. For definitions of the full model, as well as intuitive explanations, see for example [24, 23].
A tile type is a unit square with four sides, each consisting of a glue type and a nonnegative integer strength. Let be a a finite set of tile types. In all sets of tile types used in this paper, we assume the existence of a well-defined total ordering that we call the canonical ordering.
The sides of a tile type are respectively called north, east, south, and west, as shown in the following picture:
WestEastSouthNorth
An assembly is a partial function where is a set of tile types and the domain of (denoted ) is connected.333Intuitively, an assembly is a positioning of unit-sized tiles, each from some set of tile types , so that their centers are placed on (some of) the elements of the discrete plane and such that those elements of form a connected set of points. A tile is a pair where is a position and is a tile type. Hence the elements of an assembly are tiles. We let denote the set of all assemblies over the set of tile types . In this paper, two tile types in an assembly are said to bind (or interact, or are stably attached), if the glue types on their abutting sides are equal, and have strength . An assembly induces a weighted binding graph , where , and there is an edge if and only if and interact, and this edge is weighted by the glue strength of that interaction. The assembly is said to be -stable if every cut of has weight at least .
A tile assembly system is a triple , where is a finite set of tile types, is a -stable assembly called the seed, and is the temperature. Throughout this paper, .
Given two -stable assemblies and , we say that is a subassembly of , and write , if and for all , . We also write if we can obtain from by the binding of a single tile type, that is: , and the tile type at the position stably binds to at that position. We say that is producible from , and write if there is a (possibly empty) sequence where , and , such that . A sequence of assemblies over is a -assembly sequence if, for all , .
The set of productions, or producible assemblies, of a tile assembly system is the set of all assemblies producible from the seed assembly and is written . An assembly is called terminal if there is no such that . The set of all terminal assemblies of is denoted .
As mentioned, in this paper . Also throughout this paper, we make the simplifying assumption that all glue types have strength 0 or 1: it is not difficult to see that this assumption does not change the behavior of the model (if a glue type has strength , in the model then a tile with glue type binds to a matching glue type on an assembly border irrespective of the exact value of ).
2.2 Simulation between tile assembly systems and intrinsic universality
To state our main result, we must formally define what it means for one tile assembly system to “simulate” another. A number of definitions of simulation have been put forward for various self-assembly models [9, 8, 20, 6, 7, 11], here and in Appendix A we use those from [20].
Let be a tile set, and let . An -block supertile over is a partial function , where . Let be the set of all -block supertiles over . The -block with no domain is said to be empty. For a general assembly and , define to be the -block supertile defined by for all . For some tile set , a partial function is said to be a valid -block supertile representation from to if for any such that and , then .
For a given valid -block supertile representation function from tile set to tile set , define the assembly representation function444Note that is a total function since every assembly of represents some assembly of ; the functions and are partial to allow undefined points to represent empty space. such that if and only if for all . For an assembly such that , is said to map cleanly to under if for all non empty blocks , for some such that . In other words, may have tiles on supertile blocks representing empty space in , but only if that position is adjacent to a tile in . We call such growth “around the edges” of fuzz and thus restrict it to be adjacent to only valid supertiles, but not diagonally adjacent (i.e. we do not permit diagonal fuzz).
Below, let be a tile assembly system, let be a tile assembly system, and let be an -block representation function .
Definition 2.1**.**
We say that and have equivalent terminal shapes (under ) if .
Our main negative result on simulation (Theorem 1.1) shows that any claimed intrinsically universal noncooperative tileset does not satisfy Definition 2.1 when used to simulate certain noncooperative tile assembly systems. Intrinsically universal tilessets must satisfy Definition 2.1 (see Observation A.2) and moreover must satisfy a significantly stronger set of definitions than Definition 2.1; such stronger definitions are given in Appendix A.
2.3 Paths and non-cooperative self-assembly
This definition sections introduces quite a number of key definitions and concepts that will be used extensively throughout the paper.
Let and let be a set of tile types. As already defined in Section 2.1, a tile is a pair where is a position and is a tile type.
Intuitively, a path is a finite or one-way-infinite simple (non-self-intersecting) sequence of tiles placed on points of so that each tile in the sequence interacts with the previous one, or more precisely:
Definition 2.2** (Path).**
A path is a (finite or infinite) sequence of tiles , such that:
- •
for all and defined on it is the case that and interact, and
- •
for all such that it is the case that .
Whenever is finite, i.e. for some , is termed the length of . By definition, paths are simple (or self-avoiding), and this fact will be repeatedly used through the paper. A position of is an element of that appears in (and therefore appears exactly once), and an index of is simply an integer in . For a path , we define the notation , i.e. “the subpath of between indices and , inclusive”.
Although a path is not an assembly, we know that each adjacent pair of tiles in the path sequence interact implying that the set of path positions forms a connected set in and hence every path uniquely represents an assembly containing exactly the tiles of the path, more formally: For a path we define the set of tiles which we observe is an assembly555I.e. is a partial function from to tile types that is defined on a connected set. and we call a path assembly. A path is said to be producible by some tile assembly system if the assembly is producible, and we call such a a producible path. We define
[TABLE]
to be the set of producible paths of .666Intuitively, although producible paths are not assemblies, any producible path has the nice property that it encodes an unambiguous description of how to grow from the seed , in () path order, to produce the assembly .
For any path and integer , we write , or , for the position of and for the tile type of . Hence if then and .
If two paths, or two assemblies, or a path and an assembly, share a common position we say they intersect at that position. Furthermore, we say that two paths, or two assemblies, or a path and an assembly, agree on a position if they both place the same tile type at that position and conflict if they place a different tile type at that position.
Note that, since the domain of a producible assembly is a connected set in , and since in an assembly sequence of some TAS each tile binding event adds a single node to the binding graph of to give a new binding graph , and adds at least one weight-1 edge joining to the subgraph , then for any tile in a producible assembly , there is a edge-path (sequence of edges) in the binding graph of from to . From there, the following important fact about temperature 1 tile assembly is straightforward to see.
Observation 2.3**.**
Let be a tile assembly system and let . For any tile there is a producible path that for some contains .
For , we define to be the vector from to , and for two tiles and we define to mean the vector from to . The translation of a path by a vector , written , is the path where and for all indices of , and . As a convenient notation, for a path composed of subpaths and , when we write we mean (i.e. the translation of all of by ). The translation of a path by a vector , written , is the path where and for all indices of ,
The translation of an assembly by a vector , written , is the assembly defined on the set as where . A column is the set of all points of with x-coordinate , and a row is the set of all points of with y-coordinate .
Next, for a path and two indices on , we will define a (not necessarily producible) sequence called the pumping of between and .
Definition 2.4** (pumping of between and ).**
Let be a tile assembly system and . We say that the “pumping of between and ” is the sequence of elements from defined by:
[TABLE]
Hence, intuitively, has two parts. It begins with a finite sequence . Then appended to that, there is an infinite sequence where the tile types appear with positions at regular intervals in the plane. We formalize the latter intuition in the following Lemma:
Lemma 2.5**.**
Let be a path with tiles from some tileset , be two integers, and be the pumping of between and . Then for all integer , .
Proof.
By the definition of :
[TABLE]
∎
The following definition gives the notions of pumpable and finitely pumpable that are used in our proofs. It is followed by a less formal but more intuitive description.
Definition 2.6** (Pumpable).**
Let be a tile assembly system. We say that a producible path , is infinitely pumpable, or simply pumpable, if there are two integers such that the pumping of between and is a producible (infinite) path, i.e. .
In other, more intuitive, words, a producible path is infinitely pumpable, or simply pumpable, if there is a producible infinite assembly and two indices on , such that contains exactly , then , and then infinitely many occurrences of the “pumpable segment” each translated by successive positive integer multiples of , where these occurrences do not intersect , or themselves, each tile along this path assembly is bound to the previous, and contains no other tiles.777We remark that this definition of “infinitely pumpable” intentionally excludes pumping that intersects with and agrees with the seed, or some translated (pumped) segment.
For all such that both and are defined (i.e. for all if is infinite, and for all otherwise), we define the “output side of ” to be the side of adjacent to , and for all , we define the “input side of ” to be the side of adjacent to . The sides of that are neither output sides nor input sides of are said to be free, as are the glues of those sides.888By this definition of input and output sides the first tile of a path does not have an input side, and the last one does not have an output side. We also remark that this definition of input/output sides is defined relative to a specific path, and is not a property of the tiles themselves; moreover, the tiles, including the first and last tiles, may have other glue types, i.e. free glue types, not used by the path. Despite the fact free sides may have strength 1 glue types we typically ignore this in our analysis of paths—this is because our proofs typically analyse paths one at a time and thus require us to consider only the non-free tiles sides that actually bind the tiles along the path assembly and thus don’t require us to make statements about free sides.
Let . For , we say that a right turn (respectively left turn) from at index is a path with prefix for some adjacent to such that orientated in the direction , is clockwise (respectively anti-clockwise) from . More formally, let (the unit column vector from to ), let \rho=\bigl{(}\begin{smallmatrix}0&1\\ -1&0\end{smallmatrix}\bigr{)}, and let , then we say that is a right turn from if appears after in .
We define [i.e. is a pair of the form (glue type, path index)] where is the shared glue type between consecutive tiles and on the path . When we say “glue” in the context of a path, we mean a pair of the form (glue type, path index). We define to denote the glue type of , we write (the “position of glue ”) to denote the edge (of the grid graph of ) of , oriented from to . Moreover, for we define to be the midpoint of the line segment , and for a pair of tiles we define to be the midpoint of the line segment .
Definition 2.7** (The right priority path of a set of paths).**
Let and , where , be two paths with and . Let be the smallest index such that and . We say that is the right priority path of and if either (a) is a right turn from or (b) and the type of is smaller than the type of in the canonical ordering of tile types.
For sets of paths, we extend this definition as follows: let be two adjacent positions. If is a set of paths such that for all , and , we call the right-priority path of the path that is right-priority path of all other paths in .
The left priority path of a set of paths is defined symmetrically: swap left for right in Definition 2.7.
2.3.1 Curves: embedding paths in
A curve, or a curve in , is defined to be a continuous function . We say that is continuous at some if , where for all , , and we say that is continuous if and only if is continuous at all .
Intuitively, we will define the concatenation of a finite sequence of curves to be a function that for each represents by rescaling the domain of to be in the interval . Thus is defined on and has range . This is defined as follows:
Definition 2.8** (Concatenation of curves in ).**
Given a finite sequence of curves in their concatenation is the function defined for all such that and all as .
For example, Figure 2.1(c) shows the concatenation of two curves: the curve in Figure 2.1(b) and a unit-length vertical line segment.
The following observation states that the concatenation of continuous functions , that have the property for , is itself a continuous function and although the proof is straightforward, it is worth explicitly stating since it is used extensively in this paper:
Observation 2.9**.**
Let be a finite sequence of curves in that have the property that for all , and let be the concatenation of . Then is a curve in .
Proof.
First note that for each , is a continuous function and that rescaling (shrinking) the domain of from to preserves continuity. Secondly, since for each , and contains , the function is continuous on the (“double-length”) interval . Since this holds for all such , is continuous on its entire domain , and thus is a curve in .∎
Observation 2.10**.**
Let be a finite sequence of finite-length simple curves in such that for all , , also , and those nonempty intersections between are the only nonempty intersections between them. Let be the concatenation of . Then is a finite-length closed simple curve in .
Proof.
The hypotheses of Observation 2.9 are satisfied hence is a curve. is composed of a finite set of finite length component curves so is of finite length. is closed because for , , and , and is simple because those are the only nonempty intersections between . ∎
Also, we will sometimes need other curves that are not defined by paths:
Definition 2.11** (Line segment).**
Let . The line segment from to , which we write , is the curve defined for all by .
Definition 2.12**.**
For any path we define to be the canonical embedding of where , such that for all such that
[TABLE]
and
[TABLE]
Note that by Definition 2.12, the canonical embedding of a path is a curve, i.e. the canonical embedding is a continuous function from to . Figure 2.1(a) shows an example path and Figure 2.1(b) shows its canonical embedding .
This paper frequently uses the Jordan curve theorem, which is a statement about curves in : any simple closed (and hence finite) curve in partitions into exactly two connected components, a bounced one and an unbounded one.
In our proofs, we will often reason about right turns and left turns from a curve, and also about on which side of a closed simple curve is the bounded connected component. Since all of the closed simple curves we will define will be simple finite polygons (with a finite number of finite-length sides), their left-hand side and right-hand side can be defined by taking any point on a segment of the polygonal curve , not at a corner, and reasoning as follows. Since is locally a straight line around , is differentiable at . Also has a direction (from domain element 0 to domain element 1). The left-hand side of is therefore the connected component to the left of when positioned at orientated in the direction from [math] to along , and the right-hand side of is the connected component to the right of . By defining curves within a very small distance of , we can show that the left-hand side of is connected, and the right-hand side of is also connected. For example, Figure 2.1(c) shows such a polygonal closed simple curve , with its left-hand side highlighted in grey.
3 A family of tile assembly systems
Definition 3.1 defines a (very simple) infinite family of noncooperative tile assembly systems . The proof of our main theorem shows that there is no tile set that for all simulates .
Definition 3.1**.**
For each , let be the tile assembly system that assembles the infinite assembly shown in Figure 3.1.
4 Intuition behind the proofs of Theorems 1.1 and 1.2
We begin with a description of the high-level intuition behind the proof of our main result, Theorem 1.1. One of the main difficulties of this result is that for any finite number of non-cooperative tile assembly systems, there is in fact a single non-cooperative simulator for all of them: simply let the tiles of the simulator be the disjoint union of all tilesets of the simulated systems. Moreover, it is known [20] that in 3D, there is a tileset, operating at temperature 1 (i.e. noncooperative), that simulates all non-cooperative tile assembly systems. Hence our proof is going to crucially make use of the fact that any claimed simulator tileset is of finite size, and must work in the plane.
First, we assume, for the sake of contradiction, that there is a single tileset , that simulates all noncooperative (or temperature 1) tile assembly systems. Hence, in particular, the tileset simulates the class of systems described in Section 3 and shown in Figure 3.1. Hence, for all , there is a tile assembly system and scale factor such that simulates .999Later in the paper we drop the subscripts from and simply say that simulates . In particular, by the definition of simulation (Section 2.2), and in particular by Definition 2.1, this implies that for each terminal producible assembly of there is a producible assembly that represents the shape of , and vice-versa. Figure 4.1 shows what such a simulation should look like.
The proof is then broken into two stages. First, in Section 5, we consider any path that can grow in the claimed simulator long enough so it places at least one tile on a horizontal line at some height . An example such path is shown in Figure 4.1. For any such path, we let denote its shortest prefix that contains exactly one tile at height and where that tile is ’s last tile. Any assemblable path of this form is called “-successful” (see Definition 5.7). We show that any -successful path can be modified in two different ways: (1) is modified so that it grows at an invalid position, either by (1.1) infinite pumping, by which we mean can be modified to give another path which grows to form an assembly that is infinitely long horizontally to the right, and hence is not a simulation of the “flipped-L” shaped , or modifying it so that (1.2) the vertical arm grows displaced to the left or to the right (and hence is grown in the wrong position) or (1.3) grows something in the wrong position by finite pumping (repeating a path segment that gets blocked). (2) is blocked, by which we mean another assembly (a path ) can be grown that blocks (forcing to be of finite length) and thus the simulator can not rely on the growth of path to obtain a valid simulation. (1) and (2) together show that no single path can carry out a valid simulation, which is stated formally in Theorem 5.11. This can be regarded as our first technical tool for handling long paths.
However this leaves open the possibility that many paths could simultaneously and nondeterministically grow and interact in a way that carries out a valid simulation. In particular, in (2) above, if we first block a path using another path , and then attempt to block another path using a path , then may itself get blocked by , hence could possibly “escape” to become -successful and carry out the simulation. In the second part of the proof, in Section 6, we consider the ways that -successful paths , and the paths we use to block them, can interact. Based on this, we provide an explicit growth order for paths, such that if we apply (2) to each such path in turn, we guarantee that the claimed simulator fails. This can be regarded as our second technical tool: a method to control the interactions of multiple long paths.
The proof of our second main result Theorem 1.2 is very short and uses the following intuition. We note that, for the sake of contradiction, if for each time-bounded Turing machine there is a noncooperative tile set that simulates using arbitrarily large 2D space, bounded by a rectangle, then could be easily modified to build a family of assemblies that are of the same (scaled) shape as systems , thus contradicting our result that there is no such tile set. Hence we give a reduction from a Turing machine prediction problem to the problem of simulating the class of all systems, a new technique for proving negative results about computation in tile assembly.
5 Pumping or blocking any sufficiently wide and tall path
Suppose, for the sake of contradiction, that there is a tile set , such that for , there is a scale factor and a seed for which simulates at scale factor . Then it is the case that there is a path such that the simulator produces the assembly and grows up to meet a line at height above the horizontal arm of the assembly (see Figure 4.1). In this section, we prove that we can use the existence of such a “-successful” path to force the simulator to produce another assembly that either (I) illegally places tiles outside of the simulation zone or else (II) is finite and blocks from growing (i.e. is not producible from the assembly ). Case (I) contradicts that simulates and we are done with the proof in that case. Case (II) gives a way to block the arbitrary single path , but may not prevent other paths from growing and this is handled later in Section 6.
Since showing impossibility of simulating a single tile assembly system is sufficient to prove our result, we will set in the rest of the paper, and call the seed and the scale factor at which our claimed simulator simulates .
5.1 Glue visibility: definitions and basic results about and
We begin this section with a definition that will be used in every proof in the rest of the paper, and is illustrated in Figure 5.1. This notion of visibility is from the south.
Definition 5.1** (Visible glue (from the south)).**
Let be a path and let . Let where is the interacting glue type between and , and 101010Note that since paths are defined to be simple, for any , there is at most one index on such that is the position of .. We say that is visible relative to if (a) there is a vertical ray in that starts from and goes infinitely to the south and (b) for all , does not contain .
We write for the set of (glue type, path index) pairs of that are visible relative to some path . We define (respectively, ) to be the set of those (glue type, path index) pairs of that are on east (respectively, west) of output sides of tiles of . Since, on a path , each tile has exactly one output side, it follows that is a partition of .
For a path and a vertical line at some position such that , we write “’s visible glue on ” to mean the unique glue such that is on and for all , such that , it is not the case that has a smaller -coordinate on than . Moreover “the position of the visible glue of on ” is the point . For a glue that is visible relative to we write “the position of ” to mean the point . For a glue that is visible relative to we write “the visibility ray of ” to mean the infinite ray starting at the point and going vertically to the south.
It is important to note that “visible glue” is defined relative to a particular path. Hence, we often say that a glue of is “visible relative to ”, although when is clear from the context, we may simply say that a glue is “visible”. Figure 5.1 gives examples of glues on a path that are and are not visible. Intuitively, note that although a visibility ray starts at the “position” of a visible glue on the path , the ray is permitted to “touch” other free glues (Section 2.3) on tiles of (recall free glues are by definition not on the path since they are not input/output glues along the path, hence they are not visible nor can they prevent some other glue from being visible). See Figure 5.1 for examples.
In the following lemma we show that for a path that has both glues and glues, the glues are positioned to the right of its glues. The intuition behind the proof is as follows: suppose otherwise, then draw a finite length curve in that runs from a glue along the positions of to a glue, then includes segments of the visibility rays (to the south) of these two glues and finally includes a horizontal line that lies far below and runs between those two visibility rays. It turns out that is simple and closed and thus cuts the plane into an unbounded component and a bounded component . It turns out that must both go inside for a time and then leave , but since was defined using curves that never crosses we get a contradiction. This rough intuition is more rigorously formalised in the proof.
Lemma 5.2** ( glues are to the right of glues).**
Let be an assemblable path of any tile assembly system , and let and be two indices such that , . If has at least one tile where and is strictly to the right of, or strictly above, all tiles of , then . In other words, the glues of are all to the right of the glues of .
Proof.
We have argued above that is a partition of . Hence since , it is the case that which in turns implies . Assume, for the sake of contradiction, that there are two integers and that satisfy the lemma hypotheses (in particular that , ) but where .
Since , there is a vertical ray that starts from the point , goes infinitely to the south, and does not contain any point of the canonical embedding of in besides . Likewise, let be the vertical ray to the south starting from the point , and observe that since , then does not contain any point of besides . We will use and to define the three line segments , and . First let be a y-coordinate below all of , for instance
[TABLE]
We then define:
[TABLE]
where and we note that since is directly to the south of . Let be the “reverse direction” of the line segment , more precisely:
[TABLE]
Also, define the line segment
[TABLE]
And the line segment
[TABLE]
There are two (almost identical) cases, (a) and (b).
Claim (a): .
We let be the concatenation (see Definition 2.8) of the following six curves:
[TABLE]
By Observation 2.10, is a finite closed simple curve111111To see this one needs to check that the components of satisfy the hypotheses of Observation 2.10. Less formally but more intuitively, it can be seen that is of finite length because its components are, also is closed as each of the components are curves and their endpoints are pairwise equal in such a way to satisfy closure, and finally is simple since the components are simple and their only intersection is at their endpoints in the order they are given. and thus defines a bounded connected component . (See Figure 5.2 for an example.)
We claim that is inside . First, note that is to the left of (because ), and therefore, is to the left of . But since by assumption, ) by visibility, and is unit distance to the left of , then is in fact between and (i.e. to the right of and to the left of ). Secondly, is above the horizontal line . Consider the ray at x-coordinate that comes from the south and stops at position . Observe that crosses at the segment exactly once, and crosses nowhere else, and that due to the visibility of we get that does not intersect , and that by its definition is positioned away from the other four components of . Furthermore, since does not cross the short line segment then starting at the point , one can walk (westwards) along the segment to the point , without crossing . Hence is inside as claimed.
Since, from the lemma statement, has at least one tile after (i.e. ) positioned to the right of, or above, all tiles of , then has tiles positioned outside of after . But since is a path, it does not cross itself. Therefore, must leave , thus crossing by crossing at least one of or and contradicting that both and are visible. Thus .
Case (b): .
We define the curve as the concatenation (see Definition 2.8) of the following six curves:
[TABLE]
By Observation 2.10, is a finite closed simple curve@footnotemark, and thus defines a bounded connected component . (See an example in Figure 5.3.)
By a similar121212Specifically, consider the vertical ray with x-coordinate that comes from the south and stops at position . Observe that crosses exactly once at the segment , that due to the visibility of we get that does not intersect , and that by its definition is positioned away from the other four components of . Furthermore, since does not cross the short line segment then starting at the point one can walk (eastwards) along the segment to the point , without crossing . Thus is inside . See Figure 5.3 for an example of the argument. argument as Case (a) (where ), is inside . Since has at least one tile after (i.e. ) to the right of or above , then has tiles positioned outside . But since is a path, it does not cross itself, nor does it place a tile below . Therefore, must leave , thus crossing by crossing at least one of or and contradicting that both contradicting that both and are visible. Thus .
∎
Lemma 5.2 was our first statement proven using visibility, and the following lemma (5.3) similarly exploits the technique of using rays given by visibility, an embedded path, and other line segments to enclose a connected component of the plane, enabling us to reason about how visible glues are organised along a path. Together Lemmas 5.2 and 5.3 and Corollary 5.4 give properties of how tiles of and are arranged in the plane. This is formalized in greater detail in Lemma 5.8.
Lemma 5.3** ( glue order preserves path order).**
Let be a path producible by any tile assembly system , and let be such that , and . If has at least one tile after and (i.e. ), where is to the right of, or above, all tiles of , then .
Proof.
Define as in Equation (1), as in Equation (2), as in Equation (3) and as in Equation (4).
First assume, for the sake of contradiction, that . We let be the concatenation (see Definition 2.8) of the following six curves:
[TABLE]
By Observation 2.10, is a simple closed curve, hence partitions into two connected components, exactly one of which is bounded. Let be that bounded connected component. By a similar argument131313Here, comes from the south with x-coordinate , crosses (thus entering ), ends at y-coordinate , and then we walk from that end point to staying inside . using ray as in the proof of Lemma 5.2, starts inside . However, since has at least one tile to the right of, or above , then cannot be entirely inside . Therefore, needs to cross the border of , contradicting either the fact that is simple, that paths do not place tiles below their lowest tile, or that or are visible. ∎
By flipping the use of “+” and “-”, and “left” and “right”, in the statement of the previous lemma, we immediately get the following corollary:
Corollary 5.4** ( glue order preserves path order).**
Let be a path producible by any tile assembly system , and let be such that , and . If has at least one tile after and (i.e. , ), where is to the right of, or above all tiles of , then .
In the proof of Lemma 5.10, we will attempt to pump a path segment. We will make use of the following lemma stating that the glues on the prefix remain visible even if that prefix is pumped. In other words visibility survives pumping.
Lemma 5.5** (Visibility survives pumping for ).**
Let be a path producible by any tile assembly system , and , be two integers such that , , , and . Let be the pumping of between and (as defined in Definition 2.4), and let be the maximal prefix of that is an assemblable path.
Then . Intuitively, this means that all “+” glues visible relative to are also visible relative to (note that contains as a prefix).
Proof.
Setup. Let be the visibility ray of and be the visibility ray of . Now let be a leftmost tile of , and let be the horizontal ray to the west starting from . Moreover, let be a lowest tile of (i.e. with -coordinate ).
We now define two helper points of , far enough from :
[TABLE]
where , .
Intuitively, has the same y-coordinate as, and is 10 units to the left of , and has the same x-coordinate as the glue between and , and is 10 units below the lowest point of .141414The choice of 10 units is arbitrary here, we simply need to define a curve with segments that are strictly to the left of and below .
Define (the quarter-plane below and to the left of ) and (the quarter-plane below and to the left of ). Also, let be the half-unit horizontal segment of from to .
Moreover, let be the curve that is the concatenation of , , , , , . By Observation 2.10, is a simple closed curve, hence defines a bounded connected component of .
Now, let , which is also a single connected component of , because is in all components of the union () and each component is connected.
Proof argument. We claim that for all , since which can be seen as follows: (i) is contained in since is to the left of (by the contrapositive of Lemma 5.3) and reaches infinitely far to the south as does ; and (ii) by the definition of visibility the segment is contained in .
Now suppose, for the sake of contradiction, that , the canonical embedding of the path in , intersects . Then needs to enter , because is outside (by the contrapositive of Lemma 5.3). This crossing can happen at only four different parts of the border of :
- •
, but this is impossible since is a leftmost point of and (as a vector) has a strictly positive x-coordinate (by the contrapositive of Lemma 5.3).
- •
or , but this would contradict the fact that is simple.
- •
. We claim that this is impossible: assume, for the sake of contradiction, that it is not, and let be the smallest integer such that intersects . Moreover, because does not intersect its own visibility rays (except at their endpoints). Therefore, would also intersect , hence also enters , contradicting the assumption that is the smallest integer such that intersects (since in the previous bullet points we have shown that cannot cross other parts of the border of ).
Therefore, does not enter , which is a contradiction, which in turn contradicts our assumption that intersects . Hence the canonical embedding of does not cross any of the visibility rays defining , thus . ∎
By flipping the use of “” and “” in the statement of the previous lemma, and “left” and “right” in the proof, we get the following corollary:
Corollary 5.6** (Visibility survives pumping for ).**
Let be a path producible by any tile assembly system , and , be two integers such that , and , and . Let be the pumping of between and , and let be the maximal prefix of that is an assemblable path.
Then . Intuitively, this means that all “-” glues visible relative to are also visible relative to (note that contains as a prefix).
5.2 Blocking any -successful path
Keeping in mind that the seed assembly supertile of includes the origin , for the rest of the paper fix a horizontal line at height above the origin.
Definition 5.7** (The set of -successful paths of ).**
The set of -successful paths of is defined as:
[TABLE]
where is the set of producible paths of (defined in Section 2.3).
Note that any claimed successful simulation by of (defined in Section 3) must exhibit at least one path that has a -successful prefix . When we write “ is a -successful path” we mean . The set of -successful paths is finite because the tileset is finite and the area of the simulation zone below the horizontal line at height is finite.
We define a “nowhere--successful path” to be a path that has no tile at height . In other words, a nowhere--successful path has no -successful prefixes.
5.2.1 Visibility setup
We begin with the following lemma, which has a straightforward proof and is used merely to define , and , which are used extensively in later proofs. Recall that is a tile assembly system with tile set simulating at scale factor .
Lemma 5.8**.**
Let be a -successful path, and let be a vertical line in with x-coordinate . If the visible glue placed by on is a glue (respectively a glue), then there exist that satisfy all of the following properties:
* is to the right (respectively to the left) of (i.e. , respectively )* 2. 2.
* is horizontal distance at least from (i.e. )* 3. 3.
* is to the right (respectively to the left) of * 4. 4.
* and (respectively and )* 5. 5.
** 6. 6.
* and are within vertical distance (i.e. )*
Proof.
Firstly, the path is of width (horizontal extent) (as we are simulating at scale factor , see Figure 4.1). Secondly, since is -successful, crosses , and since is positioned at distance to the right151515Note that the seed supertile region contains the point . of the seed of , there are at least visible glues to the left of .
Moreover:
- •
If the visible glue placed by on is in , then since has at least one tile in the rightmost positions of the simulation zone, has at least visible glues to the right of . By Lemma 5.2 all of these glues are in .
- •
Else, since is at horizontal distance at least from the rightmost tile of , has at least visible glues to the left of By Lemma 5.2 all of these glues are in .
Thus, if we look at the first visible glues of that are immediately to the right (respectively to the left) of , by the pigeonhole principle, at least one of their glue types appears at least times. Since each x-coordinate has exactly one visible tile, we can find two (respectively ) glues, and for some , with the same type, that are at least horizontal distance away from each other, which shows Conclusions 1, 2, 4 and 5 of this lemma. Taking the contrapositive of Lemma 5.3 (in that lemma letting be the tile of at height ), we get that (respectively, of Corollary 5.4, that ), which shows Conclusion 3.
Finally, since the region we chose to apply the pigeonhole argument is located immediately to the right of (respectively, left) and is of width merely neither nor are in the “vertical part” of the simulation zone (Figure 4.1), and since the “horizontal part” of the simulation zone is of height , this proves Conclusion 6. ∎
5.2.2 Blocking any -successful path by growing a branch from it
In this section we give Lemma 5.10 which is the first main tool used in this paper. We also give Theorem 5.11 whose short proof gives a method to block any -successful path. We begin with the definition of an enclosing branch, which is a path branching from , and enclosing a connected component of . The enclosing branch achieves this in one of two ways: (1) either by intersecting (see Figure 5.4(Left)) and hence the enclosure is bordered by , the enclosing branch and possibly , or (2) by placing a new visible glue on (see Figure 5.4(Right)) and hence the enclosure is bordered by , the enclosing branch, a segment of and possibly .
Definition 5.9**.**
[Enclosing branch for a path] Let be a -successful path and for any that satisfies the hypotheses of Lemma 5.8: Let be such that includes , ’s visible glue on . We call a path an enclosing branch for at if is an assemblable path, , and is visible relative to , and at least one of the following is the case:
at the path intersects ,161616and therefore cannot grow completely from without intersecting or 2. 2.
is on and strictly below the points in the set .171717And therefore cannot grow completely from without placing a glue on that is lower than ’s visible glue on .
Before stating Lemma 5.10, we give an intuitive, although imprecise, summary of its statement, of how we obtain such a statement and why we would want such a statement. Let be any -successful path, which implies that is long enough to repeat some glue type many times. This implies one of two things (which are the two conclusions of the lemma):
There is a path, assemblable by , that places tiles outside of the simulation zone. If the proof yields this conclusion, then such a path is found either by repeating one part of enough times (this is point P1 in the proof), or else by deriving a -successful path from , and “shortcutting” a part of , so as to translate a suffix of by a large enough vector. In both cases, this contradicts that simulates , which gives the proof of our main theorem. 2. 2.
Else, we can grow a path of the form , for some , which has the following properties:
- •
, which is visible relative to , is also visible relative to , and
- •
any -successful path that turns to the right from must hide the visibility of .
First we observe that must be blocked by such a (i.e. cannot grow from an assembly that already contains ), because we can show that turns to the right from 181818From the definition of enclosing branch places a tile at therefore either branches to the right (see proof of Theorem 5.11) from , or if it happens that then is blocked by ., but this causes a contradiction as can not hide its own visible glue. This is one useful fact from Conclusion 2.
The second useful fact (and the main reason for the particular form of Conclusion 2), is that we have found a way to consume a finite resource: visible glues (note that the entire set of -successful paths is finite and each such path has a finite set of visible glues). Then, later in the proof of Theorem 1.1, we will use this “consumption of visible glues” property to show that the “supply of visible tiles” must decrease with each new “branch” to the right starting from ; and the particular form of Conclusion 2 allows us to do this.
The previous intuitive overview of the lemma statement is somewhat incomplete, but may serve as a guide. All the steps of the proof are given in Figure 5.5, with a running pictorial example, and short summaries of each step.
Lemma 5.10** (Pumping or enclosing any -successful path).**
Let be a -successful path, let be as in Lemma 5.8 with ’s visible glue on being in (respectively, ). At least one of the following holds:
There is an assemblable path (i.e. from ) that places tiles outside of the simulation zone of , contradicting that simulates . 2. 2.
(i) There is an enclosing branch for at some , such that is an assemblable nowhere--successful path that has the same visible glue on as .
(ii) Furthermore, for all paths such that for some , is -successful and turns right (respectively, left) from , at least one of the following is the case:
- •
* is not visible relative to , or*
- •
* has a lower visible glue on than .*
Proof.
A tree representing the proof is shown in Figure 5.5. The proof performs a depth-first, left-first, search of the tree. Points in the tree and proof are numbered P1, P3, , P9 correspondingly.
Intuitively, let be the sequence composed of followed by the “infinite pumping” of the segment . Formally, let be the pumping of between and (Definition 2.4), and let be the longest prefix of that (a) is a path (i.e. non-self intersecting), (b) does not intersect , and (c) is assemblable from the seed of . is either infinite or finite.
- P1
If is infinite (as in the example in Figure 5.7): Then since has a nonzero horizontal component (by Lemma 5.8 the horizontal distance between and is ), this infinite assembly reaches infinitely to the right for glue in the lemma statement being in (respectively, to the left for being in ), and thus places tiles outside of the simulation zone, giving Conclusion 1.
- P2
If some prefix of is -successful we claim that we get Conclusion 1 of the lemma statement. To see this, note that is nowhere--successful. Therefore, if were -successful, would place a tile (where is the length of ) on the horizontal line , which means that would also have a tile at position (i.e. positioned one iteration of the “pumping” earlier, see Figure 5.8). But is outside of the simulation zone: is in the simulation zone on line , the “vertical part” of the simulation zone (that intersects line and for distance below ) is of width , has horizontal length and vertical length (Lemma 5.8). This immediately gives Conclusion 1.
- P3
Else is finite, and nowhere--successful. We assert the claim that intersects , which we will next prove.191919Note that we already know that intersects or . Intuitively, if intersects itself, then since is periodic and , we can find another self-intersection indices earlier along . Applying this argument repeatedly will show an intersection with .
If intersects , we are immediately done. Else, intersects itself. Let be the smallest integer such that . We will show that . Assume, for the sake of contradiction that .
Note that . Therefore, we can apply Lemma 2.5 to show that and . But then since , and since ,202020intuitively, we are in the nd iteration of pumping we get that . Therefore, intersects itself which is a contradiction. Hence and thus intersects as claimed.
An example of this case is shown in Figure 5.9.
- P4
Let be the set of all -successful paths of the form , for any such that and any path , such that all of the following hold:
- (i)
turns right (respectively, left) from , 2. (ii)
is visible relative to , 3. (iii)
has the same visible glue as on .
If is empty212121which includes in particular the case where no -successful path can branch from , then we claim that we get Conclusion 2 of the lemma statement, with and . Indeed, is an enclosing branch for at with the same visible glue on as . Moreover, by Lemma 5.5 (respectively, Corollary 5.6), does not hide the visibility of or , hence satisfies Conclusion 2(i). Then, Conclusion 2(ii) is immediately satisfied since is empty (intuitively, is the set of paths that do not meet that conclusion). 5. P5
Else, is not empty. Until the end of this proof, let and be such that is the most right-priority (respectively, left-priority) of . Note that since all paths of are -successful, the last tile of is the only tile of at height . Such a path is shown in Figure 5.10. Notice that, because is the most right-priority path of , does not turn left from (before turning right from ), or else we could find a -successful path turning right earlier than .
We grow , and then the maximal assemblable prefix of the following “translated path”: . In other words, starting from , we grow the following path: (Figure 5.11 below highlights this “backwards translation”). 6. P6
If all of is assemblable from , as in the example in Figure 5.11, then we claim that is outside the simulation zone, yielding Conclusion 1. To see this first note that since is -successful the tile (i.e. untranslated) is on the horizontal line and thus in the “vertical part” of the simulation zone (see Figure 4.1) which is of width . But, by Lemma 5.8, has horizontal length and vertical length . This means that is outside of the simulation zone, giving Conclusion 1.
- P7
Else not all of is assemblable from . Let be the longest prefix of such that does not intersect and does not have any visible glue on below the visible glue of on . (See Figure 5.12 for an example where the longest assemblable prefix of does not place any new visible glue on , and Figure 5.13 for an example where it does.)
In this case, we make the more specific claim that conflicts with : indeed, by its definition in P5 above, does not conflict with , and hence does not conflict with , hence does not conflict with . The only part of the assembly that can conflict with is therefore .
Observe that is an enclosing branch for at (Definition 5.9222222Note that both of the cases (1) and (2) of Definition 5.9 can happen here.).
- P8
We now consider the set of -successful paths of the form for some prefix of and some path , such that all of the following hold:
- •
turns right (respectively, left) from ,
- •
is visible relative to , and
- •
the visible glue of on is visible relative to .
There are two cases:
- (a)
If is empty this gives Conclusion 2 with and . In particular, as noted in case P7, is an enclosing branch for at , which satisfies Conclusion 2(i).
Moreover, the fact that is empty immediately shows Conclusion 2(ii) (intuitively, is the set of paths that do not meet that conclusion). 2. (b)
Else, there is at least one path in . See Figure 5.14 for two examples.
- P9
The only unresolved case after step P8 is therefore case P8b, which we now reason about with the goal of obtaining Conclusion 2.
We next grow the longest assemblable prefix of the “forward translated” segment and use this to show that in all remaining cases we get Conclusion 2. See Figure 5.15 for an example.
For notation, let and . Suppose that the visible glue of on is in (respectively, in ).
From P8b, does not hide the visibility of . Therefore, does not place a glue directly below either. Notice that is assemblable (as it is a prefix of ), and let be the largest integer such that is assemblable and has the same visible glue as on .
If , then the last point of is outside of the simulation zone, because the last tile of (i.e. untranslated) is at height . This yields Conclusion 1.
Else, . Moreover, we picked in case P8b so that turns right (respectively, left) at least once from , therefore also turns right (respectively, left) at least once from .
Let , and let be any path such that is -successful and turns right (respectively, left) from , for some . Note that cannot be in , because then would more right-priority (respectively, left-priority) than , (contradicting our choice of in P5) since: either turns right (respectively, left) from earlier than , or turns right (respectively, left) from , or turn right (respectively, left) from (which turns right (respectively, left) from ).
Therefore,232323I.e. we have a path of the form (see P4), and that turns right from (satisfies P4P4(i)), yet is not in hence violates Conditions P4P4(ii) and P4P4(iii). must either have its visible glue on lower than that of , or hide the visibility of . This is precisely Conclusion 2 with . Notice that is in fact an enclosing branch for at because: neither nor hide the visibility of , and by Lemma 5.5 (respectively Corollary 5.6), neither does , and finally that is composed of subpaths from these paths.
∎
The following theorem (5.11) essentially states that for any path , we can grow an assembly containing no -successful path, conflicting with . The proof is almost a direct consequence of Lemma 5.10. Note that we can think of Theorem 5.11 as a weaker version of our main result (Theorem 1.1). That main result (Theorem 1.1) builds a single assembly containing no -successful path and that conflicts with all possible -successful paths.
Theorem 5.11**.**
Let be a -successful path. Then either there is a producible assembly with tiles outside of the simulation zone, or else there is an assemblable nowhere--successful path of the form that conflicts with , and thus prevents from growing to be -successful. Moreover, is constructed as in Lemma 5.10.
Proof.
We apply Lemma 5.10. If we get Conclusion 1, we are immediately done (we get in the statement). Else, let be as defined in Lemma 5.8, let and let be the enclosing branch constructed in Conclusion 2 of Lemma 5.10, assuming places a (respectively, ) glue on . We begin by defining a connected component . There are two cases:
- •
If intersects let be any path from (the first such intersection) to in the grid graph of . Let be the bounded connected component of enclosed by the concatenation of and (the canonical embedding of the paths and , respectively).
- •
Else, places a glue, denoted , on below the visible glue of on , and does not intersect . In this case, we let be the concatenation of the following four curves (where is the visible glue of on ):
[TABLE]
By Observation 2.10, is a finite closed simple curve and thus defines a bounded connected component .
In both cases, by the fact that is an enclosing branch, is visible relative to , which implies that the left-hand side (respectively, right-hand side) of is inside (when walking in the direction from to ).
Also, in both cases, is not -successful (by Lemma 5.10). Therefore, if can still grow to be -successful after is grown, then turns right (respectively, left) from , and thus from the statement of Lemma 5.10 is a suffix of . But this implies that places a lower visible glue than (on ) and/or (on the visibility ray ), which contradicts the visibility of and/or relative to .
Therefore, conflicts with and thus cannot grow to be -successful from the assembly . ∎
6 Blocking all paths
We restate our main theorem here:
Theorem 1.1.
The noncooperative abstract tile assembly model is not intrinsically universal. In other words, there is no tileset that at temperature 1 simulates all noncooperative tile assembly systems.
This result is an immediate corollary of Theorem 6.1 below. Intuitively, Theorem 6.1 states that there is no tile set that, at temperature 1, produces (or simulates) the “shapes” of all systems,242424The class of “flipped-L” tile assembly systems were defined earlier in Section 3. even if the simulator is allowed to use spatial rescaling. Thus Definition 2.1 is violated which immediately implies (via Observation A.2) that there is no tile set that, at temperature 1, simulates the productions of all systems (thus contradicting Definition A.1, “equivalent productions”), which in turn contradicts Definition A.6 (“intrinsicially universal”, at temperature 1), giving Theorem 1.1.
Theorem 6.1**.**
There is no tileset , scale factor , seed and -block supertile representation function such that for all , and where and .
Proof.
Assume, for the sake of contradiction, that there is a tileset such that for , there is an integer , a seed assembly , and an -block representation function such that the terminal assemblies of map cleanly to the terminal assemblies of under , where is the flipped-L tile assembly system defined in Definition 3.1.
We will show that also produces terminal assemblies mapping to non-terminal or non-producible assemblies of under . More specifically, we will show that either some of the assemblies of map cleanly to non-producible assemblies of under , or else we will construct one producible assembly conflicting with all -successful paths of . This will then conclude the proof since grows into a terminal assembly, i.e. where , that does not map cleanly to a terminal assembly of under (since all tiles of are below the horizontal line at height ).
Blocking -successful paths individually
For the remainder of the proof, let be a vertical (glue) line at x-coordinate (in other words, at distance to the right of the rightmost tile of ), as defined by Lemma 5.8. We apply Lemma 5.10 on each -successful path , individually252525By “individually” we mean that we are currently merely looking at the case where we grow each path separately: of course it may be the case that not all of these paths can be simultaneously grown as they may conflict with each other—the main point of this proof is to handled this.. For each such , Lemma 5.10 has one of two conclusions, numbered Conclusion 1 and Conclusion 2. If we get Conclusion 1 for any of the -successful paths, we can conclude the proof immediately, because that conclusion shows that it is possible to grow a path from that places tiles outside of the simulation zone of , contradicting that simulates , and hence assemblies of do not simulate the shape of and we are done with the proof of Theorem 6.1.
Therefore, in the rest of this proof, we assume that for all -successful paths of we get Conclusion 2 of Lemma 5.10. That conclusion gives, for each -successful path , a nowhere--successful enclosing branch for at some integer .
If it were the case that the entire set of these enclosing branches could grow together in the same assembly, we would immediately be done: indeed, the union of the seed with all of these enclosing branches (and their prefixes from ) would be an assembly conflicting with all -successful paths of (implying in particular that this union does not contain any -successful path).
The rest of the proof deals with the situation where this is not the case, i.e. at least one (and possibly very many) enclosing branches from Lemma 5.10 conflict with other paths or with other enclosing branches, and thus not all enclosing branches can grow completely together in the same assembly.
Path order
We will build an assembly that does not reach height and that blocks all of the paths from the set of -successful paths of . Recall that the set of -successful paths of is finite. In order to block them all, we will tackle -successful paths in a specific order, called the “path order,” defined as follows. Let be the path order relation on the set of -successful paths of where for with we say that if and only if at least one of (A) or (B) holds:
- (A)
the visible glue of on is strictly higher than the visible glue of on , or 2. (B)
the visible glues and of and on are at the same position262626I.e. . and one of the following holds:
- •
and , or
- •
, , and is the right-priority path of and , or
- •
, , and is the left-priority path and , or
- •
Else, notice that and share their suffix from their visible glue on onwards until their last tile at height (because none of these suffixes is the right-priority or left-priority one). Then is the right priority path of and if and share two consecutive tiles before272727By “before” we mean with respect to the order of tiles along the path , and along the path . disagreeing (note that ), and if they do not share such a pair then is the lexicographically first path of and if we describe both using some canonical encoding of and as two binary strings.
Here is an intuitive description of the path order: we first consider paths by the height of their visible glue on (highest first), and then if both visible glues on are in the same direction, we first consider the most right-priority of and after they cross if these glues are in and , or the most left-priority if these glues are in and , and if the glues are at the same position with different +/- orientations, the one with a “+” visible glue on comes first. Finally if and happen to agree (are equal) on their suffix from their visible glue on onwards, then we (arbitrarily) choose the right priority path (note that in this latter case all of the differences between and must be before their respective visible glues on ).
Note that the relation is a total order on the set of -successful paths, since the last case of the definition of covers all remaining cases using right-priority, and right-priority is itself a total order. Also, recall that the set of -successful paths is a finite number (see Section 5.2), and let be that number.
Thus let be the list of all -successful paths according to path order (so that no path has a higher visible glue on than ).
Enclosing branch .
For each path , applying Lemma 5.10 gives an index and an “enclosing branch for at ” such that conflicts with (by Theorem 5.11). Let
[TABLE]
The “path blocking” assembly .
Let the notation denote the path that is the longest assemblable prefix of that can be grown from the assembly .282828Observe that if is producible by some tile assembly system then for all paths it is (trivially) the case that is an assembly producible by that same tile assembly system.
We define an assembly which has a special form (composed of and assemblable prefixes of grown in path, i.e. , order), to be used in our induction hypothesis:
[TABLE]
where and for all , .
Claim: for all , .
To see this claim note that:
- •
First, is producible: indeed, is a producible path of , by Lemma 5.10. Therefore, is producible.
- •
Then, assuming is producible, i.e. , remember that is the maximal prefix of that can grow from . Therefore, , and therefore .
Hence as claimed.
To conclude the proof we will consider the assembly292929Recall that is the number of -successful paths of . which we claim has the (as yet unproven) property that all producible -successful paths conflict with it. Then allowing tiles to attach to will eventually yield303030Growth can only happen within the finite area simulation zone below height so must eventually stop. a terminal assembly with no tiles at height and thus no tiles above height , which contradicts that simulates (the shape of) . We will use induction to show that all producible -successful paths conflict with .
Induction hypothesis:
All of the paths conflict with .
Some intuition and implications of our induction hypothesis: The induction hypothesis implies that for is not -successful. To see this note that since for all the last tile of is its only tile at height , and the induction hypothesis implies that can not grow from to be -successful. Also, no tile of reaches height (because is constructed via Lemma 5.10) which implies that none of the (of which is composed) are -successful. Finally, since there are a finite number of -successful paths the induction exhausts those paths in steps, and thus yields an assembly which is a finite union of finite (path) assemblies, and thus is a finite producible assembly that blocks all -successful paths.
Initial step of induction ( and ).
At the initial step of the induction, we apply Lemma 5.10 to , to obtain an enclosing branch . This proves our induction hypothesis for the initial step: by Theorem 5.11, conflicts with (i.e. cannot grow to be -successful from ), and we have already defined where .
Inductive step ( and ).
The remainder of the proof is concerned with the inductive step. For any suppose the induction hypothesis holds,313131Recall that contains only the seed and assembled paths (i.e. ) that are respective prefixes of , none of which are -successful. i.e. all of first paths conflict with .
We recall that is the maximal prefix of that can grow from , and that . If conflicts with , then we are immediately done with the induction step for , because this proves that cannot grow from . Hence from now we will assume that does not conflict with .
If conflicts with , then we are immediately done with the induction step for , because this proves that cannot grow from . Otherwise does not conflict with . This implies that is a strict prefix of (otherwise we would contradict Theorem 5.11) and therefore (and in particular ) conflicts with for some . We will reason about this .
We next split the inductive step into three cases323232For the sake of proof simplicity, we present them in the order in which we handle these cases. each of which will be concluded independently:
- (Case 1)
and share the position of their visible glue on , one of these glues is a glue, the other one is a glue. 2. (Case 2)
and do not share the position of their visible glue on (which includes the case where does not reach ). 3. (Case 3)
and share the position of their visible glue on , and either both are glues, or both are glues.
In all three cases, let ’s visible glue on be denoted and let ’s visible glue on on be denoted .
Case 1: and share the position of their visible glue on , one of these glues is a glue, the other one is a glue.
Exactly one of and is in and the other is in . (See Figure 6.1 for an example.) At the beginning of the inductive step, we assumed that does not conflict with , hence and agree on all points where they intersect. Moreover, since and share their visible glue on (i.e. , i.e. their visible glues on are at the same position) we know they agree on at least two tiles each, specifically and . Now let be the largest integer such that there is an integer where . Since we know that , also since is -successful and is not. Consider the sequence . First note that the positions of form a connected sequence of positions in : this follows from the fact that the positions of are connected, the positions of are connected, and that . Also, we claim that is simple: to see this, note that (i) is simple, (ii) is simple, and finally that (iiix) does not intersect (by definition of ). Since has a connected simple set of positions, is a path. Furthermore it is the case that , which follows immediately from the following facts: is a path, , and .
Next we claim that . First, we know that, since all of the glues that places on are at height strictly higher than the height of on which is ’s visible (i.e. lowest) glue on . Second, since we know that all of the glues that places on are at height strictly higher than the height of on which is ’s visible glue on which is at the same height as ’s visible glue on . Since , then ’s visible glue on is strictly higher than the visible glue of on . Thus .
Since is -successful, and since and share a nonempty suffix , this implies that is also -successful. Moreover, no strict prefix of is -successful, because is not -successful and by the definition of -successful no strict prefix of is -successful. But since , this means that satisfies the induction hypothesis, meaning that conflicts with . Since is a subassembly of then the prefix of does not conflict with , which in turn implies that the suffix of conflicts with , which implies that conflicts with , satisfying the induction hypothesis.333333Recall that we have already defined and .
Case 2: and do not share the position of their visible glue on (which includes the case where does not reach ).
Moreover, the glue placed by on is a glue (respectively a glue). We assumed that does not conflict with , hence does not conflict with . We first show that intersects and agrees with , and then use an argument similar to Case 1 above:
- •
Assume, for the sake of contradiction, that does not intersect . Let be the smallest343434There is at least one such integer since we know that conflicts with , and we know that this conflict happens after (in order) the visible glue () of and . integer such that for some . We are going to define a closed connected component in which starts to grow. First note that is connected, connected to , and is connected to . Therefore, contains at least one path from to (note that is a prefix of ). Let be any shortest such path.
Let then be the closed curve defined by the concatenation of and . Curve is simple because and only intersect at their endpoints because was chosen to be the smallest integer () such that and because is a shortest path.
Therefore, by the Jordan Curve Theorem, encloses a single bounded connected component of . (This connected component is shown in gray in the example in Figure 6.2.)
Now, , the position of the visible glue of on , is on curve . Moreover, since no other point of intersects at the height of, or below , then is the unique lowest intersection of and .
Then, since is in (respectively in ), the left-hand side (respectively right-hand side) of is inside . Therefore, since is -successful and places tiles (with positions) on , needs to turn from (because all points of are below height ). However, by Lemma 5.10, cannot turn right (respectively, left) from , hence from ; if it did would hide at least one of its own visible glues, which is impossible. Therefore, must turn from, and thus intersect, other parts of , i.e. or , which is a contradiction. Hence intersects .
- •
We have shown that intersects (and agrees with) at least once. In fact all such intersections are agreements because does not conflict with . Let be the largest integer such that for some integer . We claim that is a path: indeed, does not intersect by the definition of , and is connected. Moreover, . Furthermore, , because since and is simple, and since the visible glue of on is not shared with that of , all glues of on are strictly higher than . Therefore, by the induction hypothesis, conflicts with , and hence , which means that conflicts with (since does not conflict with ).
Case 3: and share the position of their visible glue on , and either both are glues, or both are glues.
In this case, because , and and , and hence , share their visible glue at the same height on , we know by the definition of that either:
- •
is more right-priority (respectively, left-priority) than if , are both glues (respectively, glues), where is the visible glue of on , and is the visible glue of on .
- •
However, in the second case, since conflicts with (by the induction hypothesis, since ), and places the visible glue of on , then conflicts with , hence also conflicts with , and we are done with Case 3 by simply letting .
To conclude this proof, we will therefore handle the first case, i.e. the case where is more right-priority (respectively, left-priority) than .
We assumed that does not conflict with , hence in particular does not conflict with , and does not conflict with . Let and be the smallest integers such that . An example of this situation is shown in Figure 6.3.
The argument follows along the same lines as Case 2 (building a closed connected component in which starts to grow), but requires a new technique to identify the inside and outside of that connected component.
- •
Assume, for the sake of contradiction, that does not intersect .
We now describe a closed connected component inside which a suffix of starts to grow. We first introduce a new variant of embedding of paths into , which we call the nano-embedding of a path , denoted . This is illustrated in Figure 6.4 and defined as follows. For a path consider its canonical embedding . Then, define to be the curve in where all of the points of are at distance exactly from their closest point on , and are positioned on the right (respectively, left) hand side of as we walk along from to . For tiles on with input side being their west side, we show in Figure 6.4(top) all three cases of nano-embeddings. Other cases where the input side is north, east or south are rotations of these three cases. Special cases for start and end tiles of a path are illustrated in Figure 6.4.
Since intersects (because in particular, conflicts with ), let be the smallest integer such that for some integer .
We now define a simple closed curve inside which a suffix of starts to grow: let be the concatenation of , then a length line segment from the final point of to , then , and finally a line segment of length 0.25 from to , which is the first point of . (Figure 6.5 shows an example .)
We claim that is simple: indeed, since only turns left from , and since stays immediately to the right of , the four curves used to construct intersect each other only at the last and first endpoints of each pair of consecutive curves. Notice that is also closed. Therefore, by the Jordan Curve Theorem, encloses a bounded connected component of . Moreover, at the visible glue of and on , the nano-embedding of is below , and since places a (respectively, ) glue on , the left-hand (respectively, right-hand) side of is the inside of .
Finally, since does not turn right from (otherwise, by Lemma 5.10 would hide the visibility of at least one of its own glues, which is impossible), a suffix of starts inside or on . But since no point of is at or above height , and is -successful, the last tile of is positioned outside of , which can happen in only two different ways: either turns right from (contradicting Lemma 5.10), or else intersects which is also a contradiction.
- •
Therefore, intersects . Moreover, that intersection is necessarily an agreement. Let therefore be the largest integer such that for some (notice that ), and let . Note that is connected, and that does not intersect (because of our choice of ), and that the tiles and bind (since ). Therefore, is an assemblable path in .
- –
If , then and have the same visible glue on (this visible glue is on ), and the first difference between and is a right turn of from , meaning that is less right-priority than . Therefore, .
- –
Else, , and hence the visible glue of on is not the same as the visible glue of on . Therefore, the visible glue of on is strictly higher than that of . This means that .
In both cases, , hence conflicts with by the induction hypothesis. Recall that , and that , and therefore conflicts with .
Hence conflicts with which proves the induction hypothesis for .
∎
7 Noncooperative tile assembly: Impossibility of bounded Turing machine simulation
We begin by restating Theorem 1.2. Note that the “bounding function” in the statement is an arbitrary upperbound on the space usage of the Turing machine as we wish to allow any claimed temperature 1 simulator of Turing machines to be arbitrarily 2D-space-inefficient in it’s attempt to do so.
Theorem 1.2.
Let , and let such that , . Let be any Turing machine that halts on all inputs in time using space . There is no pair where is a tileset and is a function such that for all , , there is a seed assembly and tile assembly system such that:
2. 2.
for all , , where and has at least one occurrence of a special tile type on the rightmost column of , and nowhere else, if and only if accepts .
Proof.
Intuitively, the proof proceeds by supposing for the sake of contradiction that there is such a tileset and then modifying to get another tile set that can be instantiated as an infinite set of tile assembly systems each one of which produces terminal assemblies that have the same scaled (simulated) shape as some system defined in Section 3. But this violates Theorem 6.1, giving a contradiction. We argue this as follows.
Let be a Turing machine with input alphabet that accepts all of its inputs using space and time . So suppose for the sake of contradiction that there is a tileset that simulates on all inputs using some “bounding function” as described in the theorem statement.
We will modify the tile set . Since the tile type is on the rightmost vertical column of every terminal assembly , ’s east glue type is either (a) of strength [math], or else (b) of strength and matches no west glue in the tile set . On tile type we replace with a new glue type that is of strength 1 and where appears on no other tile type of . We also add two new tile types to : the west side of has the glue type and so binds to the east side of , and the south side of binds to the north side of , and the south side of binds to the north side of itself. When appears in some assembly it is always possible to bind a tile of type to the east side of in (by hypothesis is placed in the rightmost column of hence there is always sufficient (unit) space to the right of to place ). There may be a number of places where tiles of type can bind (each to the east of a tile of type ), nevertheless every terminal assembly will have an infinite vertical line of tiles growing to the north of some instance of (i.e. since is in the rightmost column, there can be nothing to the north of a tile of type , other than possibly another tile of type , and hence there is nothing to stop some tile of type growing an the infinite vertical line of tiles to its north).
For each , , using the modified tileset , the system builds an assembly that has (roughly) the same rescaled shape as (defined in Section 3), but with some spatial rescaling (by a factor of ). Let be any input such that, with , (e.g. choosing does the trick). Finally, setting , let be the -block supertile representation function that is undefined on empty -blocks and maps nonempty -blocks to the tile .353535-block supertile representation functions were defined in Section 2.2. Since the proof of Theorem 1.2 reasons merely about the shapes of terminal assemblies, we do not even require that sometimes maps different nonempty -blocks to different tile types of . In other words, having map nonempty -blocks to some tile type of (here ) is sufficient to reason about the shape of assemblies under . Then and for . Hence our modified violates violates Theorem 6.1 where in the theorem statement we set , , and . ∎
Acknowledgements
We thank Damien Regnault, Matthew Patitz, Trent Rogers and Andrew Winslow for important technical feedback and the following people for interesting discussions that helped to improve our thinking: Nicolas Schabanel, Dave Doty, Robert Schweller and Jacob Hendricks. We also thank for Nicolas Schabanel for hosting both authors at LIAFA (Paris 7, France) for the months of September 2014 and May 2015. A special thanks to our wives Elisa and Beverley.
Appendix A Additional simulation definitions
This appendix continues the definitions in Section 2.2 and were used in previous work on intrinsic universality [9, 8, 20, 6, 7, 11].
Definition A.1**.**
We say that and have equivalent productions (under ), and we write if the following conditions hold:
. 2. 2.
. 3. 3.
For all , maps cleanly to .
Observation A.2**.**
If and that have equivalent productions (they satisfy Definition A.1) then they have equivalent shapes (they satisfy Definition 2.1).
The following two definitions (for simulation dynamics) can be safely ignored by the reader and are included only for the sake of completeness.
Definition A.3**.**
We say that follows (under ), and we write if , for some , implies that .
Definition A.4**.**
We say that models (under ), and we write , if for every , there exists where for all , such that, for every where , (1) for every there exists where and , and (2) for every where , , , and , there exists such that .
The previous definition essentially specifies that whenever simulates an assembly , there must be at least one valid growth path in for each of the possible next steps could make from .
Definition A.5**.**
We say that simulates (under ) if (equivalent productions), and (equivalent dynamics).
A.1 Intrinsic universality
Now that we have a formal definition of what it means for one tile assembly system to simulate another, we can proceed to formally define the concept of intrinsic universality, i.e. when there is one general-purpose tile set that can be appropriately programmed to simulate any other tile system from a specified class of tile assembly systems. Let denote the set of all supertile representation functions (i.e. -block supertile representation functions for all ). Define to be a class of tile assembly systems, to be the class of all temperature 1 tile assembly systems, and let be a tileset.
Definition A.6**.**
We say is intrinsically universal for at temperature if there are functions and such that, for each , there is a constant such that, letting , , and , simulates at scale and using supertile representation function .
That is, is a representation function that interprets assemblies of as assemblies of , and is the seed assembly used to program tiles from to represent the seed assembly of . In this paper, we disprove the existence of an intrinsically universal tileset for (the set of all temperature 1 tile assembly systems) at temperature .
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] B. Behsaz, J. Maňuch, and L. Stacho. Turing universality of step-wise and stage assembly at temperature 1. In DNA 18: Proc. of International Meeting on DNA Computing and Molecular Programming , volume 7433 of LNCS , pages 1–11. Springer, 2012.
- 2[2] M. Bousquet-Mélou. Families of prudent self-avoiding walks. J. Comb. Theory, Ser. A , 117(3):313–344, 2010.
- 3[3] S. Cannon, E. D. Demaine, M. L. Demaine, S. Eisenstat, M. J. Patitz, R. Schweller, S. M. Summers, and A. Winslow. Two hands are better than one (up to constant factors). In STACS: Proceedings of the Thirtieth International Symposium on Theoretical Aspects of Computer Science , pages 172–184. LIP Ics, 2013. Arxiv preprint: 1201.1650 .
- 4[4] H. Chandran, N. Gopalkrishnan, and J. Reif. Tile complexity of approximate squares. Algorithmica , 66(1):1–17, 2013.
- 5[5] M. Cook, Y. Fu, and R. T. Schweller. Temperature 1 self-assembly: deterministic assembly in 3D and probabilistic assembly in 2D. In SODA: Proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms , pages 570–589, 2011. Arxiv preprint: ar Xiv:0912.0027 .
- 6[6] E. D. Demaine, M. L. Demaine, S. P. Fekete, M. J. Patitz, R. T. Schweller, A. Winslow, and D. Woods. One tile to rule them all: Simulating any tile assembly system with a single universal tile. In ICALP: Proceedings of the 41st International Colloquium on Automata, Languages, and Programming , volume 8572 of LNCS , pages 368--379. Springer, 2014. Arxiv preprint: ar Xiv:1212.4756 .
- 7[7] E. D. Demaine, M. J. Patitz, T. A. Rogers, R. T. Schweller, S. M. Summers, and D. Woods. The two-handed tile assembly model is not intrinsically universal. In ICALP: Proceedings of the 40th International Colloquium on Automata, Languages, and Programming , volume 7965 of LNCS , pages 400--412. Springer, July 2013. Arxiv preprint: ar Xiv:1306.6710 .
- 8[8] D. Doty, J. H. Lutz, M. J. Patitz, R. T. Schweller, S. M. Summers, and D. Woods. The tile assembly model is intrinsically universal. In FOCS: Proceedings of the 53rd Annual IEEE Symposium on Foundations of Computer Science , pages 439--446. IEEE, Oct. 2012. Arxiv preprint: ar Xiv:1111.3097 .
