arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020...

58
arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 The program-size complexity of self-assembled paths Pierre- ´ Etienne Meunier Damien Regnault Damien Woods § Abstract We prove a Pumping Lemma for the noncooperative abstract Tile Assembly Model, a model central to the theory of algorithmic self-assembly since the beginning of the field. This theory suggests, and our result proves, that small differences in the nature of adhesive bindings between abstract square molecules gives rise to vastly different expressive capabili- ties. In the cooperative abstract Tile Assembly Model, square tiles attach to each other using multi-sided cooperation of one, two or more sides. This precise control of tile binding is directly exploited for algorithmic tasks including growth of specified shapes using very few tile types, as well as simulation of Turing machines and even self-simulation of self-assembly systems. But are cooperative bindings required for these computational tasks? The defini- tionally simpler noncooperative (or Temperature 1) model has poor control over local binding events: tiles stick if they bind on at least one side. This has led to the conjecture that it is impossible for it to exhibit precisely controlled growth of computationally-defined shapes. Here, we prove such an impossibility result. We show that any planar noncooperative system that attempts to grow large algorithmically-controlled tile-efficient assemblies must also grow infinite non-algorithmic (pumped) structures with a simple closed-form description, or else suffer blocking of intended algorithmic structures. Our result holds for both directed and nondirected systems, and gives an explicit upper bound of (8|T |) 4|T |+1 (5|σ| + 6), where |T | is the size of the tileset and |σ| is the size of the seed assembly, beyond which any path of tiles is pumpable or blockable. Supported by European Research Council (ERC) award number 772766 and Science foundation Ireland (SFI) grant 18/ERCS/5746 (this manuscript reflects only the authors’ view and the ERC is not responsible for any use that may be made of the information it contains). Some of this work was supported by, and carried out at, Inria, Paris, France. Hamilton Institute, Maynooth University, Co. Kildare, Ireland. [email protected] IBISC, Universit´ e ´ Evry, Universit´ e Paris-Saclay, 91025, Evry, France. [email protected] § Hamilton Institute and Department of Computer Science, Maynooth University, Co. Kildare, Ireland. [email protected] 1

Transcript of arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020...

Page 1: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

arX

iv:2

002.

0401

2v1

[cs

.CC

] 1

0 Fe

b 20

20

The program-size complexity of self-assembled paths∗

Pierre-Etienne Meunier† Damien Regnault‡ Damien Woods§

Abstract

We prove a Pumping Lemma for the noncooperative abstract Tile Assembly Model, amodel central to the theory of algorithmic self-assembly since the beginning of the field.This theory suggests, and our result proves, that small differences in the nature of adhesivebindings between abstract square molecules gives rise to vastly different expressive capabili-ties.

In the cooperative abstract Tile Assembly Model, square tiles attach to each other usingmulti-sided cooperation of one, two or more sides. This precise control of tile binding isdirectly exploited for algorithmic tasks including growth of specified shapes using very fewtile types, as well as simulation of Turing machines and even self-simulation of self-assemblysystems. But are cooperative bindings required for these computational tasks? The defini-tionally simpler noncooperative (or Temperature 1) model has poor control over local bindingevents: tiles stick if they bind on at least one side. This has led to the conjecture that it isimpossible for it to exhibit precisely controlled growth of computationally-defined shapes.

Here, we prove such an impossibility result. We show that any planar noncooperativesystem that attempts to grow large algorithmically-controlled tile-efficient assemblies mustalso grow infinite non-algorithmic (pumped) structures with a simple closed-form description,or else suffer blocking of intended algorithmic structures. Our result holds for both directedand nondirected systems, and gives an explicit upper bound of (8|T |)4|T |+1(5|σ|+ 6), where|T | is the size of the tileset and |σ| is the size of the seed assembly, beyond which any pathof tiles is pumpable or blockable.

∗Supported by European Research Council (ERC) award number 772766 and Science foundation Ireland (SFI)grant 18/ERCS/5746 (this manuscript reflects only the authors’ view and the ERC is not responsible for any usethat may be made of the information it contains). Some of this work was supported by, and carried out at, Inria,Paris, France.

†Hamilton Institute, Maynooth University, Co. Kildare, Ireland. [email protected]‡IBISC, Universite Evry, Universite Paris-Saclay, 91025, Evry, France. [email protected]§Hamilton Institute and Department of Computer Science, Maynooth University, Co. Kildare, Ireland.

[email protected]

1

Page 2: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

1 Introduction

The main challenge of molecular programming is to understand, build and control matter at themolecular level. The dynamics of molecules can embed algorithms [42] and the theory of algorith-mic self-assembly [13,34,43] is one formal way to think about the computational capabilities ofautonomic self-assembling molecular systems. That theory, and more broadly the theory of mod-els of computation, guides advances in experimental work to this day: the self-assembling binarycounter of Winfree and Rothemund [37] was later implemented using tiles made of DNA [17],as were bit-copying systems [2, 3, 39] and discrete self-similar fractals [20, 38]. More recently,twenty-one self-assembly algorithms were implemented using DNA single-stranded tiles [44], in-cluding a tile-based implementation [7] of von Neuman’s fair-bit-from-an-unfair-coin and a 3-bitinstance of the computationally universal cellular automata Rule 110 [9,32]. Besides guiding ex-periment, the theory itself has undergone significant developments, with the long-term vision ofunderstanding the kinds of structure-building capabilities and computational mechanisms thatare implementable and permitted by molecular processes.

Perhaps the most studied model of algorithmic self-assembly is the abstract Tile AssemblyModel (aTAM), introduced by Winfree [42] as a computational model of DNA tile-based self-assembly. The model is an algorithmic version of Wang tilings [41], can be thought of asan asynchronous cellular automaton [5] and has features seen in other distributed computingmodels. In each instance of the model, we have a finite set of unit square tile types, withcolours on their four sides, and an infinite supply of each type. Starting from a small connectedarrangement of tiles on the Z2 plane, called the seed assembly, we attach tiles to that assemblyasynchronously and nondeterministically based on a local rule depending only on the colourof the sides of the newly placed tile and of the sides of the assembly that are adjacent to theattachment position.

This model can simulate Turing machines [42], self-assemble squares with few tile types [36,37], assemble any finite spatially-scaled shape using a small, Kolmogorov-efficient, tile set [40],and there is an intrinsically universal tile set capable of simulating the behaviour (producedshapes and growth dynamics) of any other tile set, up to spatial rescaling [14].

However, these results have all been proven using the so-called cooperative tile assemblymodel. In the cooperative, or temperature 2, model there are two kinds of bonds: strong andweak. A tile can attach to an assembly by one side if that side forms a strong (“strength 2”)bond with the assembly, or it can attach if two of its sides each match with a weak (“strength 1”)bond. Intuitively, the cooperative model exploits weak bonds to create a form of synchronisation.The attachment of a tile by two weak glues sticking to two neighbour tiles can only occur afterboth neighbour tiles are present, allowing the system to wait rather than (say) proceeding withpotentially inaccurate or incomplete information.

But what happens if we allow only one kind of bond? We get a simple model called thenon-cooperative, or temperature 1, model. In the non-cooperative model, tiles may attach tothe assembly whenever at least one of their sides’ colour matches the colour of a side of theassembly adjacent to the position where they attach. Intuitively, they need not wait for morebonds to appear adjacent to their attachment position. In this model it seems non-obvioushow to implement synchronisation; we have no obvious programmable feature that enables onegrowth process to wait until another is complete. Our attempts to build such things typicallylead to rampant uncontrolled growth.

The question of whether the non-cooperative (or “non-waiting”) model has any non-trivial

2

Page 3: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

computational abilities has been open since the beginning of the field [37]. Perhaps a reason forthis is that actually proving that one can not synchronise growth is tricky; maybe noncooperativeself-assembly can somehow simulate synchronisation using some complicated form of in-planegeometric blocking? Restrictions of the model have been shown to be extremely weak [26, 37],generalisations shown to be extremely powerful [4, 6, 10–12, 15, 18, 19, 23–25, 33, 35, 36], and, tofurther deepen the mystery, the model has been shown capable of some (albeit limited) efficienttile reuse [27,30].

1.1 Main result

Our main result is stated in Theorem 1.1, although a number of notions have yet to be formallydefined (see Section 2 for definitions). Intuitively if a noncooperative tile assembly systemproduces a large assembly, it is capable of also producing any path of tiles in that assembly.Our statement says that if the tile assembly system can produce a long enough path P , thenit must also produce assemblies where either an infinite ultimately periodic path appears (Pis “pumpable”), or else the path cannot appear in all terminal assemblies (because some othertiles can be placed to block the growth of P ), in which case we say that P is fragile. Let T bea set of tile types, and let |σ| denote the number of tiles in the (seed) assembly σ.

Theorem 1.1. Let T = (T, σ, 1) be any tile assembly system in the abstract Tile AssemblyModel (aTAM), and let P be a path producible by T . If P has vertical height or horizontal widthat least (8|T |)4|T |+1(5|σ| + 6), then P is pumpable or fragile.

Our result rules out the kind of Turing machine simulations, and other kinds of computations,that have appeared in the literature to date and execute precisely controlled growth patterns [4,6, 10–12, 15, 18, 19, 23–26, 33, 35, 36]. We do so by showing that any attempt to carry out longcomputations such as these, which provably require large assemblies and thus long paths, willresult in unbounded pumped growth or the blocking of such paths.

The essence of algorithmic self-assembly is tile reuse: growing structures that are larger thanthe number of available tile types [13, 34, 37, 43]. Meunier and Regnault [30] show that somenoncooperative systems are capable of tile reuse in the following sense: there is a tile assemblysystem with multiple terminal assemblies, all of finite size, such that each of them contains thesame long path P , where P is of width O(|T | log |T |) (i.e. larger than |T |). In that construction,P is neither pumpable (all assemblies are finite) nor fragile (P appears in all terminal assemblies,hence no assembly or path can block it). Their result should be contrasted with ours since herewe show that any attempt to generalise such a construction beyond our exponential-in-|T | boundwill fail – thus we give a limitation of the amount of tile reuse possible in such constructions.Analogous tile reuse limitations do not appear in cooperative systems [37], due to their abilityto run arbitrary algorithms.

Our theorem statement is quite similar to the pumpability conjecture of Doty, Patitz andSummers [16] (Conjecture 6.1). In that work [16] under the assumption that the conjecture istrue, they achieve a complete characterisation of the producible assemblies. Our result is slightlydifferent from that conjecture, being stronger in two ways, and weaker in one:

• First, their conjecture was stated for directed systems (that produce a single terminal assem-bly), but here we prove the result for both directed and undirected systems (systems thatproduce many terminal assemblies).1 In the directed case, our result shows that any attempt

1Directed systems do not have fragile paths, hence for directed systems the conclusion of the theorem statement

3

Page 4: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

to simulate computations by growing longer and longer paths is doomed to also produce aterminal assembly littered with more and more infinite pumped paths.

• Second, we give an explicit bound (exponential in |T |) on the length a path can reach beforeit is pumpable or fragile.

• Our result is weaker in one way: indeed, while our result only applies to paths grown all theway from the seed, the conjecture is that arbitrary paths are pumpable, regardless of theirposition relative to the seed.

However, we conjecture that our result is sufficient to achieve the same characterisation ofproducible assemblies, using the same techniques and arguments as [16].

Our result can be applied to other models. After the aTAM, another well-studied model in thetheory of algorithmic self-assembly is the hierarchical, or two-handed, model (2HAM) [6,8,12,15].There is no seed assembly in the 2HAM: in the noncooperative (temperature 1) 2HAM tiles sticktogether if glues match on one tile side, forming a collection of assemblies, and those assembliescan in turn stick to each other if they can be translated to touch without overlapping and withadjacent matching glues between them. As an almost direct corollary of Theorem 1.1 we get:

Corollary 1.2. Let H = (T, 1) be any tile assembly system in the Two-Handed Assembly Model(2HAM), and let P be a path producible by H. If P has vertical height or horizontal width atleast (88|T |)4|T |+1, then P is pumpable or fragile.

Intuitively, the corollary comes from the fact that aTAM-like growth is permitted in the2HAM. In fact, if we fix a tile set T and a temperature of 1, the set of producible assembliesin a 2HAM system over T is a superset (sometimes a strict superset [6]) of those in the aTAMover T . A brief proof sketch is given in Appendix A.

1.2 Relationship with other prior work

Perhaps due to the difficulty of analysing the standard noncooperative model (2D, square tiles,tiles attach one at a time), researchers have looked at different variants of that model.

The first restriction studied was where we permit only terminal assemblies that are “fullyconnected” meaning all tiles are fully bound to all of their neighbour tiles): Rothemund andWinfree [37] showed that for each large enough n ∈ N there does not exist a noncooperativesystem that builds a fully-connected n× n square in a tile-efficient way (using < n2 tile types).Since embedding algorithms in tiles are essentially our best (and perhaps only) way to exhibitefficient tile reuse, our result shuts the door on a wide class of algorithmic approaches. Otherrestrictions proven weak are where we disallow adjacent mismatching colours [26], or even forceany pair of adjacent tiles to bind to each other [37].

Another, quite productive, approach has been to study generalisations of the noncoopera-tive model (e.g. 3D, non-square tiles, multi-tile assembly steps, more complicated ‘active’ tiles,etc.): it turns out that these generalisations and others are powerful enough to simulate Turingmachines [4, 6, 10–12,15,18,19,21–26,33,35,36]. Each such result points to a specific feature orset of features in a generalised model that provably needs to be exploited in order to avoid ournegative result.

Since Cook, Fu, and Schweller [10] have shown that for any Turing machine there is anundirected tile assembly system, whose seed encodes an input, and where the largest producible

systems simply reads “... then P is pumpable”.

4

Page 5: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

terminal assembly (which is possibly infinite) simulates the Turing machine computation on thatinput. However, in that construction, “blocking errors” can occur where growth is prematurelyblocked and is stopped before the simulation, or computation, is completed (hence their resultis stated in a probabilistic setting). Indeed their tile assembly systems that simulate Turingmachines will produce many such erroneous assemblies. Our result shows that this kind ofblocking is unavoidable.

Assemblies that cannot be “blocked” have the opposite issue, where it seems there is alwaysa part of the assembly that can be repeated forever, which led Doty, Patitz and Summers [16]to their pumpability conjecture. They go on to show that, assuming the pumpability conjectureholds, projections to the vertical/horizontal axes of assemblies produced by directed nonco-operative systems have a straightforward closed-form description (as the union of semi-linearsets).

In the direction of negative results on Temperature 1, reference [31] showed that the noncoop-erative planar aTAM is not capable of simulating – in the sense used in intrinsic universality [43]– other noncooperative aTAM systems. In other words intrinsic universality is not possible forthe planar noncooperative model. The Temperature 2 (or, cooperative) model is capable ofsuch simulations [14], hence the main result of [31] shows a difference in the self-simulationcapabilities of the two models. Prior to that work, another result showed that Temperature 1cannot simulate Temperature 2 intrinsically [28], and hence the former is strictly weaker thanthe later in this setting (where we ignore spatial scaling). However, to obtain both of thoseresults, the use of simulation and intrinsic universality permitted a technique where we choose aparticular class of shapes we want to simulate, and restrict the analysis of produced assembliesto (scaled versions of) these shapes. The proofs [28, 31] then involved forcing certain pathsto grow outside of these pre-determined shapes. This paper makes use of a number of toolsfrom [31]. Here, however, the setting is significantly more challenging as we have no geometrichypotheses whatsoever on producible assemblies and therefore can not directly leverage [31],although we do make use of the tools of visibility and the notion of right/left priority exploitedin that prior work. As already noted, positive constructions have been found that some limitedform of efficient reuse of tile types is possible in the standard 2D noncooperative model [27,30].This paper also builds on extensive previous work by two of the authors [29].

1.3 New tools and future work

We develop a collection of new tools to reason about paths in Z2. In order to carry out com-putation in tile-assembly, a key idea is to reuse tile types (analogous to how a Boolean circuitreuses gates of a given type, or how a computer program reuses instructions via loops). Ourmain technical lemma, which we term the “shield” lemma, shows that if a path P has a certainform that reaches so far to the east that it reuses some tile types, then we can use P to constructa curve in R2 that is an almost-vertical cut c of the plane. We use this cut of the plane to showone of two things must happen: either that iterations of a pumping of P are separated from oneanother, and hence that the pumping is simple, which means that P is pumpable, or else thata path can be grown that blocks the growth of P .

This cut, and our subsequent argument can be thought of as a kind of “Window MovieLemma” [28], or pumping tool, but targeted specifically at noncooperative self-assembly.

The shield lemma can only be applied when P is of a certain form. Our second tool isa combinatorial argument on the height and width of a path. We begin by applying somestraight-froward transformations to put any wide enough or tall enough path (i.e., that meets

5

Page 6: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

the hypothesis of Theorem 1.1) into a form that its last tile is also its eastern-most tile. Then,for any such path P , our combinatorial argument shows that we can always find a cut thatsatisfies the hypothesis of the shield lemma. We hope that the techniques developed in thispaper can be applied to other self-assembly models – as an example we apply them to the2HAM (Corollary 1.2).

Although we answer one of the main unresolved questions on noncooperative self-assembly,our result does not close all questions on the model. First, there is still a big gap between thebest known lower bounds on the size of assemblies (which is O(|T | log |T |)), and the exponentialbound (8|T |)4|T |+1(5|σ| + 6) we prove here. It remains as future work to reduce that gap. Wealso conjecture that our result can be used to characterise the assemblies producible by directedsystems, using the same argument as [16]. A number of decidability questions are also stillopen such as: can we decide whether a planar nondirected tile assembly system is directed(i.e. produces exactly one terminal assembly)? An important part of self-assembly is relatedto building shapes (as opposed to decidability questions). In this direction, can we build n× nsquares any more efficiently than the best known result of 2n − 1 tile types for noncooperativesystems? For this common benchmark of shape-building, cooperative systems achieve a tilesetsize as low as Θ(log n/ log log n) [1, 22,37].

1.4 Structure of the paper

Section 2 contains key definitions and notions required for the paper. Section 3 proves our maintechnical lemma (Lemma 3.1), which we call the Shield lemma. The section begins with thedefinition of a shield of a path (a triple of indices of tiles along the path) and then gives somehigh-level intuition for the proof of Lemma 3.1. The section proceeds to prove quite a numberof claims (Claims 3.2 to 3.15) that provide an arsenal of technical tools to reason about pathsthat have a shield. The section ends with an inductive argument that proves the Shield lemma,making use of the previous claims. Finally, Section 4 proves our main result, Theorem 1.1, usinga combinatorial argument to show that every wide enough path has a shield. It begins withSubsection 4.1 which contains the Intuition behind the proof of Theorem 1.1 — some may findit helpful to begin reading there.

Appendix A proves the 2HAM result (Corollary 1.2) and Appendix B states a particularversion of the Jordan curve theorem for infinite polygonal curves and states related definitions(one curve turning from another, left-/right-hand side of the plane).

2 Definitions and preliminaries

As usual, let R be the set of real numbers, let Z be the integers, and let N be the natural numbersincluding 0. The domain of a function f is denoted dom(f), and its range (or image) is denotedf(dom(f)).

2.1 Abstract tile assembly model

The abstract tile assembly model was introduced by Winfree [42]. In this paper we study arestriction of the abstract tile assembly model called the temperature 1 abstract tile assemblymodel, or noncooperative abstract tile assembly model. For definitions of the full model, as wellas intuitive explanations, see for example [36,37].

6

Page 7: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

A tile type is a unit square with four sides, each consisting of a glue type and a nonnegativeinteger strength. Let T be a a finite set of tile types. In any set of tile types used in this paper,we assume the existence of a well-defined total ordering which we call the canonical orderingof the tile set. The sides of a tile type are respectively called north, east, south, and west, asshown in the following picture:

West East

South

North

An assembly is a partial function α : Z299K T where T is a set of tile types and the domain

of α (denoted dom(α)) is connected.2 We let AT denote the set of all assemblies over the setof tile types T . In this paper, two tile types in an assembly are said to bind (or interact, or arestably attached), if the glue types on their abutting sides are equal, and have strength ≥ 1. Anassembly α induces an undirected weighted binding graph Gα = (V,E), where V = dom(α), andthere is an edge {a, b} ∈ E if and only if the tiles at positions a and b interact, and this edge isweighted by the glue strength of that interaction. The assembly is said to be τ -stable if everycut of Gα has weight at least τ .

A tile assembly system is a triple T = (T, σ, τ), where T is a finite set of tile types, σ is aτ -stable assembly called the seed, and τ ∈ N is the temperature. Throughout this paper, τ = 1.

Given two τ -stable assemblies α and β, we say that α is a subassembly of β, and write α ⊑ β,if dom(α) ⊆ dom(β) and for all p ∈ dom(α), α(p) = β(p). We also write α →T1 β if we canobtain β from α by the binding of a single tile type, that is: α ⊑ β, |dom(β) \ dom(α)| = 1 andthe tile type at the position dom(β) \ dom(α) stably binds to α at that position. We say that γis producible from α, and write α →T γ if there is a (possibly empty) sequence α1, α2, . . . , αn

where n ∈ N ∪ {∞}, α = α1 and αn = γ, such that α1 →T1 α2 →T1 . . . →T1 αn. A sequenceof n ∈ Z+ ∪ {∞} assemblies α0, α1, . . . over AT is a T -assembly sequence if, for all 1 ≤ i < n,αi−1 →

T1 αi.

The set of productions, or producible assemblies, of a tile assembly system T = (T, σ, τ) isthe set of all assemblies producible from the seed assembly σ and is written A[T ]. An assemblyα is called terminal if there is no β such that α →T1 β. The set of all terminal assemblies of Tis denoted A�[T ].

2.2 Paths and non-cooperative self-assembly

This section introduces quite a number of key definitions and concepts that will be used exten-sively throughout the paper.

Let T be a set of tile types. A tile is a pair ((x, y), t) where (x, y) ∈ Z2 is a positionand t ∈ T 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 Z2 so that each tile in the sequence interactswith the previous one, or more precisely:

Definition 1 (Path). A path is a (finite or infinite) sequence P = P0P1P2 . . . of tiles Pi =((xi, yi), ti) ∈ Z2 × T , such that:

2Intuitively, an assembly is a positioning of unit-sized tiles, each from some set of tile types T , so that theircenters are placed on (some of) the elements of the discrete plane Z2 and such that those elements of Z2 form aconnected set of points.

7

Page 8: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

• for all Pj and Pj+1 defined on P , their positions (xj, yj) and (xj+1, yj+1) are adjacent nodesin the grid graph of Z2, moreover tj and tj+1 interact (have matching glues on their abuttingsides), and

• for all Pj , Pk such that j 6= k it is the case that (xj , yj) 6= (xk, yk).

By definition, paths are simple (or self-avoiding), and this fact will be repeatedly usedthroughout the paper. For a tile Pi on some path P , its x-coordinate is denoted xPi

