The Need for Seed (in the abstract Tile Assembly Model)

In the abstract Tile Assembly Model (aTAM) square tiles self-assemble, autonomously binding via glues on their edges, to form structures. Algorithmic aTAM systems can be designed in which the patterns of tile attachments are forced to follow the execution of targeted algorithms. Such systems have been proven to be computationally universal as well as intrinsically universal (IU), a notion borrowed and adapted from cellular automata showing that a single tile set exists which is capable of simulating all aTAM systems (FOCS 2012). The input to an algorithmic aTAM system can be provided in a variety of ways, with a common method being via the"seed"assembly, which is a pre-formed assembly from which all growth propagates. In this paper we present a series of results which investigate the the trade-offs of using seeds consisting of a single tile, versus those containing multiple tiles. We show that arbitrary systems with multi-tile seeds cannot be converted to functionally equivalent systems with single-tile seeds without using a scale factor>1. We prove tight bounds on the scale factor required, and also present a construction which uses a large scale factor but an optimal number of unique tile types. That construction is then used to develop a construction that performs simultaneous simulation of all aTAM systems in parallel, as well as to display a connection to other tile-based self-assembly models via the notion of intrinsic universality.


Introduction
Mathematical models of self-assembly provide high-level abstractions of the self-assembling behaviors of systems that typically function on a molecular level.While many natural systems harness the power of self-assembly, scientists and engineers are rapidly increasing their abilities to design self-assembling systems.One of the most versatile molecules that we have discovered is DNA.While biology utilizes DNA primarily as a storage medium, it is now being recognized for its impressive capabilities for structure-building, augmented by its ease of synthesis, durability, and programmability.Engineers are designing impressive DNA-based self-assembling systems whose complexities are increasing at a nearly exponential rate (e.g.[2,26,28,29]).Not to be outdone, theoreticians are rapidly expanding the mathematical toolkit for modeling, predicting, and analyzing such systems.The level of are assemblies that have no pathway for growth and can only stably exist if they completely form instantaneously) in Section 3.1, (2) "blocking" (which occurs when potential placement of later tiles is prevented by the prior placement of earlier tiles) by tiles in a seed assembly can impact the dynamics of systems in important ways but that it is uncomputable, in general, to determine if one or any seed tile locations have the potential to block growth (Observation 3.1), (3) the same sets of shapes of the assemblies produced by even some relatively simple multi-tile seed systems cannot be produced by systems with single-tile seeds if they are not allowed to be scaled up in size (i.e. if each single tile is replaced by an n × n square of tiles, we say that the system is scaled by factor n) in Section 3.3, and (4) that, since the aTAM does not allow for seeds of infinite size, there is an infinite set of shapes that cannot self-assemble in any aTAM system (Observation 3.2).
Given the utility of transferring information encoded in seed assemblies into tile complexity, by trading multitile seeds for single-tile seeds, we explore when and how it is possible to do so.In order to fully explore the capabilities and limitations of converting systems with multi-tile seeds to those with single-tile seeds, we provide definitions for new notions of simulation (Section 2.2).In standard definitions, both the simulated system and the simulating system start from the same assembly (modulo scale factor and interpreted through a mapping function).In these new definitions, the simulator is allowed to begin with seed assemblies as small as a single tile, and then are allowed to grow assemblies representing the seed structures.In the most permissive definition (which we call "shape-simulation"), we only stipulate that both systems have to produce terminal assemblies of the same shapes (modulo scale factor and mapping).In the most restrictive definition (which we call "seed-firstsimulation"), we require that the simulating system completely grow an assembly mapping to the seed structure of the original system before allowing any of the rest of the growth permitted by that system to occur.Using these notions of simulation, we prove the tightest results possible.We prove that even with the most relaxed version, shape-simulation, there are aTAM systems with multi-tile seeds that no systems with single-tile seeds can correctly shape-simulate at scale factors 1 or 2, or also at scale factor 3 with a technical restriction applied (i.e."cheating fuzz", as defined in Section 2.2, is not allowed) (Theorem 4.1).However, using even the most restrictive notion of simulation, seed-first-simulation, we prove that any aTAM system with a multi-tile seed can be seed-first-simulated by a system with a single-tile seed at scale factor 3 with the technical restriction removed (i.e.cheating fuzz is allowed) (Theorem 5.2) or at scale factor 4 with the technical restriction once again applied (i.e.cheating fuzz is not allowed) (Theorem 5.1).Using the restrictive notion of seed-first-simulation makes it possible to guarantee the full seed-representing assembly is grown in the simulator before any outward growth can occur, making it behave identically to the simulated system after an initial seed-building phase.
While we prove that the scale 3 and 4 simulations achieve the lower bound for scale factor, they pay the price in terms of tile complexity, which is O(|σ| + |T |) for the simulation of a system with tile set T and seed assembly σ.In order to achieve optimality for the tile complexity metric, our next result (Theorem 6.1) proves that the tile complexity can be reduced to O( K(T ) log(K(T ) ) (which, by an information theoretic argument, is the lower bound) for the seed-first-simulation of an arbitrary aTAM system T at the trade-off of a (massive) increase in scale factor (which is proportional to the running time of a relatively complex Turing machine).
Although the tradeoff in scale factor is immense for the previous construction, beyond approaching optimal tile complexity, it provides a basis for additional theoretically interesting results.As a module of that construction, we use a (minimally modified) version of the intrinsically universal aTAM tile set from [10].This machinery allows us to extend the construction to first present a new construction that simultaneously and in parallel simulates all aTAM systems (Theorem 6.2).This, of course, requires a modified definition of simulation to take into account the fact that no fixed value for a scale factor could suffice to simulate arbitrary aTAM systems, so we define a type of "mixed-scale-simulation".Then, for our final result (Theorem 6.1), we show how we can make use of the ability of systems in a different model to simulate systems of the aTAM by providing a construction that utilizes "nested simulations", allowing us to make connections between models that can simulate arbitrary systems in the aTAM and intrinsic universality for the aTAM (notions we also show are not necessarily correlated).
In summary, we prove a wide assortment of results that expose the impacts of seed assemblies on the dynamics and complexities of aTAM systems and provide tight bounds that show how it is possible to replace multi-tile seeds with single-tile seeds and what the tradeoffs are.
The paper is laid out as follows.Section 2 contains the definitions of, and related to, the aTAM, as well as definitions for the various types of simulations used throughout the paper.Section 3 contains a set of simple results and observations that lay the foundation for the more complex results to follow.Section 4 sketches the result showing the lower bound for the scale factor required to simulate systems with multi-tile seeds by those with single-tile seeds.Section 5 gives overviews of the constructions that provide a tight upper bound for the scale factor of such simulations.In Section 6 we present the results showing simulation by systems with single-tile seeds using optimal tile complexity, as well as simultaneous simulation of all aTAM systems, and one relating to intrinsic universality and the aTAM.Then, the Technical Appendix, Section 7, contains proofs and technical details omitted from the other sections.

Definitions
In this section we provide definitions of the aTAM and also related to the simulation of one tile assembly system by another.

The abstract Tile Assembly Model
This section gives a brief informal sketch of the abstract Tile Assembly Model (aTAM) [27] and uses notation from [23] and [19].For more formal definitions and additional notation, see [23] and [19].
A tile type is a unit square with four sides, each consisting of a glue label which is often represented as a finite string.An aTAM system has a finite set T of tile types, but an infinite number of copies of each tile type, with each copy being referred to as a tile.A glue function is a symmetric mapping from pairs of glue labels to a non-negative integer value which represents the strength of binding between those glues.An assembly is a positioning of tiles on the integer lattice Z 2 , described formally as a partial function α : Z 2 T .Let A T denote the set of all assemblies of tiles from T , and let A T <∞ denote the set of finite assemblies of tiles from T .We write α β to denote that α is a subassembly of β, which means that dom α ⊆ dom β and α(p) = β(p) for all points p ∈ dom α.We write α \ β to denote the assembly α without any of the tiles in locations in β, i.e. the result of starting with α and removing tiles from any locations which are in both α and β.Two adjacent tiles in an assembly interact, or are attached, if the glue labels on their abutting sides match.Each assembly induces a binding graph, a grid graph whose vertices are tiles, with an edge between two tiles if they interact.The assembly is τ -stable if every cut of its binding graph has strength at least τ , where the strength of a cut is the sum of all of the individual glue strengths in the cut.
A tile assembly system (TAS) is a 3-tuple T = (T, σ, τ ), where T is a finite set of tile types, σ : Z 2 T is a finite τ -stable seed assembly, and τ is the temperature parameter (a.k.a.binding threshold ).Given an assembly α, the frontier, ∂ τ α, is the set of locations to which tiles can τ -stably attach.An assembly α is producible if either α = σ or if β is a producible assembly and α can be obtained from β by the stable binding of a single tile to a location in ∂ τ β.In this case we write β → T 1 α (to mean α is producible from β by the attachment of one tile), and we write β → T α if β → T * 1 α (to mean α is producible from β by the attachment of zero or more tiles).An assembly sequence in a TAS T is a (finite or infinite) sequence α = (α 0 , α 1 , ...) of assemblies in which each α i+1 is obtained from α i by the addition of one tile, i.e. α i → T 1 α i+1 .We let A[T ] denote the set of producible assemblies of T .An assembly α is terminal if no tile can be τ -stably attached to it, i.e. |∂ τ α| = 0. We let A [T ] ⊆ A[T ] denote the set of producible, terminal assemblies of T .A TAS T is directed if |A [T ]| = 1.Hence, although a directed system may be nondeterministic in terms of the order of tile placements, it is deterministic in the sense that exactly one terminal assembly can be produced.
We define the producible shapes of an aTAM system T , denoted A dom [T ], as the set of shapes (i.e.domains) of all producible assemblies of T .More formally, A dom [T ] = {dom α | α ∈ A[T ]}.Similarly, we define the terminal shapes of an aTAM system T , denoted A dom [T ], as the set of shapes (i.e.domains) of all terminal assemblies of T .More formally, A dom [T ] = {dom α | α ∈ A [T ]}.We say that aTAM system T self-assembles shape S if and only if |A dom [T ]| = 1 and S ∈ A dom [T ], that is, T produces terminal assemblies of only a single shape, which is S. Definition 2.1.(TAS equivalence) Given two aTAM systems T and S, and assembly γ, we say that T and S are equivalent modulo γ if and only if for every producible assembly α ∈ A[T ] there exists a producible assembly β ∈ A[S] such that (α \ γ) = (β \ γ), and vice versa (i.e. for every producible assembly β ∈ A[S] there exists a producible assembly α ∈ A[T ] such that (β \ γ) = (α \ γ)).
Note that the notion of equivalence between aTAM systems is quite strict, requiring all of the same tile types to be used outside of the region of γ, and not allowing for any scaling factor.For more general notions of equivalence between systems, see Section 2.2. Figure 1: A basic example of blocking by a seed location.(Left) The seed tile, (Middle) Growth from the seed with tiles specific to each location, (Right) Growth back toward the seed using a single, repeating tile type.This row "crashes" into the seed (i.e. it would place a tile in the location of the seed tile if that tile weren't there), so the seed location blocks placement of a tile (of the type with x glues on its east and west).Definition 2.2.(Strict dependence) Given an aTAM system T and sets of locations L 1 , L 2 ⊂ Z 2 , we say that L 2 strictly depends upon L 1 if, for every valid assembly sequence in T , if a tile is placed in some location in L 2 , a tile was previously placed in some location in L 1 .
We define a path p as an ordered list of distinct locations in Z 2 , and refer to the ith location in p as p[i], so that each location p[i], for 0 ≤ i < |p| − 1, is adjacent to p[i + 1].Definition 2.3.(Dependence path) Given an aTAM system T , a producible assembly α ∈ A[T ], assembly sequence α which produces α, and locations l 1 , l 2 ∈ dom α, we say that there is a dependence path from l 1 to l 2 if and only if there exists a path p from 1 1 to l 2 in dom α such that, in α, for each location p[i], for 0 < i < |p| − 1, (1) the tile at location p[i] was placed before the tile in p[i + 1], and (2) the tile at location p[i + 1] was required to form a bond with the tile at location p[i] in order to attach.
Intuitively, a dependence path from l 1 to l 2 is a path formed by sequential tile attachments that leads from l 1 to l 2 .Note that, by definition, a dependence path is directional and therefore a dependence path from l 1 to l 2 cannot be the same path as a dependence path from l 2 to l 1 .
Lemma 2.1.(Dependence paths) Given an aTAM system T whose seed consists of a single tile, a producible assembly α ∈ A[T ], and sets of locations L 1 , L 2 ⊂ dom α, if L 2 strictly depends upon L 1 , then in each valid assembly sequence of T there must be a dependence path from some l 1 ∈ L 1 to some l 2 ∈ L 2 .
The proof of Lemma 2.1 can be found in Section 7.2.Definition 2.4.(Blocking) Given a TAS T and producible assembly α ∈ A[T ], a tile t at location l in α blocks a tile if there exists a valid assembly sequence which begins with α and results in one or more tiles adjacent to t which did not require glues of t to bind to the assembly and to which a tile of a type different than t could bind with τ strength in location l if t was removed.
See Figure 1 for an example of blocking.Note that we still say blocking occurs even if the tile adjacent to t strictly depends upon t, meaning it would technically be impossible to remove t and replace it with a tile of another type.

Simulation of tile assembly systems First, we give a very brief intuitive definition of what it means
for one tile assembly system to simulate another, and then provide more technically detailed definitions related to simulation, especially as it relates to scale factors greater than 1.We define new notions of simulation that are necessary to allow, and capture, the dynamics of simulating systems that don't begin from seed assemblies that represent the full seed assemblies of the systems they are simulating, and thus they have to grow those missing portions which the standard definition of simulation assumes exist at the beginning of the simulation.For the technical definitions related to the standard model of simulation, see [15].
Intuitively, simulation of a system T by a system S requires that there is some scale factor m ∈ Z + such that m × m squares of tiles in S represent individual tiles in T , and there is a "representation function" capable of inspecting assemblies in S and mapping them to assemblies in T .A representation function R takes as input an assembly in S and returns an assembly in T to which it maps.In order for S to correctly simulate T , it must be the case that for any producible assembly α ∈ A[T ] that there is a corresponding assembly β ∈ A[S] such that Figure 2: When simulating an aTAM tile 'A' with glues on its north and east faces and null glues on south and west faces, although a simulation is allowed to grow fuzz into each of the adjacent north, east, south, and west marcortile locations, we further restrict the locations for "legal fuzz" to grow only in the adjacent macrotiles to its north and east, indicated by blue hashed tiles.Locations for placement of "cheating fuzz", in adjacent directions in which no glue is presented by A, are indicated by the green hashed tiles.R(β) = α.(Note that there may be more than one such β.)Furthermore, for any α ∈ A[T ] which can result from a tile addition to α, there exists β ∈ A[S], where R(β ) = α , which can result from the addition of one or more tiles to β, and conversely, β can only grow into assemblies which can be mapped into valid assemblies of T into which α can grow.
We now present a formal, rigorous definition of what it means for one tile assembly system to "simulate" another.Our definitions are based on those of [20], but are adapted to account for the simulating system to grow a representation of the original system's seed rather than beginning from a seed assembly which already represents it.Also, note that a great amount of the complexity required for the definitions arises due to the possible dynamics of simulations with scale factors > 1, and that otherwise the mapping of assemblies and equivalence of production and dynamics are much more straightforward.
From this point on, let T be a tile set, and let m ∈ Z + .An m-block supertile over T is a partial function m be the set of all m-block supertiles over T .The m-block with no domain is said to be empty.For a general assembly α : Z 2 T and (x, y) ∈ Z 2 , define α m x,y to be the m-block supertile defined by α m x,y (i x , i y ) = α(mx + i x , my + i y ) for 0 ≤ i x , i y < m.For some tile set S, a partial function R : B S m T is said to be a valid m-block supertile representation from S to T if for any α, β ∈ B S m such that α β and α ∈ dom R, then R(α) = R(β).Note that we use the term macrotile interchangeably with supertile, to mean the same thing.
For a given valid m-block supertile representation function R from tile set S to tile set T , define the assembly representation function x,y for all (x, y) ∈ Z 2 .For an assembly α ∈ A S such that R(α ) = α, α is said to map cleanly to α ∈ A T under R * if for all non empty blocks α m x,y , (x, y) + (u x , u y ) ∈ dom α for some u x , u y ∈ {−1, 0, 1} such that u 2 x + u 2 y ≤ 1.In other words, α may have tiles on supertile blocks representing empty space in α, but only if that position is adjacent to a tile in α.We call such growth "around the edges" of α fuzz and thus restrict it to be adjacent to only valid supertiles, but not diagonally adjacent (i.e.we do not permit diagonal fuzz ).Additionally, if tiles grow as fuzz into a supertile region which maps to a location in the simulated system in which there is never an incident glue (other than the null glue) from any adjacent tile, we call this cheating fuzz.The justification for this distinction is that the goal of an intrinsic simulation is for the simulator to only utilize the dedicated macrotile space to simulate a tile or to compute if a tile may grow into a location, but cheating fuzz would be tile growth into a macrotile location that never has any input glues and therefore no chance of ever becoming a tile.See Figure 2 for an example.
In the following definitions, let T = (T, σ T , τ T ) be a tile assembly system, let S = (S, σ S , τ S ) be a tile assembly system, and let R be a valid m-block representation function R : B S m → T .
Definition 2.5.We say that S shape-simulates T if the following conditions hold: 2. For all α ∈ A [S], α maps cleanly to R * (α ).
Essentially, for S to shape-simulate T , its terminal assemblies must map to the exact same set of domains as those of the terminal assemblies of T .Definition 2.6.We say that S and T have equivalent productions modulo σ T (under R), and we write S ⇔ σ T R T if the following conditions hold:

For all
Note that the definition of equivalent productions modulo the seed assembly differs slightly from the definition of equivalent productions in other papers (e.g.[10,15,20]) since we must allow the producible assemblies of the simulating system to represent subsets of the seed of the simulated system.This is because we are interested in being able to begin with a singly-seeded system that first grows a complete representation of the seed of the simulated system, and then continues with its simulation.Alternatively, the next definition can be used to define a notion of simulation in which growth can extend beyond the simulated seed before the full representation of the seed has completed.Definition 2.7.We say that S and T have equivalent productions minus σ T (under R), and we write S ⇔ −σ T R T if the following conditions hold: 1.For all α ∈ A[S], all locations of α that map to a location in dom σ T map, under R, to the tile of T in that location of σ T .
Definition 2.8.We say that T follows S modulo σ T (under R), and we write The next definition essentially specifies that every time S simulates an assembly α ∈ A[T ], there must be at least one valid growth path in S for each of the possible next steps that T could make from α which results in an assembly in S that maps to that next step.Definition 2.9.We say that S models T (under R), and we write S |= R T , if for every α ∈ A[T ], there exists Π ⊂ A[S] where Π = Øand R * (α ) = α for all α ∈ Π, such that, for every β ∈ A[T ] where α → T β, (1) for every α ∈ Π there exists β ∈ A[S] where R * (β ) = β and α → S β , and (2) for every We now present the two new definitions for types of simulations that are relevant when we want to use systems with single-tile seeds to simulate systems with multi-tile seeds.The first, seed-first-simulation, requires that a complete representation of the multi-tile-seed of the simulated system self-assembles before any growth may occur away from the seed, and once the seed is complete, simulation continues in the standard way.The second, seed-growth-simulation, simply requires that the entire seed is eventually grown , but doesn't restrict growth away from the seed from beginning before the representation of the multi-tile-seed is complete.However it must still correctly simulate the behavior of the system with a multi-tile seed.Definition 2.10.We say that S seed-first-simulates T (under R) if S ⇔ σ T R T (they have equivalent productions modulo the seed of T ), T σ T R S and S |= R T (they have equivalent dynamics).
Definition 2.11.We say that S seed-growth-simulates T (under R) if S ⇔ −σ T R T (they have equivalent productions minus the seed of T ), T σ T R S and S |= R T (they have equivalent dynamics).
Figure 3: (Left) An example of a constant-sized tile set which can be used to form an infinite number of stable (at temperature 2) assemblies in a "Garden of Eden" manner (i.e. they are not stable if even a single tile is missing, and thus there is no valid growth process in which they form).(Middle) An example assembly encoding a binary number via its north-facing glues.(Right) An example assembly potentially encoding information in its geometry (i.e.information that could be "read" by paths of tiles that may or may not crash into tiles in specific locations).
Corollary 2.1.If system S seed-growth-simulates T or seed-first-simulates T , then S shape-simulates T .
Corollary 2.1 follows immediately from the fact that both seed-growth-simulation and seed-first-simulation require equivalent sets of terminal assemblies between the simulated system T and the simulating system S (under mapping by R), which implies shape-simulation.
Corollary 2.2 follows immediately from the fact that the only difference between the two types of simulation is that seed-first-simulation requires equivalent productions modulo σ, while seed-growth-simulation requires equivalent productions minus σ.Seed-first-simulation means that assemblies that map strictly to subassemblies of the seed are first produced, and all of these are valid under equivalent productions minus σ, and from there all producible assemblies contain the full seed and must map to producible assemblies in T , and all such assemblies are also valid under equivalent productions minus σ.

Basic Results and Observations About Seeds
In this section, we provide a set of relatively basic results and observations that display the amount of information that can be contained in a seed, that it is uncomputable to know whether or not blocking may be caused by the tiles of a seed, the fact that single-tile seeds cannot always be used to replace multi-tile seeds due to the potential for blocking, and that some shapes would require infinite-sized seeds to self-assemble in the aTAM.
3.1 Encoding information in a seed structure An aTAM system is defined as a triple.For example, system T = (T, σ, τ ).T is the tile set and can be encoded using an amount of information proportional to the number of tile types, t = |T |, multiplied by the amount of information required to represent each tile type, which given the number of glue types g and the maximum glue strength τ , is O(log(g) log(τ )) bits.The seed structure σ can be encoded using an amount of information proportional to the number of locations it contains |σ|, multiplied by the amount of information required to represent which tile type is at each location, which is O(log(t)), for a total of O(|σ| log(t)) bits.While the number of tile types in T impacts the number of bits required to represent each seed location, a constant number of tile types can clearly be used to define an infinite number of seeds.Figure 3 gives an example of a tile set which can be used to form an infinite number of seeds that can encode any binary number and are stable at temperature τ = 2.It also gives an example of a seed structure which may encode information in its geometry.

Uncomputability of blocking
Observation 3.1.Given an arbitrary aTAM system T = (T, σ, τ ), it is uncomputable to know if some locations in the seed assembly σ can block tiles (in one or more valid assembly sequences).
Proof.We prove Observation 3.1 by providing a simple reduction to the Halting problem.We'll call the language that consists of binary strings representing aTAM systems that have some seed location that can block the growth Figure 4: (Left) Schematic example of an assembly simulating a Turing machine and showing the uncomputability of blocking.The seed row (green) encodes the input to the Turing machine (TM) via exposed glues on the north and initiates growth of an assembly where the rows grow in a zig-zag pattern and simulate the TM in a standard way (i.e. each pair of rows represents the configuration of the TM at the time step following that of the pair below it).If and only if the TM halts on the input (the halt state is depicted by the red tile), a row of blue tiles grows to the left and then a column of tiles of the same type grows downward.This column will crash into the seed.Since the crashing column only grows if the TM halts, it is uncomputable to know if growth will crash into the seed.(Right) Slight modification to the construction on the left in which, upon halting, the TM initiates a crashing column on the left and another on the right side.This makes it uncomputable to know if the leftmost and/or rightmost seed locations will block and impossible to start from a single seed tile yet guarantee sufficient growth of the seed to provide whatever blocking may be needed.of a tile the BLOCKING language.Assume that BLOCKING is computable.Then, there exists some Turing machine, say M block , which decides the language.We now construct a new Turing machine, M halt as follows: On input M, b , where M is an encoding of an arbitrary Turing machine and b is an arbitrary binary string, M halt first constructs aTAM system T M = (T M , σ b , 2) following the design of the system on the left of Figure 4.The seed σ b is the green row which encodes b in its northern glues with an additional 4 tiles to the left that have no northern glues.The tile set T M consists of the seed tile types, plus a set of tiles that simulate a Turing machine in a standard manner (e.g.see [15] for a definition of zig-zag Turing machines and Figure 4 for a schematic depiction), plus a small constant-sized set (depicted by the blue tiles) that grows to the left from the tile representing the halting state (if it appears in the assembly, as it does if and only if M (b) halts), past the left edge by four tiles, and then a single tile type that can repeatedly attach to copies of itself in a downward growing column.Note that this column can only form if M halts on b, and in this case the downward growing column crashes into the leftmost seed tile, which blocks its growth.With T M thus constructed, M halt gives T M to M block as input.M block (T M ) accepts if some location of the seed blocks, which occurs if and only if M halts on b, and rejects otherwise.M halt simply outputs the answer given by M block .Thus, M halt solves the halting problem, which we know is uncomputable.Therefore, BLOCKING must also be uncomputable.

Impossible simulation at scale factor 1
Although it is uncomputable to know if the leftmost seed tile will block growth in the system on the left in Figure 4, it is still possible to simulate that system at scale factor 1 with a system utilizing a single-tile seed because the leftmost tile of the multi-tile seed could be used as the single seed tile of the simulating system.The seed could then grow to the right, and if the simulated TM ever halts and a column grows downward, it is guaranteed that the blocking tile of the seed must already be there.(Note that this simulation is only seed-growth simulation if the first row of the zig-zag TM growth starts from the right side and grows right-to-left, since only then can the seed be guaranteed to be fully grown before other growth begins.Otherwise, it would be a seed-growth-simulation.)However, the system depicted on the right of Figure 4 is different in this respect.Since there are two locations on opposite ends of the seed which have the potential to block growth, it turns out to be uncomputable to determine whether or not that system can be simulated at scale factor 1 by a system with a single-tile seed.This is because any green location which may be chosen as the location of the single seed tile in the simulator, which we'll call S, has the potential to result in an assembly in which a seed tile that would block growth in the Figure 5: A simple nondeterministic system with a multi-tile seed (green) that can be neither seed-growthsimulated, nor even shape-simulated, by any system with a single-tile seed at scale factor 1. This is because the center column grows upward to a nondeterministic height before possibly growing the pink row that initiates the downward growing blue columns.Each blue column may nondeterministically terminate with a red tile at any height, or continue until crashing into the seed.Any system attempting to simulate it at scale factor 1 must be able to grow a single side of the green row before growing rows that can crash into either side -or continue downward through and beyond the unfilled location of an incomplete side, which would lead to an invalid simulation and/or shape.(Note that the spacing of two empty tile locations between pairs of columns prevents the use of fuzz from enabling a simulation at scale factor 1, and the nondeeterministic ability of blue columns to terminate with red tiles before crashing prevents shape simulation.)original system, say T , isn't yet placed when the growth to be blocked in S arrives.Since the seed of T is a single-tile-wide row, the glues must be τ -strength between tiles in the green locations so growth can begin from the seed and directly proceed through the shortest sequence which completes placement of all tiles that serve as input to the TM simulation.At this point, it must be the case that one of the green end tiles (the leftmost or rightmost) has not been placed.From here, a valid assembly sequence is one which places no other tiles in the green locations but instead grows the TM simulations for an arbitrary amount of time.If both TMs halt, it is possible for the assembly sequence to proceed to grow both of the blue paths back down to the seed and for the one on the incomplete side to grow through the seed location.Thus, it is only possible to always block one side, and it is uncomputable to know if both sides need to be blocked, and therefore uncomputable to know whether or not the simulation will fail.
We now use Figure 5 to present a much simpler system and give intuition as to why even the relaxed notion of shape-simulation (i.e.only needing to generate terminal assemblies with the same shapes as the original system, without needing to follow the same dynamics) using single-tile seeds is impossible for certain systems at scale factor 1. Note that properly accounting for all technicalities, such as growth in fuzz locations, requires more complexities and in-depth analysis such as that which is provided for the proof of Theorem 4.1 (which includes the impossibility of shape-simulation at scale factor 1, among others), and here we will ignore issues that arise with fuzz, etc. to present a high-level sketch that gives the general idea.
We will refer to the system depicted in Figure 5 as T .In T , the green row is the seed assembly.A column grows upward, nondeterministically attaching one of two tile types at each step.The first has the same glue on the north and south and thus allows continued growth, and the second has no glue on the north but has glues on the east and west.Thus, this column can grow arbitrarily high before stopping upward growth.Once a tile of the second type attaches, a row of three tiles grows to each side.Then, a tile of either of two tile types can attach to form a downward growing column on each side.One of them has the same north and south glue and allows for the column to grow arbitrarily long, and the other (labeled 'Y') has no southern glue so stops the growth of the column.The growth of each downward column is nondeterministically either stopped by the attachment of a Y tile, or continues until it is eventually blocked by a seed tile.System T makes an infinite number of terminal assembly shapes, which include assemblies with center columns of all heights, and for each of those, assemblies with all combinations of left and right columns of all lengths from 2 to that of the center column.
To show that T cannot be shape-simulated at scale factor 1, we'll assume that aTAM system S is a system with a single-tile seed which attempts to do so.First, we note that we will make (relatively trivial) use of the Window Movie Lemma from [20] (which we include in Section 7.1 for completeness), that essentially says that as a constant-width path of tiles becomes arbitrarily long, it must eventually repeat the glues placed along multiple cuts (a.k.a.windows), as well as their ordering (a.k.a.window movies).This means that the segment of the path between those repeated cuts can be "pumped" (i.e.there is a valid assembly sequence in which that segment can be repeated an arbitrary number of times).The grey path growing upward and the blue paths which grow down to crash into the seed can be arbitrarily long.Therefore, no matter how many tile types are in S it is possible for the columns to be tall enough that they must be pumpable.
We now consider all possible locations for the single seed tile of S, which we'll call s.We'll call the leftmost green location l, the middle m, and the rightmost r.If s is located within a green location, it must be possible for the tile that fills location m to initiate upward growth of the grey column since that is the only connection between the seed and an infinite number of assemblies whose blue columns stop before crashing into the seed.There must be a valid assembly sequence that grows a row directly from the seed location to place a tile at m (noting that if m is the seed tile location, no tiles need to be added), at which point an arbitrarily tall grey column must be able to grow upward.It must be possible for this growth, after reaching the distance necessary for pumping, to place the pink tile which initiates the growth to the sides and the downward growing blue columns.Since the blue columns must also be tall enough to pump, it must be possible to pump them until they reach the seed.Since the only portion of the green row to have grown was that directly from the seed location to the grey tile, there must be at least one of the locations l or r without a tile before the blue column arrives, allowing the blue column to continue pumping past the green row.This creates a shape which is invalid (i.e. it cannot be made in T ), so the simulator fails.Trivial case analysis shows that if the seed location is in any other location, rather than one of the green locations, it is still impossible to ensure that pumpable columns will be blocked, and thus S must fail.
These scenarios display the difficulty associated with simulating systems with multi-tile seeds by those with single-tile seeds.Given an arbitrary system, it is uncomputable to know which seed locations, if any, can block growth.If multiple seed locations exist which can block growth, it is necessary that there be the ability to grow dependence paths from each to the portion of the assembly that could initiate the crashing growth.Without increasing the scale factor, it is not always possible to do so.
3.4 Shapes requiring infinite-sized seeds Trivially, any finite shape (where we define a shape as a connected subset of Z 2 ) can self-assemble in the aTAM.For instance, given a target shape S, for every point in S a unique tile type can be created which, for every adjacent tile when positioned correctly in S, has a strength-1 glue that is unique to that pair of adjacent tiles on their abutting sides.Thus, the size of the tile set is the number of points in S. The seed can be any single tile from the tile set, and the temperature τ = 1.This system will be directed and self-assemble a single terminal assembly of shape S.
Therefore, we consider infinite shapes.The aTAM requires that any seed assembly be finite, that is, a seed can contain only a finite number of tiles.Because of this, there are shapes that cannot self-assemble in any system in the aTAM.It has previously been shown that there exists an infinite class of shapes that cannot self-assemble in the aTAM [19,22] (the Sierpinski triangle and many other discrete self-similar fractals), and it would be easy to show that these could self-assemble if allowed infinite seeds (e.g. the seeds could trivially be the entire shapes).However, for completeness in our discussion of how seeds impact self-assembly in the aTAM, here we present a simpler example of a class of shapes which would also require infinite seeds to self-assemble in the aTAM and provide a short proof.An example can be seen in Figure 6.Observation 3.2.There exist shapes which could only self-assemble in the aTAM if seeds with an infinite number of tiles were allowed.
Proof.To prove Observation 3.2, we refer to the shape depicted in Figure 6, which we'll call S. S consists of two infinite paths.One is horizontal and goes infinitely far to the right.The other begins at the left end of the first and goes diagonally upward and to the right infinitely far.At every third x-coordinate, a vertical column exists between the two lines.Our proof will be by contradiction, so assume that S = (T, σ, τ ) is a system with a finite Figure 6: The left side of an infinite shape which could only self-assemble in the aTAM if seeds of infinite size were allowed.The full shape consists of an infinite horizontal line (along the bottom), an infinite diagonal line up and to the right, and vertical lines between those two in every third column.seed (i.e.|σ| < ∞) which self-assembles S. Let x max be the x-coordinate of the easternmost tile of σ.Since S is infinite to the right, each of the two main paths extends infinitely far to the right of x max , and there are an infinite number of vertical columns to the right of x max , each taller than the one to its left.Clearly, regardless of the size of S's tile set, each column eventually becomes tall enough to be pumpable.Let that height be denoted by p.Let c 2p be the first column of height 2p which is to the east of any point in σ.We note that, in order for S to correctly create an assembly of shape S, it must be possible for growth to proceed from σ to at least one of the bottom or top tiles of c 2p , and for that tile to initiate growth of at least half of column c 2p .(If that is not possible, then either the assembly never gets to column c 2p , or neither the top nor the bottom can initiate growth that gets to the middle, so column c 2p isn't completed and either way S fails to make shape S.) Without loss of generality, assume that σ can grow until placing the bottom tile of c 2p , which is then able to initiate growth upward at least half the height of that column, namely distance p. (If instead it is only the top tile that can grow this far, simply flip the directions in the rest of the proof.)There must exist some valid, minimal assembly sequence which grows from σ to place the bottom tile of c 2p .Let c 2p−1 denote the column which is the first to the left of c 2p .Note that it must be possible to grow the path from the bottom of c 2p−1 to the bottom of c 2p without growing the path from the top of c 2p−1 to the top of c 2p , since they are disjoint and each one-tile-wide and thus there cannot be a dependency that prevents this.Now, in S grow column c 2p upward to the mid-point, which it is known to be able to do.However, since the length of this path is the pumping length, it must also be possible to increase the length of this path arbitrarily.Therefore, do so and pump the growth of the column beyond the height 2p, which must be possible since the top tile of c 2p is not in place to block.This places at least one tile outside of shape S and this is a contradiction to the claim that S self-assembles shape S. The only assumption made of S was that it had a finite seed, thus S cannot be self-assembled within any aTAM system with a finite seed.However, if the seed was allowed to be the infinite bottom row, for example, a system using that seed could easily self-assemble S by growing the diagonal row upward and to the right, and initiating all column growth downward from that.Each column would be guaranteed to crash into the seed row, so S would be correctly self-assembled and Observation 3.2 is proven.
It is worth noting that this shape actually cannot self-assemble at any scale factor.As the columns get arbitrarily long, any fixed-width provided by a constant scale factor would eventually be unable to prevent pumping, and it must always be the case that either the top or the bottom could grow after the other, and thus the pumping arm could go past that boundary.There exist an infinite set of similar shapes, each differing by just the spacing between the vertical columns and each similarly impossible to self-assemble in the aTAM with a finite seed.Thus, this exhibits an infinite set of shapes, each of which cannot self-assemble in the aTAM at any scale factor.

Limits of Single-Tile Seeds
While we previously provided a relatively simple example to show that some systems with multi-tile seeds cannot be simulated at scale factor 1 by systems with single-tile seeds, in this section we maximize the scale factor for which that is true (since Theorems 5.2 and 5.1 prove that simulation is possible above the bounds shown).Namely, we present a result, Theorem 4.1, showing that there are systems with multi-tile seeds which require at least scale factor 3 plus the use of cheating fuzz, or scale factor 4 (without cheating fuzz), to shape-simulate using systems with single-tile seeds.Note that since seed-first simulation implies shape-simulation, this also proves that seed-first-simulation requires such scaling for some shapes.This section contains a brief description of the proof, and the full details can be found in Section 7.3.

Theorem 4.1.
There exist an infinite number of aTAM systems with multi-tile seeds that cannot be shapesimulated by any aTAM system with a single-tile seed at (1) scale factors 1 or 2, or (2) scale factor 3 without using cheating fuzz.
To prove Theorem 4.1, we present one system which can't be shape-simulated by any aTAM system with a single-tile seed at (1) scale factors 1 or 2, or (2) scale factor 3 without using cheating fuzz, and note how an infinite set of such systems can easily be derived from it.Let T = (T, σ, 1), the seed of which is shown in Figure 7 and a producible assembly of which is depicted in Figure 8, be such a system.In T , there are five locations on the perimeter of the seed in which glues are exposed and to which tiles can attach.They are depicted in green.Each arm can grow a uniquely colored subassembly, each of which uses tile and glue types unique to that subassembly.An infinite number of unique terminal assemblies, and assembly shapes, are possible in T , since, for instance, each path labeled 1 can be of arbitrary length.The intuition behind the proof is that it is possible for arbitrarily long paths that start at the ends of the seed's arms to grow away from the seed assembly, and then to grow paths that come back toward the seed, where they can crash into other arms.In order for a system with a single-tile seed to simulate this system, it would have to ensure that there are tiles in place in each arm to provide blocking before any arm is able to grow crashing paths.However, at the small scale factors allowed there is not enough room for all necessary dependence paths to grow between all arms, so simulation fails.The process of creating the tiles for a simulation at scale 4 with a single-tile seed.Beginning with the binding graph of a seed assembly σ (left), we generate a spanning tree from the westernmost tile of the southernmost row (middle).From this spanning tree, we replace each vertex with a tile from the template provided by Figure 20, leading to the tileset which comprises the scale factor 4 simulation of our initial multi-tile seed (right).The new single-tile seed of T 4 is shown as a teal tile.
5 Single-tile Seeds via Seed-First-Simulation at Small Scales Given that we have shown the impossibility of shape-simulation (the broadest form of simulation via singly seeding) at scale factors 1 and 2, a question that naturally follows is: do systems exist which are able to shape-simulate just above the proven lower scale bounds?The answer is yes -when allowing cheating fuzz, this is possible at scale factor 3 (Section 5.2), and restricting ourselves to no cheating fuzz allows for simulation at scale factor 4 (Section 5.1).Both constructions utilize seed-first-simulation.

Seed-First-Simulation at Scale Factor 4
We begin by introducing the construction for seed-firstsimulation at scale 4 without cheating fuzz.Although it is not the smallest possible scale factor for simulation, scale factor 4 has favorable characteristics that allow us to build an overall process for seed-first-simulation in a relatively straightforward manner that can be re-utilized in our scale factor 3 construction.The full proof of Theorem 5.1 is located in Section 7.4, and here we provide a brief overview.The construction of a simulating system T 4 consists of two main parts.First, we create a tileset T σ which assembles a scale-4 version of the seed of T , σ.The generation of T σ comprises the brunt of the construction.The new assembly that grows to represent the seed σ can be logically thought of as having 2 parts: the core path and the perimeter path.Each scale 4 supertile of T σ is shown to contain an interior scale 2 square which can be easily connected to its neighboring scale 2 squares; these 4 tiles are called core tiles.The core path is a dependence path which represents a Hamiltonian path through the core tiles, allowing for all supertiles in the seed to be connected to the remainder of the seed assembly, enabling seed-first simulation.By focusing on the connectivity of the core tiles within the supertiles of the seed assembly, the core path is generated utilizing the fact that all shapes with scale factor 2 contain a Hamiltonian cycle (see proof in [25]).We generate both the core path and the perimeter path from a set of scale factor 4 template tiles which take advantage of the presences of a Hamiltonian cycle in the core tiles.One of the supertiles represented as a template is the origin supertile which contains the single-tile seed σ 0 , and the beginning of the perimeter path.We connect the end of the core path to the beginning of the perimeter path; this is the key part of the construction which allows for seed-first simulation.On the edges of tiles of the perimeter path, exterior glues allow for the attachment of tiles.A high level visualization of the steps of generating the new tileset T 4 is found in Figure 9.
Second, we create scale 4 versions of the tileset T .Before creating the scaled versions of T , we additionally need to prevent the re-growth of portions of the seed which attempt to re-grow the perimeter path.Re-growth is prevented by generating T IO , an expansion of T , which identifies all possible τ strength combinations which can allow a tile to attach (serving as its "input" glues) and then generating new tiles with specific 'inward' and 'outward' glues.(This is a standard technique in tile assembly constructions, and can be found in the construction of [4] and others).Finally, we generate the scale 4 representations of T IO based upon a single point of cooperation and/or competition between the supertiles.(See Figure 10 for a high-level depiction.)In addition to assigning tiles which grow into legal fuzz regions, we must take into account collisions of an arbitrary supertile with the  seed assembly and add glues which allow for the continuation of the dependence path.

Seed-First-Simulation at Scale Factor 3
We demonstrate that an arbitrary aTAM system is able to be seed-first-simulated at scale factor 3 utilizing cheating fuzz.
The full proof of Theorem 5.2 is found in Section 7.5.This proof is by construction which, while similar to that presented in the construction of Theorem 5.1, requires extra care in the routing of the both the dependence path and perimeter path through the seed-representing assembly to prevent diagonal fuzz by the tiles in T σ .In a scale 4 supertile, the perimeter path contains tiles in every supertile, regardless of its location in σ.This is not possible in scale 3 seed assemblies, specifically with regards to supertiles which are not on the perimeter of a structure.This potentially inhibits the placement of perimeter tiles in supertiles adjacent to cavities (locations in Z 2 which do not contain a tile but are surrounded by seed tiles) which may be present in a multi-tile seed.This is necessary for seed-first-simulation.To ensure the perimeter path may reach these internal cavities, we provide a modification to the connectivity of the seed prior to assigning supertiles from a set of supertile templates which leverages the changes in connectivity.For the generation of the remaining tiles of T , we utilize the the same techniques of Theorem 5.1 to develop a T IO , and the design for the point of competition/cooperation in the 3 × 3 supertiles is slightly modified, as shown in Figure 11.

Optimal Tile Complexity for Seed-First-Simulation
In this section, we give an overview of a universal construction that takes as input a program P T , where P T outputs any arbitrary aTAM system, say T , and the construction outputs an aTAM system S with a singletile seed that seed-first-simulates T .Technical details can be found in Section 7.6.The tile complexity of S is asymptotically related to the length of the input program.Thus, the tile complexity is O( K(T ) log(K(T ) ), where K(T ) is the Kolmogorov complexity of T , i.e. the length of the shortest program that outputs T .Theorem 6.1.Given an arbitrary aTAM system T , there exists c ∈ Z + and aTAM system , and S T seed-first-simulates T at scale factor c.
At a high level, the construction works by taking as input the program P T and creating a hard-coded set of tiles (the first of which will be the single seed tile) that self-assemble a row whose north glues encode a compact version of that program that is first "unpacked" by a set of tiles that present the full program P T along the northern glues of a row of tiles.A tile set that simulates a Turing machine then uses that program as input, runs that program to obtain the description of aTAM system T , then uses that description to run a variety of subprograms.One subprogram executes the algorithm from the intrinsic universality construction of [10] which computes a string encoding information about T in a format that can be used by that construction to simulate the tiles of T as large supertiles with that information on their exteriors.Another creates a 2 × 2 scaling of the seed assembly of T and computes a Hamiltonian cycle through it.(An example can be seen in Figure 12.)It then creates a string containing entries for every stop along the Hamiltonian cycle that contain the information to be put on each output side.During this computation, a binary counter tile set keeps track of the number of computational steps so that the scale factor is computed and utilized.Then, the information is moved along the cycle and the information copied to the exterior sides of the assembly representing the scaled version of the seed of T .Once that structure is complete, the IU construction of [10] (only minimally changed) takes over and manages the simulation of the rest of steps in the simulation.

Simultaneous simulation
In this section, we describe a relatively simple modification to the construction of Theorem 6.1 that results in a single aTAM system that simultaneously and in parallel simulates every aTAM system.At a high level, this construction works by the (standard aTAM) assumption that there are an infinite number of copies of the seed, which in this case is a single tile.From each copy, an arbitrarily long row encoding an arbitrary binary number nondeterministically grows.Each row terminates at a random point when a special tile attaches to "cap" the growth of the row.At this point, the row encodes a random binary number n in its northern glues (and every binary number has some chance of being represented).Each such assembly encoding some number n then proceeds to grow into a simulation of the nth tile assembly system in the aTAM using the construction of Theorem 6.1.Thus, in parallel, the infinite set of seeds grows into an infinite set of assemblies, each simulating one aTAM system from the infinite set, and each aTAM system is simulated (with some non-zero Figure 13: (Left) Assuming that q 0 is the start state of Turing machine D , using the tile on the left (which we'll refer to as b seed ) as the seed tile, this set of tiles can self-assemble to represent any binary string of the form 1(0 ∪ 1) * with a terminating x and that assembly can be used as input to D .(Right) An example assembly encoding the binary string "10100".probability) 2In order to discuss such a simulator, we must define a new type of representation function and slightly modify the definition of simulation which allows multiple scale factors to be utilized in parallel.This is because there are a countably infinite number aTAM systems and therefore for any scale factor m ∈ Z + , there must exist an infinite number of aTAM systems, with increasingly large tile sets to represent, that require scale factor greater than m to simulate.
We will call this new notion of simulation mixed-scale-simulation.For use with our result, we will base it off of the definition of seed-first-simulation with the following modification.
Rather than the standard definition of a representation function, due to the fact that different scale factors must be allowed for different simulations occurring simultaneously in the same system, we define an adaptive representation function as one which is not confined to a grid of fixed-size squares, but which instead is allowed to inspect any locations of an assembly and only be restricted by the requirement that it is able to inspect only a finite portion of an assembly before reading enough information to (1) compute the scale factor of the simulation being carried out, and (2) compute the mapping from supertiles in that assembly to tiles from the simulated system, and then (3) to correctly identify supertiles at that scale.Theorem 6.2.There exists an aTAM system U ∞ that mixed-scale-simulates all aTAM systems, simultaneously and in parallel.
Proof.We prove Theorem 6.2 by construction.Therefore, we present aTAM system U ∞ = (U, σ, 2) and discuss how it is constructed and how it behaves.
Let D be the Turing machine defined in the proof of Theorem 6.1.We now define a new Turing machine D which takes as input a binary string b ∈ 1(0 ∪ 1) * (i.e.any binary string beginning with a 1) that is immediately followed by the letter 'x', and does the following: 1. D enumerates over the set of all aTAM systems following some enumeration3 , and stops after printing the bth aTAM system (where the binary string b is interpreted as a positive integer).Let T be the string representing the bth aTAM system.
2. D creates a Turing machine, which we'll call P T , that takes no input and simply prints T and halts (by having the characters of T hard-coded into its transition rules).

D runs D(P T ) and outputs what D(P T ) outputs.
We now define tile set U ∞ as the tile set T T from the proof of Theorem 6.1 minus the tile sets T σ and T D .Instead of the tiles of T σ which encode some specific program, we add the set of tiles T b pictured on the left in Figure 13.Then, instead of the tiles T D we add tiles that simulate D in the same way that the tiles of T D simulated D (i.e.zig-zag growth, an embedded counter, etc.).
We can now fully define U ∞ = (U ∞ , σ, 2), where σ is one copy of a tile of type b seed located at (0, 0).U ∞ does the following.For every i ∈ Z + , there exists a producible assembly that self-assembles from the tiles of T b that represents i in binary, followed by the character 'x'.Each such assembly initiates the growth of an assembly that simulates D on that value of i.This causes D to print out the ith aTAM system and then input that to D, which will then cause the tiles from the construction of Theorem 6.1 to use that assembly to grow in such a way that it correctly seed-first-simulates the ith aTAM system.
The adaptive representation function R * works as follows.Given an arbitrary assembly, it begins at location (0, 0), which is the location of the seed tile, b seed .It reads the number encoded by the tiles to the right of that tile until encountering a tile encoding an 'x' and thus the end of the binary number.If no such tile is found, the assembly maps to empty space as it doesn't (yet) simulate any system.For those that do encode a complete number, R * runs Turing machine D with that number as input to get the full specification of the system being simulated by that assembly (which we'll call T ), and from that it is also able to compute the scale factor of the simulation, m.R * is then able to inspect the m × m squares and match the information encoded in sufficiently completed supertiles to tiles in T .
Since, for every aTAM system, there exists an assembly which simulates it, and there exists an adaptive representation function capable of identifying the system being simulated by each assembly and correctly mapping the supertiles to tiles of that simulated system, U ∞ mixed-scale-simulates all aTAM systems, simultaneously and in parallel.

Cross-model intrinsic universality
In the following we claim that, given some model M , if for any arbitrary aTAM system T , there exists a system in M that simulates it, then there is a tile set in model M that is intrinsically universal for the aTAM (using seed-growth-simulation).This means that a single tile set in M is capable of being used to simulate any aTAM system.First, we note that our use of the term "model" in this case applies not only to the complete set of systems within a model, but also to what is commonly referred to as a "class of systems within a model".For instance, the aTAM is a model and so is the 2-Handed Assembly Model, so referring directly to one of those models would mean the full set of systems within those models.Alternatively, the subset of systems within the aTAM which are directed is often referred to as the class of directed aTAM systems.The following result applies to both models and classes of systems within models.
While it may seem like the existence of a one-to-one relationship between systems in some model A and systems in another model B that can simulate them may imply the existence of a tile set in B which is intrinsically universal for model A, this is not the case.A counterexample occurs with the class of systems in the aTAM which are directed.Trivially, using the identity function as the representation function and scale factor 1, for every system in the directed aTAM there exists a system within the directed aTAM which simulates it.However, as proven in [15], there exists no tile set which can be used within the directed class of aTAM systems to simulate all directed aTAM systems.Claim 6.1.Let M be a model of tile-based self-assembly such that, for every system T in the aTAM, there exists a system T ∈ M that simulates system T of the aTAM.Then, there exists a tile set in M which is intrinsically universal for the aTAM by performing seed-first-simulations.
To support Claim 6.1, we now define aTAM system U b as follows.Use the tile set U from U ∞ of the proof of Theorem 6.2, set the temperature to 2, select an arbitrary binary number b and create a seed assembly, σ b , that is pre-built from the tiles of T b (starting with b seed ) to represent b with an 'x' after the last bit (i.e., rather than letting such assemblies nondeterministically form, the seed is now a single, pre-selected number encoded into a seed assembly).
Let M be a model of tile-based self-assembly such that, for every aTAM system T , there exists a system T in M that simulates T .If this is true, then there must be a system in M , which we'll call M b , that simulates U b .Let T M be the tile set used by M b , c be the scale factor of the simulation, and R the representation function.We now claim that, since a seed assembly using T M , c, and R was made for an arbitrary value of b, it should be possible to use the same T M , c and R to make seed assemblies encoding all values i ∈ Z + .The intuition behind this claim is that it must be possible to reuse the macrotiles representing tiles of individual bit values, since that would have to be the case if b was large enough, so it must be possible to combine them to form any desired value.Assuming that claim, it is possible to generate system M i , using T M , R, and c to create an assembly over T M that maps to σ i so that M i simulates U i = (U, σ i , 2) for arbitrary i, and note that not only does M i simulate U i in the standard way (i.e. with a pre-built seed structure for a multi-tile seed), using R and c, but we can also determine the representation function R and scale factor c such that we can interpret the assemblies in M i as assemblies in T i , which M i is also seed-first-simulating via R at scale factor c .
Let Turing machine M * be a Turing machine that takes as input an assembly σ i and runs an aTAM simulator on the system (U, σ i , 2) until the it completes the simulation of D (i) (where D is the TM defined in the proof of Theorem 6.2).At that point, M * will be able to compute the scale factor c at which (U, σ i , 2) simulates aTAM system T i , as well as the representation function R for that simulation.
Define R as follows: On input α which is a producible assembly in M i (i.e. an assembly over the tiles of T M ), 1. Run M * on input assembly σ i to obtain c and R .(Note that the assembly σ i is hard-coded into R so that it is specific for the simulation of aTAM system i.) Since we claim it's possible, for an arbitrary i ∈ Z + , to create an assembly from the tiles of T M that represents σ i under R at scale factor c, and that such an assembly seed-first-simulates the ith aTAM system, it would then be the case that T M is intrinsically universal for the aTAM by performing seed-first-simulations.

Technical Appendix
In this section we provide technical definitions and details of proofs of the results.

Window Movie Lemma
Here we include definitions related to the Window Movie Lemma from [20], as well as restate that lemma, for completeness.
A window w is a set of edges forming a cut-set in the infinite grid graph over Z 2 .Given a window w and an assembly α, a window that intersects α is a partioning of α into two configurations (i.e. after being split into two parts, each part may or may not be disconnected).In this case we say that the window w cuts the assembly α into two configurations α L and α R , where α = α L ∪ α R .Given a window w, its translation by a vector c, written w + c is simply the translation of each of w's elements (edges) by c.
Given an assembly sequence α and a window w, the associated window movie is the maximal sequence M α,w = (v 0 , g 0 ), (v 1 , g 1 ), (v 2 , g 2 ), . . . of pairs of grid graph vertices v i and glues g i , given by the order of the appearance of the glues along window w in the assembly sequence α.Furthermore, if k glues appear along w at the same instant (this happens upon placement of a tile which has multiple sides touching w) then these k glues appear contiguously and are listed in lexicographical order of the unit vectors describing their orientation in M α,w .
, with l, m ∈ Z + ∪{∞}, be assembly sequences in T with results α and β, respectively.Let w be a window that partitions α into two configurations α L and α R , and w = w + c be a translation of w that partitions β into two configurations β L and β R .Furthermore, define M α,w , M β,w to be the respective window movies for α, w and β, w , and define α L , β L to be the subconfigurations of α and β containing the seed tiles of α and β, respectively.Then if M α,w = M β,w , it is the case that the following two assemblies are also producible: (1) the assembly Essentially, the Window Movie Lemma states that if the same window movie occurs in two different assembly sequences of some TAS T , but in different locations, valid producible assemblies in T include (1) an assembly with the "left" half created by the first sequence and the "right" half created by the second sequence, and (2) an assembly with the "left" half created by the second sequence and the "right" half created by the first sequence.Typical use of this lemma includes showing that some portion of a sufficiently large growing assembly must "pump", i.e. have repetitive structure exhibited by repetition of identical window movies.When this occurs, there must exist valid assembly sequences in T in which the portions of the assembly that grow after each occurrence of that window movie can be swapped, and/or the subassembly between the identical window movies can be repeated (a.k.a.pumped ) an arbitrary number of times.
7.2 Proof of Lemma 2.1 Restatement of Lemma 2.1 (Dependence paths): Given a singly-seeded aTAM system T , producible assembly α ∈ A[T ], and sets of locations L 1 , L 2 ⊂ dom α, if L 2 strictly depends upon L 1 , then in each valid assembly sequence of T there must be a dependence path from some l 1 ∈ L 1 to some l 2 ∈ L 2 .
Proof.We prove Lemma 2.1 by contradiction.Therefore, assume that, given singly-seeded aTAM system T = (T, σ, τ ), producible assembly α ∈ A[T ], and sets of locations L 1 , L 2 ⊂ dom α, that L 2 strictly depends upon L 1 .However, for the sake of contradiction assume that there exists some valid assembly sequence in T in which there is not a dependence path from any point l 1 ∈ L 1 to any of the points l 2 ∈ L 2 .
By the definition of strict dependence, we know that a tile is placed in L 1 before a tile is placed in L 2 .Therefore, we have two cases to consider: (1) dom σ ∈ L 1 , i.e.L 1 contains the location of the seed of T , or (2) L 1 does not contain the seed location.We'll show that case (1) can't hold by induction.The induction hypothesis is that, given a producible assembly α in which every tile has a dependency path from the seed (which is in L 1 ) to it, then any tile which binds has a dependency path to the seed.The base case is the first tile attachment, which must be directly to the seed and therefore that tile has a dependency path to the seed.We prove the induction hypothesis simply by noting that if every tile of α has a dependency path to the seed and a new tile attaches to α, the dependency path of any tile to which it binds is simply extended by 1 to be a dependency path from the location of the seed to the new tile.Therefore, there is a dependency path from the seed to any location in a producible assembly, and thus case (1) cannot hold.Now, consider case (2).Assume that L 2 strictly depends upon L 1 , but that there is no dependency path from any location in L 1 to any of the locations in L 2 .Let α be any assembly sequence which places tiles in L 1 and L 2 .Since L 2 strictly depends upon L 1 , α must place a tile in L 1 before L 2 (by definition of strict dependence).However, we can now use α to make a new assembly sequence α as follows.
Step through α one tile placement at a time.Add all tile placements from α to α until any tile placement in L 1 .Do not add that tile placement to α , and from that point add all tile placements from α which are not in L 1 and the tiles are able to attach to the assembly growing from α to that sequence as well, until and including the first tile placement in L 2 .By the assumption that there is no dependency path from L 1 to L 2 , it must be possible for α to also place the tile in L 2 .Then, in α , place the same first tile in L 1 which α places there.This must be possible because no tile has been placed in that location in α and whichever tiles bordered that location in α to allow a tile to attach there also border it in α .However, this would mean that in α , a tile is placed in L 2 before L 1 , which is a contradiction.Therefore, there must be a dependence path from L 1 to L 2 in any valid assembly sequence in T and Lemma 2.1 is proven.

Proof of Theorem 4.1 Restatement of Theorem 4.1:
There exist an infinite number of aTAM systems with multi-tile seeds that cannot be shape-simulated by any aTAM system with a single-tile seed at (1) scale factors 1 or 2, or (2) scale factor 3 without using cheating fuzz.
Proof.To prove Theorem 4.1, we present one system which can't be shape-simulated by any aTAM system with a single-tile seed at (1) scale factors 1 or 2, or (2) scale factor 3 without using cheating fuzz, and note how an infinite set of such systems can easily be derived from it.Let T = (T, σ, 1), whose seed is depicted in Figure 7, be such a system.(An infinite set of similar systems can be derived by increasing the lengths of the arms of the seed to arbitrary values and adjusting the tile set as necessary to accommodate the growth that will be described.)In T , there are five locations on the perimeter of the seed in which glues are exposed and to which tiles can attach.They are depicted in green.Each arm can grow a uniquely colored subassembly, each of which uses tile and glue types unique to that subassembly.An example assembly is depicted in Figure 14.An infinite number of unique terminal assemblies, and assembly shapes, are possible in T , since, for instance, each path labeled 1 can be of arbitrary length.
Our proof will be by contradiction, so assume that there exists singly-seeded aTAM system S = (S, σ S , τ ) such that S shape-simulates T at either (1) scale factor 1 or 2, or (2) scale factor 3 but does not use cheating fuzz.Let m be the scale factor used by S to shape-simulate T , and let g be the number of unique glues types on the tile types of S. We define p to be the "pumping length" of a simulated one-tile-wide path in S and set Figure 14: Depiction of an example assembly in T (from the proof of Theorem 4.1) in which paths have grown from each arm of the seed.In order to show all paths, their lengths are greatly reduced, but all path segments marked with an arrow are assumed to be of length greater than the pumping length p.The blue, yellow, pink, and red sets of paths, which grow from seed arms A, B, C, and E, respectively, are similar modulo rotation/reflection and the lengths of the repeating periods of some of the paths labeled 4 and 5 (i.e.some of those paths travel distance 5 horizontally and 5 vertically before repeating, and some travel 6 horizontally and 6 vertically before repeating).Path segments marked with capped lines (i.e.those marked 2 and 3 in the blue yellow, pink, and red, and that marked 6 in the gold) are fixed lengths.Note that the slopes of the lines marked 7, 8, and 9 in the gold section are ±6/4, and those of the pink are red sections are all ±1/1, so all pumpable paths can be greater than the pumping length without colliding with each other and still be aimed at the appropriate seed locations.p = ((g + 1) 6m • (6m)! + 1) • 6 + 1.This value is derived such that we can apply the Window Movie Lemma of [20].Let R : B T m S be the representation function that maps m-block supertiles over S to tiles of T .Figure 14 shows an example of a producible, terminal assembly α ∈ A [T ] (with the pumpable path segments shortened to fit on the page).From each green location of the seed a path grows outward from the seed (these paths are labeled 1 in the figure).These paths can be arbitrarily long, and we will only consider lengths significantly longer than the pumping length of S, p.Each path labeled 1 then splits, ultimately resulting in 3 paths which grow back toward the seed.Since the paths labeled 1 are significantly longer than p, so can all of these others be, and we consider an α in which this is the case.
We'll now refer to the blue paths originating from the seed point labeled A, and note that the same arguments hold for the yellow, pink, and red sections up to rotation.The gold section has a different geometry, but the same general principles hold.In this assembly α, all paths terminate, but only after growing longer than length p.Each has a periodic section which can repeat an arbitrary number of times consecutively, but for the paths labeled 4, 5, and 7, nondeterministically there is also a chance, after each repetition, for a "capping" tile to attach causing the path to terminate.However, note that the shape and slope of path 4 would allow it, if it were not capped, to extend via continued repetitions until it crashed into the green location of arm B (i.e. it would be able to place a tile in that location if there wasn't already a tile there).Similarly, the path labeled 5 could crash into the green location of arm E. Each colored section has the potential to grow paths that can crash into the green locations of the two neighboring arms.
Since S is assumed to shape-simulate T , there must be a terminal assembly β ∈ A [S] that maps, via R, to an assembly with the same shape as α.Thus, there must be an assembly sequence in S that creates β, which we'll call β.By the Window Movie Lemma, since each of paths 4 and 5 are of lengths greater than p, there must also be valid assembly sequences in S that produce extended versions of each path (by pumping an earlier segment before the terminating "capping" tile attaches).We examine a few such possible extensions and potential collision now (and a depiction of an assembly impossible to form in T , but to which the assembly maps can be seen in Figure 15).
Let l B refer to the location of the blue highlighted seed tile in arm B of α, l D to the blue highlighted location in arm D, l p4 to a location on path 4 which is greater than distance p from the beginning of path 4, and l p5 a location on path 5 which is greater than distance p from the beginning of path 5. Given some location l ∈ Z 2 , let R −1 (l) refer to the set of locations in S which map to location l in T under R. Lemma 7.2.R −1 (l p4 ) strictly depends upon R −1 (l B ).
Proof.Lemma 7.2 says that all valid assembly sequences in S place a tile in the macrotile location mapping to l B before placing any tile in the macrotile location mapping to l p4 .We prove this by contradiction, so therefore assume that there exists an assembly sequence which places a tile in the location mapping to l p4 before placing any tiles in the macrotile location mapping to l B .Because the length of path 4 is greater than p, so is the portion of β which maps to path 2. This means that, by the Window Movie Lemma, there must be a repeated window movie along cuts of the subassembly mapping to path 2, and therefore valid producible assemblies can also be made by pumping the repeated section of that subpath arbitrarily many times.(A schematic depiction of the pumping of a path can be seen in Figure 16.Let β be an assembly, which must therefore be producible in S, in which the subassembly mapping to path 2 is pumped so that it passes through the green location of arm B and places tiles which resolve to at least one more period of the path (i.e. it places the 5 tiles of each of a vertical and horizontal section of the path).This must be possible by the Window Movie Lemma (which allows the pumping) and the fact that no tiles can previously have been in locations occupied by the newly extended path since, if no tile has been placed in l B , then there also cannot be tiles in the fuzz locations to its left and right (since those are not legal fuzz locations before l B has resolved to a tile in T , which it cannot since it's empty).Thus, the tiles mapping to the blue path as well as any allowable fuzz positions around it can be freely placed (in exact duplication of the pumpable ordering that previous copies must have been placed in for an earlier segment of the path).Since the macrotiles of the previous section of the path map to tiles of path 4, so must the newly pumped macrotiles since the representation function remains constant.
At this point we can note that, regardless of whatever additional tile additions may be made to β , it must map to an assembly whose shape cannot be that of a terminal assembly of T .This is because there is no possible assembly sequence in T in which a path with the repeating period (5 horizontal and 5 vertical positions) can extend from the right side of the green location of arm B. This is because the green tile of arm B can only initiate  paths that would not be able to return to the location to its immediate east, and any path that could extend into that location from the pink growth would have a different period (i.e. 6 horizontal and 6 vertical positions).Therefore, S would fail to shape-simulate T in this case.This is a contradiction to the assumption that R −1 (l p4 ) does not strictly depend upon R −1 (l B ), and thus Lemma 7.2 is proven.
The same logic of Lemma 7.2 can be applied to show that strict dependence occurs between two of the pumpable paths growing from each arm of the seed and the locations marked in blue in Figure 15 of each of the two neighboring arms.By Lemma 2.1, this means that there is a dependence path going from a point in each blue-marked location, through each of the two neighboring arms, to the locations on those pumpable paths.In Figure 7, the blue line across each arm shows a minimal cut across each.In α that cut crosses two locations (one tiled and one that could validly include the growth of fuzz).In β, the scaled version of each cut crosses two macrotile locations (one that must resolve to a tile under R, and one that is potentially allowed to contain growth of fuzz and also potentially able to eventually resolve into a tile).The scale factor m of the simulation determines the size of each of these macrotiles.Lemma 7.3.In assembly β of S (as depicted in Figure 14), a minimal cut across the macrotiles of at least one arm (and its associated fuzz) must cross at least 4 tiles.
Proof.We prove Lemma 7.3 by contradiction, so assume that there is a cut across at least one of the arms of β that crosses fewer than 4 tiles.We first note that two consecutive tiles on a dependence path cannot also both be part of a dependence path traveling in the opposite direction.This is by the definition of a dependence path, since the ith tile of a dependence path must be placed before the (i + 1)th tile, which only allows one direction for a dependence path across a pair of tiles.
We now refer to Figure 17, which gives a schematic depiction of the directed paths that must exist between each neighboring pairs of arms.The topmost figure depicts each path growing separately, and shows that in this case, there would need to be four paths traveling through each arm, resulting in minimal cuts across 4 tiles for every arm, so this cannot be the case.Since all dependencies must be resolved by dependence paths, the only alternative is to concatenate paths (which can allow dependencies to be resolved in a cyclic manner).Concatenating paths only serves to reduce the need for some separate path if a single path is created which visits all arms.This is depicted in the middle and bottom figures of Figure 17, which show that it is impossible for all necessary dependence paths to exist without requiring at least 4 paths passing through each arm.Even though, in some cases, at different points the same path may pass into or out of an arm (e.g. when the same path travels through all arms and extends to revisit one or more arms), in each such case an additional path of tiles is required to maintain the dependencies of the full path and/or the correct directionality.Therefore, in all cases, at least one arm must have a minimal cut crossing at least 4 tiles.This is a contradiction to the assumption that some cut crosses less than 4 tiles, and proves Lemma 7.3.
We now know by Lemma 7.3 that the minimal cut across some arm must cross at least 4 tiles.This immediately means that the simulation scale factor of S, m, must be greater than 1 since the shortest cut across each arm at scale factor one (depicted as blue lines in Figure 7) crosses only one tile and one valid fuzz location.Additionally, for the case of m = 3 where cheating fuzz is not allowed, we note that the cuts represented by the blue lines in Figure 7 each cross only one macrotile location which can resolve to a tile, providing a maximum of three tiles to be crossed by the cut, and the fuzz macrotile location (outlined in red) is not allowed to receive any tiles.This is because no glues are exposed on the exterior edges of the seed tiles adjacent to those locations and since β is terminal, no paths can crash into those locations.This means that those fuzz locations could never resolve to tiles or be in locations that map to locations adjacent to exposed glues, and thus represent cheating fuzz.Therefore, S must not be simulating T at scale factor 3 without using cheating fuzz, since at least one of the dependence paths would have to place tiles in locations of cheating fuzz.
Thus, the only remaining case to consider is that in which the scale of the simulation is m = 2.In this case, the cuts marked in blue cross exactly 4 locations which can receive tiles.This provides enough locations for the dependence paths to grow, but requires that if there are any unfilled locations within any of the fuzz location outlined in red, they must be contained between a pair of dependence paths and unreachable from the exterior, which is a fact we will utilize shortly.
We now have two cases to consider: (1) there exists even one assembly sequence that results in β and which fills one of those locations in a way that the representation function R maps to a tile in T , or (2) in all assembly sequences, such locations are filled so that R maps them to empty space in T .In case (1), we follow such an assembly sequence and since β is terminal, the domain of the assembly that it maps to in T via R is a domain that no terminal assembly in T matches (since there is no chance for a tile to grow from the seed at that location and no path crashes into it) and thus S fails to shape-simulate T .Therefore, case (1) cannot hold.This leaves us with the final case to consider, that in which there is always at least one red outlined fuzz position that maps to empty space.Since any unfilled locations in such macrotiles are sealed off from the exterior, and we've already determined that no tiles can be placed within those cavities, there is no way to add tiles to those macrotile locations and thus they must always map to empty space.We can now simply note that the paths labeled 7 have the potential to grow so that they crash into each of those locations (examples seen as the two filled locations outlined in red in Figure 8).This means that there are producible assemblies in T that have tiles in those locations, but there are no producible assemblies in S that can map to assemblies that have tiles in those locations.Therefore, S also fails in the case, meaning that it fails in all cases.This is a contradiction that S shape-simulates T at either (1) scale factor 1 or 2, or (2) scale factor 3 without using cheating fuzz.Since the only assumption made about S is that it is singly-seeded, it holds that no singly-seeded aTAM system can shape-simulate T at (1) scale factors 1 or 2, or (2) scale factor 3 without using cheating fuzz.As previously mentioned, T can be easily modified by changing the lengths of the seed arms (and appropriately modifying the path-growing tiles) through an infinite range, yielding an infinite set of aTAM systems with multi-tile seeds that cannot be shape-simulated by singly-seeded systems at these scale factors, and thus Theorem 4.1 is proven.Proof.We prove Theorem 5.1 by construction.Let T = (T, σ, τ ) be an arbitrary aTAM system, and let s = |dom σ| be the number of tiles in the seed σ.
We define the system T 4 which seed-first-simulates T by T 4 = (T 4 , σ 0 , τ 4 ).The temperature is defined by the function τ 4 = max(2, τ ).Temperature 1 systems can be trivially simulated by temperature 2 systems, and cooperative growth is utilized in the perimeter path to allow for correct seed-first-simulation.We define T 4 as the combination of two sets of tiles, T 4 = T σ ∪ T IO .T σ are the 16s tiles which will self-assemble the scaled version of σ.T IO is the scaled expansion of the tileset T .
We begin by the generation of T σ .
Observation 7.1 is demonstrated in Figure 18, and from this we define this scale 2 square as the core tiles of a scale 4 supertile.Figure 18 also demonstrates that the core tiles of adjacent supertiles can be connected via 2  additional tiles in each supertile, demonstrated by the red lines.The presence of a Hamiltonian cycle is proven to exist for shapes of scale factor 2, as shown in [25].This allows us to guarantee that a core path can be created which visits each supertile contained in the seed.The generation of this Hamiltonian cycle follows the procedure developed in [14] which consists of the following two steps.
First, a spanning tree must be generated; this can be found utilizing breadth-first or depth-first search algorithms.For convenience, we define the origin supertile as the westernmost tile in the southernmost row of the seed.The root of the spanning tree is set as the origin from which either breadth-first or depth-first search is carried out.
Second, we are able to replace each tile in the spanning tree with an associated supertile based upon its neighbors -we begin with the origin supertile.If s = 1, the system T already contains a single-tile seed, and we utilize a specific origin tile; this is case 0).Due to the location of the origin supertile, only 3 additional cases exist for how the origin tile is connected to the remainder of the seed: 1) the origin tile is connected to the remainder of the seed by its north edge only, 2) the origin tile is connected to the remainder of the seed by its east edge only, 3) the origin tile is connected along both its north and east edges.Cases 0), 1), 2) and 3) are illustrated as σ, N, E and N+E in Figure 19, respectively.The new seed tile of our single-tile seed (σ 0 ) is defined by the teal tiles in Figure 19; these are the tiles which encode the start of core path.The remaining tiles of the spanning tree are represented by a set of five supertiles (adapted from [14]), shown in Figure 20.These five supertiles (and their rotations) allow for the core path to be connected to any supertile in the representation of a seed.The tiles of the core path are assigned once all supertiles are assigned to the spanning tree.The first tile of the core path is σ 0 , and to ensure that the core path is a dependence path tiles are added with unique strength τ 4 glues along adjacent edges.Additionally, each tile in the core path assigns a unique strength τ 4 − 1 glue on the edge facing the exterior of the supertile; this glue is utilized in the creation of the precedence path.The final process in the creation of the seed is creating the tiles of the perimeter path.This is the set of tiles that allow for the encoding of the glues which are present on the exterior of the seed.The first tile of the perimeter path is the yellow tile in the origin supertiles of Figure 19, and is connected via a unique strength τ glue to the last tile of the core path (indicated by the vertical bar).The remaining tiles of the perimeter path then 'follow' the direction of the core path.For perimeter path tiles which share an edge with tiles of the core path, a unique strength τ 4 − 1 glue is present along that edge for each supertile.A strength 1 glue of type p is present along the the edge the perimeter tile shared with its predecessor in the perimeter path.Certain perimeter path tiles may not share an edge with a tile of the core path -this occurs in tiles of types d and e (on the corners) in Figure 20 when the perimeter path takes a 90 degree turn.In this case, the dependence path tiles which share two edges with other dependence path tiles have one edge with a unique strength τ glue connecting to the preceding tile in the dependence path.The second edge contains a strength 1 glue of type p, allowing for the next tile in the dependence path to attach to the seed assembly using cooperative growth.On the exterior-facing edges of all perimeter path tiles, the glues which represent the glues of the simulation of the tile being simulated by the supertile are added to the tiles of the perimeter path following the encoding and point of competition demonstrated in Figure 10.The glues exposed by the perimeter path function identically to that of the remaining scale 4 supertile representations, allowing for growth of fuzz into points of cooperation (the process by which will be outlined).
A visualization of the process of seed tile generation is presented in Figure 9, from the initial scale 1 seed to the creation of a perimeter path.
To complete the creation of the full tile set, we must create a supertile representation of each tile type in T that can attach outside of the assembly representing the seed σ.An interesting item to note here is that, for each tile type t ∈ T for which one or more tiles of type t appear in the seed assembly σ, there will be two logically different types of supertiles that represent t in T 4 .One will be that which is grown via the tiles of T σ (and which contains the core and precedence paths), and one which is a "standalone" supertile that represents a copy of a tile of type t outside of the seed.The result of the transformation to make the T IO (a.k.a."inward/outward") tile set is that it is never possible to regrow any portion of a version of a supertile that is specific to the seed in any location outside of that representing the seed, and to always instead allow supertiles of the standalone version for type t to grow in those locations.
We generate this tile set in the manner similar to that outlined in [4] in the sections "minimal glue sets" and "inward-outward glues" (and note that this technique is now relatively common in tile assembly results).T IO is an expansion of the tiles of T so that for each t ∈ T , we make a new tile for every subset of glues that share glue labels with the seed whose strengths sum to "just barely" τ 4 .Each glue in T is expanded to have N, E, S, W variants corresponding to the the direction they are pointing, also represented by the unit vectors {(0, 1), (1, 0), (0, −1), (−1, 0)}.For example, a glue of type x would be represented by types x N , x E , x S , x W .We say a glue is pointing inwards if the the glue type has a direction opposite of the edge which it resides (e.g. x N on a south edge of a tile or x E on a west edge).Alternatively, a glue is pointing outwards if the glue type matches the edge which it resides (e.g., x N on a north edge of a tile or x E on an east edge).For each tile t ∈ T , we consider every combination of that tile's glues.We define a minimal glue set S as a set of glues such that, if any glue is removed from S, the set falls below combined strength τ 4 .For each minimal glue set, we generate a tile where the glue labels of the minimal set are such that they are pointing inwards (i.e. they act as "input" glues), and the remaining glue labels are pointing outwards (i.e. they act as "output" glues).Finally, the only tiles of T σ which are modified are perimeter path tiles which represent exterior-facing glues.These perimeter path tiles are modified such that their glues labels are modified to be outward facing.This transformation ensures the invariant that any tile which is designed to be part of a supertile that represents a tile in σ appears only in the assembly mapping to σ, and prevents incorrect regrowth of any portion of the seed outside of that, since the seed supertiles are designed to only grow a full copy of the seed, rather than allowing individual supertiles to grow independently.
Next, we create the tiles to form the scale four supertiles representing each tile generated by T IO .We begin by defining a point of cooperation and/or competition in each supertile which allows for supertiles of T IO to be mapped from assemblies of T 4 to T by R * .Figure 10 shows this cooperation point with the tile labeled 'C'.Given this point of cooperation, for each t ∈ T IO we provide a single tile with the minimum glue set of inward glue labels at the prescribed strength.Whichever tile type attaches in location C of a supertile fully determines the tile type in T that the supertile maps to under R.Each neighboring supertile that has grown to represent a tile in T grows a path toward the C locations in the neighboring supertiles that haven't yet filled in.For those whose edges represent adjacent glues of strength τ , this path, if unblocked, can grow into the neighboring supertile's C location without cooperation to determine the type of tile that that supertile will represent all by itself, which is by design since the τ -strength glue being represented would be able to cause the neighboring tile to bind all by itself.In this case, the location C acts as a point of "competition" where various growth paths may be competing to be the first to arrive and place a tile there.For those that edges that represent glues of strength less than τ , upon reaching the C location in a neighboring supertile the path stops and exposes a glue of strength less than τ 4 , which forces a tile placed in the C location to use cooperation if it is going to bind using that path.This is analogous to the cooperation that would be required with the glue exposed by the tile which is represented in T , and in this case location C acts as a point of "cooperation".As soon as the C location of a supertile receives a tile, that supertile represents the corresponding tile in T , and the output sides of the tile in location C each have τ 4 strength glues which match with a set of 3 tiles that grow towards the cooperation point of an adjacent supertile.We note that these paths are legal fuzz, since the supertile with the C location filled in now maps to a tile and those locations are thus (non-diagonally) adjacent to at least one mapping supertile.
At this point, we've described both portions of the tile set of T 4 : T σ which contains the tiles that grow the supertiles representing the seed σ, and T IO which contains the tiles that form the supertiles that represent all tiles not contained within the seed-representing assembly.We've shown how the single seed tile in T 4 initiates growth of first a core path that goes through the center of every supertile of the seed-representing assembly (providing the correctness of the "seed-first" portion of the simulation, since these supertiles can then map to the full seed assembly before allowing any growth outside of the seed).It then initiates the growth of the perimeter path, which circles the entire assembly and effectively "activates" each supertile by placing glues on their perimeters that allow them to initiate growth away from the supertile.The growth away from the supertile is handled by the tile types in T IO , which are able to correctly grow the 4 × 4 supertiles representing each tile type of T by growing paths representing glues from neighboring supertiles to points of cooperation/competition that correctly handle the selection of valid supertiles to grow into, which in turn then grow the necessary output glue paths to neighbors.Only in cases where the tile represented by a supertile has a glue in direction d that wasn't used in its initial binding (i.e. an "output" glue) does that supertile grow a path into the neighboring supertile.Since the supertile originating the output path maps to a tile in T at this point, this represents legal fuzz, and since Figure 21: A possible case of the perimeter path growth around the supertiles representing σ being blocked by growth of non-seed representing supertiles.The supertile represented by the fuchsia tiles, which itself is allowed to grow from the supertile represented by the yellow tiles, grows north to the point of cooperation.Further growth north of the fuchsia tiles is blocked by the presence of the core path, but the currently placed tiles of the perimeter path can no longer cooperate with the core path to allow for placement of additional perimeter path tiles.The next tile of the perimeter path is indicated by the grey tile with dashed edges -it cooperates with a strength 1 'p' glue provided the fuchsia tiles in the path along with the τ 4 − 1 strength glue provided by the core path tile to continue the growth of the perimeter path.sides which do not have output glues do not grow such fuzz, cheating fuzz is never grown.Furthermore, the careful design of T IO and the exterior glues of the seed-representing structure using the "inward/outward" glue conventions ensures that the tiles of T σ never appear outside of the seed-representing supertiles.
To complete the proof of correctness of the seed-first-simulation by T 4 , the final case left to consider is that where a portion of the assembly representing the seed has completed its perimeter path, allowing growth to proceed away from the seed while the perimeter path hasn't yet completed for another portion of the seed-representing assembly.This growth away from the seed could potentially eventually crash into a portion of the seed-representing assembly which hasn't yet completed growth of its perimeter path.Potentially this could obstruct the completion of the perimeter path and thus stall the completion of the seed structure.More specifically, this may occur where the tiles attempting to grow an output path from a completed supertile into the location of a neighboring supertile (which happens to be one in the seed structure that hasn't yet completed its perimeter path), to the cooperation/competition point of that supertile.This may 'obstruct' the normal growth of the perimeter path (and is demonstrated in Figure 21).To allow for the continued growth of the perimeter path, the tile of the output path growing into the seed supertile's location contains a strength 1 p glue on exposed sides along the direction of the perimeter path.Thus in the case that growth of the perimeter path is 'cut off'; east and west growing output tiles have a p glue on their north and south edges, and north and south growing output tiles have a p glue along their east and west edges.Additionally, depending upon the direction from which the output path grows into the perimeter path, it may block the corners diagonal to the growth path.The output path growth from each direction will place a tile in the diagonal corners of the supertiles, denoted by the locations highlighted in white in Figure 10.In this way, it is ensured that a perimeter path can always complete and that growth away from the seed cannot cause incorrect or incomplete growth.Note that in cases of these collisions, the tiles on both sides of the collision map to the correct tiles in T under R, and these cases are representative of situations where there is blocking performed by a seed tile.
We investigate the overall tile complexity of T 4 .For the tile complexity of T 4 , we define the function C 4 (s, t, g) : N → N where s = |σ|, t = |T |, g is the total number of unique glue/strength combinations in T and σ.We consider the worst possible upper bound for each of the items, and thus our tile complexity is a conservative estimate.This function takes into account the number of tiles utilized by both T σ and T IO .
For T σ , each tile utilizes all 16s tiles to include the perimeter path and core path.We then consider the fuzz required for each edge of a tile which contains an exterior facing glue.At maximum, each tile in the seed can have 3 exterior facing glues; we take this as our upper bound.For each edge with tiles will have up to 2 additional tiles required to grow to the point of cooperation from the perimeter.This leads to an additional 3 × s × 2 = 6s tiles.
Let us consider the tiles of T IO .For output glues, fuzz can be shared between different tiles; it is the tile at the point of cooperation/competition which causes the output to be differentiated.Glue has an input and output Figure 22: The basic outline of a scale 3 supertile t.This general tile makes no assumption on the path which is utilized to represent the tiles of the dependence path within the supertile.The green edge represents the edges shared with the neighbor supertile t in which contains tiles of the dependence path with an index smaller than any tile in t (i.e., assembled earlier than t).The red edges represent the edges shared with up to 3 neighbor supertiles t out,1 , t out,2 , t out,3 such that there exists tiles of t in the dependence path with indices smaller than any tile in t out,1 , t out,2 , t out,3 .Two edges are taken, as this allows for the dependence path to both extend and return through the edges shared with t in .The three tiles on the right demonstrate the rotations of this tile.
variant, and we assume this is present for all 4 sides.4 tiles of fuzz are required per side to grow to adjacent points of cooperation/competition, leading to 2 × 4 × 4 × g = 16g.Finally, we consider the T IO expansion.From [4], the size of the minimal glue set is at most 6 (4 choose 2) for a tile at maximum, thus we require at most 6 tiles for each tile in t for our expansion.We additionally include tiles of the seed in this count -leading to an additional 6t + 6s tiles.
Thus, T 4 correctly seed-first-simulates an arbitrary aTAM system T at scale factor 4 without making use of cheating fuzz using T 4 ≤ 28s + 16g + 6t tiles, and so Theorem 5.1 is proven.Proof.We prove Theorem 5.2 by construction.Let T = (T, σ, τ ) be an arbitrary aTAM system.We generate the tile system T 3 = (T 3 , σ 0 , τ 3 = max(2, τ )) taking as input tileset T , seed σ and temperature τ .The first step is to generate the tileset T σ ⊂ T 3 which allows for growth of the seed assembly.We develop a template for all scale 3 supertiles which allows for the creation of tiles which allow for seed-first simulation, shown in Figure 22.We show by induction that utilizing this template (without specifying exact tile locations at this point), Lemma 7.4.Given a finite scale 1 assembly, α 1 , we can generate an arbitrary finite scale 3 assembly, α 3 , such that a dependence path l exists which visits each supertile and returns to the supertile which contains the tile.
Proof.We prove by induction.Let us consider the binding graph of α 1 .The base case is the westernmost tile of the southernmost row; we assign the supertile of Figure 22 to this location.Due to the location of the tile, no other tile will be present along the location t in ; as such, this contains the minimal value of the dependence path.We call this tile the 'origin' tile.For this tile, we investigate the tile locations adjacent to the origin tile in α 1 .For each location of t out,i which contains a tile where i ∈ {1, 2, 3}, we rotate the supertile of Figure 22 as necessary such that t in matches up with the edge of t out,i Once all supertiles adjacent to the origin (which is at most 2) have been added, we select the an arbitrary supertile which has neighbor tiles adjacent to it in α 1 which are not part of α 3 .This repeats until all locations of α 1 have an associated supertile in α 3 .At termination, the resulting α 3 then contains a supertile in each location of α 1 with a dependence path l which visits each supertile and begins and ends the origin.With Lemma 7.4 we have a template which to define our supertiles, which will guarantee a dependence path through an assembly α 3 .In addition, we define the single tiles which provide input and output to the system by specific edges of Figure 22.The light green edge shares a glue from the precedent path of the prior supertile adjacent to the current supertile.Light red edges are those where the precedent path exits the current tile.Dark red edges are those where the precedent path re-enters the current tile.Finally, the dark green edge is that which the precedent path returns to the prior supertile.As such, we then are restricted for the precedent path traveling between specific edges; tiles adjacent to light green can only have a precedent path which leads to a tile adjacent to dark green or light red.Tiles adjacent to light red can only have a precedent path which leads to a tile adjacent to dark red or dark green.
Using the prior restrictions, the process of seed tile creation begins by defining the origin supertile.As in Lemma 7.4, we define the origin supertile as the westernmost tile in the southernmost row of the seed.If the system T already contains a single-tile seed, we utilize a specific origin tile; this is case 0).Due to the location of the origin supertile, only 3 possible cases exist for how the origin tile is connected to the remainder of the seed: 1) the origin tile is connected to the remainder of the seed by its north edge only, 2) the origin tile is connected to the remainder of the seed by its east edge only, 3) the origin tile is connected along both its north and east edges.Cases 0), 1), 2) and 3) are illustrated as σ, N, E and N+E in Figure 23, respectively.
As compared to scale 4, the number of general supertiles is increased in scale 3. Simply applying rotation to a single case of a supertile with 3 neighbors (similar to supertile b in Figure 20) would result in the dependence path unable to be connected between neighbor tiles.An additional difference is that instead of the dependence path taking the the clockwise most neighbor, it utilizes the counter-clockwise most neighbor.This results in a total of 8 supertiles, as shown in Figure 24.We note that these These tiles have an additional invariant -any possible perimeter path which utilizes fuzz outside the borders of the scale 3 supertile does not utilize diagonal fuzz.While each of the tile types may need cheating fuzz, we must guarantee that fuzz is not diagonal.We note that diagonal fuzz is only reachable from a subset of the supertiles in Figure 24 which may be present on convex corners of σ: these are a, c and d.The perimeter path for this scale 3 construction also follow the dependence path, similar to scale 4. By inspection and comparing the locations of diagonal fuzz shown as red locations in Figure 2, no locations which contain cheating fuzz overlap with diagonal fuzz.Any fuzz which may be required by the perimeter path to be in a diagonal location is present on corners where two tiles are adjacent -as such, this is a location of acceptable cheating fuzz.
Lemma 7.5.The supertiles of Figure 24 generate a dependence path which visits each supertile and returns to the supertile which contains the origin.
Proof.The tiles of Figure 24 obey the edge restrictions of the template scale 3 tile; as such, Lemma 7.4 follows for these tiles.
The application of general set of scale 3 supertiles to the spanning tree of an arbitrary seed has the potential to isolate cavities from the perimeter path.For full seed-first-simulation (and thus, also shape-simulation) it may be required for tiles to attach to glues inside of cavities.Figure 25 demonstrates a case where a seed which is assigned supertiles from Figure 24 and a cavity is prevented from being accessed by the perimeter path.To resolve this issue, we require two solutions: 1) developing a set of tiles which we guarantee allow for the perimeter path to access a cavity regardless of its location, and 2) correctly placing the tiles in the seed.At a high level, we choose the northernmost corner of the westernmost edge of the cavity and draw a line in the +y direction until it reaches either another cavity or the perimeter of the seed.All the edges which this line passes through we remove.We Figure 24: The supertile types which allow for the dependence path to follow the depth-first spanning tree depending upon the side of the origin tile which the tile can be connected through.Note, we can rotate these to allow for all possible path through the seed assembly.Blue dashed boxes indicate the locations of cheating fuzz which may be needed for the perimeter path.
Figure 25: A valid assignment of supertiles which leads to cavities which are not reachable by the perimeter path.The red line indicate the cavities which are connected together but unable to be accessed from the perimeter path on the exterior of the seed.Due to the orientations of tiles, the dependence paths are adjacent to one another and block any possible perimeter path from reaching the internal cavities.demonstrate his can be done safely in the case of cyclic cavities -cavities for which there exists a cycle between the vertices of the binding graph of the seed which contain only the vertices within a Chebyshev distance of 1 from any location within the cavity.In the case of non-cyclic cavities, cavities for which there does not exist a cycle between the vertices of the binding graph of the seed which contain only the vertices within a Chebyshev distance of 1 from any location within the cavity, we demonstrate that they can be recursively combined until either they form a cyclic cavity or they are connected to the perimeter path.
We first provide a description of cyclic and non-cyclic cavities, with the smallest possible cyclic cavity (a single tile missing from the center of a 3 × 3 square) demonstrated in Figure 26.We define regions as (potentially infinite) connected subsets of Z 2 .The regions split into 3 categories -cavities, the assembly, and free space (the remaining plane).When taking the complement of the domain of an assembly, there exists the infinite connected subset of Z 2 which is the free space.Additionally, for shapes which contain cavities (sometimes called holes in the literature), we will find finite connected subsets -these are the cavities within an assembly.Given that a cycle is formed around cyclic cavities, we can safely remove a single edge from the cycle without causing a tile in that cycle to become disconnected.Non-cyclic corners either separate two cavities in scale 1, or separate a cavity from the exterior of the shape.Figure 27 demonstrates that in the worst case, two tiles which are at the non-cyclic corners of a scale 3 supertile will have a 1 tile wide path.This path allows for tiles to be generated which connect the Figure 27: For a non-cyclic cavity, we demonstrate how even in the worst case of corner tiles connected to two neighbors themselves in a non-cyclic corner that a 1 tile wide path exists between the non-cyclic cavity and the adjacent space.This applies to all possible rotations of non-cyclic cavities.two regions -as such, we then can assign a new cavity from the union of the two connected subsets of Z 2 .Either the two regions are a both non-cyclic cavities and can be combined, or the non-cyclic cavity is connected to the perimeter (and thus, free space).In the latter case that the non-cyclic cavity is connected to the perimeter, we are done; no further modifications need to be made.In the former case, the two non-cyclic cavities are joined and can the resulting cavity may remain a non-cyclic cavity.We continue the process of joining the non-cyclic cavity together with its neighbor region.Otherwise, the two non-cyclic regions may become a cyclic region themselves, at which point we halt.Once all non-cyclic cavities have been combined and are either part of cyclic cavities or connected to the perimeter, the binding graph can then be modified.
After the prior steps have finished, all cavities are now cyclic cavities.This provides us with the property that a single edge can be removed from all cavities, and the vertices which are contained in the cycle remain connected.For all remaining cyclic cavities, we remove the edge between the vertices surrounding the cyclic cavity adjacent to the northern most vertex of the western most column of the cavity.From this vertex, we can then define the two vertices which will have their edge removed; for a northwest vertex location of (i, j) we add the vectors (−1, 1) and (0, 1) to identify the two vertices to separate.This provides us with the tuple ((x 0 , y 0 ), (x 1 , y 1 )) which corresponds to the coordinates of the two vertices.Of the two vertices, we take x 0 as the x coordinate of the two vertices with the smallest value (i.e., the western-most vertex).We then increment y 0 and y 1 by 1 successively, removing all edges with the coordinates until either vertex is in the location of another cavity or free space.When edges are removed from the binding graph such that two cavities are connected, similar to the combination of non-cyclic cavities we combine the two cavities.We track the values of the vertices defined by (x 0 , y 0 ) and store these values for modifying the supertiles in these locations, we additionally include the vertex at (−1 + i, j); this guarantees the 1-tile wide path will reach into the cavity.We call this tracked set of vertices M .This process is repeated for all cavities until the perimeter is connected to all cavities.Upon connecting all cavities to the perimeter, we then assign supertiles of Figure 24 to the modified binding graph demonstrated in Figure 28.
With the modifications of the binding graph, we additionally must assign new supertiles which allow for the perimeter path to take advantage of the new binding graph structure.The deletion of the edges from each cyclic cavity provides opportunity for a 1 tile wide path to exist in two manners.Either the dependence path exists in a north-south direction, following the removed edges, or the dependence path enters from the west and terminates at a vertex which was adjacent to the deleted edges.In the latter case, tile a from Figure 24 is utilized in the Figure 28: (left) The initial binding graph of a seed which contain cavities.We note that cavities (B) and (C) are, by themselves, non-cyclic cavities.These can be combined to form a larger cyclic cavity.(middle) After being combined, from the northernmost corner of the westernmost edge of each cavity we remove edges of the connection graph along the yellow line, guaranteeing access of the perimeter path to each cavity.We note that both cyclic cavities (B)(C) and (D) are connected to the cavity of (A), which is then connected to the perimeter.(right) A spanning tree is formed from the assignment of the scale 3 supertiles in Figure 24. Figure 30: The five cavity connector supertiles which allow for the perimeter path to reach all cavities.The left three tile types allow for the dependence path of the cavity connector tiles to be joined to the dependence path of the remaining seed.The right two tiles shift the dependence path to the west side of the supertiles, guaranteeing that a 1 tile wide path exists to the cavity in question.We note that the tile 'a' from Figure 24 may also be utilized in the cavity connector as shown; it also provides a 1 tile wide path for the perimeter path to utilize.
presented rotation.This supertile in its presented state allows for a 1 tile wide path.If the dependence path follows north-south growth, additional tiles must be utilized which allow for the 1 tile wide path.We note that for proper dependence path alignment, five new variants of tiles are defined.The three left supertiles in Figure 30 allow for dependence path utilized by the supertiles in Figure 24 to be shifted; in turn, this facilitates the usage of the right two supertiles which shift the dependence path to the left 2/3 tiles and leaving the necessary 1 tile wide gap for the perimeter path.Tiles from each set of vertices which describe the 1 tile wide path, M , are replaced by the supertiles in Figure 30.
The final remaining task for the creation of the seed tiles is assigning the tiles of the dependence path and perimeter path.As with the scale 4 construction, the dependence path tiles are assigned according to the supertile templates and are assigned unique strength τ 3 glues shared between adjacent tiles of the dependence path.When the dependence path terminates at the origin supertile, another unique strength τ 3 glue is assigned to the edge between the final tile of the dependence path and the first tile of the perimeter path (yellow tile, Figure 23) The perimeter path tiles begin by "following" the outermost tiles of the dependence path in a clockwise fashion.The core tiles contain a unique strength τ 3 − 1 glue which is shared with the perimeter path tile adjacent to it, and tiles in the perimeter path exposes a strength 1 glue of type p along the the edge the perimeter tile shared with its predecessor in the perimeter path.As in the scale 4 simulation, strength τ 3 glues are required for attachment of perimeter path tiles which carry out 90 degree turns.A key difference between the perimeter paths of scale 3 versus scale 4 is that scale 3 perimeter paths may be required to branch; in particular, this occurs when the perimeter path may need to access cavities which have only a width-1.This requires that perimeter path tiles may require having two outwards facing p glues; these are denoted by the circle with the surrounding.Additionally, not all tiles of of the supertile may be immediately defined by either the perimeter path or the dependence path.This may require small 'offshoots' from the dependence path to provide a path to follow; we can see an example of this in Figure 29 in the tile type a which is rotated 90 degrees clockwise.We note that in cases like these, they manifest when type a supertiles from Figure 24 are leafs of a spanning tree adjacent to the perimeter path.
For the remaining simulations of 3 × 3 tiles, we define the point of cooperativity/competition as the central tile in a 3 × 3 square, as shown in Figure 11.The process of developing T IO and the modification of T σ to prevent regrowth of the dependence path follows directly from the scale 4 example.In the case of tiles crashing into the perimeter path, the fuzz growing from the point of cooperation/competition must be able take additional locations, as the perimeter path is guaranteed to be located in any particular location due to the use of cheating fuzz.These locations have been highlighted in white -tiles which grow into these locations have p glues facing towards the interior of the supertile which the fuzz is growing into.
We investigate the overall tile complexity of T 3 .For the tile complexity of T 3 , we define the function C 3 (s, t, g) : N → N where s = |σ|, t = |T | and g is the total number of unique glue/strength combinations in T and σ.We consider the worst possible upper bound for each of the items, and thus our tile complexity is a conservative estimate.This function takes into account the number of tiles utilized by both T σ and T IO .
For T σ , there exists a variable number of tiles, depending upon the perimeter path taken.Figure 24 c requires at most 14 tiles for both perimeter path and dependence path -we take that as our high value; 14s.We then consider the fuzz required for each edge of a tile which contains an exterior facing glue.Based upon our assumption high value, the fuzz is already present and reaches the cooperation/competition point.Comparing with the all other tiles, the most possible fuzz required (Figure 24 a) also requires 14 tiles.Thus, we have 14s tiles required at most for the seed.
Let us consider the tiles of T IO .For output glues, fuzz can be shared between different tiles; it is the tile at the point of cooperation/competition which causes the output to be differentiated.Glue has an input and output variant, and we assume this is present for all 4 sides.4 tiles of fuzz are required per side to grow to adjacent points of cooperation/competition, leading to 2 × 4 × 4 × g = 16g.Finally, we consider the T IO expansion.From [4], the size of the minimal glue set is at most 6 (4 choose 2) for a tile at maximum, thus we require at most 6 tiles for each tile in t for our expansion.We additionally include tiles of the seed in this count -leading to an additional 6t + 6s tiles.
Thus, T 3 correctly seed-first-simulates an arbitrary aTAM system T at scale factor 3 requiring the use of cheating fuzz using at most |T 3 | ≤ 20s + 16g + 6t tile types, and so Theorem 5.2 is proven.
7.6 Technical details of the optimal tile complexity for seed-first-simulation In this section we provide the proof and technical details for Theorem 6.1.
First, we define a few structures and auxiliary tile sets that will be useful in our construction.
In [10], a tile set U was given that is intrinsically universal for the aTAM.This means that, given an arbitrary aTAM system T = (T, σ, τ ), there is a function that specifies how the tiles of U can be arranged to form a seed structure, say σ T , and another function that returns a representation function R mapping macrotiles of over U to tiles of T , so that the resulting system correctly simulates T (at temperature 2, regardless of the value of τ in T ) using R.In that construction, the macrotiles (a.k.a.supertiles) use a well-defined format for their sides, called supersides.The format used in [10] is shown on the top in Figure 31.For our construction, we will slightly modify the encoding of supersides by adding "spacer" sections, which are potentially very large sections that are simply passed over by the gadgets of the construction and used merely to allow for correct alignment and a larger scale factor that is driven by the space required to simulate a relatively complex Turing machine.In our construction, we will utilize the superside encoding on the bottom, and it will frequently be split in half into portions we'll refer to as g l and g r .For a given T , all segments will have constant encodings across all macrotiles except for the "glue" sections which will consist of the binary encoding of the specific glue that each superside is simulating.To correctly utilize the superside encoding to perform simulations following the procedure of [10], our construction will use a slightly modified version of their tile set U , which we will call U .The only differences with U will be its ability to skip over the (arbitrarily long) spacer sections (effectively just absorbing the larger scale factor imparted by them, and a slight change to the tiles that form the left end of a so-called "frame" row (which will be discussed when the tiles for growing the "activation row" are explained. Proof.We prove Theorem 6.1 by construction.Therefore, let P T be a program that outputs T = (T, σ, τ ), an arbitrary aTAM system.We will define S T = (T T , σ T , 2) such that σ T consists of a single tile and S T seed-firstsimulates T at some scale factor c ∈ Z + while using O( |P T | log |P T | ) tile types.First, we will use the technique of [1] to compress P T , allowing for the use of an optimal number of tile types.We note that the binary string P T can be encoded in a higher base, which we'll refer to as b.This allows for the length of the compressed encoding to be reduced to |P T | log(b) .Tiles can be designed so that from the seed tile a row of |P T | log(b) tiles assemble with that compressed encoding on their north sides (requiring |P T | log(b) unique tile types).Following the construction of [1], tiles of O(b) types can then assemble to the north of that row to "decompress" the string, resulting in the encoding of P T on the northern glues of the tiles of their northern row.Note that, in order to correctly integrate with the tiles to be described later, these decompression tiles also perform binary counting to count the number of rows that they assemble during the decompression.(This only increases the tile complexity by a constant multiplicative factor, thus the decompression still only requires O(b) tile types.)The subest of tile types described so far will be referred to as T σ later in this proof.At this point, the tile complexity is |P T | log(b) + O(b).As discussed in [1], the base b can be selected such that this quantity is equal to O( |P T | log(|P T )) ).Finally, we note that the length of the shortest program P T which outputs T is the Kolmogorov complexity of T , denoted K(T ).Thus, this portion of the construction requires O( K(T ) log(K(T ) ) tile types.As will be shown, all other tile types used are from a constant tile set, independent of the system T , and thus the overall tile complexity is O( K(T ) log(K(T ) ).This is the information theoretic lower bound for an aTAM tile set representing T .We now define the rest of the construction.Let σ 2 be a mapping of each point of σ to a 2 × 2 square (i.e. the Figure 31: (Top) Encoding of the information presented on a superside in the intrinsically universal construction of [10].The length of each section is listed below it, with respect to the tile set T that is being simulated, (Bottom) Modified superside encoding for the construction in Theorem 6.1.Note the additional "spacer" sections (whose sizes will be related to the running time of Turing machine D), and the division into halves called "g l " and "g r ".
points of σ at scale factor 2). Let H be a Hamiltonian cycle through σ 2 and consider it to begin and end in the leftmost of the bottom-most 2 × 2 square of σ 2 , starting in its top-left and ending in its bottom-left.(See Figure 12 for an example.)Define Turing machine D that uses a one-way-infinite-to-the-right tape, takes as input program P T , and does the following: 1. D moves its head across the input from left-to-right then back from right-to-left.(This is merely a technicality to guarantee that the runtime is longer than the output, a fact which will be utilized later.) 2. D runs P to obtain the string encoding the definition of T , which we will refer to as T .
3. D uses T to run the algorithm of [10] and compute the modified encoding of a superside for a macrotile simulating T (as shown in Figure 31).In the base encoding, the spacer sections will be a single tile wide and the glue encoding will be of the null glue.This encoding will be split into a left half and a right half, which we will call g l and g r , respectively.
4. D uses the definition of the seed σ from T to compute the set of points contained within σ 2 , which we will refer to as σ 2 .(See Figure 12 for an example.) 5. D uses σ 2 to compute the Hamiltonian cycle H . (See Figure 12 for an example.) 6. D creates a string, which we'll call H, that contains a section encoding each location on the cycle H .The full string H is a concatenation of one section for each point on the path.The encoding for each point is the following: (a) Each contains 3 portions, labeled F , L, and R for "forward", "left", and "right", respectively.
(b) For all sections other than the one for the final point, exactly one of the portions will be marked with either a " * " or a "#", indicating that that is the direction of travel to the next point.(For example "F * " means the path continues forward in the same direction as from the previous point, "L * " means it turns left, and "R * " means it turns right.)The difference between the " * " or a "#" markings are that " * " indicates that the next location is within the same 2 × 2 macrotile as the current location, and "#" indicates that the location is in a different, neighboring 2 × 2 macrotile.
(c) Each of the two remaining un-marked portions will either have (i) the symbol " " to indicate that its side is an interior side of σ 2 (i.e. it is adjacent to another block in σ 2 ) and thus no information needs to be output to that side, or (ii) if the side is an exterior side of σ 2 (i.e. it is on the perimeter of σ 2 , whether that is the external perimeter or the perimeter of a cavity enclosed by σ) one of the strings g l or g r , with either the null glue or the encoding of a glue type in the portion of g l or g r labeled "glue" in Figure 31.(Figure 12 shows a shorthand encoding of the first 7 locations of the path.Rather than giving a full encoding of each of g l or g r , it simply notes which is used for that location and gives the name of the glue that is encoded within it, or " " if it is the null glue.)Traveling clockwise around the exterior of a 2 × 2 square of σ 2 , the counterclockwise most of the two edges making up each side receives the g l string, and the clockwise most receives the g r string.Additionally, there are special markings that may be added to the end of the g r encoding as follows: i.If the right side of the g r encoding will be at the end of a convex corner, the symbol 'c' is added to the rightmost glue of g r .ii.If the right side of the g r encoding will be at the boundary between two different 2 × 2 blocks of macrotiles but not at a concave corner, the symbol '4' is added to the rightmost glue of g r .iii.If the right side of the g r encoding will be at the boundary between two different 2 × 2 blocks of macrotiles at a concave corner, the symbol '7' is added to the rightmost glue of g r .
Additionally, another type of special marker is added to H as follows: (a) In the encoding of the last location in H, for the portion labeled L, the leftmost symbol of the encoding of g r is given the additional special marker 'A'.This will be used to eventually trigger the initiation of the pre-activation row which will begin its growth around the exterior of the seed-representing assembly after this final macrotile of H has grown.
(b) If the seed σ contains any internal cavities that are completely enclosed by σ, special handling for those cavities is required.For each such cavity, D determines which side of which macrotile will be the final to be grown along it.Let d ∈ {F, L, R} be the direction of that side relative to the growth of that macrotile.Let g d ∈ {g l , g r } be the string that is to be placed on the d side of the macrotile.If g d = g l , then the rightmost symbol is given the additional special marker 'A'.Else, if g d = g r , then the leftmost symbol is given the additional special marker 'A'.This will be used to eventually trigger the initiation of the pre-activation row which will begin its growth around the the interior cavity to which it is adjacent after this final macrotile of on the perimeter of that cavity has grown.
7. D outputs H and halts.
The tile set T T can now be constructed as follows.T T is the union of the following tile sets: 1.The previously defined tile set U , which is a modification of the tile set U from [10].
2. The tile set T σ , which was previously discussed, is hard-coded to grow from the seed tile a row whose northern glues encode the compressed version of P T , and then decompress the bits of P T (the program which outputs T ) in binary.It will also display a binary number encoding the number of rows which have grown upward to that point.The rightmost tile of the initial row will be the seed tile, σ T of S T .The glues between the tiles of this initial row will be strength-2, allowing the full row to grow directly from the seed tile.Additionally, the northern glue of the leftmost tile of the northern row will not only encode the first bit of P T , but it will also encode the start state of Turing machine D and be a strength-2 glue.
3. The tile set T D , which is a tile set that simulates Turing machine D in a standard zig-zag manner (see [15], among many others, for examples of zig-zag Turing machine simulations).Additionally, (1) each row of the simulation of D grows one additional tile to each of the left and right sides, and (2) the bits of a binary counter are overlaid on the tiles of the simulation, with the least significant bit being on the leftmost tape cell (although each row extends by one additional tile to both the left and right ends, the Turing machine D's tape has a fixed left end which never moves) and the bits extending to the right.This counter starts from the value encoded by the binary counter of T σ and is incremented during the growth of every row so that it effectively keeps a count of the runtime of D.

4.
The tile set T splitter .(There are four rotated versions of these tiles, so we will explain the version that grows from north to south.The other three versions simply consist of rotated versions of the described tile types.)These tiles grow on top of row which encodes (from left to right) an arbitrary number of "blank encoding" tiles, followed by an encoding of H overlaid with the bits of a binary counter, followed by an arbitrary number of "blank encoding" tiles.The grow in a zig-zag manner and cause portions of the information in the input row to be rotated to each of the left and right, as well as propagated northward.These tiles only copy a subset of the input row to be propagated in each direction.(See Figure 32 for an example of the "splitter" in the middle square.)The subset for each direction is determined by the leftmost section of the encoding of H, which contains a portion for each direction (F , L, and R).(a) For the direction marked with either a " * " or a "#", the full encoding of H is copied to the side minus the leftmost section (i.e. the leftmost F , L, and R portions are not copied, but instead replaced by "blank" values).This serves to erase that portion from H as it is passed to the next block, so that the leftmost remaining portion will encode the correct instructions for that block.If the erased direction was marked with "#", that symbol is still included on the left side of H to signal to the next component (the copier) that the information is being copied across the boundary of one 2 × 2 macrotile into another.Additionally, the overlaid bits of the binary counter are copied in this direction.
(b) For any direction which consist of either g l or g r (with the appropriate glue encodings), that string is rotated to that side, along with the overlaid bits of the binary counter.The rest of the positions encode "blank" values.
(c) For any direction consisting of just the blank, " ", nothing is rotated to that side, and that side of the macrotile is not grown (since it is interior to the 2 × 2 block of σ 2 and thus can't be used to initiate any additional growth).

5.
The tile set T shif ter .(There are four rotated versions of these tiles, so we will explain the version that grows from north to south.The other three versions simply consist of rotated versions of the described tile types.) These tiles grow on top of row which encodes (from left to right) an arbitrary number of "blank encoding" tiles, followed by an encoding of either g l or g r , followed by an arbitrary number of "blank encoding" tiles, with a subset of the tiles overlaid with the bits of a binary counter.These tiles cause zig-zag rows to grow which decrement a copy of the binary counter value until it reaches the value 0 , extend row by an additional tile on each of the left and right sides, and copy the encoding of g l or g r upward while shifting its two halves to either end of the final row.As mentioned previously, and shown in the bottom of Figure 31, each of g l and g r have a "spacer" section which is initially a side tile wide.As these zig-zag rows grow upward, they shift the information on the left of the spacer to the left, and the information to the right of the spacer to the right.Since rows alternate direction of growth, they alternate the direction in which they can shift information.Initially, the information which is being shifted in the same direction as the growth of a row is shifted by 6 positions.This is possible by having glues that encode up to the last 6 "remembered" values at a time.Once the information being shifted reaches the end of the row, the shifting switches to 2 positions per shift so that the information remains at the end of the row until arriving at the final row.(See Figure 34 for a schematic depiction of the dimensions of a macortile and how the encodings of g l and g r are shifted.)The reason for initially shifting 6 spaces at a time is that, since shifting occurs every second row for each direction, this provides a slope for the information being shifted of 2/6, i.e. 1/3.The dimensions of the macrotiles are largely dictated by dictated by the runtime of D(T ), which is denoted by the value t in Figure 34.Since D is designed so that its runtime must always be greater than the length of its output, the length of H must always be less than t (by -significantly -more than 2).Therefore, the maximum amount that any information could need to be shifted is bounded above by 3t (see Figure 34).Since the shifter grows upward a distance of t − 2 rows, that means a slope of 1/3 must always suffice to shift the information to the correct information before reaching the top row.Once reaching the edge of the row, the information can then be shifted at a slope of 1/1 for the remaining rows to stay at the end of the rows.The tiles that perform the shifting can easily accommodate this by having a special marking on the tiles at the end of the rows to detect when the shifting information overlaps that mark.
6.The tile set T copier .(There are four rotated versions of these tiles, so we will explain the version that grows from north to south.The other three versions simply consist of rotated versions of the described tile types.)These tiles grow on top of row which encodes (from left to right) an arbitrary number of "blank encoding" tiles, followed by an encoding of H overlaid with the bits of a binary counter, followed by an arbitrary number of "blank encoding" tiles.There may also be a "#" symbol on the left end of the encoding of H.These tiles cause zig-zag rows to grow which simply decrement a copy of the binary counter value until it reaches 0, while also copying the original value of the binary counter as well as the encoding of H upward.If a "#" symbol is on the left end of H, an additional 4 rows are grown upward, copying all of the same information but erasing that "#" symbol.(This accounts for growth from one 2 × 2 macrotile into another and the spacing required to account for the pre-activation and activation rows that are between each pair of macrotiles where at least one is a non-seed macrotile.These will be described later.)Since this copying behavior will always need to be performed twice in a row (except for the possible spacing of the extra 4 rows), a special marking is also copied upward through the first occurrence of the copier so that a second occurrence of the copier is initiated.(An example can be seen at the top of the first macrotile and bottom of the second macrotile in Figure 33.) 7. The tile set T act .This tile set creates two rows that grow around a perimeter of the assembly consisting of the seed-representing macrotiles.This includes the external perimeter around the entire seed-representing assembly, as well as the perimeters of any internal cavities (if there are any).The first row to grow is called the pre-activation row, and begins growth when the special marker 'A' makes it to the exterior row of a macrotile tile.This special marker causes the tile that is placed there to include an exterior facing strength 2 glue that initiates the growth of the pre-activation row that grows in a clockwise direction around the perimeter of which that side is a part.(This is shown as the green row in Figure 35.)The tiles of this row (and the activation row which will piggyback on it) grow via cooperation between a glue on the side of the tile most recently placed in the path facing the direction of growth, and a glue on the exterior of the macrotile over which it is growing.However, there are a few special cases in which such cooperation is not possible during the growth of the pre-activation row.Each of these is detected by the growing row due to a special glue marking on the rightmost glue of a g r encoding.They are as follows: (a) Convex corner: Since such cooperation isn't possible when the row needs to grow around a convex corner, whenever the row reaches the of the encoding of a copy of g r and the rightmost glue is marked with a 'c', this signifies that it is at a convex corner, so a tile is placed with a strength 2 glue allowing for the placement of a tile that facilitates turning the corner.(Examples can be seen as purple tiles in the pre-activation row in Figure 35.)(b) Straight gap between macrotiles of different 2 × 2 blocks: Since there will be an additional spacing of 4 tiles between such macrotiles, the rightmost glue of g r will have been marked with a '4', and this will cause a pre-activation row tile to attach that is able to initiate the growth of a set of 4 tiles that can grow across the gap.They can be generic tiles, unspecific to the encodings of g l or g r because they will be in locations don't need to propagate any such information since they will be interfacing with the tiles from the IU construction of [10] and in the corresponding locations there are generic 'frame' tiles.
(c) Concave corner between macrotiles of different 2 × 2 blocks: Since there will be a spacing requiring 7 non-cooperative tiles between such macrotiles to go around the corner crossing the two 4-tile-wide gaps, the rightmost glue of g r will have been marked with a '7', and this will cause a pre-activation row tile to attach that is able to initiate the growth of a set of 7 tiles that can grow around that corner, across the gaps.As before, these can be generic tiles.
This pre-activation row is guaranteed to be able to successfully complete for each perimeter on which it grows, even if it has to temporarily pause progress as some output sides generated by shifter modules may need extra time to complete.However, all macrotiles are guaranteed to already be in place and to have initiated their outputs to the point of supporting growth of the pre-activation row, but none of them can initiate any growth beyond that point, so there is no growth that can interfere with the completion of the pre-activation row.The tiles of the pre-activation row copy the information from the exterior of the macrotiles to their exterior sides, resulting in the perimeter of each pair of adjacent macrotiles in the same 2 × 2 square containing a complete superside representation in the form shown in Figure 31, which is equivalent to that of the IU construction in [10] with the addition of the two extra "spacer" segments.This is because the two adjacent macrotiles will expose the encodings of g l and g r so that they are concatenated.In this way, each 2 × 2 block of seed-representing macrotiles in S T will represent a single tile of the seed in T .
When a pre-activation row completes by placing the final tile, which is adjacent to the first tile, (the final tile of the external perimeter is shown as yellow in Figure 35) that final tile presents a strength 2 glue outward to initiate growth of the activation row.The activation row also grows in a clockwise manner, on the outside of the pre-activation row.The activation row is the final row to grow around the edges of the 2 × 2 blocks of macrotiles that each represent single tiles of the seed of T .This row is always able to cooperate using a tile from the pre-activation row except for the case when it goes around a convex corner.In this case, the glue of the tile in the pre-activation row at that corner signals the upcoming corner and a tile attaches with a strength 2 glue, allowing the activation row to grow around the corner.
As each segment completes, it exposes the glues of a superside that, modulo the spacing regions that are ignored, are identical to those used in the construction of [10].What this means is that, at that point, each superside can behave identically to the simulated side of a tile in the intrinsically universal simulator.All of the information that needs to be propagated to newly growing adjacent supertiles is presented, and from the exterior (other than the larger scale factor accommodated by the spacer sections), the supertiles representing the seed structure are identical to those used by that simulator.Because of this, we call this the activation row since as soon as it grows across a supertile side, if that supertile simulates a tile with a glue exposed on the corresponding side, growth can now proceed outward, out of the representation of the seed into adjacent supertile locations.Thus, the supertile has been "activated" to begin simulation of growth beyond the seed assembly.
Since no growth outside of the macrotiles representing the seed can occur before the activation row grows over them, and the activation row cannot even begin until the entire pre-activation row is complete, which can only occur once every macrotile representing the seed that is on the exterior of the seed assembly has completed, nothing can interfere with the growth of the assembly representing the seed until the activation row is growing.Therefore, we only need to consider interactions between growth outside of the seed and macrotiles that have already completed pre-activation rows but don't necessarily have completed activation rows.The only potential conflict then occurs if a supertile outside of the representation of the seed, but adjacent to the seed, attempts growth into the location that would have been occupied by the activation row, potentially blocking its further growth.To handle this situation, since we are leveraging the construction of [10] to handle all growth beyond the seed, we make use of the growth pattern used by that construction.The supertiles of that construction have empty 2 × 2 squares in the corners between them (which can be seen in Figures 35 and 36).The row in which the activation row would have been attempting to grow but was blocked would instead be filled by a row of the 'frame' of the IU construction.A simple modification to the the tiles of such a row from that tile set (specifically the tiles which are the leftmost tiles -from the perspective of the supertile growing that row -of those rows) adds a strength 2 glue that allows a newly designed tile to attach to the left of that tile into the otherwise empty 2 × 2 square.In most circumstances, this tile will be completely unused but out of the way.However, in circumstances in which the row to which it is attached blocked formation of the activation row, then this tile will be able to cooperate with a tile from the next segment of the pre-activation row to place a tile of the activation row and begin a new segment of its growth.This can been seen occurring three times in Figure 36, with correct growth of the activation row being restarted each time.Note that if such an encroaching supertile (as depicted in red in Figure 36) were to beat the activation row to the right side of the macrotile edge instead of the left side, then all that does is pause growth until that supertile's growth also occupies the left side (which it must eventually do, by design of the frame tiles in [10] which attempt to occupy both ends of such a row and then grow toward each other in the middle, since growth would pause in the middle until that supertile's growth occupies the left side).Therefore, growth of the activation row can be temporarily paused but never stopped.
As each macrotile completes its activation row, any simulation growth which would be valid can commence.
Collisions with any inactive portions of the seed do not cause errors, as don't previously mentioned collisions that pause the growth of the activation row, since the seed representation of the seed tile is sufficiently completed by that point to represent the appropriate tile, and there is no need for it to grow output from the colliding side since there is clearly already a supertile in that location.
Although the necessary glue markings aren't always explicitly described above, each module places specially augmented glues in one or more positions (as needed) of its output row that allow the correct next module to begin growth from that output.This is possible because whenever a module completes growth, it is known which module will use that output to begin the next phase of growth.
With the seed σ T and tile set T T defined as above, and τ = 2, the definition of S is complete.We now provide a sketch of the growth and correctness of the construction.
Starting from a single seed tile, a hard-coded row grows which encodes a program that outputs T (potentially the shortest such program).A Turing machine is then simulated by the growth of a set of tiles designed to both simulate that particular Turing machine and also to maintain a counter which keetps track of the runtime of that Turing machine.The Turing machine computes a Hamiltonian cycle through a 2 × 2 scaled version of the seed, and then computes the necessary encodings to navigate the growth of the assembly along the cycle and also the strings to be encoded along the exposed sides of those microtiles.During the computation, the increase of width, on each side, of the subassembly performing the computation, is equal to the height it grows (which is equivalent to the runtime).Utilizing these dimensions, a few relatively simple sets of modular construction components are able to assemble the macrotiles along the Hamiltonian cycle and place the necessary encodings along the outer perimeter of the seed-representing assembly so that each 2 × 2 block of macrotiles is able to map to a single tile in the seed of T , with the appropriate information encoded on their perimeters for the assembly to eventually initiate growth that appears from the outside as though it is coming from supertiles of the original IS construction [10] (apart for the extra spacing fields), and thus growth outside of the simulated seed structure follows the design of the IU construction, which has been proven to correctly simulate the system whose information is encoded into the supersides.
The representation function R is able to map a 2 × 2 square of macrotiles to a tile of T once the fourth macrotile begins forming.At that point, R is able to inspect the encodings of g l and g r designated for every side, and within them read the glues encoded for those sides, and then map the 2 × 2 block of macrotiles to a single tile in the seed of T .This ensures that all supertiles simulating tiles in the seed of T resolve to those tiles Figure 36: Extending the example of Figure 35, a depiction of the growth protocol which ensures that, even if the growth of surrounding macrotiles completes and attempt to initiate growth into seed macrotiles locations, the activation of the seed remains correct and no erroneous growth can occur.before any growth can occur away from the seed (since all tiles will then be represented before the pre-activation and activation rows grow, which are required for growth away for the seed to begin).Therefore, S T completely grows the seed first, following the requirement for seed-first-simulation.By connecting with the tiles of the IU construction [10], we can utilize the full construction and proof of it to assert that as growth now proceeds, it correctly simulates T .Therefore, given an optimally short program that outputs an arbitrary aTAM system T , S T seed-first-simulates T using an optimal O( K(T ) log(K(T )) tile types and a single-tile-seed, so Theorem 6.1 is proven.

Figure 7 :
Figure 7: (left) The seed of aTAM system T from the proof of Theorem 4.1.Grey and green locations represent tiles, white positions outlined in black represent potentially valid fuzz locations, tile positions outlined in blue and fuzz positions outlined in red are referenced in the proof.Green locations indicate the only seed tiles which have exterior-facing glues capable of initiating growth.The light blue lines show minimal cuts across each arm and its fuzz (each crossing two locations).The "arms" of the seed are labeled A-E for convenience.

Figure 8 :
Figure 8: Depiction of an assembly producible in T in the proof of Theorem 4.1.(The seed alone is shown in Figure 7.) From each arm of the seed, paths can grow away from the seed, and two such (each labeled 1) are depicted here.The paths labeled 1 can grow arbitrarily far away from the seed and initiate the growth of paths back toward the seed.For example, the blue path 7 from arm A, and gold path 7 from arm D, have pumped and crashed into the red locations of those arms.

Figure 9 :
Figure9: The process of creating the tiles for a simulation at scale 4 with a single-tile seed.Beginning with the binding graph of a seed assembly σ (left), we generate a spanning tree from the westernmost tile of the southernmost row (middle).From this spanning tree, we replace each vertex with a tile from the template provided by Figure20, leading to the tileset which comprises the scale factor 4 simulation of our initial multi-tile seed (right).The new single-tile seed of T 4 is shown as a teal tile.

Figure 10 :
Figure 10: High-level scheme for scale-4 supertiles, showing the point of competition/cooperation.Consider the fully colored 4 × 4 supertiles that are filled in to already be representing tiles of the simulated system, and the central 4 × 4 supertile to not yet be filled in enough to represent a tile.Locations in the central supertile with the same colors as neighboring supertile locations depict the paths by which tiles from the filled-in supertiles grow into an empty neighboring supertile.The location labeled 'C' is the point of competition/cooperation where tile placement decides the identify of the supertile.

Figure 11 :
Figure 11: For a scale 3 supertile, the point of cooperativity/competition resides in the center of the 3 × 3 square (denoted with 'C').

Figure 12 :
Figure 12: (Left) The seed σ of T , (Middle) σ 2 with a Hamiltonian cycle through it (beginning in the green location and ending in the red location), (Right) A shorthand representation of the sections representing the first 7 locations along the Hamiltonian cycle in the string encoding it.

Figure 15 :
Figure 15: Depiction of an assembly (derived from α in the proof of Theorem 4.1) in which blue paths from arm A have pumped and crashed into the green locations of arms B and E, and gold paths from arm D have pumped and crashed into the green locations of arms C andE.Note that such an assembly is not actually possible in T since all tiles of the seed, including the green tiles, are present before any paths begin growth.Additionally, the figure depicts the blue and gold paths growing through each other in arm E, which is also impossible but depicted to show the trajectory of each path.

Figure 17 :
Figure 17: Schematic depiction of the dependence paths between the arms of β from the proof of Lemma 7.3.Arrows above a label indicate which of the two neighbors has the required dependence path leading to that arm.(Top) Every dependence path is separate (i.e.formed by a disjoint set of tiles).This leads to all arms having minimal cuts across 4 tiles.(Middle) A single path originates in arm A, visits every other arm, then returns to arm B. That path satisfies the dependencies of arms A, B, and E. A separate path grows from E to D, satisfying the dependencies of D. At this point, the only ways to satisfy the missing dependency for arm C (i.e. a path from D), are to (1) continue the path from B (since it has passed through arm D) or to grow a new path directly from arm D. The first results in a minimal cut across 4 tiles in arm B, and the second results in a minimal cut across 4 tiles in arm D. (Bottom) Besides the circular path which begins and ends at arm A (satisfying dependencies for A and E), paths grow from arm C to arm B, and from arm E to arm D (satisfying the dependencies for B and D, respectively).At this point, the most succinct way to satisfy the missing dependency for arm C requires a path from D to C, which causes a minimal cut across 4 tiles in arm D. All other options either require increasing additional cut sizes and/or are identical modulo rotation.

Figure 18 :
Figure 18: The scale 2 square contained inside the scale 4 supertiles is defined by the green tiles.Note that scale 2 squares of adjacent supertiles can be connected by 2 tiles, indicated by the tiles under red lines.

Figure 19 :
Figure 19: The four possible supertiles which allow for the new single-tile seed system to begin growth.The green arrows indicate the order of tile connections of the core path, and the blue arrows indicate the order of the perimeter path.The teal tile indicates the location of the new seed tile σ 0 , the yellow tile indicates the first tile placed by the perimeter path.The yellow tile is connected by a strength 2 glue to the final tile of the core path.The rightmost origin tile is the case of system being simulated already containing a single-tile seed.

Figure 20 :
Figure 20: The five possible supertiles which allow for the core and perimeter path to be connected to each tile in the spanning tree of the seed.Green arrows indicate order in which the tiles of the core path are connected to each other.Blue arrows indicate the order in which the tiles of the perimeter path follow the core path.Note that these supertile templates may be rotated to connect adjacent supertiles as necessary.

Figure 23 :
Figure 23: The 4 possible origin supertiles of westernmost tile of the southernmost row of the seed.'N+E' is the case where the origin supertile is connected to two neighbors along both its North and East edges, whereas 'N' and 'E' are connected to only one neighbor along their North or East edge, respectively.σ is utilized in the case that the system being simulated is already singly seeded.The teal tile represents the location of the new single tile seed.Green bars indicate location of the final tile of the precedent path.The yellow tile represents the location of the first tile of the precedent path.

Figure 26 :
Figure 26: The two types of cavities possible in assemblies.

Figure 29 :
Figure 29: The seed resulting from the addition of supertile templates assigned to each vertex of the modified binding graph from Figure 28.The teal square represents the new single-tile seed for T 3 .Green squares represent tiles of the dependence path, with the black arrows demonstrating the order of tile addition of the dependence path.Blue dashed squares represent locations of cheating fuzz available for the perimeter path.The blue arrow indicates the growth of the tiles of the perimeter path, barring a collision occurring.

Figure 32 :
Figure32: Growth of the first seed macrotile, representing one location of a 2 × 2 block in σ 2 .Note that this is a generic example that doesn't match with the first macrotile of the example from Figure12.For an example which does match, and depicts the first two macrotiles, see Figure33.

Figure 33 :
Figure 33: Example of the first two macrotiles from the example in Figure 12.

Figure 34 :
Figure34: A schematic depiction of dimensions of portions of the macrotiles in S and how the shifting of the information from the encoding of either g l or g r occurs.

Figure 35 :
Figure35: Depiction of the growth of the pre-activation (green) and activation (blue) rows around a simple assembly of seed macrotiles representing a single-tile seed σ, and the locations of possible future surrounding macrotiles outside of the representation of σ.Note that the rows showing the locations of pre-activation and activation rows, and between surrounding macrotile locations, are not remotely to scale but shown much larger for clarity, as the scale factor is very large and the size of is significantly smaller in the depicted macrotiles in the center.