and itsy-coordinate is denoted yPi

. The concatenation of two paths P and Q is the concatenation PQof these two paths as sequences, and PQ is a path if and only if (1) the last tile of P interactswith the first tile of Q and (2) P and Q do not intersect each other.

For a path P = P0 . . . PiPi+1 . . . Pj . . ., we define the notation Pi,i+1,...,j = PiPi+1 . . . Pj ,i.e. “the subpath of P between indices i and j, inclusive”. Whenever P is finite, i.e. P =P0P1P2 . . . Pn−1 for some n ∈ N, n is termed the length of P and denoted by |P |. In the specialcase of a subpath where i = 0, we say that P0,1,...,j is a prefix of P and that P is an extensionof P0,1,...,j. The prefix or extension are said to be strict if j < |P | − 1. Else, when j = |P | − 1,we say that Pi,...,|P |−1 is a suffix of P , and is a strict suffix of P if i > 0.

For any path P = P0P1P2, . . . and integer i ≥ 0, we write pos(Pi) ∈ Z2, or (xPi, yPi

) ∈ Z2,for the position of Pi and type(Pi) for the tile type of Pi. Hence if Pi = ((xi, yi), ti) thenpos(Pi) = (xPi

, yPi) = (xi, yi) and type(Pi) = ti. A “position of P” is an element of Z2 that

appears in P (and therefore appears exactly once), and an index i of a path P of length n ∈ Nis a natural number i ∈ {0, 1, . . . , n − 1}. For a path P = P0P1P2 . . . we write pos(P ) to mean“the sequence of positions of tiles along P”, which is pos(P ) = pos(P0)pos(P1)pos(P2) . . . .

Although a path is not an assembly, we know that each adjacent pair of tiles in the pathsequence interact implying that the set of path positions forms a connected set in Z2 andhence every path uniquely represents an assembly containing exactly the tiles of the path, moreformally: for a path P = P0P1P2 . . . we define the set of tiles asm(P ) = {P0, P1, P2, . . .} whichwe observe is an assembly3 and we call asm(P ) a path assembly. Given a tile assembly systemT = (T, σ, 1) the path P is a producible path of T if asm(P ) does not intersect4 the seed σ andthe assembly (asm(P ) ∪ σ) is producible by T , i.e. (asm(P ) ∪ σ) ∈ A[T ], and P0 interacts witha tile of σ. As a convenient abuse of notation we sometimes write σ ∪ P as a shorthand forσ ∪ asm(P ). Given a tile assembly system T = (T, σ, 1) we define the set of producible paths ofT to be:5

P[T ] = {P | P is a path that does not intersect σ and (asm(P ) ∪ σ) ∈ A[T ]}

So far, we have defined paths of tiles (Definition 1). In our proofs, we will also reason about(untiled) binding paths in the binding graph of an assembly.

Definition 2 (Binding path). Let G = (V,E) be a binding graph. A binding path q in G isa sequence q0,1,...,|q|−1 of vertices from V such that for all i ∈ {0, 1, . . . , |q| − 2}, {qi, qi+1} ∈ E(q is connected) and no vertex appears twice in q (q is simple).

3I.e. asm(P ) is a partial function from Z2 to tile types, and is defined on a connected set.4Formally, non-intersection of a path P = P0P1, . . . and a seed assembly σ is defined as: ∀t such that t ∈ σ, ∄i

such that pos(Pi) = pos(t).5Intuitively, although producible paths are not assemblies, any producible path P has the nice property that

it encodes an unambiguous description of how to grow asm(P ) from the seed σ, in path (P ) order, to producethe assembly asm(P ) ∪ σ.

8

Page 9: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Observation 2.1. Let T = (T, σ, 1) be a tile assembly system and let α ∈ A[T ]. For any tile((x, y), t) ∈ α either ((x, y), t) is a tile of σ or else there is a producible path P ∈ P[T ] that forsome j ∈ N contains Pj = ((x, y), t).

Proof. If ((x, y), t) is a tile of σ we are done. Assume otherwise for the rest of the proof.Since dom(α) is a connected subset of Z2 there is an integer n ≥ 0 and a binding path p0,1,...,n

in the binding graph of α where p0 ∈ dom(σ) and pn = (x, y). Let i0 be the largest integer suchthat pi0 ∈ dom(σ). We can then define P as the path:

P = P0,1,...,n−(i0+1) = (pi0+1, α(pi0+1))(pi0+2, α(pi0+2)) . . . (pn, α(pn))

By definition of binding graph, for all i ∈ {i0+1, i0+2, . . . , n−1}, the tiles (pi, α(pi)) = Pi−(i0+1)

and (pi+1, α(pi+1)) = Pi+1−(i0+1) on P are adjacent in Z2 and interact on their abutting sides.Moreover, by the definition of i0, P does not intersect σ and the tile (pi0+1, α(pi0+1)) = P0 (thefirst tile of P ) interacts with a tile of σ, meaning that P ∈ P[T ], thus proving the statement.

For A,B ∈ Z2, we define−−→AB = B − A to be the vector from A to B, and for two tiles

Pi = ((xi, yi), ti) and Pj = ((xj , yj), tj) we define−−→PiPj = pos(Pj) − pos(Pi) to mean the vector

from pos(Pi) = (xi, yi) to pos(Pj) = (xj, yj). The translation of a path P by a vector −→v ∈ Z2,written P + −→v , is the path Q such that |P | = |Q| and for all indices i ∈ {0, 1, . . . , |P | − 1},pos(Qi) = pos(Pi) +

−→v and type(Qi) = type(Pi). We always use parentheses for scoping oftranslations when necessary, i.e. P (Q + −→v ) is the sequence containing the path P followed bythe translation of the entire pathQ by vector −→v . The translation of an assembly α by a vector −→v ,written α+−→v , is the assembly β defined for all (x, y) ∈ (dom(α)+−→v ) as β(x, y) = α((x, y)−−→v ).

Let P be a path, let i ∈ {1, 2, . . . , |P | − 2}, and let A 6= Pi+1 be a tile such that P0,1,...,iAis a path. Let also ρ be the clockwise rotation matrix defined as ρ =

(

0 1−1 0

)

, and let ∆ =

(ρ−−−−→PiPi−1, ρ

2−−−−→PiPi−1, ρ3−−−−→PiPi−1) (intuitively, ∆ is the vector of possible steps after Pi, ordered

clockwise). We say that P0,1,...,iA turns right (respectively turns left) from P0,1,...,i+1 if−−→PiA

appears after (respectively before)−−−−→PiPi+1 in ∆.

Definition 3 (The right priority path of a set of paths or binding paths). Let P and Q be twopaths, where P 6= Q and moreover neither is a prefix of the other, and with pos(P0) = pos(Q0)and pos(P1) = pos(Q1). Let i be the smallest index such that i ≥ 0 and Pi 6= Qi. We saythat P is the right priority path of P and Q if either (a) P0,1,...,i is a right turn from Q or (b)pos(Pi) = pos(Qi) and the type of Pi is smaller than the type of Qi in the canonical ordering oftile types.

Similarly, let p and q be two binding paths, where p 6= q and moreover neither is a prefix ofthe other, and with p0 = q0 and p1 = q1. Let i be the smallest index such that i ≥ 0 and pi 6= qi.We say that p is the right priority path of p and q if p0,1,...,i is a right turn from q.

For any finite set S of paths, or of binding paths, we extend this definition as follows: letp0 ∈ Z2, p1 ∈ Z2 be two adjacent positions. If for all s ∈ S, we have s0 = p0 and s1 = p1, we callthe right-priority path of S the path that is the right-priority path of all other paths in S.

For all i ∈ {0, 1, . . . , |P |− 2}, we define glue(PiPi+1) = (g, i), where g is the shared glue typebetween consecutive tiles Pi and Pi+1 on the path P . Similarly, when we say “glue” in the contextof a path P , we mean a pair of the form (glue type, path index). We define type(glue(PiPi+1)) =g to denote the glue type of glue(PiPi+1). The position of the glue glue(PiPi+1) is the midpoint

of the unit-length line segment[

pos(Pi),pos(Pi+1)]

and is written as pos(glue(PiPi+1)). We

9

Page 10: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

say that glue(PiPi+1) is pointing to the north (or points to the north, for short) if−−−−→PiPi+1 =

(

0

1

)

,

pointing to the west if−−−−→PiPi+1 =

(

−1

0

)

, pointing to the south if−−−−→PiPi+1 =

(

0

−1

)

, and pointing to the

east if−−−−→PiPi+1 =

(

1

0

)

.

2.3 Fragile paths

If two paths, or two assemblies, or a path and an assembly, share a common position we saythat they intersect at that position. Furthermore, we say that two paths, or two assemblies, or apath and an assembly, agree on a position if they both place the same tile type at that positionand conflict if they place a different tile type at that position. We say that a path P is fragileto mean that there is a producible assembly α that conflicts with P (intuitively, if we grow αfirst, then there is at least one tile that P cannot place), or more formally:

Definition 4 (Fragile). Let T = (T, σ, 1) be a tile assembly system and P ∈ P[T ]. Wesay that P is fragile if there exists a producible assembly α ∈ A[T ] and a position (x, y) ∈(dom(α) ∩ dom(asm(P ))) such that α((x, y)) 6= asm(P )((x, y)).6

2.4 Pumping a path

Next, for a path P and two indices i, j on P , we define a sequence of points and tile types (notnecessarily a path) called the pumping of P between i and j:

Definition 5 (Pumping of P between i and j). Let T = (T, σ, 1) be a tile assembly system andP ∈ P[T ]. We say that the “pumping of P between i and j” is the sequence q of elements fromZ2 × T defined by:

qk =

{

Pk for 0 ≤ k ≤ i

Pi+1+((k−i−1) mod (j−i)) +⌊

k−i−1j−i

⌋−−→PiPj for i < k,

Intuitively, q is the concatenation of a finite path P0,1,...,i and an infinite periodic sequence oftile types and positions (possibly intersecting σ ∪ P0,1,...,i, and possibly intersecting itself). Weformalise this intuition in Lemma B.2.

The following definition gives the notion of pumpable path used in our proofs. It is followedby a less formal but more intuitive description.

Definition 6 (Pumpable path). Let T = (T, σ, 1) be a tile assembly system. We say that aproducible path P ∈ P[T ], is infinitely pumpable, or simply pumpable, if there are two integersi < j such that the pumping of P between i and j is an infinite producible path, i.e. formally:q ∈ P[T ].

In this case, we say that the pumping vector of q is−−→PiPj , and that P is pumpable with

pumping vector−−→PiPj .

For a path P to be pumpable between i and j implies that Pi+1 +−−→PiPj interacts with Pj .

It also implies that q is self-avoiding and that in particular, for any positive integers s 6= t, the

path Pi+1,...,j + s−−→PiPj does not intersect with the path Pi+1,...,j + t

−−→PiPj . Lemma B.1 shows that

a sufficient condition for this is that Pi+1,...,j does not intersect Pi+1,...,j +−−→PiPj .

6 Here, it might be the case that α and P conflict at only one position by placing two different tile types t andt′, but that t and t′ may place the same glues along P . In this case P is not producible when starting from theassembly α because one of the tiles along the positions of P is of the wrong type.

10

Page 11: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

2.5 2D plane

2.5.1 Column, glue column, row, glue row

When referring to sets of positions, we use the term “the column x” for some fixed x ∈ Z tomean the set {(x, y) | y ∈ Z}, and the term “the row y” for some fixed y ∈ Z to mean the set{(x, y) | x ∈ Z}. The glue column x, for some fixed x ∈ Z, is the set of 2D half-integer positions{(x+0.5, y) | y ∈ Z}. The glue row y, for some fixed y ∈ Z, is the set of 2D half-integer positions{(x, y + 0.5) | x ∈ Z}.

Using the canonical embedding of Z2, the definition of a glue column x can also be definedas the set of edges of the grid graph of Z2 between column x and column x + 1, and the gluerow y is the set of edges of the grid graph of Z2 between row x and row x+1. Which definitionwe use will always be clear from the context.

2.5.2 Curves

A curve c : I → R2 is a function from an interval I ⊂ R to R2, where I is one of a closed, open,or half-open. All the curves in this paper are polygonal, i.e. unions of line segments and rays.

For a finite path P , we call the embedding E[P ] of P the curve defined for all t ∈ [0, |P |−1] ⊂R by:

E[P ](t) = pos(P⌊t⌋) + (t− ⌊t⌋)−−−−−−→P⌊t⌋P⌊t⌋+1

Similarly, for a finite binding path p, the embedding E[p] of p is the curve defined for all t ∈[0, |p| − 1] ⊂ R by:

E[p](t) = p⌊t⌋ + (t− ⌊t⌋)−−−−−−→p⌊t⌋p⌊t⌋+1

The ray of vector −→v from (or, that starts at) point A ∈ R is defined as the curve r : [0,+∞[→R2 such that r(t) = A + t−→v . The vertical ray from a point A to the south (respectively to thenorth) is the ray of vector (0,−1) (respectively (0, 1)) from A, and the horizontal ray from apoint A to the west (respectively to the east) is the ray of vector (−1, 0) (respectively (1, 0))from A.

If C is a curve defined on some real interval of the form [a, b] or ]a, b], and D is a curvedefined on some real interval of the form [c, d] or [c, d[, and moreover C(b) = D(c), then theconcatenation concat(C,D) of C and D is the curve defined on dom(C)∪(dom(D)−(c−b)) by:7

concat(C,D)(t) =

{

C(t) if t ≤ b

D(t+ (c− b)) otherwise

A curve c is said to be simple or self-avoiding if all its points are distinct, i.e. if for allx, y ∈ dom(c), c(x) = c(y) ⇒ x = y.

For a, b ∈ R with a ≤ b, the notation [a, b] denotes a closed real interval, ]a, b[ an open realinterval, and [a, b[ and ]a, b] are open on one end and closed on the other. The reverse c← ofa curve c defined on some interval [a, b] (respectively [a, b[, ]a, b], ]a, b[ ) is the curve defined on[−b,−a] (respectively ]− b,−a], [−b,−a[, ]− b,−a[ ) as c←(t) = c(−t).

If A = (xa, ya) ∈ R2 and B = (xb, yb) ∈ R2, the segment[

A,B]

is defined to be the curve

s : [0, 1] → R2 such that for all t ∈ [0, 1], s(t) = ((1− t)xa + txb, (1− t)ya + tyb). We sometimes

7dom(D) − (c− b) means [b, d− (c− b)] if dom(D) = [c, d], and [b, d− (c− b)[ if dom(D) = [c, d[

11

Page 12: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

abuse notation and write[

A,B]

even if A or B (or both) is a tile, in which case we mean the

position of that tile instead of the tile itself.For a curve c : R → R2 we write c(R) to denote the range of c (whenever we use this notation

the curve c has all of R as its domain). When it is clear from the context, we sometimes writec to mean c(R), for example

For a path or binding path, p0,1,...,k of length ≥ 1, for 0 ≤ i < k the notation mid(pipi+1) de-notes the midpoint of the unit-length line segment E[pi,i+1]. For a path P , we have mid(pipi+1) =pos(glue(PiPi+1)), hence this notation is especially useful for binding paths, since they do nothave glues.

2.5.3 Cutting the plane with curves; left and right turns

In this paper we use finite and infinite polygonal curves to cut the R2 plane into two pieces.The finite polygonal curves we use consist of a finite number of concatenations of vertical andhorizontal segments of length 1 or 0.5. If the curve is simple and closed we may apply the JordanCurve Theorem to cut the plane into connected components.

Theorem 2.2 (Jordan Curve Theorem). Let c be a simple closed curve, then c cuts R2 into twoconnected components.

Here, we have stated the theorem in its general form, although for our results the (easier toprove) polygonal version suffices.

The second kind of curve we use is composed of one or two infinite rays, along with a finitenumber of length 0.5 or length 1 segments. For such infinite polygonal curves we also state andprove a slightly different version of the polygonal Jordan Curve Theorem, as Theorem B.3.

In Section B.1 we define what it means for one curve to turn left or right from another, aswell as left hand side and right hand side of a cut of the real plane.

2.5.4 Visibility

Let P be a path producible by some tile assembly system T = (T, σ, 1), and let i ∈ {0, 1, . . . , |P |−2} be such that glue(PiPi+1) points east or west. We say that glue(PiPi+1) is visible from the

south if and only if the ray ℓi of vector (0,−1) starting at ℓi(0) =(

xPi+xPi+1

2 , yPi

)

does not

intersect E[P ] nor σ.8

We define the terms visible from the east, visible from the west and visible from the northsimilarly.

In many of our proofs, we will use curves, in particular curves that include visibility ray(s),to define connected components. For example, consider the curve e, where we have a pathPi+1,i+2,...,j,j+1 with i < j and two glues glue(PiPi+1) and glue(PjPj+1) which are visible fromthe south with respective visibility rays li and lj:

e = concat(

li←,[

li(0),pos(Pi+1)]

,E[Pi+1,...,j],[

pos(Pj), lj(0)

]

, lj)

The curve e is defined on ]−∞,+∞[ = R.

8For a glue ray (whose range has half-integer x-coordinate), to not intersect σ (whose tiles are on integerpoints), we mean that the glue ray does not intersect any segment between two adjacent tiles of σ (even if theseadjacent tiles do not interact).

12

Page 13: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

We will use the following lemma about visibility, which was stated in [31] (it is the fusion ofLemmas 5.2 and 6.3 in that paper). For the sake of completeness, we prove this result again,with slightly different notation.

Lemma 2.3. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last glue of P is visible from the north. Let i, j ∈ {0, 1, . . . , |P | − 2} be two integers. If bothglue(PiPi+1) and glue(PjPj+1) are visible from the south and glue(PiPi+1) points to the east(respectively to the west), and xPi

< xPj(respectively xPi

> xPj), then i < j and glue(PjPj+1)

points to the east (respectively to the west).

Proof. We first assume that glue(PiPi+1) points to the east and xPi< xPj

: indeed by takingthe vertical symmetric of each tile in T , of σ, and of P , we get the “respective” version of thisstatement, where glue(PiPi+1) points to the west and xPi

> xPj. In particular, this flip about a

vertical line does not change the visibility hypotheses.Let li and lj be the respective visibility rays of glue(PiPi+1) and glue(PjPj+1). Additionally,

let mi and mj be two real numbers such that li(mi) ∈ R2 and lj(mj) ∈ R2 have the samey-coordinate, and are below all the points of σ ∪ asm(P ). Moreover, let ti = i + 0.5 ∈ R,tj = j +0.5 ∈ R and tk = |P | − 1.5 ∈ R, and note that E[P ](ti) = pos(glue(PiPi+1)), E[P ](tj) =pos(glue(PjPj+1)) and E[P ](tk) = pos(glue(P|P |−2P|P |−1)).

Now, assume for the sake of contradiction that i > j, which means that ti > tj. We define

a curve c as the concatenation of li([0,mi]),[

li(mi), lj(mj)

]

, lj([0,mj ])←

and the restriction to

the interval [tj , ti] of E[P ].By the Jordan Curve Theorem (Theorem 2.2), c cuts the plane R2 into two connected

components. Let C be the connected component inside c. We claim that E[P ]([ti, tk]) has atleast one point inside C: indeed, the translation by a distance 0.1 to the east of li, i.e. li+(0.1, 0),which starts at E[P ](ti+0.1), does not intersect E[Pj,j+1,...,i] (by visibility of li), does not intersect

li nor lj, and intersects[

li(mi), lj(mj)

]

exactly once (since xPi< xPj

). Therefore, E[P ](ti+0.1)

is inside C.However, glue(P|P |−2P|P |−1), the last glue of P , is visible from the north, hence cannot be

in C, since there is at least one glue of Pj,j+1,...,i to the north of any glue inside C. Therefore,E[P ]([ti, tk]) starts in C and has at least one point outside C. But E[Pi+1,i+2,...,|P |−1] cannot

cross li nor lj (because of visibility), nor E[P ]([tj , ti]) (because P is simple), nor[

li(mi), lj(mj)

]

(because[

li(mi), lj(mj)

]

is strictly below all points of P ). This is a contradiction, and hence

ti < tj and i < j.Finally, we claim that glue(PjPj+1) points to the east. We first redefine c to be the con-

catenation of lj([0,mj ]),[

lj(mj), li(mi)

]

, li([0,mi])←, and the restriction to interval [ti, tj ] of

E[P ]9. Assume, for the sake of contradiction that glue(PjPj+1) points to the west. This meansthat E[P ](tj + 0.1) is inside C, since by the same argument as above, lj − (0.1, 0) starts atE[P ](tj + 0.1) and intersects c exactly once. But E[P ]([tj , tk]) has at least one point inside Cand ends outside C, yet cannot cross c (for the same reasons as before). This is a contradiction,and hence glue(PjPj+1) points to the east.

We will sometimes use this lemma when the last tile of P is the unique easternmost tile ofσ ∪ asm(P ), in this case the last glue of P is visible from the south and from the north.

9this new definition of c follows the same points as the previous one, but some parts are reversed because nowwe know that i < j.

13

Page 14: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

3 Shield lemma

The goal of this section is to prove Lemma 3.1, which is the main technical tool we prove inthis paper. The following definition is crucial to the lemma statement and defines notation usedthroughout this section. It is illustrated in Figure 3.1.

Definition 7 (A shield (i, j, k) for P ). Let P be a path producible by some tile assembly systemT = (T, σ, 1). We say that the triple (i, j, k) of integers is a shield for P if 0 ≤ i < j ≤ k < |P |−1,and the following three conditions hold:

1. glue(PiPi+1) and glue(PjPj+1) are both of the same type, visible from the south relative toP and pointing east; and

2. glue(PkPk+1) is visible from the north relative to P , for notation let lk be the visibility rayto the north of glue(PkPk+1); and

3. E[Pi,i+1,...,k]∩(lk+−−→PjPi) ⊆ {lk(0)+

−−→PjPi}. In other words, if E[Pi,i+1,...,k] intersects l

k+−−→PjPi

(which may not be the case), there is exactly one intersection, which is at the start-point of

the ray lk +−−→PjPi.

It should be noted that x−−→PiPj

> 0, i.e. the x-component of the vector−−→PiPj is strictly positive,

which follows from i < j together with the contrapositive of Lemma 2.3: indeed, the contrapos-itive of Lemma 2.3, with i and j swapped, is i ≤ j ⇒ xPi

≤ xPj, and since here P is simple, we

also have i < j ⇒ xPi< xPj

). Throughout the paper, li and lj denote the vertical (visibility)rays to the south that start at pos(glue(PiPi+1)) and pos(glue(PjPj+1)), respectively.

Definition 8 (The cut c and workspace C of shield (i, j, k)). Let P be a path producible bysome tile assembly system T = (T, σ, 1), and let (i, j, k) be a shield for P . We say that the cutof the shield (i, j, k) is the curve c defined by:

c = concat(

li←,[

li(0), Pi+1

]

,E[Pi+1,i+2,...,k],[

Pk, lk(0)

]

, lk)

By Claim 3.2 below, c cuts the plane into the two connected components defined in the conclusionof Theorem B.3: the left-hand side and right-hand side of c. The right-hand side of c is theconnected component C that is intuitively to the east of li and lk, and includes c itself. We saythat C is the workspace of shield (i, j, k) (see Figure 3.2 for an example).

Lemma 3.1 (Shield lemma). Let P be a path producible by some tile assembly system T =(T, σ, 1), such that (i, j, k) is a shield for P (see Definition 7). Then P is pumpable with pumping

vector−−→PiPj , or P is fragile.

Moreover, if P is fragile, there is a path Q, entirely contained in the workspace of shield(i, j, k) (see Definition 8), such that P0,1,...,iQ is a producible path and conflicts with Pi+1,i+2,...,k.

We prove Lemma 3.1 in Section 3.3. First, we state a simplifying assumption on P (thatwe show is without loss of generality), then give an intuition for the overall proof strategy.The section then proceeds with a number of technical claims followed by the actual proof ofLemma 3.1. In this section, for the sake of brevity, claims are stated without repeating thehypotheses on P and related notation.

Assumption on P used throughout this section. Observe that if we prove that anyprefix of P is pumpable or fragile, this means that P is also pumpable or fragile. Therefore,

14

Page 15: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Pj

Pi

Pk

ljli

lklk +−−→PjPi

Figure 3.1: A suffix Pi,i+1,...,k+1 of a path P . Tiles Pi, Pj and Pk are shown along with the four rays andthe three glues (at ray starting points) of Hypotheses 1–3 of Definition 7, thus (i, j, k) is a shield for P .The goal of this section is to prove Lemma 3.1 showing that such a path is pumpable or fragile.

without loss of generality, for the remainder of this section (including the proof of Lemma 3.1)we suppose that the last tile of P is Pk+1, i.e. that P = P0,1,...,k+1.

Intuition for the proof of Lemma 3.1. Starting from a producible path P with theproperties described in Definition 7, we define three indices on P (called a “shield”) which inturn are used to define an infinite curve c that partitions R2. Then to build a path R thatstays on the right hand side of c, and that will ultimately allow us to reason about P and showthat P is pumpable or fragile. Since the proof is rather involved, we split it up into parts, eachcontaining one or more Claims:

• Using Definition 7, in Subsection 3.1 we define a bi-infinite curve c using the ray li, thepath Pi+1,i+2,...,k and the ray lk. By Definition 12, and Theorem B.3, c cuts R2 into twopieces: the left-hand and right-hand side of c. In the rest of the proof, we will use theright-hand side C ⊂ R2 of c as a “workspace” where we can edit paths freely (hence thename of that connected component in Definition 8). The intuition is that c “shields ouredits” from σ ∪ asm(P0,1,...,i), which is entirely in the left-hand side of c, and thus preventsσ ∪ asm(P0,1,...,i) from blocking these paths in the workspace C.

• We then reason by induction on the length of P . The initial setup for the inductive argumentis given in Subsection 3.2, and goes as follows (in a number of places we may reach the earlyconclusion that P is fragile, in which case we are done with the entire proof of Lemma 3.1):

– In Subsection 3.2.1, we define a tile Pm0of P called a dominant tile, which means that

Pm0is such that for all integers n ≥ 0, Pm0

+ n−−→PiPj is in C.

– Then, in Subsection 3.2.3, we define a binding path r in Z2 and prove a number of key

properties about about it and it’s translation r +−−→PjPi. We then use r as a sequence of

locations along which we we can either tile a producible path R, or else show that P

is fragile. The path R is built in such a way that both R and R +−−→PjPi are producible

15

Page 16: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

and in C.

– To complete the setup for the inductive argument, in Subsection 3.2.4 we use R and m0

to define the initial inductive indices u0 and v0. To define these indices, we use a rayLm0 that starts from the tile Pm0

and splits the component C into two parts (called C+

and C−), which guarantees that u0 ≤ m0 ≤ v0, which in turn means that the pumping of

P between u0 and v0 is well-defined (i.e. u0 < v0) and has pumping vector−−→PiPj . (note

that the pumping is not a simple path until the last step of the induction, where weeventually find a simple pumping of P ).

The inductive step is then defined in Subsection 3.3, where we show that either P is pumpableor fragile, or else we can use R again, along with inductive indices un, mn, vn, to find newindices un+1, mn+1 and vn+1, but with mn+1 > mn. Since P is of finite length, we willeventually run out of new indices (values for mn+1, in particular), leading to the conclusionthat P is either pumpable or fragile.

3.1 Reasoning about the curve c and the workspace C

Claim 3.2. Let (i, j, k) be a shield for P . The cut of shield (i, j, k), called curve c Definition 8,is simple and cuts the plane R2 into two connected components. Moreover, these two componentsare defined in the conclusion of Theorem B.3.

Proof. We first claim that c is a simple curve. Indeed, E[Pi+1,i+2,...,k] intersects neither li← nor

lk (by visibility of glue(PiPi+1) and glue(PkPk+1), respectively). The half-line li←

(from thesouth) and the ray lk (to the north) do not intersect by Definition 7 and in particular by thevisibility of glue(PiPi+1) and glue(PkPk+1) and since i 6= k. Moreover, the length-1/2 segments[

li(0),pos(Pi+1)]

(that joins the ray li←

to E[Pi+1,i+2,...,k]), and[

pos(Pk), lk(0)

]

(that joins

E[Pi+1,i+2,...,k] to lk) are horizontal, and only intersect E[Pi+1,i+2,...,k] and those rays at theirrespective endpoints. Hence, c is a simple curve. Moreover, c is connected since the endpointsof the five connected curves that define it are equal in the order given.

Hence c satisfies Definition 12. Then, by Theorem B.3, c cuts the plane R2 into the twoconnected components defined in its conclusion.

By definition, dom(σ ∪ asm(P0,1,...,i)) is a subset of Z2. The following claim captures theintuition that allows us to think of C as a “workspace” that is “shielded” from σ∪ asm(P0,1,...,i):

Claim 3.3. Let (i, j, k) be a shield for P and let C be the workspace of shield (i, j, k). Thendom(σ ∪ asm(P0,1,...,i)) is a subset of R2 \ C.

Proof. By the definition of c, since glue(PiPi+1) points east, pos(Pi) is on the left-hand sideof c, hence pos(Pi) is not in C. Moreover, since P is a producible path, σ ∪ asm(P0,1,...,i) is aconnected assembly. We claim that σ ∪ asm(P0,1,...,i) has no tile in C, since otherwise one orboth of (a) E[P0,1,...,i] or (b) some of the tile positions of σ, or glue positions of abutting tiles ofσ, would have to intersect c to reach that tile. If that were the case, the intersection would beon one of the five curves used to define c:

• If E[P0,1,...,i] intersects any of E[Pi+1,i+2,...,k],[

li(0),pos(Pi+1)]

, or[

pos(Pk), lk(0)

]

, this con-

tradicts the fact that P is simple.

• If dom(σ) intersects dom(asm(Pi+1,i+2,...,k)), this contradicts the fact that P is a produciblepath.

16

Page 17: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

C

ljli

lklk +−−→PjPi

Figure 3.2: The path and shield triple (i, j, k) from Figure 3.1, annotated with curve c and component C.The border of the shaded region is the curve c (from Definition 8), and the shaded region itself is thecomponent C (Definition 8).

• If dom(σ ∪ asm(P0,1,...,i)) has a glue positioned on li or lk, this contradicts the fact thatglue(PiPi+1) is visible from the south, and glue(PkPk+1) is visible from the north, relativeto P .

In all cases, we get a contradiction, and hence dom(σ ∪ asm(P0,1,...,i)) is disjoint from C, andthus contained in R2 \ C.

The following claim restates Hypothesis 3 of Definition 7 to be in a form more suited to our

proofs. Specifically, Claim 3.4 states that lk(0) +−−→PjPi is the only position of the ray lk +

−−→PiPj

that may be in C and if this is the case then lk(0) +−−→PjPi is also a point of c.

Claim 3.4. ((lk +−−→PjPi) ∩ C) = ((lk +

−−→PjPi) ∩ c) ⊆ {lk(0) +

−−→PjPi}.

Proof. First, we prove that if there is an intersection between lk+−−→PjPi and the curve c then this

happens only at the point lk(0)+−−→PjPi, by analysing the five curves used to define c (Definition 8):

• since x−−→PjPi

is a non-zero integer then lk +−−→PjPi does not intersect l

k nor[

pos(Pk), lk(0)

]

;

• by Hypothesis 3 of Definition 7, the point lk(0) +−−→PjPi is the only intersection permitted

between the ray lk +−−→PjPi and either of the curves

[

li(0),pos(Pi+1)]

or E[Pi+1,i+2,...,k];

• since li is a ray to the south, if lk +−−→PjPi intersects li then lk +

−−→PjPi also intersects

[

li(0),pos(Pi+1)]

which means, by the previous case, that lk(0) +−−→PjPi = li(0) is the only

permitted intersection between these two rays.

Thus lk(0) +−−→PjPi is the only possible intersection of lk +

−−→PjPi with c, which shows the second

part of our claim, i.e. ((lk +−−→PjPi) ∩ c) ⊆ {lk(0) +

−−→PjPi}.

We now show the first part of our claim, i.e. ((lk +−−→PjPi) ∩ C) = ((lk +

−−→PjPi) ∩ c). First,

since lk is a ray to the north, there exists z ∈ R, z ≥ 0 such that lk(z) is strictly to the north

17

Page 18: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

of all positions of concat(

li←,[

li(0),pos(Pi+1)]

, E[Pi+1,i+2,...,k],[

pos(Pk), lk(0)

])

. Also, since

x−−→PjPi

< 0, the point lk(z) +−−→PjPi is to the west of all positions of lk. Thus, lk(z) +

−−→PjPi is on

the strict left-hand side of c, that is, in R2 \ C.

Therefore, if there were a z′ > 0 such that lk(z′) +−−→PjPi ∈ C (the right hand side of c), and

since {lk(z) +−−→PjPi} is not in the right hand side of c, there would be at least one real number

z′′ ∈ [z′, z[ such that lk(z′′) +−−→PjPi is on c, contradicting the first part of this proof. Therefore,

((lk +−−→PjPi) ∩ C) = ((lk +

−−→PjPi) ∩ c).

3.2 The first dominant tile Pm0and the path R

In this subsection, we define a tile Pm0of P , and a path R, that will be used in the inductive

argument in Section 3.3.

3.2.1 The ray ρ used to define the first dominant tile Pm0

Let ρ be the lowest (southernmost) ray of vector−−→PiPj that starts on li and intersects at least

one tile of Pi+1,i+2,...,k. Such a ray exists because in particular, the ray of vector−−→PiPj starting

on li and going through pos(Pi+1) intersects pos(Pj+1) (these two positions are positions of tilesof Pi+1,i+2,...,k because i < j ≤ k), and since Pi+1,i+2,...,k is of finite length there is one ray thatis the southernmost ray (meaning that out of all such rays, ρ is the ray whose start positionρ(0) is the southernmost on li).

Then, let m0 ∈ {i+1, i+2, . . . , k} be the index such that Pm0is positioned on ρ, and is the

easternmost tile of Pi+1,i+2,...,k that is positioned on ρ. See Figure 3.3 for an example.

C

li

lk

ρ

Pm0

Lm0

Figure 3.3: The ray ρ and tile Pm0. We define ρ as the southernmost ray of vector

−−→PiPj that starts on li

and intersects the position of at least one tile of Pi+1,i+2,...,k. The easternmost such intersection is thendefined to be pos(Pm0

), and Pm0is called the dominant tile.

18

Page 19: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Claim 3.5. m0 > i+ 1.

Proof. By its definition, we know that m0 ≥ i + 1. If we had m0 = i + 1, then Pj+1 would

also be on ρ, and hence since x−−→PiPj

> 0 (i.e.,−−→PiPj has positive x-component, a consequence of

Definition 7 and Lemma 2.3), we would have m0 ≥ j + 1, contradicting the fact that i < j.

Claim 3.6. Let Lm0 be a vertical ray from pos(Pm0) to the south. Then Lm0 only inter-

sects E[Pi+1,i+2,...,k] at pos(Pm0), and for all integers n > 0, Lm0 + n

−−→PiPj does not intersect

E[Pi+1,i+2,...,k].

Proof. Remember that m0 ∈ {i + 1, i + 2, . . . , k}. Thus, by definition of Lm0 , Lm0 intersectsE[Pi+1,i+2,...,k] at pos(Pm0

). If there were another intersection point then that intersection wouldbe strictly lower (strictly to the south) on Lm0 and that intersection would define a ray of vector−−→PiPj that intersects Pi,i+1,...,k strictly lower than ρ thus contradicting the definition of ρ as thelowest such ray. Thus Lm0 only intersects E[Pi+1,i+2,...,k] at pos(Pm0

).For the second conclusion of this lemma, suppose, for the sake of contradiction, that there

is an integer n > 0 such that E[Pi+1,i+2,...,k] and Lm0 + n−−→PiPj intersect. Then that intersection

is either:

• At Lm0(0) +n−−→PiPj. Since n > 0, that intersection is on ρ (since ρ is of vector

−−→PiPj and goes

through pos(Pm0) = Lm0(0) for n = 0) and strictly to the east of Pm0

(because x−−→PiPj

> 0),

contradicting the definition of Pm0as the easternmost tile of P whose position is on ρ.

• Or else strictly lower (more southern) on Lm0 + n−−→PiPj than Lm0(0) + n

−−→PiPj . Since Lm0 +

n−−→PiPj is on a column (vertical line of integer positions), that intersection happens between

Lm0 +n−−→PiPj and a tile of Pi+1,i+2,...,k, which contradicts the definition of ρ as the lowest ray

of vector−−→PiPj through the position of a tile of Pi+1,i+2,...,k.

Claim 3.7. Lm0 is entirely in C.

Proof. By Claim 3.6, Lm0 only intersects Pi+1,i+2,...,k at Lm0(0) = pos(Pm0), which is on the

border c of C since m0 ∈ {i+ 1, i+ 2, . . . , k}. Also, Lm0 does not otherwise intersect c since li

and lk are both on glue columns (half-integer x-coordinate) and Lm0 is on a column (integer x-coordinate). Finally, Lm0 is strictly to the east of li (by definition of ρ), and hence by Definition 8,Lm0 is entirely in C.

Claim 3.8. Recall that Lm0 and lj are vertical rays to the south starting at pos(Pm0) and

pos(glue(PjPj+1)), respectively. If m0 > j, the vertical ray to the south Lm0 is strictly to the

east of the ray lj , and Lm0 +−−→PjPi ∩ E[Pi+1,i+2,...,k] ⊆ {Lm0(0) +

−−→PjPi}.

Proof. The proof has four cases, depending on the glues around Pm0. We show that cases 1 and

2 below cannot occur, and that cases 3 and 4 yield the conclusion of this claim:

1. If glue(Pm0Pm0+1) is pointing south, the ray of vector

−−→PiPj through pos(Pm0+1) is strictly

lower than ρ, contradicting the definition of ρ.

2. If glue(Pm0Pm0+1) is pointing west, then we claim that glue(Pm0

Pm0+1) would be visiblefrom the south relative to P . Indeed, by Claim 3.7, Lm0 ∈ C, and since Lm0 is on a tilecolumn, Lm0 − (0.5, 0) is on a glue column, and at x-coordinate at least xpos(glue(PiPi+1)).

19

Page 20: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

That, together with the fact that Lm0 intersects Pi+1,i+2,...,k only at pos(Pm0), implies that

no glue of P can be positioned on the line defined as Lm0(z) − (0.5, 0) for z > 0, z ∈ R (i.e.on line Lm0 − (0.5, 0) and strictly below glue(Pm0

Pm0+1)). Thus glue(Pm0Pm0+1) is visible

from the south. But, since m0 > j and glue(PjPj+1) points east, glue(Pm0Pm0+1) pointing

west and being visible from the south contradicts Lemma 2.3.

3. If glue(Pm0Pm0+1) is pointing east, then glue(Pm0

Pm0+1) is visible from the south relative toP (by the same argument as in the previous case, with Lm0+(0.5, 0) instead of Lm0−(0.5, 0)).Therefore by Claim 3.5 and Lemma 2.3, Lm0 is strictly to the east of li, and if m0 > j, thenLm0 is strictly to the east of lj too.

Furthermore, if m0 > j and if Lm0 +−−→PjPi intersected E[Pi+1,i+2,...,k] other than at Lm0(0) +

−−→PjPi, we could find a ray of vector

−−→PiPj through a tile of Pi+1,i+2,...,k strictly lower (strictly

to the south) than ρ, which is a contradiction. Hence, if m0 > j, then Lm0 +−−→PjPi does not

intersect E[Pi+1,i+2,...,k] except possibly at Lm0(0) +−−→PjPi.

4. If glue(Pm0Pm0+1) is pointing north, we consider all possibilities for glue(Pm0−1Pm0

):

(a) If glue(Pm0−1Pm0) points north, this contradicts the definition of ρ, since the ray of

vector−−→PiPj going through Pm0−1 is strictly lower than ρ.

(b) If glue(Pm0−1Pm0) points west, then glue(Pm0−1Pm0

) is visible relative to P (by Claim 3.6),and this contradicts Lemma 2.3 since m0 > i.

(c) glue(Pm0−1Pm0) pointing south contradicts P being simple: indeed, this would mean

that pos(Pm0−1) = pos(Pm0+1).

(d) Therefore, glue(Pm0−1Pm0) points east, and is therefore visible from the south rela-

tive to Pi+1,i+2,...,k (by Claim 3.6). By Lemma 2.3, since m0 > i, the visibility ray ofglue(Pm0−1Pm0

) is strictly to the east of li, and hence Lm0 is strictly to the east of li. If

m0 > j, then Lm0 is also strictly to the east of lj , hence Lm0 +−−→PjPi does not intersect

Pi+1,i+2,...,k, except possibly at Lm0(0)+−−→PjPi, by the same argument as in Case 3 above.

3.2.2 Splitting C into two components, C− and C+, using Pm0

By Claim 3.7, Lm0 is entirely in C. Moreover, by Claim 3.6, Lm0 intersects c only at pos(Pm0).

Therefore, we use Lm0 to split C into two components: let cm0 be the curve defined as

cm0 = concat(

Lm0←,E[Pm0 ,m0+1,...,k],[

pos(Pk), lk(0)

]

, lk)

Since cm0 starts and ends with vertical rays, and is otherwise made of a finite concatenation ofhorizontal and vertical segments, cm0 splits R2 into two connected components by Theorem B.3.Moreover, since cm0 is in C (because the four curves that define cm0 are in C), let C+ ⊆ C be theright-hand side of cm0 (including cm0), and let C− = (C \ C+)∪Lm0(R)10. See Figure 3.4 for anillustration.

Moreover, Pi+1,i+2,...,m0is entirely in C− (and on the border of C−, by definition of C) and

Pm0,m0+1,...,k is entirely in C+ (and on the border of C+, by definition of C).

10Recall that Lm0(R) is the set of all points in the range of of Lm0

20

Page 21: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

C−

C+

ljli

lk

ρ

Pm0

Lm0

Figure 3.4: The components C+ and C−. In Subsection 3.2.1, C+ and C− were defined so that C+∪C− = Cand C+ ∩ C− = Lm0 .

Claim 3.9. For any integer n > 0, Lm0 + n−−→PiPj is in C+.

Proof. Let integer n > 0. By Claim 3.6, Lm0+n−−→PiPj does not intersect E[Pi+1,i+2,...,k]. Moreover,

since x−−→PiPj

> 0 we know that Lm0 + n−−→PiPj is strictly to the east of Lm0 , and Lm0 + n

−−→PiPj does

not intersect lk (because Lm0 is on a tile column, and lk on a glue column) nor[

Pk, lk(0)

]

(because that would mean that Lm0 + n−−→PiPj intersects Pk).

Therefore, Lm0 + n−−→PiPj does not intersect the border of C+, and starts to the east of Lm0

(which is on the border of C+). Therefore, Lm0 + n−−→PiPj is entirely in C+.

3.2.3 A path R that can grow in two different translations

The goal of this subsection is to define a path R that can grow in two possible translations

(respectively, R that starts at pos(Pi+1) and R+−−→PiPj that starts at pos(Pj+1)). We proceed in

two steps: the first step is to specify a binding path called r below (from Definition 2, a bindingpath is a simple sequence of adjacent positions in Z2, i.e. a path but without tiles), and thesecond step is to “tile” that binding path to get the path R.

The binding path r. The definition of r is illustrated in Figure 3.5. Let G be the bindinggraph G = (V,E) where:

V = {pos(Pn) | n ∈ {i+ 1, i+ 2, . . . , k}} ∪ {pos(Pn) +−−→PjPi | n ∈ {j + 1, j + 2, . . . , k}}

E = {{pos(Pn),pos(Pn+1)} | n ∈ {i+ 1, i+ 2, . . . , k − 1}}

∪ {{pos(Pn) +−−→PjPi,pos(Pn+1) +

−−→PjPi} | n ∈ {j + 1, j + 2, . . . , k − 1}}

We define the set S of all binding paths in the graphG′ = (V ∪{pos(Pi)}, E∪{pos(Pi),pos(Pi+1)})such that q ∈ S if and only if:

21

Page 22: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

C

ljli

lk

C

ljli

lk

Figure 3.5: Left: Following from Figure 3.2, E[Pi+1,i+2,...,k+1] is shown in brown and E[Pj+1,j+2,...,k+1]+−−→PjPi is shown in green. Right: The route traced by (the embedding of) the binding path r defined inSubsection 3.2.3: red indicates when r takes positions from Pi+1,i+2,...,k only, and brown indicates when

r takes positions from Pj+1,j+2,...,k +−−→PjPi and/or Pi+1,i+2,...,k.

• q starts with q0q1 = pos(Pi)pos(Pi+1) and has its final vertex q|q|−1 being a vertex of G

that is “adjacent” to lk; more precisely there exists z ∈ R, z ≥ 0 such that lk(z) ∈ {q|q|−1 −(0.5, 0), q|q|−1 + (0.5, 0)}; and

• the curve concat([

li(0),pos(Pi+1)]

, E[q1,2,...,q|q|−1],[

q|q|−1, lk(z)

])

is entirely in C.

We now define the set S ⊆ S of all paths q ∈ S such that for all q′ ∈ S that is a strictprefix or a strict extension of q, the last tile of q′ is strictly lower than the last tile of q, i.e.yq′|q′|−1

< yq|q|−1.

Let q′ be the most right priority binding path of S (see Definition 3). We claim that q′ iswell-defined. First, we claim that S is nonempty: indeed, S is nonempty as there is at leastone binding path q that starts with q0q1 = pos(Pi)pos(Pi+1), ends with a vertex adjacent tolk, and stays in C, since pos(Pi,i+1,...,k) satisfies the first and second conditions. Second, eitherP or one of its strict prefixes is in S. Third, since all binding paths q ∈ S have their first twovertices q0q1 = pos(Pi)pos(Pi+1) in common, the right priority path of S is well-defined. Thusq′ is well-defined. Finally, let r = r0,1,...,|r|−1 = q′1,2,...,|q′|−1, i.e. r is the same binding path as q′

but without its the first vertex q′0.Thus, by definition, r is entirely in C. We now go on to prove some properties about r. The

proof of Claim 3.10 is illustrated in Figures 3.6 and 3.7.

Claim 3.10. Let a and b be two integers such that 0 ≤ a < b ≤ |r| − 1. If there are indicesd, e ∈ {i+ 1, i+ 2, . . . , k} such that pos(Pd) = ra and pos(Pe) = rb, then d < e.

Proof. Assume, for the sake of contradiction, that there are two indices d and e such thatpos(Pd) = ra, pos(Pe) = rb and d ≥ e. Because r and P are simple and a 6= b, we also haved > e. Note that e > i + 1 (since r0 = pos(Pi+1), b > a ≥ 0 and r is simple). We assumewithout loss of generality that e is the smallest integer satisfying the hypotheses of this claim.(See Figure 3.6 for an example.)

22

Page 23: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

pos(Pe) = rb

pos(Pd) = ra

li

lk

Figure 3.6: Initial setup for the proof Claim 3.10. We assume, for the sake of contradiction, that thereare two indices a < b such that ra = pos(Pd), rb = pos(Pe), for some d and e such that d > e. Here thebrown path is pos(Pi+1,i+2,...,k+1), and the red path is r.

Let s be the curve defined by:

s = concat(

li←,[

li(0),pos(Pi+1)]

, E[Pi+1,i+2,...,e], E[rb,b+1,...,|r|−1],[

r|r|−1, lk(z)

]

, lkz

)

where lk(z) ∈ R2 is the point of lk at the same y-coordinate as r|r|−1 and lkz is the ray to the north

starting at lk(z). The curve s is entirely in C because the six curves used to define s are in C. Thesix curves used to define s only intersect pairwise at their endpoints meaning that s is simple(in particular by the minimality of e, Pi+1,i+2,...,e−1 does not intersect rb,b+1,...,|r|−1). Therefore,since s starts and ends with vertical rays, and is otherwise made of a finite number of horizontaland vertical segments, s cuts the plane into two connected components, by Theorem B.3. Weclaim that E[Pe,e+1,...,k] does not turn right from s, by looking at each part of s:

• glue(PiPi+1) and glue(PkPk+1) are visible relative to P , hence E[Pe,e+1,...,k] does not intersectli←

nor lk.

• P is simple, hence E[Pe,e+1,...,k] cannot intersect E[Pi+1,i+2,...,e−1].

• If E[Pe,e+1,...,k] turns right from a point of[

li(0),pos(Pi+1)]

, then E[Pe,e+1,...,k] must intersect

Pi or li(0) (or both), which is already covered by the two previous points.

• E[Pe,e+1,...,k] (which is in C) does not turn right from E[rb,b+1,...,|r|−1]. There are two subcases:

– If that right turn happens on a point of r strictly before |r|− 1, then this contradicts thedefinition of r as a most right-priority path.

– Else, that right turn happens at r|r|−1 = pos(Pf ) for some integer f , which meansthat f < k. This means that E[P ] also turns right from the curve defined as ρ =

concat(

li←,[

li(0),pos(r0)]

,E[r],[

r|r|−1, lk(z)

]

, lkz

)

. However, Pk is not in the connected

component on the right-hand side of ρ, since f < k. Therefore, P must intersect ρ, andthat can only happen on r. However, this implies that not all of r is on the same side ofP , contradicting the definition of r as being in C.

23

Page 24: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

s

r0

pos(Pe) = rb

pos(Pd) = ra

li

lk

Figure 3.7: Illustration for the proof of Claim 3.10. pos(Pi+1,i+2,...,k+1) is in brown, r is in red, andwe assume that there are two indices a < b such that ra = pos(Pd) and rb = pos(Pe) and such that(for the sake of contradiction) we have d > e. If we draw rb,b+1,...,|r|−1 after ra,a+1,...,b, then since r issimple, then although r0,1,...,a must enter the grey zone where ra is, any attempt by r0,1,...,a to do soleads it having position(s) outside C (contradicting that E[r] stays in C by definition) or r intersectingitself (contradicting that r is a simple binding path – a situation shown by the dashed curve).

• if E[Pe,e+1,...,k] turns right from a point of[

r|r|−1, lk(z)

]

then this can only occur at one of

the two endpoints of this segment (which is a horizontal line segment of length 0.5) which isalready covered in the first or fourth point above.

This means that E[Pe,e+1,...,k] does not turn right from s, and therefore, ra = pos(Pd) is eitheron s, or in the component of R2 that is on the left-hand side of s.

If ra is on s, then since d > e and P is simple, ra cannot be on Pi+1,i+2,...,e. But ra cannotbe on rb,b+1,...,|r|−1 either, since r is simple and a < b. Therefore, ra is not on s, and sincer0 = pos(Pi+1), this implies that E[r0,1,...,a] turns left from E[s]. The position of that left turnfrom E[s] must be on one of the six curves used to define s (see Figure 3.7 for an example):

• If the left turn is from a point on E[rb,b+1,...,|r|−1], this contradicts that r is simple.

• If the left turn is from a point on li←,[

li(0),pos(Pi+1)]

, E[Pi+1,i+2,...,e],[

r|r|−1, lk(z)

]

or lkz ,

then either we are also in the previous case (i.e. the left turn is on E[rb,b+1,...,|r|−1], or wecontradict the definition of E[r] as being in C.

In all cases, we get a contradiction. Therefore, d < e.

Next we show that if (i, j, j) is a shield for P , then P is pumpable with pumping vector−−→PiPj .

Claim 3.11. Let (i, j, k) be a shield for P (as in Definition 7). If j = k then P is pumpable.

Proof. Since j = k, the ray lk+−−→PjPi = pos(glue(PkPk+1))+

−−→PjPi = pos(glue(PjPj+1))+

−−→PjPi =

pos(glue(PiPi+1)) = li(0), and thus, by Definition 7, glue(PiPi+1) is visible from both thenorth and the south. Moreover, glue(PiPi+1) points east (Definition 7), hence all positions ofσ ∪ asm(P0,1,...,i) are strictly to the west of the vertical line through pos(glue(PiPi+1)).

24

Page 25: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Since j = k, then lj(0) = lk(0) and by Definition 7 glue(PkPk+1) is visible from both thenorth and the south. Moreover, by the visibility of glue(PiPi+1), the path Pi+1,i+2,...,k is entirelypositioned between the two vertical lines that run through glue(PiPi+1) and glue(PkPk+1). Asnoted after Definition 7, x−−→

PiPj= x−−−→

PiPk> 0. Hence, for all n ∈ N, the path Pi+1,i+2,...,k +

(n + 1)−−→PiPj is strictly to the east of Pi+1,i+2,...,k + n

−−→PiPj . Moreover, for all n ∈ N, the pair of

tiles Pk + n−−→PiPj and Pi+1 + (n + 1)

−−→PiPj interact, hence the pumping of P between i and k is

simple and producible (Definition 5). Hence P is a pumpable path (Definition 6) with pumping

vector−−→PiPj.

From now on, we assume that j < k, otherwise P is pumpable by the previous claim. Weuse this to define a second connected component D ⊆ C (see Figure 3.8 for an example), sincej < k makes the following curve simple:

Definition 9. Let d be the curve defined as the concatenation of five curves:

d = concat(

lj←,[

lj(0),pos(Pj+1)]

, E[Pj+1,j+2,...,k],[

pos(Pk), lk(0)

]

, lk)

By a similar argument to Claim 3.2 for curve c (Definition 8), here d is a simple connectedcurve starting with a vertical ray to the south (lj) and ending with a vertical ray to the north(lk). Therefore, by Theorem B.3, d cuts R2 into two infinite connected components. Let D ( R2

be the connected component on the right-hand side of d (intuitively, the component connectedto the east of li and lk), including d itself.

Moreover, since each of the five curves used to define d are in C (Definition 8) we get that dis entirely in C. Hence D is a subset of C.

The following two claims are illustrated in Figure 3.8.

D

E[r] +−−→PiPj

ljli

lk

Figure 3.8: The component D ⊂ R2 (shaded) and the embedded binding path E[r] +−−→PiPj . Claim 3.12

asserts that no tile of σ∪asm(P0,1,...,j) is in D and Claim 3.13 asserts that E[r]+−−→PiPj is entirely contained

in D.

25

Page 26: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Claim 3.12. dom(σ ∪ asm(P0,1,...,j)) ⊂ (R2 \ D).

Proof. Similar argument to Claim 3.3, but respectively substitute j, d,D for i, c, C in the proofof Claim 3.3.

Claim 3.13. E[r] +−−→PiPj is entirely in D.

Proof. Assume otherwise, for the sake of contradiction. Since r0 +−−→PiPj = pos(Pj+1) is on the

border d of D and thus in D, this would mean that E[r]+−−→PiPj turns left from d (see Definition 14

for one curve turning from another). That left turn is on one of the five curves that define d(Definition 9), which we handle in four cases:

1. E[r]+−−→PiPj turns left from d at a position on lj

←: But since glue(PiPi+1) and glue(PjPj+1) are

both visible relative to P , and r is made of positions taken from Pi+1,i+2,...,k and Pj+1,j+2,...,k+−−→PjPi, this implies E[r] does not intersect the visibility ray li of glue(PiPi+1), and hence

E[r] +−−→PiPj does not intersect lj . Thus having the left turn be from lj

←is a contradiction.

2. E[r]+−−→PiPj turns left from d at a position on E[Pj+1,j+2,...,k]. Since this case is rather involved,

we split it into a number of paragraphs, and each paragraph header gives the core argumentbeing proven in the paragraph. We first define the curve ρ as:

ρ = concat(

li,[

li(0), r0

]

,E[r],[

r|r|−1, lkz (0)

]

, lkz

)

where lkz = lk([z,+∞[) is the ray to the north starting at lkz (0) = lk(z) ∈ R2 which is thepoint of lk at the same y-coordinate as r|r|−1.

Setup: Indices a and b such that pos(Pa) = rb+−−→PiPj and E[r0,1,...,b+1]+

−−→PiPj turns left

from d. First, E[r] turns left from d +−−→PjPi at a position on E[Pj+1,j+2,...,k +

−−→PjPi]. The

curve ρ is a simple infinite almost-vertical polygonal curve (Definition 12) – in particular, itis simple because its five component curves intersect each other only at their endpoints inthe order given. Using Definition 13, let R ( R be the right-hand side of ρ, and let R\ ρ(R)denote the strict right-hand side of ρ.Since we are in Case 2, E[r] has a point in the strict left hand side (Definition 13) of

the simple infinite almost-vertical polygonal curve d +−−→PjPi, with the left turn being on

E[Pj+1,j+2,...,k]. Hence, let b ∈ {0, 1, . . . , |r| − 1} be the smallest integer such that there is

an a ∈ {j + 1, j + 2, . . . , k} where rb +−−→PiPj = pos(Pa) and E[r0,1,...,b+1] +

−−→PiPj has a point

on the strict left hand side of curve d. Hence, r0,1,...,b is entirely in the right hand side of

d+−−→PjPi, and the point mid(rbrb+1) is in the strict left hand side of d+

−−→PjPi.

We claim that a < k. Suppose for the sake of contradiction that a = k. Then rb =

pos(Pk) +−−→PjPi. Since E[r] makes a left turn from d +

−−→PjPi at pos(Pk) +

−−→PjPi, and since

E[r0,1,...,b] is on the right hand side of d+−−→PjPi, E[r] makes a left turn from the curve

ρ′ = concat(

li,[

li(0), r0

]

,E[r0,1,...,b],[

pos(Pk) +−−→PjPi, l

k(0) +−−→PjPi

]

, lk +−−→PjPi

)

at the position rb. By the definition of r, we know that rb+1,b+2,...,|r|−1 has its last point

within horizontal distance ±0.5 of the ray lk. But any such position is in the strict right

26

Page 27: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

hand side of ρ′ because: (a) since i < j, lk is at least distance 1 to the east of lk +−−→PjPi, (b)

since i < k (because i < j ≤ k), and by visibility, lk does not intersect li, and (c) E[r] does notintersect lk by definition of r. Hence E[rb+1,b+2,...,|r|−1] intersects ρ′, but that intersectioncan not happen along li (by its definition E[r] does not intersect li) nor along E[r0,1,...,b]

(because r is simple), nor at lk(z) +−−→PjPi for all z ∈ R, z > 0 (because, by Definition 7,

the curves E[Pi+1,i+2,...,k] and E[Pj+1,j+2,...,k] +−−→PjPi from which E[r] is composed do not

touch lk(z) +−−→PjPi), nor

[

pos(Pk) +−−→PjPi, l

k(0) +−−→PjPi

]

because r turns left from d+−−→PjPi at

rb = pos(Pk) +−−→PjPi. Thus we get a contraction. Hence a < k as claimed.

We claim that E[Pj+1,j+2,...,k +−−→PjPi] has a point in R\ρ(R) (the strict right hand side

of ρ). We first treat the case b = 0 as a special case: in this case, rb = r0 = pos(Pj+1)+−−→PjPi

and, by the statement of the case we are in (Case 2), the point mid(Pj+1Pj+2) +−−→PjPi is in

the right hand side of ρ. The point mid(Pj+1Pj+2) +−−→PjPi is not on ρ, because mid(r0r1) 6=

mid(Pj+1Pj+2) +−−→PjPi (because of the turn at r0) and because if it were r would not be

simple (there would be an intersection of r1,2,...,|r|−1 with r0). Hence mid(Pj+1Pj+2) +−−→PjPi

is in the strict right hand side of ρ. Thus if b = 0, we are done with our current argument,

i.e. E[Pj+1,j+2,...,k +−−→PjPi] has a point in R \ ρ(R).

Else b > 0. There are two possibilities for rb−1. First, suppose rb−1 = pos(Pa−1)+−−→PjPi. Since

rb−1,b = pos(Pa−1,a) +−−→PjPi, we get that rb−1,b,b+1 turns left from11 pos(Pa−1,a,a+1 +

−−→PjPi)

and thus the point mid(PaPa+1) +−−→PjPi is in R \ ρ(R) and we are done with our current

argument, i.e. that E[Pj+1,j+2,...,k +−−→PjPi] has a point in R \ ρ(R).

Otherwise, we have rb−1 6= pos(Pa−1) +−−→PjPi, which we split into two cases:

• rb−1 6= pos(Pa+1) +−−→PjPi.

In this case, the four positions around Pa +−−→PjPi = rb are each occupied by one of the

following tiles Pa−1 +−−→PjPi, Pa+1 +

−−→PjPi, rb−1 and rb+1 (since r and P are simple and

by the hypothesis of this case). Consider the enumeration of these four tiles around

Pa +−−→PjPi = rb in clockwise order starting with Pa−1 +

−−→PiPj . By definition of b, rb+1

comes before Pa+1 +−−→PjPi and by minimality of b, rb−1 cannot come before Pa+1 +

−−→PiPj ,

then the four tiles are ordered as follow:

Pa−1 +−−→PjPi, rb+1, Pa+1 +

−−→PjPi, rb−1

which means that Pa−1,a,a+1 +−−→PjPi turns right form r at Pa +

−−→PjPi = rb.

Then, the point mid(PaPa+1)+−−→PjPi is on the strict right hand side of ρ (note in particular

that mid(PaPa+1)+−−→PjPi is not on lkz , for else we would get an extension of r that would

be in S and end higher than r, contradicting the fact that by definition, r ∈ S). Thus

E[Pj+1,j+2,...,k +−−→PjPi] has a point in R \ ρ(R), which is the claim of this paragraph.

• rb−1 = pos(Pa+1) +−−→PjPi. There are two cases:

11We’ve already shown that a < k, hence the tile Pa+1 +−−→PjPi is a tile of Pj+1,j+2,...,k +

−−→PjPi and thus is

well-defined. Also, b > 0 implies a 6= j + 1 which in turn implies a > j + 1, hence Pa−1 +−−→PjPi is a tile of

Pj+1,j+2,...,k +−−→PjPi and thus is well-defined.

27

Page 28: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

∗ b−(k−a) > 0. We claim that pos(Pa,a+1,...,k+−−→PjPi) = rb,b−1,...,b−(k−a) (intuitively, we

are claiming that rb,b−1,...,b−(k−a) tracks “backwards” along pos(Pa,a+1,...,k +−−→PjPi),

without either turning from the other). Since r0,1,...b is on the right hand side of

d+−−→PjPi, E[rb,b−1,...,b−(k−a)] has all its points on the right hand side of d+

−−→PjPi (and

none on the strict left hand side of d+−−→PjPi). Hence if E[rb,b−1,...,b−(k−a)] turns from

d +−−→PjPi, it turns to the right from d +

−−→PjPi (and in particular has points in the

strict right hand side of d+−−→PjPi).

But this means that d +−−→PjPi has points on the strict left hand side of ρ←, or in

other words d +−−→PjPi has points on the strict right hand side of ρ. This yields the

claim of this paragraph.

∗ b−(k−a) ≤ 0. There are two cases, depending on whether or not rb,b−1,...,0 turns from

pos(Pa,a+1,...,k +−−→PjPi). First, if rb,b−1,...,0 turns (right or left) from pos(Pa,a+1,...,k +

−−→PjPi), then by using the same argument as the previous bullet, we get the claim ofthis paragraph.Finally, assume for the sake of contradiction, that rb,b−1,...,0 does not turn from

pos(Pa,a+1,...,k +−−→PjPi). We have r0 = Pm +

−−→PjPi for some m ∈ {a, a + 1, . . . , k}.

Since we are in a case where b > 0, we also get11 that j + 1 < a, hence j + 1 6= m.

But, by the definition of r, r0 = pos(Pj+1) +−−→PjPi, hence j + 1 = m, which is

a contradiction, hence rb,b−1,...,0 must turn from pos(Pa,a+1,...,k +−−→PjPi) we get a

contradiction.

Hence we have proven that E[Pj+1,j+2,...,k +−−→PjPi] has a point in R \ ρ(R).

Pj+1,j+2,...,k +−−→PjPi does not intersect ρ again after entering R \ ρ(R), yielding a

contradiction. We have already proven that E[Pj+1,j+2,...,k +−−→PjPi] has a point in R\ρ(R)

(previous paragraph). Using that fact, let a′ ∈ {j+1, j+2, . . . , k−1}, b′ ∈ {0, 1, . . . , |r|−1} be

so that b′ is the smallest integer such that rb′ = pos(Pa′)+−−→PjPi and pos(Pj+1,j+2,...,a′+1)+

−−→PjPi

turns right from ρ at position rb′ . Hence pos(glue(Pa′Pa′+1) +−−→PjPi) is in R \ ρ(R) (since

E[Pj+1,j+2,...,a′+1] +−−→PjPi cannot intersect with li and lk).

Claim 3.4, states that ((lk +−−→PjPi) ∩ C) = ((lk +

−−→PjPi) ∩ c) ⊆ {lk(0) +

−−→PjPi} which in turn

implies that the point pos(glue(PkPk+1)) +−−→PjPi = lk(0) +

−−→PjPi is not in C \ c, and therefore

not in R \ c (recall that R ⊂ C). Therefore, E[Pa′,a′+1,...,k+1 +−−→PjPi] intersects ρ for some

real number t > 0 at a point Z = E[Pa′,a′+1,...,k +−−→PjPi](t) ∈ R2. 12 We analyse where such

an intersection point Z might occur on ρ:

• Z is not on li nor[

li(0), r0

]

: Since j+1 ≤ a′, the curve E[Pa′,a′+1,...,k] does not intersect

lj by visibility, and thus E[Pa′,a′+1,...,k +−−→PjPi] does not intersect li. Also, Z is not on

[

li(0), r0

]

=[

li(0),pos(Pj+1 +−−→PjPi)

]

, since j + 1 ≤ a′, t > 0 and P is simple.

• If the first such intersection point Z along E[Pa′,a′+1,...,k +−−→PjPi] (i.e., smallest t > 0) is

with lk or[

r|r|−1, lkz (0)

]

, then let r′ = r0,1,...,b′ pos(Pa′+1,a′+2,...,g +−−→PjPi) where the index

12Remember that E[Pa′,a′+1,...,k+1 +−−→PjPi] has domain [0, k + 1− a′].

28

Page 29: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

g ∈ {a′ + 1, a′ + 2, . . . , k} is defined such that[

pos(Pg),pos(Pg+1)]

+−−→PjPi intersects

[

pos(Pk), lk(z)

]

∪ lk.

Then, by the definition of a′ and b′, either r is a prefix of the binding path r′ (if b′ = |r|−1)

or r′ turns right from r at rb′ = pos(Pa′ +−−→PjPi) (if b′ < |r| − 1). In the former case,

this contradicts the definition of r, since then r′ ∈ S and r 6∈ S. In the latter case, thiscontradicts that r is the most right-priority path of S, since r′ ∈ S is more right-priority.

• Else, the first (i.e., smallest t > 0) such intersection point Z along E[Pa′,a′+1,...,k +−−→PjPi]

is on E[r], in other words Pa′+1,a′+2,...,k+−−→PjPi has a position on r. Since pos(Pa′)+

−−→PjPi =

rb′ , we know that Pa′+1,a′+2,...,k +−−→PjPi does not intersect rb′ , and we have two subcases:

– If Pa′+1,a′+2,...,k+−−→PjPi intersects rb′+1,b′+2,...,|r|−1, let g ∈ {a′ + 1, a′ + 2, . . . , k} be the

smallest index such that pos(Pg+−−→PjPi) = rh for some h ∈ {b′ + 1, b′ + 2, . . . , |r| − 1}.

Then r′ = r0,1,...,b′ pos(Pa′+1,a′+2,...,g−1 +−−→PjPi) rh,h+1,...,|r|−1 turns right from r by

definition of a′ and b′.13 This right turn contradicts the definition of r as the mostright-priority binding-graph path that starts at r0, ends adjacent to lk (r|r|−1 is

horizontal distance ±0.5 from lk), and whose embedding stays entirely in C.

– If Pa′+1,a′+2,...,k +−−→PjPi intersects r0,1,...,b′−1, then let g ∈ {a′+1, a′ +2, . . . , k} be the

smallest index such that pos(Pg +−−→PjPi) = rh for some index h ∈ {0, 1, . . . , b′ − 1},

and let r′ = r0,1,...,hpos((Pa′+1,a′+2,...,g−1 +−−→PjPi)

←)rb′,b′+1,...,|r|−1.14 15

Since pos(glue(Pa′Pa′+1) +−−→PjPi) ∈ R \ E[r], then r′ turns right from r. Also, E[r′]

is in R ⊆ C, since E[Pa′+1,a′+2,...,g−1 +−−→PjPi]

←does not intersect E[r] and all other

points of E[r′] are in R since they are taken from E[r] (plus two length 1 line segmentsthat are in R). Moreover, r′ starts and ends at the same positions as r does, whichcontradicts the definition of r as the most right priority such path.

In all cases we contradict the existence of the intersection point Z on ρ, and hence E[r]+−−→PiPj

does not turn left from d at a position on E[Pj+1,j+2,...,k].

3. E[r] +−−→PiPj turns left from d at a position on

[

lj(0),pos(Pj+1)]

: since r is a binding path in

graph G, this can only happen at a tile position, i.e., at pos(Pj+1), and this case was alreadycovered in Case 2.

4. E[r] +−−→PiPj turns left from d at a position on concat

([

pos(Pk), lk(0)

]

, lk)

. If E[r] +−−→PiPj

turns left from d at pos(Pk) this was already covered in Case 2.

By Hypothesis 3 of Definition 7, P may only intersect lk +−−→PjPi at lk(0) +

−−→PjPi, and by

Hypothesis 2 of Definition 7 P may only intersect lk at lk(0). Therefore, P and P +−−→PjPi

13In the special case of g = a′ +1, although pos(Pa′+1,a′+2,...,g−1 +−−→PjPi) is empty, the segment

[

rb′ , rh

]

is not

entirely on E[r] (only its endpoints are). This follows from the fact that b′ < h, i.e., b′ 6= h (due to the existence

of the turn from r at rb′). Moreover,[

rb′ , rh

]

is entirely in R ⊂ C since rb′−1,b′,h is a right turn from r at rb′ .14Here the “reverse arrow” notation applied to a path denotes the path in reverse order, i.e. (Pa′,a′+1,...,g−1)

←+−−→PjPi = Pg−1Pg−2 . . . Pa′+1Pa′ +

−−→PjPi.

15In the special case of g = a′ + 1, although pos((Pa′+1,a′+2,...,g−1 +−−→PjPi)

←) is empty, the segment[

rh, rb

]

is

not entirely on E[r] (although its endpoints are). This follows from the fact that h < b′, i.e., h 6= b′ (due to the

existence of the turn from r at rh). Moreover, the segment[

rh, rb′]

is entirely in R ⊂ C since rh−1,h,b′ is a right

turn from r at rh.

29

Page 30: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

can only intersect lk +−−→PjPi at l

k(0) +−−→PjPi, and E[r] +

−−→PiPj can only intersect lk at lk(0),

thus for all z ∈ R, z > 0 the left turn does not occur at lk(z).

It remains to handle the case of the left turn of E[r]+−−→PiPj from d being along the half-open

segment(

pos(Pk), lk(0)

]

. Since r is a binding path in graph G, an intersection of E[r]+−−→PiPj

and lk(0) = pos(glue(PkPk+1)) can only occur if E[r] +−−→PiPj contains exactly one of the

unit-length horizontal line segments[

pos(Pk+1),pos(Pk)]

or[

pos(Pk),pos(Pk+1)]

. There

are two cases.

• If glue(PkPk+1) points to the east, then[

pos(Pk+1),pos(Pk)]

is not (does not contain)

a left turn from concat([

pos(Pk), lk(0)

]

, lk)

, and[

pos(Pk),pos(Pk+1)]

is a right turn,

from concat([

pos(Pk), lk(0)

]

, lk)

. Thus, in this case we contradict that E[r]+−−→PiPj turns

left from d at a point on concat([

pos(Pk), lk(0)

]

, lk)

.

• Else glue(PkPk+1) points to the west. Since[

pos(Pk+1),pos(Pk)]

is not (does not

contain) a left turn from concat([

pos(Pk), lk(0)

]

, lk)

and since[

pos(Pk),pos(Pk+1)]

is a left turn from concat([

pos(Pk), lk(0)

]

, lk)

, we know that E[r] +−−→PiPj contains

[

pos(Pk),pos(Pk+1)]

. Thus E[r] contains the segment s =[

pos(Pk),pos(Pk+1)]

+−−→PjPi.

The segment s is entirely in C because E[r] is (by definition of r). We also claim thatthe segment s has no points in C \ c: By Claim 3.4, the midpoint of s is not in C \ c,and hence that midpoint is on c. The segment s is not on li nor lk (because E[r] doesnot intersect li nor lk). Hence the midpoint of s is on E[Pi+1,i+2,...,k], a curve whoseunit length horizontal segments start and end at integer coordinates and thus s has allof its points on c. By Claim 3.10, s (a segment of E[r]) and E[Pi+1,...,k] have the samecurve-direction (points along both curves occur in the same order).

We claim that s being a segment of E[Pi+1,i+2,...,k] yields a contradiction: Since s is a

horizontal segment “pointed” to the west, lk+−−→PjPi is a right turn from s. But lk(z)+

−−→PjPi,

for all z ∈ R, z > 0 is on the left hand side of c, and thus lk +−−→PjPi is a left turn from

E[Pi+1,i+2,...,k], yielding the claimed contradiction. Thus E[r] +−−→PiPj does not turn left

from d at a point on concat([

pos(Pk), lk(0)

]

, lk)

.

Each of the four cases contradicts the claim that E[r] +−−→PiPj turns left from d.

The path R. We now define a path R capable of growing in two translations, as stated in thefollowing claim:

Claim 3.14. There is a path R such that all of the following hold:

• P0,1,...,iR is a producible path, and

• P0,1,...,j(R+−−→PiPj) is a producible path, and

• Exactly one of the following is the case:

– pos(R) = r, and R does not conflict with Pi+1,i+2,...,k nor Pj+1,j+2,...,k +−−→PjPi.

30

Page 31: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

– pos(R) is a strict prefix of r and R or R +−−→PiPj (or both) conflict with P , meaning in

particular that P is fragile.

Proof. We first define the length s0 of R. If there is an integer s ∈ {0, 1, . . . , |r| − 1} such that

rs = pos(Pa) = pos(Pb +−−→PjPi) for some a ∈ {i+ 1, i+ 2, . . . , k} and b ∈ {j + 1, j + 2, . . . , k},

and type(Pa) 6= type(Pb), then let s0 be the smallest such s (and note that, in this case s0 is anindex on r and rs0 is the position of the conflict). Else, we simply let s0 = |r|16.

We next define R to be of length s0, and for all s ∈ {0, 1, . . . , s0 − 1}, we define the tile Rs

as follows:

• If there is an index a ∈ {i+ 1, i+ 2, . . . , k} such that rs = pos(Pa) then we let Rs = Pa.

• Else, by definition of r, there is an index a such that rs = pos(Pa) +−−→PjPi. In this case, we

let Rs = Pa +−−→PjPi.

Regardless of whether or not s0 < |r|, we prove the following two claims:

• First, we claim that P0,1,...,iR is a producible path:

– We claim that the glues along R match: indeed, by definition of the graph G in which ris a path, for any a ∈ {0, 1, . . . , |r| − 2}, there is an edge {ra, ra+1} in G. Moreover, since

asm(Pi+1,i+2,...,k) and asm(

Pj+1,j+2,...,k +−−→PjPi

)

agree on all tiles that happen to share

positions of r0,1,...,s0−1 the glues along R match.

– Moreover, we claim that P0,1,...,iR is simple and producible: indeed, by definition of r,and since the positions of R are exactly r (i.e., pos(R) = r), R is entirely in C, and sinceneither σ ∪ asm(P0,1,...,i) has no tile in C (Claim 3.3), σ ∪ P0,1,...,i does not conflict withR. Finally, since Pi and R0 = Pi+1 interact, P0,1,...,iR is a producible path.

• Next, we claim that P0,1,...,j(R+−−→PiPj) is also a producible path. First, we already proved in

the previous bullet that R has matching glues and is simple. By Claim 3.13, R is in D (notethat if D is not correctly defined, i.e. j = k, then P is pumpable by lemma 3.11), and since

σ∪P0,1,...,j is in R2 \D (Claim 3.12), R+−−→PiPj does not intersect σ∪asm(P0,1,...,j). Moreover

this implies that P0,1,...,j(R+−−→PiPj) is simple. Finally, since Pj and R0+

−−→PiPj = Pj+1 interact,

P0,1,...,j(R+−−→PiPj) is producible.

• Finally, R conflicts with neither Pi+1,i+2,...,k and Pj+1,j+2,...,k +−−→PjPi since by the definition

of R the index s0 (the first index of a potential tile conflict along the positions of r) is notan index on R.

Then, there are two cases, depending on whether s0 = |r| or s0 < |r|:

• If s0 = |r|, we are done, since in this case pos(R) = r, and we have already proved the otherthree conclusions of this lemma for the case where we are not showing P to be fragile.

• Else s0 < |r|, and we claim that P is fragile. By the definition of rs we have that Pi+1,i+2,...,k

and Pj+1,j+2,...,k +−−→PjPi have a conflict at position rs0 . There are two cases:

1. rs0−1 = pos(Pa) +−−→PjPi for some a ∈ {j + 1, j + 2, . . . , k} (an example is shown in

Figure 3.9). In this case, we first grow σ ∪ asm(P0,1,...,iR) (we have already proved that

P0,1,...,iR is a producible path). We claim we can producibly place the tile Pa+1 +−−→PjPi:

16Note that, in particular, s0 is not an index on r (nor R) since the maximum index on R is |r| − 1

31

Page 32: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

ljli

lk

Figure 3.9: We are in the case where s0 < |r| and rs0−1 = pos(Pa) +−−→PjPi. To show that P is fragile,

we first produce σ ∪ asm(P0,1,...,i) (not shown), then produce R (red tiles) and then we place the tile

Pa+1 +−−→PjPi (marked ×) at the position rs0 . The path P , shown in brown, can not be grown from this

assembly due to the conflict at ×.

– pos(Pa+1 +−−→PjPi) = rs0 , and thus Pa+1 +

−−→PjPi interacts (has a matching abutting

glue) with Pa +−−→PjPi = R|R|−1 which is at position rs0−1,

– Pa+1 +−−→PjPi conflicts with Pi+1,i+2,...,k and hence does not share any position of a

tile of σ ∪ asm(P0,1,...,i) (since Pi+1,i+2,...,k does not intersect σ ∪ asm(P0,1,...,i) by thedefinition of producible path), and

– since r is simple that position is not occupied by any other tile of R.

By the definition of s0, the tile Pa+1 +−−→PjPi conflicts with Pi+1,i+2,...,k, which shows that

P is fragile.

2. Else, rs0−1 = pos(Pa) for some a ∈ {i+ 1, i+ 2, . . . , k} (an example is shown in Fig-

ure 3.10). We first grow σ ∪ asm(

P0,1,...,j(R+−−→PiPj)

)

(which we have shown is pro-

ducible). We claim we can then producibly place the tile Pa+1 +−−→PiPj :

– pos(Pa+1+−−→PiPj) = rs0+

−−→PiPj and thus Pa+1+

−−→PiPj interacts (has a matching abutting

glue) with Pa +−−→PiPj = R|R|−1 +

−−→PiPj which is at position rs0−1,

– Pa+1 +−−→PiPj conflicts with Pj+1,j+2,...,k and hence does not share any position of a

tile of σ∪asm(P0,1,...,j), (since Pj+1,j+2,...,k does not intersect σ∪asm(P0,1,...,j) by thedefinition of a producible path), and

– since r is simple pos(Pa+1) +−−→PiPj is not occupied by any other tile of R+

−−→PiPj .

By the definition of s0, the tile Pa+1 conflicts with Pj+1,j+2,...,k +−−→PjPi thus Pa+1 +

−−→PiPj

conflicts with Pj+1,j+2,...,k, which shows that P is fragile.

In either Case 1 or 2, P is fragile.

32

Page 33: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

ljli

lk

ljli

lk

Figure 3.10: Left: We are in the case where s0 < |r| and rs0−1 = pos(Pa). Right: We first grow

σ∪asm(P0,1,...,i) (not shown), then we grow asm(

Pi+1,i+2,...,j(R+−−→PiPj)

)

(red tiles), and then Pa+1+−−→PiPj

(marked with a ×). Pj+1,j+2,...,k is shown in brown and can not grow from this assembly due to theconflict at ×.

3.2.4 Using m0 and R to define u0 and v0

Using the index m0 from Subsection 3.2.1, and the path R from Subsection 3.2.3 we prove thefollowing claim (illustrated with an example in Figure 3.11):

Claim 3.15. If |R| = |r| (i.e. if R does not conflict with Pi,i+1,...,k nor with Pj,j+1,...,k +−−→PiPj),

there are two indices u0 and v0 satisfying all of the following conditions:

1. i+ 1 ≤ u0 ≤ m0 ≤ v0, and

2. Pu0= Pv0 +

−−→PjPi, and

3. Pu0,u0+1,...,m0+

−−→PiPj is entirely in C+, and

4. (Pu0,u0+1,...,m0+

−−→PiPj) ∩ Pi+1,i+2,...,k = {Pv0}.

Proof. We first claim that Pm0is a tile of R, and moreover that E[R] ∩ Lm0 = {Lm0(0)} =

{pos(Pm0)}. By definition of R, R0 = Pi+1, and since li is strictly to the west of Lm0 (by

Claim 3.8 and since x−−→PiPj

> 0 meaning li is to the west of lj), since m0 > i+1 (Claim 3.5), and

by the definition of C+ (Subsection 3.2.2), pos(Pi+1) 6∈ C+. By definition of r, pos(R|R|−1) ∈ C.We also claim that pos(R|R|−1) ∈ C+. Indeed, assume for the sake of contradiction that

pos(R|R|−1) ∈ C−. However, lk is in C+, and pos(R|R|−1) is at a horizontal distance 0.5 to the

east or to the west of lk and is in C (by definition of r). Then the horizontal segment fromR|R|−1 to lk crosses Lm0 , and since Lm0 is on a tile column, the only position where that canhappen is at R|R|−1, contradicting our assumption. Therefore, R|R|−1 ∈ C+.

Now, since E[R] is entirely in C (by definition of r) and has a position in C− and an-other one in C+, R intersects the border of C+. Moreover, that intersection happens on Lm0

since Lm0 partitions C into C− and C+ (Subsection 3.2.2). However, since R is composed only

of segments of Pi+1,i+2,...,k and Pj+1,j+2,...,k +−−→PjPi, E[R] cannot intersect Lm0 strictly below

Lm0(0) = pos(Pm0), because by Claim 3.6, E[Pi+1,i+2,...,k] can only intersect Lm0 at Lm0(0), and

E[Pj+1,j+2,...,k +−−→PjPi] does not intersect Lm0 (because by Claim 3.6, E[Pi+1,i+2,...,k] does not

intersect Lm0 +−−→PiPj). Therefore, R intersects Lm0 at position Lm0(0), and hence Pm0

is also atile of R. Let b ∈ {0, 1, . . . , |R| − 1} be the index such that Rb = Pm0

.

33

Page 34: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

We now define the index v0 to be used in the statement of this claim: let a ∈ {0, 1, . . . , b−1} be

the largest index such that there is an index v0 ∈ {i+ 1, i+ 2, . . . , k} such that Ra+−−→PiPj = Pv0 .

Indices a and v0 exist because with a = 0 and v0 = j+1, we have R0+−−→PiPj = Pi+1+

−−→PiPj = Pj+1

(this equality holds by the definition of R at the beginning of the proof of Claim 3.14, and by thefinal conclusion of Claim 3.14 which states that there are no conflicts between R and Pi+1,i+2,...,k,

and no conflicts between R and Pj+1,j+2,...,k +−−→PjPi).

Next, we define the index u0 to be used in the statement of this claim: Ra+1,a+2,...,b +−−→PiPj

does not intersect Pi+1,i+2,...,k (by definition of a and b), therefore Ra+1,a+2,...,b does not intersect

Pj+1,j+2,...,k+−−→PjPi either. Hence, Ra+1,a+2,...,b is a segment of P (because R is only composed of

segments of Pi+1,i+2,...,k and segments of Pj+1,j+2,...,k +−−→PjPi), and moreover Ra is both a tile of

Pi+1,i+2,...,k and a tile of Pj+1,j+2,...,k +−−→PjPi. We then define u0 ∈ {i+ 1, i+ 2, . . . , k} to be the

index such that Ra = Pu0. By Claim 3.10, since a < b and Rb = Pm0

, this means that u0 < m0,and we get Conclusion 2.

C+

Ra,a+1,...,b +−−→PiPj

Pv0Pu0

ljli

lk

Lm0

Figure 3.11: Definition of u0 and v0. The path Ra,a+1,...,b +−−→PiPj is shown in red and shares its start

position pos(Ra) with the tile Pv0 . Also, in the example, it can be seen that pos(Pu0) = pos(Ra). In the

proof of Claim 3.15 we find that Ra,a+1,...,b = Pu0,u0+1,...,m0, and we go on to show that u0 ≤ m0 ≤ v0,

Pu0= Pv0 +

−−→PjPi, and Pu0,u0+1,...,m0

+−−→PiPj is in C+.

Then, we claim that v0 ≥ m0 and that Ra,a+1,...,b +−−→PiPj = Pu0,u0+1,...,m0

+−−→PiPj is in C+.

There are two cases:

• If m0 > j, Lm0 is entirely in D, since Lm0 is then a right turn from curve d. Therefore,

C+ ⊆ D. By Claim 3.6, Pm0+

−−→PiPj is in C+. Moreover, by Claim 3.8, Lm0 +

−−→PjPi does

not intersect Pi+1,i+2,...,k, except possibly at Lm0(0) +−−→PjPi, hence Lm0 does not intersect

Pu0,u0+1,...,m0+

−−→PiPj , except possibly at Lm0(0) = pos(Pm0

) (and in this case, pos(Pm0) =

pos(Pu0) +

−−→PiPj and m0 = v0). Thus, Pu0,u0+1,...,m0

+−−→PiPj does not turn left from Lm0 .

Therefore, since by Claim 3.13, Ra,a+1,...,b+−−→PiPj is entirely in D, then Pu0,u0+1,...,m0

+−−→PiPj is

entirely in D. Then, Pu0,u0+1,...,m0+−−→PiPj does not turn left from E[Pm0,m0+1,...,k] or from lk.

This implies that Pu0,u0+1,...,m0+−−→PiPj is inside C

+ and that Pv0 is a tile of Pm0,m0+1,...,k (which

34

Page 35: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

is the only part of P on the border of C+), and hence that v0 ≥ m0, showing Conclusions 1and 3. Since v0 was chosen as a largest index, we also get Conclusion 4.

• If m0 ≤ j, then D ⊆ C+. Similarly as the previous case, by Claim 3.13, Pu0,u0+1,...,m0+−−→PiPj

is inside D ⊂ C+, hence we have Conclusion 3. In particular, pos(Pu0+

−−→PiPj) = pos(Pv0)

is in D. Since the only part of Pi+1,i+2,...,k that is in D is Pj+1,j+2,...,k, this means thatv0 ≥ j + 1 > m0 showing Conclusion 1. Since v0 was chosen as a largest index, we also getConclusion 4.

3.3 Proof of Lemma 3.1

We restate Lemma 3.1 and give its proof.

Lemma 3.1. Let P be a path producible by some tile assembly system T = (T, σ, 1), such that

(i, j, k) is a shield for P (see Definition 7). Then P is pumpable with pumping vector−−→PiPj , or

P is fragile.Moreover, if P is fragile, there is a path Q, entirely contained in the workspace of shield

(i, j, k) (see Definition 8), such that P0,1,...,iQ is a producible path and conflicts with Pi+1,i+2,...,k.

Proof. As noted at the beginning of Section 3, without loss of generality, we suppose that thelast tile of P is Pk+1, i.e. that P = P0,1,...,k+1. We prove this lemma by induction on a triple(un,mn, vn) of indices of P and a curve fn.

We first apply Claim 3.14 to P and shield (i, j, k). If |R| < |r|, this yields the conclusionthat P is fragile, with a path that satisfies the conclusion of this lemma and we are done withthe proof. Otherwise, we assume until the end of this proof that |R| = |r|, and R conflicts with

neither Pi+1,i+2,...,k nor with Pj+1,j+2,...,k +−−→PjPi.

Induction hypothesis. The induction hypothesis is that for all natural numbers n ≥ 0,the following four conditions are satisfied (we recall some notation: i, j, k, lk were defined inDefinition 7 and li, lj immediately after it; c and C were defined in Definition 8; Pm0

, Lm0 wereintroduced in Subsection 3.2):

H1 fn is a simple curve, and is the concatenation of: (a) Lm0←+sn−−→PiPj for some natural number

sn ≥ 0, and (b) a curve that is the concatenation of embeddings of translations of segments17

of Pi+1,i+2,...,k and that connects Lm0(0) + sn−−→PiPj to pos(Pmn).

H2 fn is entirely in C and intersects c exactly once, at the endpoint pos(Pmn) of fn.

H3 for all integers u > 0, fn + u−−→PiPj intersects neither fn nor c.

H4 un ≤ mn ≤ vn and E[Pun,un+1,...,mn ] +−−→PiPj intersects c exactly once, at pos(Pun) +

−−→PiPj =

pos(Pvn), and intersects gn only at that position, where gn is the curve defined by:

gn = concat(

fn,E[Pmn ,mn+1,...,k],[

Pk, lk(0)

]

, lk)

Special case. Sometimes, we need to consider some cases where H1, H2, H3 and un ≤ mn ≤

vn hold, but where vn = k, Pun +−−→PiPj = Pk and pos(Pun+1

) +−−→PiPj = pos(Pk+1) (which can

17We are intentionally not fully describing where these segments appear on P ; that is one of the goals of theremainder of the proof.

35

Page 36: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

occur only if glue(PkPk+1) points to the east) and in this case, Pun,un+1,...,mn +−−→PiPj intersects c

only at[

Pk, lk(0)

]

. We now prove that P is pumpable in such a case by considering the curve:

ρ = concat(

fn, E[Pun+1,un+2,...,mn ]←,

[

Pun+1, lk(0) +

−−→PjPi

]

, lk +−−→PiPj

)

By Theorem B.3, ρ partitions the plane R2 into two connected components. Note that for all

t ≥ 0, ρ+ t−−→PiPj does not intersect ρ+(t+1)

−−→PiPj . Moreover, since lk does not intersect ρ then lk

is in the right hand-side of this curve (and then in particular lk(0) and Pk). Thus Pun+1,un+2,...,vn

is in the right-hand side of ρ. Now note that for all t > 0, the right-hand side of ρ + t−−→PiPj

is included into C and σ ∪ P has no tile in the right-hand side of ρ + t−−→PiPj . In particular,

for t = 1 this means that Pun+1,un+2,...,vn is in the strict left-hand side of ρ +−−→PiPj . Thus for

all t, Pun+1,un+2,...,vn + t−−→PiPj is in the right hand-side of ρ and in the strict left-hand side of

ρ+ (t+1)−−→PiPj. Since Pvn + t

−−→PiPj and P

un+1+(t+1)−−→PiPj

interact, this means that P is pumpable.

Initialisation (n = 0). We initialise the induction by applying Claim 3.15 to P to geti + 1 ≤ u0 ≤ m0 ≤ v0, and by letting f0 = Lm0←. We show that the induction hypothesis isindeed satisfied for (u0,m0, v0) and f0.

H1 f0 is indeed equal to Lm0← (i.e. s0 = 0) concatenated with a zero length segment ofPi+1,i+2,...,k (i.e. pos(Pm0

)), and f0 ends at pos(Pm0).

H2 By Claim 3.7, f0 is indeed entirely in C. By Claim 3.6 and the fact that Lm0 is on a columnand li, lk are on glue columns, f0 intersects c exactly once, at pos(Pm0

) (which is on c sincei+ 1 ≤ m0 ≤ k).

H3 Let u > 0 be an integer. Since x−−→PiPj

> 0, f0 + u−−→PiPj = Lm0 + u

−−→PiPj does not intersect

f0 = Lm0←. Claim 3.6 shows that Lm0 + u−−→PiPj does not intersect E[Pi+1,i+2,...,k], and since

Lm0 + u−−→PiPj does not intersect lk nor li (because Lm0 + u

−−→PiPj is on a tile column, and lk,

li are on glue columns) we get that Lm0← + u−−→PiPj does not intersect c.

H4 By Claim 3.15, u0 ≤ m0 ≤ v0 and Pu0,u0+1,...,m0+

−−→PiPj intersects P exactly once, at Pu0

+−−→PiPj = Pv0 . Since m0 ≤ v0 ≤ k, Pu0,u0+1,...,m0

+−−→PiPj intersects c and g0 at pos(Pv0).

We claim that this is the only intersection between Pu0,u0+1,...,m0+

−−→PiPj and g0: indeed, by

Hypothesis 3 of Definition 7, Pu0,u0+1,...,m0+−−→PiPj cannot intersect l

k or[

Pk, lk(0)

]

(or we are

in the special case where P is pumpable). Moreover, by definition of Lm0 , Pu0,u0+1,...,m0+−−→PiPj

can only intersect f0 = Lm0 at position pos(Pm0), and by the previous argument, this can

only happen if m0 = v0.

Therefore, there is exactly one intersection between g0 and Pu0,u0+1,...,m0+

−−→PiPj, and that

intersection is at pos(Pv0).

Finally, by Claim 3.15, Pu0,u0+1,...,m0+−−→PiPj is entirely in C+. Therefore, Pu0,u0+1,...,m0

+−−→PiPj

cannot intersect li either, which shows that the only intersection between Pu0,u0+1,...,m0+−−→PiPj

and c is at position pos(Pv0).

Restricting C. We start by defining a connected component Hn ⊂ C, so that at least one

translation of Pun,un+1,...,mn by a multiple of−−→PiPj must intersect the border of Hn. Let hn be

36

Page 37: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

C

unvn

mn

ℓk

fn

Figure 3.12: Definition of un ≤ mn ≤ vn. We have Pun= Pvn +

−−→PjPi. The curve fn ends in mn which is

the only intersection between fn and c.

the curve defined as:

hn = concat(

fn +−−→PiPj , E[Pun,un+1,...,mn ]

← +−−→PiPj , E[Pvn,vn+1,...,k],

[

Pk, lk(0)

]

, lk)

The endpoints of the successive parts of that concatenation are equal. Moreover, by H1, fnis a curve, hence hn is also a curve. We now claim that hn is simple, by considering each ofits parts in the order of the concatenation, and checking each time that that part does not

intersect the remaining parts. First, by H2, concat(

fn +−−→PiPj ,E[Pun,un+1,...,mn ]

← +−−→PiPj

)

=

concat(fn,E[Pun,un+1,...,mn ]←) +

−−→PiPj is a simple curve. Moreover, by H3, fn +

−−→PiPj does not

intersect c, hence intersects neither E[Pvn,vn+1,...,k],[

Pk, lk(0),

]

nor lk. And finally, by H4, the

only intersection between E[Pun,un+1,...,mn ] +−−→PiPj and c is at pos(Pun) +

−−→PiPj = pos(Pvn).

Finally, since c is a simple curve (by Claim 3.2), so is concat(

E[Pvn,vn+1,...,k],[

Pk, lk(0)

]

, lk)

,

and therefore, hn is simple.

Also, we claim that hn is entirely in C. Indeed, E[Pvn,vn+1,...,k],[

Pk, lk(0)

]

, lk are on c, the

border of C. Moreover, since fn is in C (H2), and fn +−−→PiPj is to the east of of fn and does not

intersect c (H3), we get that fn +−−→PiPj is in C. Finally, fn(0) +

−−→PiPj = pos(Pmn) +

−−→PiPj (H2)

is in C and since the only intersection between E[Pun,un+1,...,mn ]←+

−−→PiPj and c is pos(Pun)+

−−→PiPj

(H4), we get that E[Pun,un+1,...,mn ]← +

−−→PiPj is in C.

Since hn is a simple curve, entirely in C, that begins and ends with a vertical ray, hn partitionsC into two connected components. Let Hn be the connected component on the right-hand side

37

Page 38: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Hn

unvn

mn

ℓk

fn +−−→PiPj

Figure 3.13: The component Hn, whose border hn is defined as the concatenation of fn +−−→PiPj ,

Pun,un+1,...,mn+−−→PiPj , Pvn,vn+1,...,k and lk (and a half-length segment between Pk and lk(0)).

of hn, including hn itself, as shown in Figure 3.13.

Finding mn+1 and fn+1. Let a ∈ {un, un + 1, . . . ,mn} and t ≥ 1 be the two integerssuch that (a, t) is the largest pair (ordered first by largest a, then by largest t) such that

pos(Pa) + t−−→PiPj = pos(Pmn+1

) for some integer mn+1 ∈ {i+ 1, i+ 2, . . . , k}. These indices exist

because by H4, with a = un, mn+1 = vn and t = 1, we have pos(Pun) +−−→PiPj = pos(Pvn).

Using a and t, we set fn+1 = concat(fn,E[Pa,a+1,...,mn ]←) + t

−−→PiPj (see Figure 3.14).

We claim that for all s > 1, Pa,a+1,...,mn + s−−→PiPj is entirely in Hn. Suppose for the

sake of contradiction that this is not the case, and let s > 1 be the smallest integer such that

Pa,a+1,...,mn + s−−→PiPj is not entirely in Hn.

We first claim that fn + s−−→PiPj is entirely in Hn. Indeed, by H3, for all u ≥ 1, fn + u

−−→PiPj

intersects neither fn nor c. Therefore, since s ≥ 2, fn + s−−→PiPj intersects neither fn +

−−→PiPj nor

c +−−→PiPj nor c, and therefore doesn’t intersect hn (since hn is entirely composed of parts of

fn +−−→PiPj , c +

−−→PiPj and c). By H1, the beginning of fn is Lm0 + sn

−−→PiPj for sn ≥ 0, and hence

the beginning of fn + s−−→PiPj is Lm0 + (sn + s)

−−→PiPj , which starts on the right-hand side of hn

(because x−−→PiPj

> 0), and doesn’t intersect hn. Hence, fn + s−−→PiPj is entirely in Hn, as claimed.

Then, we claim that Pa,a+1,...,mn+s−−→PiPj intersects hn. Indeed, since fn+s

−−→PiPj is in Hn, then

fn(0)+s−−→PiPj = pos(Pmn)+s

−−→PiPj is also in Hn. Therefore, since we assumed Pa,a+1,...,mn+s

−−→PiPj

38

Page 39: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Hn

unvn

mn

mn+1

a

ℓk

fn fn +−−→PiPj fn+1

Figure 3.14: Finding mn+1 and fn+1: we let (a, t) be the largest pair of integers such that pos(Pa) +

t−−→PiPj = pos(Pmn+1

) for some integer mn+1 ∈ {i + 1, i + 2, . . . , k}, and let fn+1 be equal to fn + t−−→PiPj ,

plus Pa,a+1,...,mn+ t

−−→PiPj . Here, t = 2 and a = un + 3.

is not completely in Hn, this means that E[Pa,a+1,...,mn + s−−→PiPj ] intersects hn. That intersection

can only happen on one of the five parts of hn:

1. if Pa,a+1,...,mn +s−−→PiPj intersects l

k at some lk(z) with z ≥ 0 then we claim that Pa,a+1,...,mn +

(s−1)−−→PiPj is in Hn: if s = 2, this is because Pa,a+1,...,mn +

−−→PiPj is actually part of the border

hn of Hn, else, s > 2, and this is because s is minimal.

Moreover, by maximality of a, Pa+1+(s−1)−−→PiPj is not on Pvn,vn+1,...,k. Therefore, l

k(z)+−−→PjPi

is inside Hn and is not on E[Pvn,vn+1,...,k]. Since Hn ⊂ C and since the only part of P that is

in Hn is E[Pvn,vn+1,...,k], this means that lk(z)+−−→PjPi is inside C and is not on E[Pi+1,i+2,...,k].

This contradicts Claim 3.4.

2. If E[Pa,a+1,...,mn + s−−→PiPj ]

←intersects Pvn,vn+1,...,k, then Pa+1,a+2,...,mn + s

−−→PiPj intersects

Pvn,vn+1,...,k (because pos(Pmn) + s−−→PiPj = fn(0) + s

−−→PiPj is in Hn). However, this con-

tradicts the definition of a as the largest integer such that pos(Pa)+ t−−→PiPj = pos(Pmn+1

) forsome mn+1.

3. If Pa,a+1,...,mn + s−−→PiPj intersects fn +

−−→PiPj then Pa,a+1,...,mn + (s− 1)

−−→PiPj intersects fn. We

have argued in Point 1 that Pa,a+1,...,mn + (s − 1)−−→PiPj is entirely in Hn. However, the only

point of fn that can be in Hn is fn(0) = pos(Pmn), which happens only when mn = vn.

If s = 2, this means that Pa,a+1,...,mn +−−→PiPj intersects fn, but the only place where that

can happen is at pos(Pa) = fn(0), which means that a = un. However, by maximality of a,

this means that for all t > 1, Pa+1,a+2,...,mn + t−−→PiPj does not intersect hn, contradicting our

39

Page 40: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

assumption.

If s = 3, Pa,a+1,...,mn + (s − 2)−−→PiPj intersects Pun , which is not in Hn, contradicting that

Pa,a+1,...,mn +−−→PiPj is on the border hn of Hn.

Else, s > 3, and Pa,a+1,...,mn + (s− 2)−−→PiPj intersects Pun , which is not in Hn, contradicting

the minimality of s.

4. If Pa,a+1,...,mn+s−−→PiPj intersects Pun,un+1,...,vn+

−−→PiPj then Pa,a+1,...,mn+(s−1)

−−→PiPj intersects

Pun,un+1,...,mn .

However, by minimality of s, Pa,a+1,...,mn + (s − 1)−−→PiPj is in Hn, and the only position of

Pun,un+1,...,mn that may be in Hn is pos(Pmn) = fn(0). Therefore Pmn + s−−→PiPj intersects

fn(0) +−−→PiPj = pos(Pmn) +

−−→PiPj , and this case is already covered in Point 3 above.

This shows that for all s > 1, Pa,a+1,...,mn + s−−→PiPj is entirely in Hn as claimed.

Now, remember that pos(Pmn+1) = pos(Pa) + t

−−→PiPj. This means that Pmn+1

is in Hn.However, the only part of P that is inside Hn is Pvn,vn+1,...,k, hence mn+1 ≥ vn ≥ mn.

Satisfying the induction hypotheses for step n+1. Our final step is to prove that eitherP is pumpable, or we can find two indices un+1 and vn+1 (we have already specified the indexmn+1 and the curve fn+1) to move on to the next step of the induction. There are two cases:

A If mn+1 = mn then we claim that P is pumpable.

Since Pa,a+1,...,mn + t−−→PiPj is in Hn, pos(Pa + t

−−→PiPj) = pos(Pmn+1

) = pos(Pmn) is in Hn.However, by definition ofHn, the only position of Pmn,mn+1,...,vn inHn is Pvn , hencemn = vn.In this case, Pun,un+1,...,vn = Pun,un+1,...,mn and the only position of Pun,un+1,...,vn that is in

Hn is pos(Pvn). Moreover, E[Pun,un+1,...,vn ] +−−→PiPj is on the border of Hn, which implies

that the only intersection between Pun,un+1,...,vn and Pun,un+1,...,vn +−−→PiPj is pos(Pvn) =

pos(Pun) +−−→PiPj . By Lemma B.1, this means that for all s > 2, Pun,un+1,...,vn + s

−−→PiPj does

not intersect Pun,un+1,...,vn . Therefore, t = 1 and a = un.

By definition of a, we have for all s ≥ 1, Pun,un+1,...,vn + s−−→PiPj is in Hn ⊂ C, this means that

the pumping of P between un and vn is simple (since σ ∪ asm(P0,1,...,i) is not in C and byLemma B.1), and hence that P is pumpable, and we are done: indeed, that is one of theconclusions of this lemma.

B Else mn+1 > mn. We already defined fn+1 = concat(fn,E[Pa,a+1,...,mn ]←) + t

−−→PiPj . We let

sn+1 = sn + t. We will define un+1 and vn+1, and prove that the induction hypothesis holdsfor (un+1,mn+1, vn+1) and fn+1:

H1 fn+1 = concat(fn,E[Pa,a+1,...,mn ]←) + t

−−→PiPj is indeed the concatenation of fn + t

−−→PiPj

and a finite curve made of the concatenation of embeddings of translations of segmentsof Pi+1,i+2,...,k (we have merely added the reverse of one such segment). Since pos(Pa) +

t−−→PiPj = pos(Pmn+1

) we get that fn+1 connects Lm0(0)+ sn+1−−→PiPj to pos(Pmn+1

). More-over, by H2 the only intersection between fn and E[Pa,a+1,...,mn ] is pos(Pm) and thusfn+1 is simple.

H2 fn+1 is entirely in Hn ⊂ C and intersects c exactly once at pos(Pmn+1): indeed, fn+t

−−→PiPj

is in C and does not intersect c at all by H3, and E[Pa,a+1,...,mn+1] + t

−−→PiPj starts at

fn+1(0) ∈ C, and intersects c exactly once by definition of a.

H3 We claim that for all u > 0, fn+1 + u−−→PiPj does not intersect c: indeed, by H3, fn + (t+

40

Page 41: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

u)−−→PiPj does not intersect c. Moreover, since t is maximal, then Pa,a+1,...,mn +(t+u)

−−→PiPj

does not intersect c. Moreover, we show that fn+1 + u−−→PiPj does not intersect fn+1, by

considering the two parts of fn+1 + u−−→PiPj , namely fn + (t + u)

−−→PiPj and Pa,a+1,...,mn +

(t+ u)−−→PiPj :

• By H3, fn+(t+u)−−→PiPj intersects neither fn+ t

−−→PiPj nor E[Pa,a+1,...,mn ]+

−−→PiPj (which

is a segment of c+−−→PiPj), nor c.

• We claim now that E[Pa,a+1,...,mn ] + (t + u)−−→PiPj does not intersect E[Pa,a+1,...,mn ] +

t−−→PiPj , or equivalently, that E[Pa,a+1,...,mn ] + u

−−→PiPj does not intersect E[Pa,a+1,...,mn ].

We showed above that E[Pa,a+1,...,mn ] + u−−→PiPj is in Hn. However, the only point of

E[Pa,a+1,...,mn ] that may be in Hn if Pmn , which happens if and only if vn = mn.

Moreover, if u > 1, then E[Pa,a+1,...,mn ] + (u − 1)−−→PiPj intersects Pun , which is not

in Hn, and this is a contradiction. Therefore, if u = 1, we also have a = un andmn = mn+1, which was already handled in Case A.

Finally, if E[Pa,a+1,...,mn ]+(t+u)−−→PiPj intersects fn+t

−−→PiPj , then E[Pa,a+1,...,mn ]+u

−−→PiPj

intersects fn. Therefore, by H4, mn = vn and a = un, which means that mn+1 = mn,and this was already handled in Case A.

Therefore, fn+1 + u−−→PiPj does not intersect fn+1.

H4 We first define the curve gn+1 = concat(

fn+1,E[Pmn+1,mn+1+1,...,k],[

pos(Pk), lk(0)

]

, lk)

.

Rd,d+1,...,b +−−→PiPj

vn+1un+1unvn

mn

mn+1

fn gn+1 fn+1 +−−→PiPj

Figure 3.15: Finally, we find un+1 and vn+1 by translating fn+1 by−−→PiPj , and looking at the first

intersection between Pi,i+1,...,mn+1+

−−→PiPj and P . In order to find such an intersection, we define the

infinite curve gn+1, which cuts R2 into two connected components by Theorem B.3.

To conclude, we proceed as in Section 3.2.4 by using R to find un+1 and vn+1. The path Rstarts on the left-hand side of gn+1 (at pos(Pi+1), which is not on fn+1 since by Claim 3.5m0 > i + 1) and ends on the right-hand side of gn+1 or on gn+1 (at a position within

41

Page 42: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

horizontal distance 0.5 of lk, and possibly at pos(Pk)). Therefore, R must intersect gn+1.

Now, fn+1 only intersects Pi+1,i+2,...,k at pos(Pmn+1), and fn+1+

−−→PiPj does not intersect

c (by H3), and hence does not intersect Pi+1,i+2,...,k. Therefore, fn+1 does not intersect

Pj+1,j+2,...,k +−−→PjPi. Therefore, R intersects Pmn+1

. Let b be the integer such that

Rb = Pmn+1, and let d ≤ b be the largest integer such that Rd +

−−→PiPj is on Pi+1,i+2,...,k

(at least i+ 1 ≤ b has that property, hence d is well-defined).Since d is maximal, Rd,d+1,...,b is a segment of P . Let un+1 be such that Rd = Pun+1

.

Since d ≤ b, by Claim 3.10, un+1 ≤ mn+1. Let vn+1 be such that Rd +−−→PiPj = Pvn+1

.These tiles have the same type by Claim 3.14.

We claim that vn+1 ≥ mn+1. By Hypothesis 3 of Definition 7, E[Pun+1,un+1+1,...,mn+1+

−−→PiPj ]

can only intersect lk at pos(glue(PkPk+1)), and can only intersect[

Pk, lk(0)

]

at pos(Pk),

in which case k = vn+1. Moreover, we have already argued that E[Pun+1,un+1+1,...,mn+1+−−→PiPj ]

can only intersect fn+1 at pos(Pmn+1) (only in the case where mn+1 = vn+1). Therefore,

E[Pun+1,un+1+1,...,mn+1+

−−→PiPj ] intersects gn exactly once, at pos(Pvn+1

) (or we are in thespecial case where P is pumpable).

Finally, since E[Pun+1,un+1+1,...,mn+1+

−−→PiPj ] starts on the right-hand side of gn+1, and

intersects gn+1 only at pos(Pun+1) +

−−→PiPj , E[Pun+1,un+1+1,...,mn+1

+−−→PiPj ] is entirely on

the right-hand side of gn+1, which means that vn+1 ≥ mn+1.

Conclusion of the inductive argument. Since for all n ≥ 0, mn+1 > mn, and since Pis of finite length (|P | = k + 2) we eventually run out of indices along P . This implies that atsome point end up in Case A above, where mn+1 = mn, which implies that P is pumpable with

pumping vector−−→PiPj . This completes the proof of Lemma 3.1.

4 Proof of main theorem

4.1 Intuition and roadmap for the proof of Theorem 1.1

To prove Theorem 1.1, we need to find three indices i, j, k ∈ {0, 1, . . . , |P | − 1} of P that satisfythe hypotheses of the Shield Lemma (Lemma 3.1, Definition 7) on P , the conclusion of whichis that P is pumpable or fragile. Throughout the proof we apply the Shield Lemma in severaldifferent ways. We proceed in three steps:

1. First, in the proof of Theorem 1.1, we make some trivial modifications to P (a rotation andtranslation of our frame of reference, and a truncation) so that P is in a canonical formwhere, intuitively, it reaches far to the east (P ’s final tile is to the east of the seed σ). Wethen invoke Theorem 4.6, the combinatorial-based proof of which goes through the followingsteps.

2. In Lemma 4.3, we use Lemma 4.2 to show that either P is pumpable or fragile (in turn, byapplying Lemma 3.1), or else that at most |T |+1 glues of P that are visible from the southor from the north can be pointing west (the remaining ≥ (4|T |)(4|T |+1)(4|σ| + 6)− |T | − |σ|glues visible from the south are pointing east).

3. Then, using the notion of spans (Definitions 10 and 11, intuition in Figure 4.1) we show(Lemma 4.5) that if we find two spans S = (s, n) and S′ = (s′, n′) of the same orientationand type, and such that s < s′ and the height of S′ is at least the height of S, then we can

42

Page 43: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

σ

Ps

Pn

Pn′

Ps′

Pn′′

Ps′′

Figure 4.1: The seed is in blue, and P is in brown. Three example spans are shown in this figure,S = (s, n), S′ = (s′, n′) and S′′ = (s′′, n′′). A span (s, n) is a pair of indices such that glue(PsPs+1) isvisible from the south, glue(PnPn+1) is visible from the north, and glue(PsPs+1) and glue(PnPn+1) areon the same glue column. Here, both S and S′ have both of their glues pointing east, hence we say thatthe span is pointing east. Moreover, since s < n and s′ < n′, S and S′ are “up spans”. On the otherhand, S′′ has its south glue pointing east, and its north glue pointing west, hence S′′ is not pointingin any particular direction. Moreover, n′′ < s′′, hence S′′ is a “down span”. Span S has height 6, andspans S′ and S′′ have height 8. If the spans (s, n) and (s′, n′) happen to be of the same type (meaningtype(glue(PsPs+1)) = type(glue(Ps′Ps′+1))), since the height of S′ is at least the height of S, we couldapply Lemma 3.1 directly to prove that P is pumpable or fragile.

apply Lemma 3.1 to P , proving that P is pumpable or fragile.

4. Finally, the proof of Theorem 4.6 uses a combinatorial argument, showing that if the pathis long enough, there are enough spans that we can always find two spans of the same typeand orientation, and of increasing height.

4.2 First step: Putting P into a canonical form

We first restate Theorem 1.1, the short proof of which merely contains some initial setup toput P in a canonical form and finishes by invoking Theorem 4.6, where the main heavy liftinghappens.

Theorem 1.1. Let T = (T, σ, 1) be any tile assembly system in the abstract Tile AssemblyModel (aTAM), and let P be a path producible by T . If P has vertical height or horizontalwidth at least (8|T |)4|T |+1(5|σ| + 6), then P is pumpable or fragile.

Proof. Since the vertical height or horizontal width of P is strictly greater than |σ| (the numberof tiles in σ) for all |T | ≥ 1, we know that P extends beyond the bounding box of σ.

Let B be a square in Z2 (its four sides are parallel to the x and y axes) whose center is at theorigin, and where each side is distance (4|T |)(4|T |+1)(4|σ|+6)+ |σ| from the origin. Without lossof generality, we translate P ∪σ so that pos(P0) = (0, 0) ∈ Z2. Then we let b ∈ {0, 1, . . . , |P |−1}be the smallest index so that tile Pb is positioned on B. Note that b is correctly defined sinceeither the width or height of P (which is at least (8|T |)(4|T |+1)(5|σ| + 6)) is greater than thelength of the side of B (which is less than (8|T |)(4|T |+1)(4|σ|+ 6) + 2|σ|+ 1)). From now on we

redefine P to be its own prefix up to Pb, i.e., Pdef

= P0,1,...,b (since proving the theorem conclusionon any prefix of P implies that conclusion also holds for P ).

43

Page 44: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Without loss of generality, we assume that the last tile Pb = P|P |−1 of P is the uniqueeasternmost tile of P ∪ σ (if it is not, we simply rotate all tiles of T , and the seed assembly σ,to make it so – thus redefining P again). Note that, pos(P0) is still (0, 0) after this rotation.Uniqueness follows from the fact that σ does not reach to B for all |T | ≥ 1, and that we assumedthat P places exactly one tile on B.

Finally, we also assume, without loss of generality, that the westernmost tile of σ∪asm(P ) isat x-coordinate 0 and that the southernmost tile of σ∪asm(P ) is at y-coordinate 0 (we translateP ∪ σ if this is not the case – thus redefining P again). Since we have pos(P0) = (0, 0) beforethe translation, then σ∪P is translated to the east. Moreover, since P0 and the seed interactedthen the last tile of P is at least (4|T |)(4|T |+1)(4|σ|+ 6) to the east of the easternmost tile of σ.

P now satisfies the hypotheses of Theorem 4.6, thus P is pumpable or fragile.

4.3 Second step: P has many visible glues pointing east, or else is pumpableor fragile

For the remainder of this section, we define X ∈ Z to be the x-coordinate of the easternmostglue column, i.e. X is the largest integer such that P has a glue with x-coordinate X + 0.5.Recall (Section 2.2) that for a tile Pi, its x-coordinate is denoted xPi

.We will need the following lemma, which uses a similar proof technique as Lemma 2.3:

Lemma 4.1. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last tile of P is the unique easternmost tile of σ ∪ asm(P ). Either (a) all glues visible fromthe north relative to P point to the east or (b) all glues visible from the south relative to P pointto the east.

Proof. Suppose, for the sake of contradiction, that for some integer i, glue(PiPi+1) is visiblefrom the south relative to P and points west, and for some integer j, glue(PjPj+1) is visiblefrom the north relative to P and points west.

Assume without loss of generality that i < j, and let li and lj be the respective visibilityrays of glue(PiPi+1) and glue(PjPj+1). We define a curve c as

c = concat(

li←,[

li(0), Pi+1

]

,E[Pi+1,i+2,...,j ],[

Pj , lj(0)

]

, lj)

By Theorem B.3, c cuts R2 into two connected components. Observe that the last tile of P ison the right-hand side of c, yet Pj+1 is on the left-hand side of c. Therefore, E[Pj+1,j+2,...,|P |−1]must intersect c. However:

• That intersection is not be on li←

or on lj, by visibility of glue(PiPi+1) and glue(PjPj+1).

• That intersection is not be on E[Pi+1,i+2,...,j], because P is simple.

• That intersection is not be on[

li(0), Pi+1

]

nor[

Pj , lj(0)

]

, since P can only intersect these

segments at the endpoints of these segments, and we have already handled this case.

Therefore, we get a contradiction, hence either all glues visible from the north relative to Ppoint to the east, or all glues visible from the south relative to P point to the east.

Lemma 4.2. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last tile of P is the unique easternmost tile of P ∪ σ. If more than |T | + 1 glues of P arevisible from the south and are pointing to the west then P is fragile or pumpable.

44

Page 45: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Proof. We claim that the hypotheses of Definition 7 are satisfied, and establishing that claimwill in turn allow us to apply Lemma 3.1. Since there are |T | + 1 glues visible from the southrelative to P and pointing west, then by the pigeonhole principle, there are two indices i < jsuch that glue(PiPi+1) and glue(PjPj+1) are visible from the south, pointing west and of thesame glue type. Since the last tile P|P |−1 of P is the unique easternmost tile of P ∪ σ, then for

k = |P | − 2, glue(PkPk+1) is visible from the north relative to P . Hence, let lk be the visibilityray of glue(PkPk+1) (this means that lk is the vertical ray from glue(PkPk+1) to the north). By

Lemma 2.3, we have xPi> xPj

. Therefore, lk +−−→PjPi is strictly to the east of lk, and hence does

not intersect P .We claim that the three hypotheses of Definition 7 are satisfied by the horizontal mirror

flip of T and of P : In the mirror-flip of P we (still) have 0 ≤ i < j < k < |P | − 1, alsoglue(PiPi+1) and glue(PjPj+1) are visible to the south (with respect to the mirror-flip of P ∪σ),point to the east, and are of the same type (Hypothesis 1); glue(PkPk+1) is visible to the north

(Hypothesis 2); and E[Pi,i+1,...,k] ∩ (lk +−−→PjPi) = ∅ (Hypothesis 3). Thus for the mirror-flip

of P and of T , the mirror-flip of P is pumpable or fragile, hence P is pumpable or fragile asclaimed.

4.4 Third step: repeated spans imply P is pumpable or fragile

We need two key definitions that are illustrated in Figure 4.1.

Definition 10 (span). Let P be a path producible by some tile assembly system T = (T, σ, 1),whose last glue is the unique easternmost (respectively highest) glue of P ∪ σ. A span (respec-tively horizontal span) of P is a pair (s, n) ∈ {0, 1, . . . , |P | − 2}2 of indices of tiles of P suchthat, at the same time:

• xglue(PnPn+1) = xglue(PsPs+1) (respectively yglue(PnPn+1) = yglue(PsPs+1)), and

• glue(PnPn+1) is visible from the north (respectively from the east), and

• glue(PsPs+1) is visible from the south (respectively from the west).

Remark on Definition 10: Notice that P has exactly one span on each glue column that doesnot have seed glues18 and on which P has at least one glue. Hence in the rest of the proof wewill use terms such as “the span of P on glue column x”.

The following properties of spans will be useful.

Definition 11 (span properties: orientation, pointing direction, type and height). The orien-tation of a span (respectively of a horizontal span) (s, n) is up (respectively right) if s ≤ n19 ordown (respectively left) if s > n.

A span (respectively horizontal span) (s, n) points east (respectively points north) if bothglue(PsPs+1) and glue(PnPn+1) point east (respectively point north), and that (s, n) points west(respectively points south) if both glue(PsPs+1) and glue(PnPn+1) point west (respectively pointsouth)20.

The type of a span or horizontal span (s, n) is the type of its first glue in the growth orderof P , i.e. the type of glue(PsPs+1) if s ≤ n and the type of glue(PnPn+1) otherwise.

18Seed glues are glues that are located on tiles belonging to the seed σ. Thus, in particular, the ≥ 1 glue(s) onσ that are abutting to tile P0 of P are seed glues.

19In the case where s = n, P has only one glue on the glue column of glue(PsPs+1), and (s, n) is an up span.20If glue(PsPs+1) and glue(PnPn+1) point to different direction, the span has no direction.

45

Page 46: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

The height (respectively width) of a span (respectively horizontal span) (s, n) is yPn − yPs

(respectively xPn − xPs).

Lemma 4.3. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last tile of P is the unique easternmost tile of σ ∪ asm(P ). Either P is pumpable or fragileor else there is a glue column x0 ≤ |T |+ |σ| such that for all x ∈ {x0, x0 + 1, . . . ,X}, the spanof P on glue column x is pointing east.

Proof. First, by Lemma 4.1, we can assume without loss of generality (by vertical mirror-flip)that all glues visible from the north relative to P are pointing east.

Then, since P|P |−1 is the unique easternmost tile of P , glue(P|P |−2P|P |−1) is pointing eastand visible both from the south and from the north. Therefore, the span of P on glue columnX is pointing east. Let x0 ∈ Z be the westernmost glue column on which the glue visible fromthe south relative to P is pointing east. By Lemma 2.3, for all x ∈ {x0, x0 +1, . . . ,X}, the gluevisible from the south relative to P on column x is also pointing east. If x0 > |T | + |σ| thenthere are at least |T | + |σ| + 1 columns on which either P has no visible glue (meaning that σhas glues on these columns), or on which the glue visible from the south relative to P is pointingwest. Since the size of the seed is |σ|, this means that at least |T |+1 glues visible from the southrelative to P are pointing west, and we can conclude using Lemma 4.2 that P is pumpable orfragile.

In all other cases, the span of P on glue column x is pointing east.

In the final theorem, we need the following corollary of Lemma 4.3, whose statement is abouthorizontal spans instead of spans. The corollary statement is simply a rotation of the statementof Lemma 4.3 along with Y substituted for X in the latter, hence the proof is immediate.

Corollary 4.4. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last tile of P is the unique northernmost (respectively southernmost) tile of σ ∪ asm(P ), letY be the largest integer such that P or σ has a glue on glue row Y +0.5 and let y be the smallestinteger such that P or σ has a glue on glue row y + 0.5. Either P is pumpable or fragile orelse there is a glue row y0 ≤ y + |T | + |σ| (respectively y0 ≥ Y − |T | − |σ|) such that for allz ∈ {y0, y0 + 1, . . . , Y } (respectively z ∈ {y, y + 1, . . . , y0}), the horizontal span of P on glue rowz is pointing north (respectively south).

The following simple but powerful lemma shows how to exploit spans in order to applyLemma 3.1:

Lemma 4.5. Let P be a path producible by some tile assembly system T = (T, σ, 1) such thatthe last tile of P is the unique easternmost tile of P ∪ σ. If there are two spans S = (s, n) andS′ = (s′, n′) on P , both pointing east, of the same orientation and type, and such that xPs < xPs′

and the height of S′ is at least the height of S, then P is pumpable or fragile.

Proof. Without loss of generality, since S and S′ have the same orientation, we assume that Sand S′ both have the “up” orientation (i.e. s ≤ n and s′ ≤ n′). We claim that we can applyLemma 3.1 by setting i = s, j = s′ and k = n′.

Indeed, both glue(PsPs+1) and glue(Ps′Ps′+1) are visible from the south and pointing east.Since S and S′ are of the same type, glue(PsPs+1) and glue(Ps′Ps′+1) are also of the same type.Moreover, since xPs < xPs′

, applying Lemma 2.3 shows that i < j. By definition of a span,glue(Pn′Pn′+1) is visible from the north, and since S′ has the up orientation, s′ < n′, hencej ≤ k.

46

Page 47: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

Finally, let ln′be the visibility ray from glue(Pn′Pn′+1) to the north. Note that pos(glue(Ps′Ps′+1))+

−−−→Ps′Ps = pos(glue(PsPs+1)), and since the height of S is smaller than or equal to the height of

S′, E[P ] may only intersect ln′+−−−→Ps′Ps at l

n′(0)+−−−→Ps′Ps, which on the same column, and at least

as high as glue(PnPn+1).21

We can therefore conclude by applying Lemma 3.1 which shows that P is pumpable orfragile.

4.5 Fourth step: proof of the main theorem

Theorem 4.6. Let P be a path producible by some tile assembly system T = (T, σ, 1) where thefinal tile P|P |−1 is the easternmost one and it is positioned at distance at least (4|T |)(4|T |+1)(4|σ|+6) to the east of the easternmost tile of σ. Then P is pumpable or fragile.

Proof. We first apply Lemma 4.3, yielding one of two possible conclusions: (1) either P ispumpable or fragile, in which case we are done, or (2) there is an integer x0 ≤ |T | + |σ| suchthat for all x ∈ {x0, x0 + 1, . . . ,X}, the span of P on glue column x is pointing east.

Let x0 < x1 < . . . < xn be the sequence of glue columns such that, both of the followinghold:

• for all a 6= b, the spans of P on glue columns xa and xb have different orientations or differenttypes (or both); and

• for all x ∈ {x0, x0 +1, . . . ,X}, there is an integer a ∈ {0, 1, . . . , n} such that xa ≤ x and thespans of P on glue columns xa and x have the same orientation and the same type.

In other words, the sequence x0, x1, . . . , xn is the sequence of the first occurrences, in in-creasing x-coordinate order, of each span type and orientation. That sequence has at least oneelement (x0), and since that sequence contains at most one occurrence of each span type andorientation, n < 2|T |.22 Moreover, as a consequence of our use of Lemma 4.3 in the beginningof this proof, all the spans of P on glue columns x0, x1, . . . , xn point east.

We extend the sequence by one point, by letting xn+1 = X (i.e. we add the easternmostpossible span), and for all i ∈ {0, 1, . . . , n}, we let hi be the height of the span of P on gluecolumn xi.

Intuitively, we consider a “cone” from σ to the east (see Figure 4.2), and consider two cases,depending on whether all spans are within the cone. The only difference with an actual geometriccone is that the y-coordinate of spans might not be aligned.

There are two cases:

1. If there is an integer c ∈ {0, 1, . . . , n+ 1} such that hc > 4|T |2(xc + 4|σ|+ 6), then we claimthat P is pumpable or fragile.Indeed, without loss of generality, we assume that the span (sc, nc) of P on glue column xchas the “up” orientation (i.e. sc ≤ nc). Let X ′ be the easternmost glue column reached byQ = P0,1,...,nc+1. See Figure 4.3. There are two subcases, depending on the relative sizes ofhc and X ′:

(a) If hc < 4|T |(X ′ + 2) + 3|σ| + 1, we first claim that X ′ > |T |(xc + 3) + |σ| + 1. SeeFigure 4.4.

21S and S′ have the same height if and only if ln′

(0) +−−−→Ps′Ps = pos(glue(PnPn+1))

22There are 2 orientations, and ≤ |T | glue types that appear as the east glue of some tile in T , and the indexingup to n begins at 0.

47

Page 48: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

σ

x1

h1

x0

h0

Figure 4.2: P is drawn schematically in brown. This proof has two cases: if the height of the spansare increasing no more than proportionally to their x-coordinate, which we represent by a cone here(even though the spans are not actually in a cone, since the spans might not be vertically aligned), weare in Case 2. Else, if we can find at least one c such that hc gets out of the cone, i.e. such thathc > 4|T |2(xc + 4|σ|+ 6), we are in Case 1.

Indeed, we have hc > 4|T |2(xc + 4|σ|+ 6), and hence:

4|T |(X ′ + 2) + 3|σ| + 1 > 4|T |2(xc + 4|σ| + 6)

X ′ >4|T |2(xc + 4|σ| + 6)− 3|σ| − 1

4|T |− 2

X ′ >4|T |2(xc + 3)

4|T |+

4|T |2(4|σ| + 3)− 3|σ| − 1− 8|T |

4|T |

X ′ > |T |(xc + 3) + |σ|16|T |2 − 3

4|T |+

12|T |2 − 1− 8|T |

4|T |

Finally, since |T | ≥ 1, 16|T |2−34|T | ≥ 3, and 12|T |2−1−8|T |

4|T | ≥ 3|T |−22 − 1

4|T | ≥12 − 1

4 ≥ 0, and

therefore (ignoring the last term, and since |σ| ≥ 1):

X ′ > |T |(xc + 3) + 3|σ| ≥ |T |(xc + 3) + |σ|+ 2

thus proving the claim that X ′ > |T |(xc + 3) + |σ|+ 1.Let k = nc and lk be the ray from glue(PkPk+1) to the north. By Lemma 2.3, we have s0 ≤sc, and since span (sc, nc) has the “up” orientation then s0 ≤ nc. Then glue(Qs0Qs0+1) isvisible from the south relative to Q, and pointing east, hence by Lemma 2.3, all the gluesvisible from the south relative to Q and to the east of glue(Ps0Ps0+1) also point east. Andsince X ′ ≥ |T |(xc+3)+|σ|+1, there are at least X ′−x0 ≥ X ′−(|T |+|σ|) ≥ |T |(xc+2)+1of them.By the pigeonhole principle, at least xc+2 of these glues share the same type. Let i ∈ Nbe the index on Q of the westernmost of these glues, and let j be the index on Q of theeasternmost one. By Lemma 2.3, this means that i ≤ j.

Moreover,−−→PjPi is at least xc+1 columns wide (and

−−→PjPi is to the west), since there are at

least xc+1 glue columns between glue(PiPi+1) and glue(PjPj+1). Therefore, lk+

−−→PjPi is

48

Page 49: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

σ

xc

hc

P

X ′

Figure 4.3: P is drawn schematically in brown. In Case 1, at least one span, at column xc, gets out ofthe cone, i.e. is of height hc > 4|T |2(xc + 4|σ| + 6). We define X ′, the rightmost column reached byP0,1,...,nc

, and split this case into two Cases, 1a and 1b, depending on the relative values of hc and X ′.

to the west of xc+0.5− (xc+1) ≤ −0.5, and hence cannot intersect P (since we assumedin the beginning of this section that the westernmost tile of P ∪ σ has x-coordinate 0).We can therefore apply Lemma 3.1, using (i, j, k), as a shield, to P thus proving that Pis pumpable or fragile.

(b) Else, hc ≥ 4|T |(X ′ + 2) + 3|σ|+ 1. See Figure 4.5.

Therefore, there is a tile of Q at least⌈

hc−|σ|2

≥ 2|T |(X ′ + 2) + |σ| + 1 to the north of

all the tiles of σ, or to the south of all the tiles of σ.If the highest tile of Q is at least 2|T |(X ′ + 2) + |σ| + 1 rows to the north (respectivelyto the south) of all the tiles of σ, then let Q′ be the shortest prefix of Q whose highesttile is 2|T |(X ′ + 2) + |σ|+ 1 rows to the north (respectively to the south) of all the tilesof σ.By Corollary 4.4, either Q is pumpable or fragile or at least 2|T |(X ′+1) horizontal spansof Q point north (respectively south), and by the pigeonhole principle, at least X ′+1 ofthese spans have the same orientation and type. Since the width of all these horizontalspans is bounded by X ′ (because X ′ is by definition the easternmost column reached byQ), at least two of them have the same width, and hence by Lemma 4.5, Q is fragile orpumpable, and so is P (because Q is a prefix of P ).

2. Otherwise, hc ≤ 4|T |2(xi + 4|σ| + 6) for all c ∈ {0, 1, . . . , n}, i.e. intuitively, just like inFigure 4.2, all the spans are inside the “cone”.We first claim that at least one of the xc (for c ∈ {0, 1, . . . , n+ 1}) must be “large enough”,specifically we claim there is an xc > x0 +

∑c−1d=0 hd. Indeed, suppose, for the sake of

contradiction, that for all c ∈ {0, 1, . . . , n + 1}, xc ≤ x0 +∑c−1

d=0 hd. We prove that the

49

Page 50: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

σ

xc

hc

Pnc

X ′

x0

h0

Figure 4.4: P is drawn schematically in brown. In Case 1a, X ′ is large enough that we can find two gluespans between x0 and X ′ that have the same type and orientation, and are at least xc columns apart.We can therefore apply Lemma 3.1 by letting i and j be the indices of the south glues of these spans onP , and letting k be the index of Pnc

.

following inequality holds by induction on c ∈ {0, 1, . . . , n+ 1}:

x0 +

c−1∑

d=0

hd ≤ (4|T |)2c+1(4|σ| + 6)− 2

First, the induction hypothesis holds for c = 0, since x0+∑c−1

d=0 hd = x0 ≤ 4|T |(4|σ|+6)−2.Then, if the induction hypothesis holds for any c ∈ {0, 1, . . . , n}, i.e. if xc ≤ x0+

∑c−1d=0 hd ≤

(4|T |)2c+1(4|σ| + 6)− 2, then:

hc ≤ 4|T |2(xc + 4|σ|+ 6)

x0 +

c−1∑

d=0

hd + hc ≤ (4|T |)2c+1(4|σ| + 6)− 2 + 4|T |2(xc + 4|σ| + 6)

≤ (4|T |)2c+1(4|σ| + 6) + 4|T |2xc + 4|T |2(4|σ|+ 6)− 2

≤ (4|T |)2c+1(4|σ| + 6) + 4|T |2(4|T |)2c+1(4|σ| + 6) + 4|T |2(4|σ| + 6)− 2

≤ ((4|T |)2c+1 + 4|T |2(4|T |)2c+1 + 4|T |2)(4|σ| + 6)− 2

≤ (4|T |)2c+1

(

1 + 4|T |2 +4|T |2

(4|T |)2c+1

)

(4|σ| + 6)− 2

≤ (4|T |)2c+1(4|T |2 + |T |+ 1)(4|σ| + 6)− 2

≤ (4|T |)2c+1(16|T |2)(4|σ| + 6)− 2

≤ (4|T |)2c+3(4|σ| + 6)− 2

This proves the induction hypothesis for c + 1, and hence by induction, the induction hy-pothesis holds for all c ∈ {0, 1, . . . , n+ 1}.

50

Page 51: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

σ

xc

hc

Pnc

X ′

y0

y1

y2

Figure 4.5: P is drawn schematically in brown. In Case 1b, hc is large enough, and X ′ is small enoughthat if we consider all horizontal spans of P (there are at least hc of them), two of them will have thesame width, and we can apply Lemma 4.5.

However, xn+1 = X ≥ (4|T |)4|T |+1(4|σ| + 6) − 1 > x0 +∑n

d=0 hd, which is a contradiction.Therefore, there is at least one c ∈ {0, 1, . . . , n} such that xc > x0 +

∑c−1d=0 hd.

Let c0 be the smallest such c. There is at least one d < c0 such that the type and orientationof the span of P on xd is repeated strictly more than hd times between xd (included) andxc0 (excluded).There are two cases:

• There is a glue column x, such that xd < x < c0 and the spans of P on glue columns xdand x have the same type and orientation, and furthermore the height of the span of Pon x is at least hd. Since by definition, the height of the span on glue column xd is hd,we conclude immediately setting S and S′ to be the spans on xd and x, respectively, inLemma 4.5. Thus P is pumpable or fragile.

• Otherwise, at least hd+1 spans of the same type and orientation as the span of P on xd,have height at most hd. By the pigeonhole principle, two of them have the same heightand we can also apply Lemma 4.5 setting S to be the more western of the two spans,and S′ being the more eastern. Thus P pumpable or fragile.

A The 2HAM is pumpable or blockable: proof sketch

This section contains a proof sketch of Corollary 1.2: an application of our main result to thetwo-handed, or hierarchical, tile assembly model (2HAM). A full proof requires using formal2HAM definitions, and making some notions below more precise. We restate the Corollary here,see [6, 8, 15] for 2HAM definitions.

Corollary 1.2. LetH = (T, 1) be any tile assembly system in the Two-Handed Assembly Model(2HAM), and let P be a path producible by H. If P has vertical height or horizontal width at

51

Page 52: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

least (88|T |)4|T |+1, then P is pumpable or fragile.

Proof sketch of Corollary 1.2: Let H = (T, 1) be a temperature 1 2HAM system with tile set Tthat grows a (tile) path P of horizontal or vertical width (88|T |)4|T |+1. Then redefine P to bea shortest segment of P that has horizontal or vertical width exactly (88|T |)4|T |+1 (it is alwayspossible to remove a prefix of P and a suffix of P so that this is the case). If necessary, redefineH by rotating all tiles T by 90◦ so that P has horizontal width (88|T |)4|T |+1. We define anaTAM system T = (T, σ, 1) by setting T = H and by choosing the westernmost (smallest x-coordinate) tile t of P , setting σ = t. Since P is a producible in H, and since σ is a tile of P , Pis also producible by T (note that asm(P ) = σ∪asm(P ), and P is simple, and all adjacent gluesalong P match). Since (8|T |)4|T |+1(5|σ| + 6) ≤ (88|T |)4|T |+1 for |σ| = 1, we apply Theorem 1.1to T , and P , and thus P is pumpable or fragile in T . Specifically, this means that there is aproducible assembly α ∈ A[T ] such that either (i) α contains exactly σ = t, a prefix P0,1,...,i ofP , and then infinitely many repetitions of a segment Pi+1,i+2,...,j, each translated by a unique

vector d ·−−→PiPj for all d ∈ N, or (ii) α is an assembly that places a tile that conflicts with P

(prevents P from growing). Since assemblies that are producible in the aTAM (i.e. in T ) areproducible in the 2HAM (i.e. in H), we get that α is producible in H. Hence P is pumpable orfragile in H.

B Wee lemmas and left/right turns for curves

Lemma B.1 (Lemma 6.3 of [11]). Consider a two-dimensional, bounded, connected, regularclosed set S, i.e. S is equal to the topological closure of its interior points. Suppose S istranslated by a vector v to obtain shape Sv, such that S and Sv do not overlap. Then the shapeSc∗v obtained by translating S by c ∗ v for any integer c 6= 0 also does not overlap S.

The following lemma [31] formalises the intuition behind Definition 5:

Lemma B.2 (Lemma 2.5 of [31]). Let P be a path with tiles from some tileset T , i < jbe two integers, and q be the pumping of P between i and j. Then for all integers k ≥ i,

qk+(j−i) = qk +−−→PiPj .

Proof. By the definition of q (and using the fact that (j − i) mod (j − i) = 0):

qk+(j−i) = Pi+1+((k+(j−i)−i−1) mod (j−i)) +

k + (j − i)− i− 1

j − i

−−→PiPj

= Pi+1+((k−i−1) mod (j−i)) +

k − i− 1

j − i

−−→PiPj +

−−→PiPj

= qk +−−→PiPj

B.1 Jordan curve theorem for infinite polygonal curves and left/right turns

The line ℓ : (−∞,+∞) → R2 of vector −→w = (u, v) passing through a point (a, b) ∈ R2 is definedas {(x, y) | −v(x − a) + u(y − b) = 0}. This line cuts the 2D plane R2 into two connectedcomponents: the right-hand side R = {(x, y) | −v(x− a) + u(y − b) ≤ 0} and the left-hand sideL = {(x, y) | −v(x − a) + u(y − b) ≥ 0}. We say that a curve c turns right (respectively left)

52

Page 53: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

of ℓ if there exist ǫ > 0 and t ∈ R such that c(t) is a point of ℓ and for all t < z ≤ t + ǫ, c(z)belongs to R (respectively L) and is not on ℓ. Moreover, we say that c crosses ℓ from left to right(respectivelyfrom right to left) if there exist t and ǫ > 0 such that c turns right (respectivelyleft) of ℓ at c(t), for all t− ǫ ≤ z ≤ t, c(t) ∈ L (respectively c(t) ∈ R) and c(t− ǫ) is not on ℓ.23

We say that c crosses ℓ if c crosses ℓ either from left to right or from right to left. Now, wegeneralise these notions to a specific class of polygonal curves:

Definition 12. A simple infinite almost-vertical polygonal curve is a simple curve that is aconcatenation of an (infinite) vertical ray from the south, a finite curve made of horizontal andvertical segments of lengths 1 or 0.5, and an (infinite) vertical ray to the north.

Examples of simple infinite almost-vertical polygonal curves appear throughout this paper,including: the curve c in Definition 8 and shown as the border of C in Figure 3.2, e in Subsec-tion 2.5.4, cm0 in Subsection 3.2.2, and d in Definition 9.

Let w0, w1 ∈ R2 and let c be a curve. We say that w0 is connected to w1 while avoiding c ifthere is a curve d : [0, 1] → R2 with d(0) = w0 and d(1) = w1 and d does not intersect c.

Theorem B.3. Let c : R → R2 be a simple infinite almost-vertical polygonal curve, and let xmin

and xmax be the respective minimum and maximum x-coordinates of c(R).Then c cuts R2 into two connected components:

1. the left-hand side of c: c(R) ∪ {w | w ∈ R2 is connected to (xmin, 0) while avoiding c},

2. the right-hand side of c: c(R) ∪ {w | w ∈ R2 is connected to (xmax, 0) while avoiding c}.

Proof. The proof is similar to the proof of the Jordan Curve Theorem for polygonal curves.For each point (x, y) ∈ R2 we define ℓ(x, y) to be the line of vector (1, 1) through (x, y),

ℓ+(x, y) to be the ray of vector (1, 1) from (x, y), and ℓ−(x, y) to be the ray of vector (−1,−1)from (x, y).

Since c is made only of two vertical rays and a finite number of horizontal and verticalsegments, for all (x, y) ∈ R2, ℓ−(x, y) and ℓ+(x, y) intersects c at a finite number of points.Moreover, because ℓ(x, y) cuts the plane into two connected components, ℓ(x, y) crosses c anodd number of times,

Let L be the subset of R2 such that for all (x, y) ∈ L, c crosses23 ℓ+(x, y) an odd numberof times,24 and let R be the subset of R2 such that for all (x, y) ∈ R, c crosses ℓ−(x, y) an oddnumber of times. Note that L ∩ R = c(R) (where c(R) is the range of c), or in other words theintersection of L and R is the set of all points of c.

We claim that L (respectively R) is a connected component: indeed, since c is connected, if(x0, y0) and (x1, y1) are both in L (respectively both in R), let t0, t1 ∈ R be the smallest realnumbers such that ℓ+(x0, y0)(t0) (respectively ℓ−(x0, y0)(t0)) is on c, and ℓ+(x1, y1)(t1) (respec-tively ℓ−(x1, y1)(t1)) is on c. We know there is at least one such intersection because ℓ+(x0, y0)and ℓ+(x1, y1) (respectively ℓ−(x0, y0) and ℓ−(x1, y1)) cross c an odd number of times, hence atleast once. Without loss of generality we suppose that ℓ+(x0, y0)(t0) (respectively ℓ−(x0, y0)(t0))is before ℓ+(x1, y1)(t1) (respectively ℓ−(x1, y1)(t1)) according to the order of positions along c.

Let d be the curve defined as the concatenation of:23The definition of “c crosses ℓ from left to right” ensures that certain kinds of intersections between c and ℓ

are not counted as crossing, those include: coincident intersection between two straight segments of length > 0,and “glancing” of a line “tangentially” to a corner.

24The term “crosses” was defined with respect to a line ℓ(x, y). This definition is easily generalised to the(coincident) ray ℓ+(x, y), by considering only those crossings at locations that are simultaneously on both ℓ andthe ray. Likewise for the ray ℓ−(x, y).

53

Page 54: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

• ℓ+(x0, y0) (respectively, ℓ−(x0, y0)) from (x0, y0) up to ℓ+(x0, y0)(t0) (respectively, ℓ

−(x0, y0)(t0)),

• c from ℓ+(x0, y0)(t0) to ℓ+(x1, y1)(t1) (respectively, from ℓ−(x0, y0)(t0) to ℓ−(x1, y1)(t1)),

• ℓ+(x1, y1)←

(respectively, ℓ−(x1, y1)←) from ℓ+(x1, y1)(t1) (respectively, ℓ−(x1, y1)(t1)) to

(x1, y1).

The curve d is entirely in L (respectively in R), starts at (x0, y0) and ends at (x1, y1), whichproves that L (respectively R) is indeed a connected component.

We claim that L∪R = R2: indeed, for all (x, y) ∈ R2, since ℓ(x, y) crosses c an odd numberof times, ℓ+(x, y) crosses c an even number of times if and only if ℓ−(x, y) crosses c an oddnumber of times (and vice-versa), hence (x, y) is in at least one of L and R, and only the pointsof c are in both.

As a conclusion, c cuts the plane into two disjoint connected components: L \ c(R) which wecall the strict left-hand side of c and R \ c(R) which we call the strict right-hand side of c.

Let (x, 0) be a point so far to the east of c that ℓ+(x, 0) intersects c exactly once, along c’shorizontal ray to the north. (x, 0) is in L, and since L is connected, we get Conclusion 1. Let(x, 0) be a point so far to the west of c that ℓ−(x, 0) intersects c exactly once, along c’s horizontalray to the north. (x, 0) is in R, and since R is connected, we get Conclusion 2.

Using the technique in the proof of Theorem B.3, the definitions of turning right and leftcan be extended from a line to an infinite polygonal curve.

Definition 13 (left-hand and right-hand side of a curve). The conclusion of Theorem B.3defines the left-hand side L ( R2, and right-hand side R ( R2 of a simple infinite almost-vertical polygonal curve c. The strict left-hand side of an infinite almost-vertical polygonal curvec : R → R2 is the set L \ c(R). Likewise the strict right-hand side of an infinite almost-verticalpolygonal curve c is the set R \ c(R), where R is the right-hand side of c.

We have already defined what ti means for a curve to cross a line. Theorem B.3 enables usto generalise that definition to one curve turning from another simple infinite almost-verticalpolygonal curve.

Definition 14 (One curve turning left or right from another). Let d be a curve and let c : R →R2 be a simple infinite almost-vertical polygonal curve. We say that d turns left (respectively,right) from curve c at the point d(z) = c(w), for some z, w ∈ R, if there is an ǫ > 0 such thatd(z+ ǫ) is in the strict left-hand (respectively, right-hand) side of d and d(z′) is not on c, for allz′ where z < z′ < z + ǫ.

Definition 14 is consistent with the definition of one path turning left/right from another(Section 2.2) in the following sense. Consider two paths P and Q such that Q turns right(respectively, left) of P and consider a curve c which contains E[P ] (with the same orientation)then E[Q] turns right (respectively, left) of c. However, not all curves are the embedding ofsome path, hence the reverse implication does not hold. Also, the curve turning definition hasno requirement analogous to the orientation requirement for path turns (implied by i > 0 andthe definition of ∆ in the path turning definition).

Throughout the article, we will use the following fact several times. First, let c be a simpleinfinite almost-vertical polygonal curve (Definition 12), and let ℓ1 and ℓ2 be two vertical raysfrom the south such that ℓ1 is the vertical ray from the south used to define c, and ℓ2 is strictlyto the east (respectively, west) of ℓ1 and does not intersect c, then ℓ2 belongs to the right-handside (respectively, left-hand side) of c. The same conclusion holds if ℓ1 and ℓ2 go to the north,with ℓ1 being the vertical ray from the north used to define c.

54

Page 55: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

References

[1] Leonard Adleman, Qi Cheng, Ashish Goel, and Ming-Deh Huang. Running time andprogram size for self-assembled squares. In STOC: Proceedings of the 33rd Annual ACMSymposium on Theory of Computing, pages 740–748, Hersonissos, Greece, 2001.

[2] Robert D Barish, Paul WK Rothemund, and Erik Winfree. Two computational primitivesfor algorithmic self-assembly: Copying and counting. Nano letters, 5(12):2586–2592, 2005.

[3] Robert D Barish, Rebecca Schulman, Paul WK Rothemund, and Erik Winfree. Aninformation-bearing seed for nucleating algorithmic self-assembly. Proceedings of the Na-tional Academy of Sciences, 106(15):6054–6059, 2009.

[4] B. Behsaz, J. Manuch, and L. Stacho. Turing universality of step-wise and stage assemblyat Temperature 1. In DNA18: Proc. of International Meeting on DNA Computing andMolecular Programming, volume 7433 of LNCS, pages 1–11. Springer, 2012.

[5] Hugues Bersini and Vincent Detours. Asynchrony induces stability in cellular automatabased models. In Artificial life IV, pages 382–387. MIT Press, MA, 1994.

[6] Sarah Cannon, Erik D. Demaine, Martin L. Demaine, Sarah Eisenstat, Matthew J. Patitz,Robert Schweller, Scott M. Summers, and Andrew Winslow. Two hands are betterthan one (up to constant factors). In STACS: Proceedings of the Thirtieth InternationalSymposium on Theoretical Aspects of Computer Science, pages 172–184. LIPIcs, 2013.Arxiv preprint: 1201.1650.

[7] Cameron T Chalk, Bin Fu, Alejandro Huerta, Mario A Maldonado, Eric Martinez, Robert TSchweller, and Tim Wylie. Flipping tiles: Concentration independent coin flips in tile self-assembly. In Andrew Phillips and Peng Yin, editors, DNA21: Proceedings of the 21stInternational Conference on DNA Computing and Molecular Programming, volume 9211 ofLNCS, pages 87–103. Springer, 2015.

[8] Qi Cheng, Gagan Aggarwal, Michael H. Goldwasser, Ming-Yang Kao, Robert T. Schweller,and Pablo Moisset de Espanes. Complexities for generalized models of self-assembly. SIAMJournal on Computing, 34:1493–1515, 2005.

[9] Matthew Cook. Universality in elementary cellular automata. Complex systems, 15(1):1–40,2004.

[10] Matthew Cook, Yunhui Fu, and Robert T. Schweller. Temperature 1 self-assembly: deter-ministic assembly in 3D and probabilistic assembly in 2D. In SODA: Proceedings of the22nd Annual ACM-SIAM Symposium on Discrete Algorithms, pages 570–589, 2011. Arxivpreprint: arXiv:0912.0027.

[11] Erik D. Demaine, Martin L. Demaine, Sandor P. Fekete, Matthew J. Patitz, Robert T.Schweller, Andrew Winslow, and Damien Woods. One tile to rule them all: Simulating anytile assembly system with a single universal tile. In ICALP: Proceedings of the 41st Inter-national Colloquium on Automata, Languages, and Programming, volume 8572 of LNCS,pages 368–379. Springer, 2014. Arxiv preprint: arXiv:1212.4756.

55

Page 56: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

[12] Erik D. Demaine, Matthew J. Patitz, Trent A. Rogers, Robert T. Schweller, Scott M. Sum-mers, and Damien Woods. The two-handed tile assembly model is not intrinsically universal.In ICALP: Proceedings of the 40th International Colloquium on Automata, Languages, andProgramming, volume 7965 of LNCS, pages 400–412. Springer, July 2013. Arxiv preprint:arXiv:1306.6710.

[13] David Doty. Theory of algorithmic self-assembly. Communications of the ACM, 55(12):78–88, December 2012.

[14] David Doty, Jack H. Lutz, Matthew J. Patitz, Robert T. Schweller, Scott M. Summers, andDamien Woods. The tile assembly model is intrinsically universal. In FOCS: Proceedingsof the 53rd Annual IEEE Symposium on Foundations of Computer Science, pages 439–446.IEEE, October 2012. Arxiv preprint: arXiv:1111.3097.

[15] David Doty, Matthew J. Patitz, Dustin Reishus, Robert T. Schweller, and Scott M. Sum-mers. Strong fault-tolerance for self-assembly with fuzzy temperature. In FOCS: Proceedingsof the 51st Annual IEEE Symposium on Foundations of Computer Science, pages 417–426,2010.

[16] David Doty, Matthew J. Patitz, and Scott M. Summers. Limitations of self-assembly attemperature 1. Theoretical Computer Science, 412(1–2):145–158, 2011. Arxiv preprint:arXiv:0903.1857v1.

[17] Constantine Glen Evans. Crystals that count! Physical principles and experimental inves-tigations of DNA tile self-assembly. PhD thesis, California Institute of Technology, 2014.

[18] Sandor P. Fekete, Jacob Hendricks, Matthew J. Patitz, Trent A. Rogers, and Robert T.Schweller. Universal computation with arbitrary polyomino tiles in non-cooperative self-assembly. In SODA: ACM-SIAM Symposium on Discrete Algorithms, pages 148–167. SIAM,2015.

[19] Bin Fu, Matthew J. Patitz, Robert T. Schweller, and Robert Sheline. Self-assembly withgeometric tiles. In ICALP: Proceedings of the 39th International Colloquium on Automata,Languages, and Programming, volume 7391 of LNCS, pages 714–725. Springer, 2012.

[20] Kenichi Fujibayashi, Rizal Hariadi, Sung Ha Park, Erik Winfree, and Satoshi Murata.Toward reliable algorithmic self-assembly of DNA tiles: A fixed-width cellular automatonpattern. Nano Letters, 8(7):1791–1797, 2007.

[21] David Furcy and Scott M Summers. Optimal self-assembly of finite shapes at temperature 1in 3D. Algorithmica, 80(6):1909–1963, 2018.

[22] David Furcy, Scott M Summers, and Christian Wendlandt. New bounds on the tile com-plexity of thin rectangles at temperature-1. In DNA25: International Conference on DNAComputing and Molecular Programming, pages 100–119. Springer, 2019.

[23] Oscar Gilbert, Jacob Hendricks, Matthew J Patitz, and Trent A Rogers. Computing incontinuous space with self-assembling polygonal tiles. In SODA: ACM-SIAM Symposiumon Discrete Algorithms, pages 937–956. SIAM, 2016. Arxiv preprint: arXiv:1503.00327.

56

Page 57: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

[24] Jacob Hendricks, Matthew J. Patitz, Trent A. Rogers, and Scott M. Summers. The powerof duples (in self-assembly): It’s not so hip to be square. In COCOON: Proceedings of20th International Computing and Combinatorics Conference, pages 215–226, 2014. Arxivpreprint: arXiv:1402.4515.

[25] Natasa Jonoska and Daria Karpenko. Active tile self-assembly, part 1: Universality attemperature 1. Int. J. Found. Comput. Sci., 25(2):141–164, 2014.

[26] Jan Manuch, Ladislav Stacho, and Christine Stoll. Two lower bounds for self-assemblies atTemperature 1. Journal of Computational Biology, 17(6):841–852, 2010.

[27] Pierre-Etienne Meunier. Non-cooperative algorithms in self-assembly. In UCNC: Uncon-ventional Computation and Natural Computation, volume 9252 of LNCS, pages 263–276.Springer, 2015.

[28] Pierre-Etienne Meunier, Matthew J. Patitz, Scott M. Summers, Guillaume Theyssier, An-drew Winslow, and Damien Woods. Intrinsic universality in tile self-assembly requirescooperation. In SODA: Proceedings of the ACM-SIAM Symposium on Discrete Algorithms,pages 752–771, 2014. Arxiv preprint: arXiv:1304.1679.

[29] Pierre-Etienne Meunier and Damien Regnault. A pumping lemma for noncooperative self-assembly. 2015. Arxiv preprint: arXiv:1312.6668v4 [cs.CC].

[30] Pierre-Etienne Meunier and Damien Regnault. Non-cooperatively assembling large struc-tures. In DNA Computing and Molecular Programming - 25th International Conference,DNA 25, Seattle, WA, USA, August 5-9, 2019, Proceedings, 2019.

[31] Pierre-Etienne Meunier and Damien Woods. The non-cooperative tile assembly model is notintrinsically universal or capable of bounded Turing machine simulation. In STOC: Proceed-ings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 328–341, Montreal, Canada, 2017. ACM. Arxiv preprint with full proofs: arXiv:1702.00353v2[cs.CC].

[32] Turlough Neary and Damien Woods. P-completeness of cellular automaton Rule 110. InICALP: The 33rd International Colloquium on Automata, Languages and Programming,volume 4051 of LNCS, pages 132–143. Springer, 2006.

[33] Jennifer E. Padilla, Matthew J. Patitz, Robert T. Schweller, Nadrian C. Seeman, Scott M.Summers, and Xingsi Zhong. Asynchronous signal passing for tile self-assembly: Fuelefficient computation and efficient assembly of shapes. International Journal of Foundationsof Computer Science, 25(4):459–488, 2014. Arxiv preprint: arxiv:1202.5012.

[34] Matthew J. Patitz. An introduction to tile-based self-assembly and a survey of recentresults. Natural Computing, 13(2):195–224, 2014.

[35] Matthew J. Patitz, Robert T. Schweller, and Scott M. Summers. Exact shapes and Turinguniversality at Temperature 1 with a single negative glue. In DNA 17: Proceedings of theSeventeenth International Conference on DNA Computing and Molecular Programming,LNCS, pages 175–189. Springer, September 2011. Arxiv preprint: arXiv:1105.1215.

57

Page 58: arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 · 2020-02-11 · arXiv:2002.04012v1 [cs.CC] 10 Feb 2020 Theprogram-sizecomplexityofself-assembledpaths∗ Pierre-Etienne Meunier´ † Damien

[36] Paul W. K. Rothemund. Theory and Experiments in Algorithmic Self-Assembly. PhDthesis, University of Southern California, December 2001.

[37] Paul W. K. Rothemund and Erik Winfree. The program-size complexity of self-assembledsquares (extended abstract). In STOC: Proceedings of the thirty-second annual ACM Sym-posium on Theory of Computing, pages 459–468, Portland, Oregon, 2000. ACM.

[38] Paul W.K. Rothemund, Nick Papadakis, and Erik Winfree. Algorithmic self-assembly ofDNA Sierpinski triangles. PLoS Biology, 2(12):2041–2053, 2004.

[39] Rebecca Schulman, Bernard Yurke, and Erik Winfree. Robust self-replication of combina-torial information via crystal growth and scission. Proceedings of the National Academy ofSciences, 109(17):6405–6410, 2012.

[40] David Soloveichik and Erik Winfree. Complexity of self-assembled shapes. SIAM Journalon Computing, 36(6):1544–1569, 2007.

[41] Hao Wang. Proving theorems by pattern recognition – II. The Bell System TechnicalJournal, XL(1):1–41, 1961.

[42] Erik Winfree. Algorithmic Self-Assembly of DNA. PhD thesis, California Institute ofTechnology, June 1998.

[43] Damien Woods. Intrinsic universality and the computational power of self-assembly. Philo-sophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sci-ences, 373(2046), 2015. dx.doi.org/10.1098/rsta.2014.0214.

[44] Damien Woods, David Doty, Cameron Myhrvold, Joy Hui, Felix Zhou, Peng Yin, andErik Winfree. Diverse and robust molecular algorithms using reprogrammable DNA self-assembly. Nature, 567(7748):366–372, 2019.

58