Self-Assembly with Geometric Tiles

Self-Assembly with Geometric Tiles

Bin Fu Department of Computer Science, University of Texas - Pan American,    Matthew J. Patitz Department of Computer Science, University of Texas - Pan American,    Robert T. Schweller Department of Computer Science, University of Texas - Pan American,    Robert Sheline Department of Computer Science, University of Texas - Pan American,

In this work we propose a generalization of Winfree’s abstract Tile Assembly Model (aTAM) in which tile types are assigned rigid shapes, or geometries, along each tile face. We examine the number of distinct tile types needed to assemble shapes within this model, the temperature required for efficient assembly, and the problem of designing compact geometric faces to meet given compatibility specifications. Our results show a dramatic decrease in the number of tile types needed to assemble squares to at temperature 1 for the most simple model which meets a lower bound from Kolmogorov complexity, and in a model in which tile aggregates must move together through obstacle free paths within the plane. This stands in contrast to the tile types at temperature 2 needed in the basic aTAM. We also provide a general method for simulating a large and computationally universal class of temperature 2 aTAM systems with geometric tiles at temperature 1. Finally, we consider the problem of computing a set of compact geometric faces for a tile system to implement a given set of compatibility specifications. We show a number of bounds on the complexity of geometry size needed for various classes of compatibility specifications, many of which we directly apply to our tile assembly results to achieve non-trivial reductions in geometry size.

1 Introduction

The stunning diversity of biological tissues and structures found in nature, including examples such as signaling axons stretching from neurons, powerfully contracting muscle tissue, and specifically tailored coats protecting viral payloads, are composed of basic molecular building blocks called proteins. These proteins, in turn, are assembled from an amazingly small set of only around 20 amino acids. So how is it that so much structural and functional variety can be derived from so few unique components? The simplified answer is “geometry”. Essentially, a protein’s function is determined by its -dimensional shape, or geometry. The exact sequence of amino acids which compose a protein (along with environmental influences such as temperature and pH levels) determine how that particular string of amino acids will fold into a protein’s characteristic -dimensional structure. However, as simple as it may sound, the resulting geometries are often extremely complex, and predicting them has proven to be computationally intractable. It is from such geometrically intricate structure that nearly all of the complexity of life as we know it arises.

Scientists and inventors have always recognized nature as providing invaluable examples and inspiration, and as for many other fields, this is also true for the study of artificial self-assembling systems. Self-assembling systems are systems in which sets of relatively simple components begin in disconnected and disorganized initial states, and then spontaneously and autonomously combine to form more complex structures. Self-assembling systems are pervasive in nature, and their power for creating intricate structures at even the nano-scale have inspired researchers to design artificial systems which self-assemble. One such productive line of research has followed from the introduction of the Tile Assembly Model (TAM) by Winfree in  [27]. As a basic model, the TAM has proven powerful, providing a basis for laboratory implementations [23, 24, 20, 19, 29, 7, 5, 16] as well as copious amounts of theoretical work [18, 25, 28, 9, 12, 11, 6, 26]. However, in this work, we have once again looked to the guidance provided by nature, this time in terms of the power and importance of the geometric complexity of the components of self-assembling systems, to extend the TAM in an attempt to harness that power.

1.1 Overview

Figure 1: The use of jigsaw faced macro tiles for self-assembly is emerging in both theoretical and experimental work. This figure contains three separate recent examples. The first figure depicts the theoretical technique of encoding binary strings within the geometry of tile growth into the third dimension, as seen by small blue tiles in this figure [9]. The second figure depicts a macro tile assembled using staged assembly from smaller tile types [10]. Finally, the third figure depicts the experimental work of [14] in which a jigsaw geometry on the face of tiles is created with the DNA origami technique.

We introduce a generalization of the abstract Tile Assembly Model (aTAM) in which tile types are assigned rigid shapes, or geometries, along each tile face. This model is motivated by the plausibility of implementing novel sophisticated nanoscale shapes with technology such as DNA origami [21]. We show that this model permits substantially greater efficiency in terms of tile type complexity when compared to assembling shapes in the basic temperature 2 aTAM. Furthermore, these efficiency improvements hold even at temperature 1.

1.2 Results

square Tile Types Temperature Geometry Size
ATAM (previous work) [22, 3] 2 -
GTAM (Thms. 3.1,3.3) 1
2GAM (Thm. 4.1) 2
Zig-zag simulation Tile Type Scale Glues Temperature Geometry Size
Theorem 3.5 1
Theorem 3.6 1 1
Compact Geometry Design Geometry Size Run Time
Random Matrix (Thms. G.5)
Diagonal 1’s (Cor. G.4)
Diagonal 0’s (Cor. G.9)
Ind. Sub. Matrices (Thm. G.18)
Ind. Sub. Matrices (Thm. G.18)
Ind. Sub. Matrices (Thm. G.18)
Bar to Bump Reduction Geometry Size
Theorem F.3,F.2
Table 1: Summary of our Results. denotes the number of distinct glues of a tile system to be simulated, with and denoting only the number of north/south and west/east glue types respectively. is the size of the smallest geometry that can satisfy a binary compatibility matrix .

The abstract tile assembly model (aTAM) [27], as well as many of the nanoscale self-assembly models spawned by it, feature single stranded DNA sequences as the primary mechanism for decision making. This commonality applies to weak systems such as deterministic temperature-1 assembly, as well as stronger ones that rely on higher temperatures or stochastic methods. Since it is known that DNA strands are capable of hybridizing with sequences other than their exact Watson-Crick compliments, it is therefore reasonable to consider a tile assembly model in which one glue can potentially bond with an arbitrary subset of the other glues, with possibly differing strengths. Aggarwal et. al. [8] have shown that such a non-diagonal glue function allows for significant efficiency gains in terms of the numbers of unique tiles used to assemble a target shape. Despite this potentially promising result, it is also true that designing non-specific hybridization pairs, while possible, is severely limited in a practical sense, and would likely introduce a potential for error in a much greater sense than is already present in laboratory experiments.

Figure 2: Examples of geometric tiles. Note that only the black portions on the corners are binding surfaces with glues, while the “teeth” in between provide potential geometric hindrance. Left: Compatible tiles. Right: Incompatible tiles (colliding teeth, which prevent the glue pads from coming together, are circled).

If non-specific binding is impractical or impossible to implement, but powerful in theory, the question remains: are there any other mechanisms by which this power can be realized? One possible answer to this question is motivated by advances in DNA origami[21, 14] in which DNA strands can be folded into blocks with semi-rigid jig-saw faces (see the rightmost image in Figure 1). In this work we introduce a generalization of the aTAM in which tile faces are given some rigid shape (which we hereon refer to as geometry). As suggested in Figure 2, the geometric hindrance which can be provided by this geometry is capable of simulating non-diagonal glue functions by creating a set of compatible and non-compatible faces. We show that this new model realizes much of the power of non-specific hybridization. Among our results, we show that squares can be assembled in distinct tile types, which meets an information theoretic lower bound for the model and improves what is possible without geometric tiles from (see [22]). In addition, this tile efficient construction requires only a temperature threshold of 1, thus showing this model can mimic both non-specific glue functions and temperature 2 self-assembly simultaneously.

Next, we show that temperature- systems utilizing geometry can efficiently simulate a powerful class of temperature- aTAM systems. This class of systems, called zig-zag systems, is capable of simulating arbitrary Turing machines and therefore universal computation. Furthermore, the simulation performed using geometric tiles is efficient in that it requires no increase in tile complexity (i.e. the number of unique tile types required) or in the size of the assembly. This is especially notable due to the fact that it is conjectured (although currently unproven) that temperature- systems in the aTAM are not computationally universal (see [15, 13] for more discussion about temperature- assembly in the aTAM).

While tile geometries provide a method for greatly reducing the tile complexity required to build squares in a seeded model similar to the aTAM (i.e. one in which tiles can only combine with a growing assembly one at a time), our next result holds for geometric tiles considered within the 2-handed assembly model (sometimes referred to by other names) [8, 10, 28, 18, 4, 2, 1]. We show that, in this model, the tile complexity required to build a square is reduced to only tile types. The construction presented utilizes the ability of 2-handed assembly to grow assemblies by the combination of sub-assemblies composed of groups of previously combined tiles, and, coupled with complex geometric patterns on the tile edges, forces assembling components to undergo intricate patterns of relative motion in order to combine with each other. The tile geometries required are, however, complex () and in a -dimensional model require disconnected components. We then show a simple extension to dimensions which allows for connected components while retaining all other features.

Finally, we conduct a detailed analysis of problems related to computing necessary patterns for tile geometries given specifications of the desired compatibility matrices (i.e. the listings of which tile sides should be compatible and incompatible with each other), with the goal being to minimize the size of the necessary geometries (as well as the running time of the computations). They deal with designing tile face geometries as a subset of . Their solutions help show the feasibility and limitations of geometric tile face designs. We show a number of lower and upper bounds related to variants of the problem, some of which are incorporated into the previously mentioned constructions.

1.3 Organization of this paper

The remainder of this paper is organized as follows. In Section 2 we describe and define the new models introduced here. In Section 3, we present our constructions and proofs related to the self-assembly of squares using tile types, as well as the simulation of zig-zag, temperature- aTAM systems by temperature- systems with geometric tiles. Section 4 describes our construction which utilizes geometric tiles as well as -handed assembly to self-assemble squares using tile types. Additionally, there is a technical appendix which contains the majority of the proofs and construction details for the results presented in the previous sections, as well as the results related to computing compatibility matrices.

2 Model

In this section we define the basic geometric tile assembly model (GTAM) and the two-handed planar geometric tile assembly model (2GAM). We begin with an informal description of the aTAM. We then define the Geometric Tile Assembly Model (GTAM). The GTAM generalizes the aTAM [27] by adding a geometry to each tile face that may prevent two tiles from attaching.

2.1 Basics

A tile type is a unit square with four sides, each having a glue consisting of a label (a finite string) and strength (0, 1, or 2). We assume a finite set T of tile types, but an infinite number of copies of each tile type, each copy referred to as a tile. A supertile (a.k.a., assembly) is a positioning of tiles on the integer lattice . Two adjacent tiles in a supertile interact if the glues on their abutting sides are equal. Each supertile induces a binding graph, a grid graph whose vertices are tiles, with an edge between two tiles if they interact. The supertile is -stable if every cut of its binding graph has strength at least , where the weight of an edge is the strength of the glue it represents. That is, the supertile is stable if at least energy is required to separate the supertile into two parts. A seeded tile assembly system (TAS) is a triple , where T is a finite tile set, is the temperature, usually 1 or 2, and is a special tile type denoted as the seed. Given a TAS , a supertile is producible if either it is the seed tile, or it is the -stable result of attaching a single tile to a producible supertile. A supertile is terminal if for every tile type , cannot be -stably attached to . A TAS is directed (a.k.a., deterministic or confluent) if it has only one terminal, producible supertile. Given a connected shape , a TAS T produces X uniquely if every producible, terminal supertile places tiles only on positions in (appropriately translated if necessary).

2.2 Geometric Tiles and the Basic Geometric Tile Assembly Model (GTAM)

In this paper we generalize the basic aTAM by assigning a geometric pattern to each side of a tile type along with its glue. For each tile set in the GTAM, fix two values . While at a high-level we still consider tiles as occupying unit squares within the plane, in order to determine whether or not adjacent tiles are geometrically compatible with each other, we define a tile body to be an square (see Figure 3), and we define a (tile face) geometry to be a subset of . A geometric tile type consists of a tile body which has both a glue and a geometry assigned to each side. For a tile type , let denote the geometry assigned to the north side of . Define , , and analogously. Intuitively, the geometry of a tile type face represents the positions of inflexible bumps, or “filled-in” locations of the rectangle, that can prevent two tiles from lining up adjacently to one another so that the rectangles of their adjacent geometries completely overlap. Only if the geometries on adjacent sides of two combining tiles can completely overlap so that no location contains a filled-in portion of both, can any glues on those adjacent sides interact. Formally, we say a tile type is east incompatible with tile type if . We define north, south, and west incompatibility analogously. Seeded Geometric Tile Assembly takes place in the same manner as in the aTAM, with the added requirement that a tile type cannot be attached to a supertile at a position in which the tile type is either east, west, north, or south incompatible with another adjacent tile type in the supertile at a position west, east, south, or north, respectively, of the attachment position. As in the original aTAM, tiles are not allowed to rotate and must always maintain their pre-specified orientation, even while moving into position to attach to an assembly.

Figure 3: Definition of a geometric tile.

2.3 Two-Handed Geometric Tile Assembly Model

The Two-Handed Geometric Tile Assembly Model (2GAM) extends the GTAM by allowing large assembled supertiles to attach to one another. We further restrict the model to planar assembly in which two supertiles may only attach if there exists a collision free path for the supertiles to traverse to reach their point of connection. In two dimensional assembly this enforces that supertiles must be able to slide into position while staying in the 2D plane. With standard aTAM tiles, this requirement enforces that individual tiles of a supertile do not collide with individual tiles from another supertile while the supertiles shift into position. With geometric tiles, we must also enforce that the geometries of individual tiles do not overlap with other tile geometries.

Informal Definition of the 2GAM

As in the GTAM, tiles are composed of tile bodies and tile face geometries as shown in Figure 3. Within the 2GAM, two tiles may attach if 1) there exists a collision free path within the 2D plane to shift the tiles into an adjacent position in which the east (or south) geometry box of one tile exactly overlaps the west (or north) geometry box of the second tile, and 2) the east (north) and west (south) glues of each tile are equal and have strength at least . More generally, preassembled multiple tile supertiles may come together if there is a collision free path in which the supertiles line up to create a -stable assembly. The set of producible supertiles within the 2GAM is defined recursively: As a base case, all singleton supertiles consisting of a single tile are producible. Recursively, for any two producible supertiles and such that there exists a collision free path within the plane to shift and into a -stable configuration , then the supertile is also producible. The subset of producible assemblies of a 2GAM system to which no producible assembly can attach defines the terminally produced supertiles. Intuitively, this set represents the set of assemblies we expect to see from a system if it is given enough time to assemble, and we refer to this as the output of the system. A 2GAM is directed (e.g., deterministic, confluent) if it has only one terminal, producible supertile. Given a connected shape , a 2GAM produces uniquely if every producible, terminal supertile places tiles only on positions in (appropriately translated if necessary).

Please refer to Section A for a more formal definition of the 2GAM model. Additionally, for a discussion of the different types of tile face geometries that are possible and the classes into which they can be categorized, please see Section B.

3 Complexities for the GTAM: Squares and Assembly

In this section we examine the power of the GTAM in the context of efficiently building squares and simulating temperature ATAM systems at . We first show in Secton 3.1 that the tile complexity of squares in the GTAM is for almost all by providing an order tile complexity upper bound construction for all , and a matching information theoretic lower bound for almost all . In addition, our upper bound construction utilizes only temperature . This stands in contrast to the temperature , tile complexity result that can be achieved in the ATAM [3].

As the square construction shows, the GTAM seems to be powerful at . In Section 3.2 we consider the problem of simulating ATAM systems within the GTAM, but at . We show that for a large class of temperature ATAM systems called zig-zag systems, such a simulation is possible with no scale up in tile complexity or assembly size. Of particular note is the fact that zig-zag systems are capable of simulating universial Turing machines, something that is conjectured to not be possible in the ATAM at .

3.1 The Tile Complexity of GTAM squares:

In this section we analyze the size of the smallest tile type GTAM system that uniquely assembles an square. Our first result is a construction that will assemble an square using tile types. We then show that this is tight for almost all by applying an information theoretic argument to show that for almost all , at least distinct tile types are required to uniquely assemble an square. This result stands in contrast to the tile complexity for building squares in the standard ATAM model, showing that the GTAM is strictly more powerful than the ATAM. Further, our upper bound construction uses only temperature 1, while the ATAM construction requires temperature 2.

In the remainder of this section we prove the following theorems:

Theorem 3.1.

The minimum tile complexity required to assemble an square in the GTAM is . Further, this complexity can be achieved by a temperature system with size geometry.

Theorem 3.2.

For almost all integers , the minimum tile complexity required to assemble an square in the GTAM is .

For the sake of brevity, we only give a high level overview of the upper bound construction and place the details in referenced appendix sections.

3.1.1 Construction Overview

The tile system for the assembly of squares in the GTAM at temperature and tile complexity starts with the assembly of a roughly rectangle ( to be precise) that is used as a base to encode a roughly digit binary number ( digits to be precise). The rectangle is efficiently built with tile types by using a tile set for simulating a 2-digit, base- counter. Such counters are known to exist in the ATAM at . To achieve in the GTAM, we apply the transformation described in Theorem 3.6 to convert a zig-zag (see Definition 3.4) version of the counter into a GTAM system. The tileset for the basic ATAM counter is given in Figure 10, and the GTAM version is given in Figure 11. The details of this portion of the construction are described in Section C.0.2.

Figure 4: (a) The decoder set of tiles grows across the north face of the assembled counter from Figure 11 to build a binary string of tiles by placing at each position a tile type representing either a 0-bit or a 1-bit. (b) For a given binary string to be assembled, the geometries , , and are assigned such that and are compatible if and only if . (c) For a given binary string to be assembled, the listed compatibility matrix is obtained, along with the described assignment of geometry to each tile face. Such compatibility constraints can be achieved with geometry of length for a length string . For more compact geometries in the case of less complex strings , see Section G. (d) An example assembly of decoder tiles.

The next step of the construction grows a third row of tiles on top of the surface of the roughly rectangle. Within this assembled row one tile type representing a binary 0 or 1 bit is placed at each position, thus assembling a length roughly binary string upon completion. To generate bits from only distinct tile types is impossible in general within the ATAM. Within the GTAM, at this stage in the assembly we make use of the non-specific hindrance property of geometric tile faces to select the correct bit (and reject the wrong bit) at each of the bit positions. The key idea is that a collection of geometric tile faces can be designed such that each face is compatible with a specified subset of the other faces, while incompatible with all others. Thus tile faces can encode a compressed binary pieces of information (compatible or not compatible), thereby providing the possibility for a more tile type succinct assembly of an square. A description of the decoder tile set is given in Figure 4 along with an example of how the assignment of geometry to tile faces permits the decoder tiles to efficiently select the correct bits. The details of this portion of the construction are described in Section C.0.3.

Once the binary string is assembled on the surface of the rectangle, we utilize a well known constant sized set of tiles that implement a binary counter in the ATAM at  [22]. This system reads a given surface of glues that denote an initial binary value for the counter, and then assembles upwards, incrementing a binary value encoded in tile types at every other row of the assembly. Once the counter is maxed out the construction stops, thus growing a rectangle of height roughly minus the initial value of the counter. This ATAM counter construction is a zig-zag construction (see Definition 3.4). Thus, our construction applies Theorem 3.6 to convert to a GTAM version.

Finally, with the ability to generate large length rectangles with tile types at , we combine 3 of these constructions to assemble the border of an square using a factor of 3 times more tile types. A high level schematic of the approach is given in Figure 9. With the shell constructed, the completion of the final rectangle can seed a growth of filler tiles to fill in the body of the square, finishing the construction. The final details of the construction are described in Section C.0.4.

3.1.2 Tight Kolmogorov Lower Bound for GTAM Squares:

Theorem 3.3.

For almost all integers , the minimum tile complexity required to assemble an square in the GTAM is .


The Kolmogorov complexity of an integer with respect to a universal Turing machine is s.t. where is the binary representation of n. It is known that for at least of all (see [17] for results on Kolmogorov complexity). Thus, for any , for almost all .

Consider a tile simulator program (of constant size in bits) that reads as input a GTAM tile system (encoded as a bit string). Suppose the simulator is modified so that it outputs the maximum extent (i.e. width or length) of a shape that is terminally produced by the input system. When such a simulator is paired with a GTAM system that uniquely assembles an square, the combined program constitutes a program that outputs the integer , implying that the total number of bits of the simulator (constant) plus the encoding of the tile set must be at least . As the simulator has a constant size, this implies that the number of bits to to encode the GTAM system must be at least , which is for almost all . To achieve our bound we now show that any GTAM system can be encoded using bits (independent of the size/area of the tile face geometries) assuming a constant bounded temperature. To achieve this, we do not explicitly encode the geometry for each tile face, but instead utilize a compatibility matrix.

Encoding a GTAM system.

For a GTAM system , arbitrarily index each distinct face of each distinct tile in from to . Define the compatibility matrix for to be the matrix such that is the index of an east (or north respectively) edge and is the index of a west (south respectively) edge and and have incompatible edge geometries. can be encoded using bits, and the remaining portions of can easily be encoded in asymptotically fewer bits, yielding an bit encoding for any GTAM system. Note that even without the explicit representation of the GTAM’s geometries, a simulator can derive what the system will build from the compatibility matrix .

Now consider the smallest tile type GTAM system that uniquely assembles an square. As can be encoded in bits, we know that for almost all , for constants . Therefore, for almost all . ∎

3.2 Simulating Temperature ATAM Systems with GTAM Systems

Definition 3.4.

Zig-Zag System. A tile system is called a zig-zag system if:

  1. The location and type of the tile to attach is the same for all assembly sequences.

  2. The tile attachment occurs to the north, west, or east (not south) of the previously placed tile attachment in all assembly sequences.

For the proofs of the following two theorems and technical details about the notion of tile system “simulation”, please see Section D.

Theorem 3.5.

Any temperature zig-zag ATAM tile system can be simulated by a GTAM tile system with tile type scale . The simulation utilizes geometry size at most where is the number of distinct north/south glue types represented in .

Theorem 3.6.

Any temperature zig-zag ATAM tile system can be simulated by a GTAM tile system using only 1 non-null glue type and tile type scale . The geometry size of the simulation system is at most where is the number of distinct glue types represented in .

4 2GAM Results

In this section, we explore the theoretical limits achievable when utilizing geometric tiles by designing tiles whose edges contain highly complex geometries. Furthermore, we move to the 2-handed variant of the GTAM, the GAM, to allow for the geometric hindrances experienced by individual tiles to be grouped and combined to provide more complex interactions between larger supertiles. The goal, rather than providing a realistic and potentially experimentally realizable set of constructions, is to gain further understanding into the interplay between geometry and the types of computations which can be carried out via algorithmic self-assembly.

We now present the details of our construction, which reduces the tile complexity required to self-assemble an square to a mere tile types, while requiring a geometry size of . Our construction requires the constraint of planarity, in which components are not allowed to float into position from above or below the assembly, but must always be able to slide into position with a series of translations along only the and axes. However, the intricate geometric designs and complex series of movements require that individual tile geometries are composed of disconnected components. (Note that in Section E.5 we show how to extend the tiles into the third dimension, utilizing a total of planes, in a manner which results in connected tiles and also implicitly enforces the restriction that only tile translations along the and axes must be sufficient to allow for tile attachments.)

4.1 Self-assembly of an square with tile types

Theorem 4.1.

For every , there exists a 2GAM tile system which uniquely produces an square, where , and with size geometry.

To prove Theorem 4.1, we present the following construction.

Figure 5: A high-level sketch of the construction for building a square in the 2GAM.

4.1.1 High-level sketch of the construction

Following is a list of values based on the particular dimensions of the square to be formed and which are used throughout the following discussion:

  • : dimensions of the square to self-assemble

  • :

  • :

  • :

  • :

  • : -handed counter which counts from through for a total of columns

  • : standard counter which counts from through for a total of columns

  • : -handed counter with “buffer” columns which counts from through for a total of columns

Figure 5 shows a high level view of the main components of this construction. Without loss of generality, we can consider the construction to be composed of a series of sub-assemblies, or modules, which assemble in sequence, with each module completely assembling before the next begins. The careful design of all modules ensures that none can grow so that they occupy space required by another, and that each will be able to terminally grow to precisely defined dimensions that result in the final combination forming exactly an square. For the rest of this discussion, we will describe the formation of the modules in such a sequence. (See Figure 12 for a series of high-level images which exemplify the ordering of the formation of the square from these modules.)

Similar to the construction in Section 3.1, this construction makes use of one counter, , to assemble an encoding of a number which in turn seeds another counter, . assembles in a -handed manner, meaning that each number which is counted is represented by exactly one one-tile-wide column of tiles, and individual columns form separately and then combine to form the full counter of length (similar in design to counters found in [12]). Each column of the counter, besides representing a counter value, is used to represent (on the north face of the northernmost tile) one bit of the seed value for . Each column can form in one of two versions: one that represents a , and one that represents a , for the corresponding bit of . The east and west sides of the tiles forming the columns of this counter contain geometries which force the columns, in order to combine, to “wiggle” up and down in patterns based on the counter values of those columns. See Figure 6 for an example pair of compatible columns. The columns also contain tiles with geometries which “read” those patterns of wiggling and allow columns to combine with each other if and only if they are the correct versions of the counter columns, namely those with the seed bit values which correctly correspond to their location in the counter. It is the tiles of this component as well as those of the counter to which the intricate geometries are applied, and thus they receive a much more detailed explanation in Section E.1.

Figure 6: Example columns for the counter . Note that all colored areas are filled-in, and areas colored white are empty, although they may be outlined for reference.

is a standard binary counter (i.e. one that would also assemble correctly in the aTAM) which utilizes tile types (see Figure 15) and grows to complete the majority of the western side of the square. Next, a small set of “filler” tile types (see Figure (b)b) fill in the majority of the square, and once they have filled in a sufficient portion of the northern portion they provide a platform to which can attach (as long as is fully formed). In order to provide a directed system with only one terminal assembly, the “incorrect” columns (those which couldn’t become part of ) are able to combine into the -handed counter structure via some extra buffer columns (see Figures 14 and 19). Finally, the filler tiles are able to complete the formation of the square. Note that the tile types which make up and the filler tiles require no geometries but only standard glues.

By utilizing the assembly of supertiles (i.e. sub-assemblies of grouped tiles) and carefully designing geometries which force the supertiles forming to move in well-defined patterns as they attach, we are able to essentially “transmit” information about tiles in one location of a supertile to the interfaces where potential binding is occurring with other tiles in the same supertile. By concatenating this information from such a group of distant tiles, the binding “decision” can be made based on an arbitrarily large amount of information (as long as the geometry sizes scale appropriately). This results in a dramatic lowering of the tile complexity required to assemble an square, with the tradeoff being an increase in the complexity of the tiles themselves.

Please see Section E for much more detail and several supplementary images describing this construction. Additionally, a comprehensive example has been provided in Section E.4 to which the reader can refer for additional clarity.

4.2 Analysis of tile complexity and geometry size

First, we analyze the tile complexity of this construction, module by module, in order to determine the overall complexity.

The tile complexity of each component is as follows:

  • :

    Counter tiles: There are bit positions which each require a constant number of tile types (as can be seen from the depiction in Figure (a)a), plus the requirement for a hard-coded column on each of the west and east sides, for a total of tile types.

    Cap tiles: There are cap tile positions which each need to be able to represent a or a cap, for a total of tile types.

  • : 16 tile types.

  • :

    Counter tiles: There are bit positions in the buffer columns which each require a constant number of tile types, for a total of tile types.

    Buffer cap tiles: There are cap tile positions which each require a single tile type, for a total of tile types.

  • Filler tiles: 7 tile types.

Thus, the total tile type complexity is .

Next, we simply note that the geometries defined for all tiles in this construction consist of rectangles of dimensions , and therefore the geometry size is .


  • [1] Zachary Abel, Nadia Benbernou, Mirela Damian, Erik Demaine, Martin Demaine, Robin Flatland, Scott Kominers, and Robert Schweller, Shape replication through self-assembly and RNase enzymes, SODA 2010: Proceedings of the Twenty-first Annual ACM-SIAM Symposium on Discrete Algorithms (Austin, Texas), Society for Industrial and Applied Mathematics, 2010.
  • [2] Leonard Adleman, Toward a mathematical theory of self-assembly (extended abstract), Tech. Report 00-722, University of Southern California, 2000.
  • [3] Leonard Adleman, Qi Cheng, Ashish Goel, and Ming-Deh Huang, Running time and program size for self-assembled squares, Proceedings of the thirty-third annual ACM Symposium on Theory of Computing (New York, NY, USA), ACM, 2001, pp. 740–748.
  • [4] Leonard Adleman, Qi Cheng, Ashish Goel, Ming-Deh Huang, and Hal Wasserman, Linear self-assemblies: Equilibria, entropy and convergence rates, In Sixth International Conference on Difference Equations and Applications, Taylor and Francis, 2001.
  • [5] Robert D. Barish, Rebecca Schulman, Paul W. Rothemund, and Erik Winfree, An information-bearing seed for nucleating algorithmic self-assembly, Proceedings of the National Academy of Sciences 106 (2009), no. 15, 6054–6059.
  • [6] Harish Chandran, Nikhil Gopalkrishnan, and John H. Reif, The tile complexity of linear assemblies, 36th International Colloquium on Automata, Languages and Programming, vol. 5555, 2009.
  • [7] Ho-Lin Chen, Rebecca Schulman, Ashish Goel, and Erik Winfree, Reducing facet nucleation during algorithmic self-assembly, Nano Letters 7 (2007), no. 9, 2913–2919.
  • [8] Qi Cheng, Gagan Aggarwal, Michael H. Goldwasser, Ming-Yang Kao, Robert T. Schweller, and Pablo Moisset de Espanés, Complexities for generalized models of self-assembly, SIAM Journal on Computing 34 (2005), 1493–1515.
  • [9] Matthew Cook, Yunhui Fu, and Robert Schweller, Temperature 1 self-assembly: Deterministic assembly in 3d and probabilistic assembly in 2d, Proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms, 2011.
  • [10] Erik D. Demaine, Martin L. Demaine, Sándor P. Fekete, Mashhood Ishaque, Eynat Rafalin, Robert T. Schweller, and Diane L. Souvaine, Staged self-assembly: nanomanufacture of arbitrary shapes with glues, Natural Computing 7 (2008), no. 3, 347–370.
  • [11] David Doty, Jack H. Lutz, Matthew J. Patitz, Scott M. Summers, and Damien Woods, Intrinsic universality in self-assembly, Proceedings of the 27th International Symposium on Theoretical Aspects of Computer Science, 2009, pp. 275–286.
  • [12] David Doty, Matthew J. Patitz, Dustin Reishus, Robert T. Schweller, and Scott M. Summers, Strong fault-tolerance for self-assembly with fuzzy temperature, Proceedings of the 51st Annual IEEE Symposium on Foundations of Computer Science (FOCS 2010), 2010, pp. 417–426.
  • [13] David Doty, Matthew J. Patitz, and Scott M. Summers, Limitations of self-assembly at temperature 1, Theoretical Computer Science 412 (2011), 145–158.
  • [14] Masayuki Endo, Tsutomu Sugita, Yousuke Katsuda, Kumi Hidaka, and Hiroshi Sugiyama, Programmed-assembly system using DNA jigsaw pieces, Chemistry: A European Journal (2010), 5362–5368.
  • [15] Yunhui Fu and Robert Schweller, Temperature 1 self-assembly: Deterministic assembly in 3d and probabilistic assembly in 2d, Tech. Report 0912.0027, Computing Research Repository, 2009.
  • [16] T.H. LaBean, E. Winfree, and J.H. Reif, Experimental progress in computation by self-assembly of DNA tilings, DNA Based Computers 5 (1999), 123–140.
  • [17] M. Li and P. Vitanyi, An introduction to komogorov complexity and its applications (second edition), Springer Verlag, New York, 1997.
  • [18] Chris Luhrs, Polyomino-safe DNA self-assembly via block replacement, DNA14 (Ashish Goel, Friedrich C. Simmel, and Petr Sosík, eds.), Lecture Notes in Computer Science, vol. 5347, Springer, 2008, pp. 112–126.
  • [19] Chengde Mao, Thomas H. LaBean, John H. Relf, and Nadrian C. Seeman, Logical computation using algorithmic self-assembly of DNA triple-crossover molecules., Nature 407 (2000), no. 6803, 493–6.
  • [20] John Reif, Sudheer Sahu, and Peng Yin, Compact error-resilient computational DNA tiling assemblies, DNA: International Workshop on DNA-Based Computers, LNCS, 2004.
  • [21] Paul W. K. Rothemund, Folding DNA to create nanoscale shapes and patterns, Nature 440 (2006), no. 7082, 297–302.
  • [22] Paul W. K. Rothemund and Erik Winfree, The program-size complexity of self-assembled squares (extended abstract), STOC ’00: Proceedings of the thirty-second annual ACM Symposium on Theory of Computing (Portland, Oregon, United States), ACM, 2000, pp. 459–468.
  • [23] Rebecca Schulman and Erik Winfree, Programmable control of nucleation for algorithmic self-assembly, DNA: International Workshop on DNA-Based Computers, LNCS, 2004.
  • [24]  , Synthesis of crystals with a programmable kinetic barrier to nucleation, Proceedings of the National Academy of Sciences 104 (2007), no. 39, 15236–15241.
  • [25] David Soloveichik, Matthew Cook, and Erik Winfree, Combining self-healing and proofreading in self-assembly, Natural Computing 7 (2008), no. 2, 203–218.
  • [26] David Soloveichik and Erik Winfree, Complexity of self-assembled shapes, SIAM Journal on Computing 36 (2007), no. 6, 1544–1569.
  • [27] Erik Winfree, Algorithmic self-assembly of DNA, Ph.D. thesis, California Institute of Technology, June 1998.
  • [28]  , Self-healing tile sets, Nanotechnology: Science and Computation (Junghuei Chen, Natasa Jonoska, and Grzegorz Rozenberg, eds.), Natural Computing Series, Springer, 2006, pp. 55–78.
  • [29] Erik Winfree, Furong Liu, Lisa A. Wenzler, and Nadrian C. Seeman, Design and self-assembly of two-dimensional DNA crystals., Nature 394 (1998), no. 6693, 539–44.

Appendix A Formal 2GAM Definition

Hindrance Map

To permit a supertile to interweave itself into an attachable position requires modeling translations of a supertile at the resolution of the size of individual units of the tile face geometries. To this end we define a Hindrance Map for a supertile that represents the set of positions that a supertile takes up, including the bodies of each tile in the supertile, along with the positions blocked by each geometry for each tile face.

Formally, consider a supertile . The Hindrance Map is the following set of positions: For each tiled position in supertile , the following points are defined to be in . (Please refer to Figure 7 for depictions of tile components in terms of and , and note that the entire area occupied by a






The final hindrance map is the union of the sets BODY, SOUTH, NORTH, EAST, and WEST for each tiled position of .

Figure 7: Mapping of tile coordinates (red) to dimensions and units of tile bodies and geometries.
Planar Translation of Supertiles

Given two supertiles and , a collision free translation of with respect to is any translation of that can be obtained by a sequence of unit translations where is an initial translation that shifts such that all positions of are northwest of all positions of , and each is one of the translations . Further, after each translation , it must be the case that does not overlap . A grid locked collision free translation is a collision free translation in which has been shifted by multiples of in both the and direction. We are interested in grid locked translations as they correspond to direct translations of at the resolution of tiles, rather than the higher resolution translations of . We require grid locked translations for a supertile to attach to another supertile as such a translation is needed for the tiles to line up.

2GAM Model

A Two-Handed Planar Geometric Tile Assembly System consists of a duple where is a set of geometric tile types and is the positive integer temperature of the system. Given a 2GAM system , a supertile is producible if either it is a single tile from T, or it is the -stable result of a grid locked collision free translation of two producible assemblies. A supertile is terminal if for every producible supertile , and cannot be -stably attached. A 2GAM is directed (e.g., deterministic, confluent) if it has only one terminal, producible supertile. Given a connected shape , a 2GAM produces uniquely if every producible, terminal supertile places tiles only on positions in (appropriately translated if necessary).

Appendix B Classes of Tile Face Geometries

Here we discuss different classes into which tile face geometries can be classified. Note that all GTAM results presented in this paper have “bump” geometries, while the 2GAM result (in its -dimensional form) has “unrestricted” geometries. See Figure 8 for an example of each class.

Figure 8: Classes of tile geometries.

This is the most general class of geometries and places no restrictions on the portions of a tile face geometry region (i.e. the rectangle) which are filled-in and which are empty. Such geometries may be infeasibl to implement as the pieces of a geometric face may not be connected to the tile body. However, given a third dimension it is plausible that such a scheme might be implemented by attaching particles to the face of a substrate which also attaches to the tile body.


A slightly more restricted class, the connected class allows arbitrary patterns to be filled-in in within the tile face geometries as long as all such portions retain a connected path to the tile body.


A bar geometry is restricted to lines of filled-in points which are connected to the tile body and extend directly away from it. Each bar can be of length where .


Bump geometries are the simplest possible types of geometry and consist of a set of points which are directly connected to the tile body. This class can be thought of as simplified bar geometry with .

Appendix C Additional Details for the GTAM Square Construction

c.0.1 Construction Notation

Consider a positive integer (the width of the square we wish to assemble). For the sake of clarity, assume is even.

  • Let .

  • Let .

  • Let .

Figure 9: This figure shows a high level overview of the different steps in the assembly of squares in the GTAM with tile types at temperature . In phase 1, a tile set that implements a 2-digit, base counter is used to form a length bed upon which a binary number will be assembled. Phase 2 places green and orange decoder tiles which denote either a 0 or 1 bit at each position of the third row of the assembly. In phase 3, the assembled binary string is utilized as the seed for a binary counter set of tile types which grow a length rectangle. Phases 1-3 are repeated two more times to create the outer shell of an square. Finally, a collection of filler tiles are seeded to fill in the body of the square.

c.0.2 Base Counter at Temperature

Figure 10: This figure contains a tile system that assembles a rectangle for a given integer . The construction is an implementation of a 2-digit, base- counter with tile complexity that assembles at temperature in the standard ATAM.
Figure 11: This tile system is the result of applying the transformation from Theorem 3.6 to the zig-zag counter described in Figure 10. The systems utilizes a single (red) glue at temperature . For each east/west (or north/south) glue type in the initial ATAM system, there exist two corresponding geometries and (or and ) in the new GTAM system such that is compatible with , but incompatible with all other geometries in the system.

The first step of the construction is the assembly of a rectangle that will serve as a bed for a third layer that will place a row of tiles that represent a bit binary number. The GTAM system used for this portion of the assembly is obtained by applying the transformation from Theorem 3.6 to convert an efficient ATAM system into a equivalent GTAM system.

The temperature ATAM system that will be converted is described in Figure 10 and constitutes a 2-digit, base counter. The counter works within the ATAM at temperature and is a generalization of the base-2 version first described in [22]. By specifying the east glues of tiles and , the counter can be seeded to any specified starting value. In the tile set given in the figure, the counter is initialized to value 0. The value of the counter is incremented at every other column as the assembly grows from west to east, finally halting when the counter rolls over to 0. Thus, for a given choice of and an initial seed value , the final assembly will be a rectangle. For our construction, we utilize , which guarantees enough room to place a length binary string in the next step of the construction. As we can initialize the counter to be shorter if needed, we assume the counter has been initialized to grow to length exactly (an extra 2 positions are not used to encode bits in our constructions, thus the extra 2 length).

To modify the ATAM system of Figure 10 to a system, we observe that it is a zig-zag system according to Definition 3.4 (rotated 90 degrees). Therefore, we can apply Theorem 3.6 to obtain an equivalent GTAM system shown in Figure 11. The general case details of the conversion are detailed in Section 3.2, but the basic idea of the transformation is to replace east strength 1 glues with the null glue type, and assign a unique geometry to each edge for each glue type. In particular, for an east/west glue type x, a corresponding pair of geometries are computed, and , such that is incompatible with all other geometries within the system with the exception of , and vice versa. Each occurrence of the glue type x on the east face of a tile type is replaced by a GTAM tile type with geometry for the east face geometry. The same replacement by is done for west occurrences of . This geometry assignment is also applied to all north/south glue types as well. The result is a system that assembles in the same fashion as the original temperature system and with the same tile complexity, but does so at temperature .

c.0.3 Bit Decoder Tiles

The next step in the construction consists of a collection of decoder tiles which grow across the surface of the rectangle assembled from the previous step. The general tile set for these decoder tiles is given in Figure 4. The growth of these tiles is initialized by the blue glue displayed by the final tile placement of the base counter from the previous section. The decoder tiles consist of a repeating chain of tiles with labels to . The west geometry of tiles with label are compatible with the east geometries of tiles with label , and incompatible with all other geometries. Thus, the chain of tiles must assemble in the proper order. Further, there exactly 2 tile types with each integer label from to , a green type and an orange type. Our goal is to assemble a supertile that encodes a given target binary string along its surface. The encoding is the pattern of green and orange tiles with orange tiles representing binary 0 bits, and green representing binary 1 bits. The key to get the goal binary string assembled is to enforce that at each bit position the correct bit is chosen. We do this by appropriately assigning geometry to the south face of the decoder tiles and the north face of the base counter tiles.

In more detail, suppose we are given a target binary string to be assembled, the geometries , , and are assigned such that and are compatible if and only if . A detailed example of such a compatibility matrix is given in Figure 4, along with a sample set of geometry assignments to tile faces that satisfies such constraints. More generally, such compatibility constraints can be achieved with geometry of length for a length string by way of Theorem G.5, which is asymptotically the best achievable in most cases. In the case of less complex binary strings, more compact geometries can be obtained as discussed in Section G. From these compatibility constraints, the desired target binary string is guaranteed to assemble. Further, the final placed tile can be specified as a special type with a north purple glue which seeds the next portion of the construction.

c.0.4 Binary Counter Tiles

The next portion of the construction, seeded by the final tile placed during the decoder tile portion, consists of a binary counter tile system which grows north, start from the binary string decoded in the previous section, up until the counter rolls over. The construction is a GTAM version of a well known temperature ATAM construction of tile types [22]. The counter increments every other row, and thus will grow to a height of exactly , where is the initial value of the counter which is the binary string encoded in the previous phase of the construction. Our goal is for the counter to build to a height equal to , the dimension of the goal square. We thus choose in the previous section to be .

Finally, the construction is finished by observing that the binary counter construction can be implemented such that the final tile placed at the northeast corner of the assembly exposes a glue type which seeds the assembly of a rectangle that grows east for exactly units. This can be accomplished in the exact same way we achieved a north growing rectangle of length , but with an alternate choice of initial binary string assignment. This construction can in turn seed a south growing rectanle of the same length. This final rectangle can seed the growth of a final size collection of tile types which fills in the casing of the hollow square, yielding the final full square. A high level figure depicting the construction is given in Figure 9.

Appendix D Details of Zig-Zag Simulation

Definition D.1.

Nice Zig-Zag System. A zig-zag system is called a nice zig-zag system if:

  1. The terminal assembly of contains no exposed east-west non- glue types.

  2. All producible assemblies of contain no mismatched glues.

Definition D.2.

Tile System Simulation. An ATAM or GTAM system is said to simulate a second ATAM or GTAM system if:

  1. There exists a function such that an assembly sequence is valid for system if and only if there exists tile types such that the assembly sequence is valid for .

The tile complexity scale factor of the simulation is defined to be . This definition only considers the case of simulating a system without scaling the size of the assembly (scale factor 1). See [9] for a more general definition of simulation that permits scaled assembly size factors.

Observation D.3.

The “simulate” relation between tile systems is transitive. Further, if system simulates with tile type scale factor , and simulates with tile type scale factor , then simulates with tile type scale factor .

Lemma D.4.

Any zig-zag system can be simulated by a nice zig-zag system with tile type scale factor .


of Theorem 3.5: Consider a zig-zag system . By Lemma D.4, there exists a zig-zag system that simulates with tile type scale such that the assembly of has the “nice” properties described in Definition D.1.

We now define a system that simulates with tile type scale, and thus simulates with tile type scale by the transitivity of simulation.

Let denote the set of all west-east glues that are represented in the tile set . Let denote the set of all north-south glues that are represented in the tile set . Let denote an injective mapping from the glue types represented in to some new set of strength-1 glues .

For each , define the the geometric tile type as follows. Denote the north, south, east, and west glues of as , , , and respectively. Let the west glue of be and . If is a strength-2 glue, then , otherwise . If is a strength-2 glue, then , otherwise .

We assign the empty set geometry to all east/west edges of tile types in . We assign non-empty geometries to north/south edges of each tile type such that the south edge of a given is compatible with a north edge of a tile type if and only if . By Theorem G.9, we can achieve such compatibility requirements with a geometry of size at most .

We now show that the system simulates (with tile type scale factor 1). Consider the function to map tile types from to . Suppose correctly simulates up to the first steps. That is, for the first assembly sequence steps of the unique assembly sequence of , the first steps of the assembly sequence of are . Consider the step in the assembly sequence of , . We know that the placement position must occur north, west, or east of the previously placed tile position . If the placement occurs to the north, then is a valid step in the assembly sequence for . This is because the tile transformation explicitly assigns tile type a strength-1 north glue that matches the south glue of , as must have a north strength-2 glue that matches the south glue of . Further, by the the fact that is nice, there are no exposed east/west glue faces of the assembly after steps, and thus the assembly will have no other exposed glues (of strength-1) beyond the single north glue of . This implies that the placement of at position is the only possible next tile placed for system .

Now suppose the tile attachment occurs to the east of the previously placed tile in the assembly. The required strength-2 attachment threshold for the tile can be achieved by two strength-1 glues, or by a single strength-2 glue. In the cooperative strength-1 glue case, we know that is the only tile in that both matches the east glue of and has a compatible geometry with the north face of the tile type at position . Thus, is a valid next element of ’s assembly sequence, and is the only valid next element by the nice properties of . For the case of a strength-2 east attachment, we know that the attachment is valid for because of the the matching strength-1 east glue of and west glue of , and because the tile type south of , if there is one, is guaranteed to have a compatible north geometry with by the “no mismatched glue” property of nice zig-zag systems. The attachment is also unique because of the “no exposed glues” property of nice zig-zag systems. The remaining west attachment case is analogous to the east attachment case.

Therefore, simulates with tile type scale , and therefore also simulates with tile type scale . The size of the geometry of the simulation is at most by Theorem G.9, and is thus where is the number of north/south glue types in . ∎


of Theorem 3.6: We use the same approach for simulating nice zig-zag systems as given in the proof for Theorem 3.5, with the modification that all non-null glue types from system are mapped to a single strength-1 glue type . Further, rather than empty set geometry assigned to all east west glues in the simulation set, we assign geometries that satisfy a compatibility matrix which assigns a 0 to entries which correspond to identical glues, and 1 to entries corresponding to non-identical glues. Thus, while there is a single glue, only the appropriate tile with geometry representing the appropriate east/west glue will attach. By the same analysis given for Theorem 3.6, we achieve a simulation set for any zig-zag system with tile type scale and geometry size. ∎

Appendix E Additional details for 2GAM Results

This section includes additional details and images describing the construction in Section 4.

Figure 12: A sketch of the assembly sequence of the square and its components: 1. first the counter module assembles; 2. the initial value is seeded by , which allows to assemble; 3. filler tiles complete a sufficient portion of the square; 4. A fully formed version of attaches; and 5. filler tiles complete the square.

e.1 The -handed counters and

For each tile in this construction, the bodies are squares of geometric units. (See Figure (a)a for an example.) The north and south geometries consist of rectangles of geometric units (i.e. rectangles of length and width ). All north geometries are completely empty, while all south geometries are completely filled in. However, the east and west geometries are composed of rectangles of geometric units (i.e. rectangles of length and width ) which contain intricate collections of gaps, which we call sockets, and projections, which we call prongs.

Note that while the techniques utilized in this construction can be generalized to form counters of arbitrary bases, the tile complexities are asymptotically identical regardless of the base, so for simplicity of explanation we utilize only base counters.

(a) Dimensions of the geometric units of a counter tile for bit position , representing bit on its west side and on its east side. White portions indicate areas which are not filled in, while grey areas are filled in (although areas , , and contain a mixture).
(b) Patterns used to represent bit values (left) and (right) on the southern corners of west and east geometries, respectively.
Figure 13: Details of the geometries of the counter tiles.

The purpose of the counter module is to count from through , for a total of values, each represented by exactly one column. The northern glue on the northernmost tile of each of column is used to represent one of the bits of the value (from left to right, the most significant bit to the least significant). Each column is composed of tiles arranged vertically. The tiles in each column perform two tasks: 1. represent an -bit binary number for , and 2. present a northern glue which represents the correct value ( or ) for the th bit of . The southern tiles, which we call the counter tiles, each represent one bit of , from top to bottom the most significant bit to the least significant. The northernmost tiles are gadgets called caps which serve to represent the bit values on the north of the columns, while ensuring their correct positioning relative to the bits of . There are two possible caps which can form, a -cap and a -cap. Either cap can nondeterministically attach to any column of counter tiles to provide the northernmost tiles of any column (except for the leftmost and rightmost columns, which are special cases discussed later). This allows for the formation of two versions of the columns which represent each counter value : one that represents a on the north and one that represents a . It is the purpose of the cap to ensure that only the version of the column with the correct bit of (i.e. for the column representing the value and thus the th bit of , the one representing the bit value matching the th bit of ) can attach to neighboring columns.

Each column can completely form independently of every other column, and in fact must be fully formed before it can combine with any other column. For each bit position of the counter, there are two tile types, one representing a and one a . Only those for the least significant bit position have strength- glues on their east and west, while those for every other bit position have glues on their east and west sides. However, all counter tiles have geometries on their east and west sides which will be explained shortly. The north and south sides of these tiles have flat geometries and strength- glues which allow them to nondeterministically combine with the bit values above and below (but only in the correct order of significance). Thus, the counter portions of each column can form by nondeterministic combinations of exactly one tile type for each bit position, and therefore columns can form which represent each of the values through . For each counter value, two columns can form: one with a -cap and one with a -cap. The east and west sides of the cap tiles have geometries but glues, except for the northernmost which has strength- glues on the east and west. The north and south sides of each cap tile are similar to those of the counter tiles in that they have only flat geometries and strength- glues, except for the northernmost cap tile which has a strength- glue that represents the bit of provided by that column. (The rightmost, and therefore least significant, bit of will be represented by a strength- glue, and both the most significant and least significant bits will be represented by special glues which convey both the bit values and the most and least significance of those positions.) The positioning of the two strength- east and west glues in each column, on only the top and bottom tiles, ensures that the only way that two columns can possibly combine with each other (keeping in mind that this construction operates at temperature ) is if they are fully formed (i.e. they contain all cap tiles and exactly one counter tile for each bit position).

(a) Template for the tile set which allows the formation of columns representing binary numbers in the range through (preventing the formation of numbers and ), and which increment the binary numbers represented by each column from west to east. The bit significance positions for each group of tiles are shown. Note that a unique group of tile types is created for every bit position, although those for positions through are shown in a single group. Each tile has strength- glues on its north and south edges (except for the north edge of the northernmost group and the south edge of the southernmost group). The east and west bit values are represented in the actual tile set by the east and west geometries.
(b) Filler tiles which fill in the bulk of the square.

e.1.1 Counter tiles

Figure (a)a shows a tile set which performs portions of the functionality of the counter tile types. This tile set is designed to form tile columns representing -bit binary numbers, with specific groups of tile types designed for various groups of bit positions. All tiles have strength- glues on their north and south sides (except for the north glue of those in the most significant bit position and the south glue of those in the least significant bit position) which match only those of the adjacent edges of tiles for adjacent bit positions. The columns formed represent -bit binary numbers on their west and east sides such that for each number represented on the west, the value is represented on the east. Additionally, every possible -bit binary value can form except for the values and (i.e. all ’s or all ’s). Those values are represented by the leftmost and rightmost columns, respectively, of the counter and are formed by a separate set of hard coded tile types since the leftmost column must expose a special glue on the north which marks that bit of as the most significant bit, and the rightmost column must expose a special strength- glue on the north which marks that bit of as the least significant bit, and it must also have flat geometries and strength- glues along its eastern side which can attach to the filler tiles.

For each bit position (where ), in order to represent bit values on the west and on the east, the geometries are designed as shown in Figure (a)a. The rectangles labeled and each have exactly one position filled in and one left empty, depending on the bit values being represented and following the patterns shown in Figure (b)b. It is these regions which enforce the restriction that only if two columns represent the same bits in all positions can they line up and come together completely to combine. The remaining area of the west geometry is completely empty except for one unit located units from the southern edge and units from the east. This single point is referred to as the prong, which will slide into a complementary socket in the east geometry of a tile in the same bit position of a column to the left.

The portion of the east geometry to the left of region is a rectangle which is completely filled in. The geometry immediately to the north of that creates the socket, which has one empty column units from the east and one additional empty spot units up that column and one unit to the west. The area labeled consists of columns which are divided horizontally into a number of blocks dependent upon , the bit position being represented. It is divided into blocks of width and height . Those blocks can be thought of as being numbered from the southernmost as , through the northernmost as . If , then each even numbered block is empty and each odd numbered block is filled in. If , then the even numbered blocks are empty and the odd numbered blocks are filled in. Examples can be seen in Figure 17.

Intuitively, the eastern socket is split into two groups of regions - those representing a and those representing a . If the socket is part of a -tile (i.e. a tile which represents a for the particular bit of the counter value), the regions representing are left open and those representing are filled in. For a -tile, the opposite is true. The number of regions is determined by the bit position. For the most significant bit position, there are only two regions, with the bottom representing and the top . The tile for the next bit down has four regions, which are essentially each of the regions of the previous tile split into sections, with the bottom of each new pair representing and the top . This splitting and doubling continues downward until the tile for the least significant bit which has regions consisting of individual squares. In a -tile, the bottom of each pair starting from the bottom is left open and the top of each is filled in, and vice versa for a -tile.

The portion of the east geometry above the socket, which is an empty rectangle, is referred to as the padding region. A padding region exists on the north of each west and east geometry, and its purpose is to guarantee that the geometries of tiles in one bit position of a column will not collide with the geometries of those in adjacent bit positions of a column correctly combining with it. This padding region is sufficient because the maximum relative translation that two columns which can combine with each other will ever need to experience is a vertical offset of , and the padding region plus the separation provided by the north-south geometries of combined tiles is at least that large.

e.1.2 Cap tiles

The remainder of each column of consists of four tiles called the cap which combine to form a vertical column one tile wide and tiles high. There are two possible types of cap, a -cap and a -cap, which can nondeterministically attach to any partial column representing a counter value to form the top four tiles of a complete column. It is the job of a -cap (for or ) to ensure that only if it has attached to a counter value (which will be positioned at the location of the th bit of ) and matches that bit of , only then can that column attach to other columns within (specifically, those columns representing and ) and thus become a portion of that counter. Otherwise, an unmatching column (i.e. one to which the “wrong” cap has nondeterministically attached) is relegated to use within , which will be described later.

Please refer to Figure 14 for a graphical depiction of the geometries of the cap tiles. The north and south geometries of all cap tiles are the same as those of the counter tiles: a completely filled in south geometry and a completely empty north geometry. The prong in the west geometry of cap tile is located units from the souther and the prong in east geometry of cap tile is located units from the north. Each consists of a single filled-in location units away from the bodies. The remainder of those geometries are empty. Additionally, the west geometry of cap tile and the east geometry of cap tile are completely empty. Thus, it is the sockets, one on each cap tile, which provide the bulk of the functionality of the caps.

The east geometries of cap tiles and each have two empty rows on the south and a buffer region on the north. In between are sockets which each have one completely filled-in row above and below them. The west geometries of cap tiles and each have one filled-in row on the south, a buffer region on the north, two empty rows south of the buffer, one filled-in row south of that, and sockets in between the two filled-in rows. The socket patterns of the cap tiles occupy a single column and are referred to as and , plus their complements and . (Note that the sockets and are not “utilized” during the combination of columns which form into , but only for those which become part of .) These columns are units tall, and by associating each of these units with one of the possible values of a counter column to which a cap can attach, it is possible to utilize the pattern of gaps and blocks in a socket to determine which type of cap ( or ) can be attached to a particular counter value while allowing that column to become part of . By virtue of the fact that the prongs are relatively short compared with those of the counter tiles, and due to the patterns of sockets and prongs on the counter tiles, compatible columns (which can only combine if they are completely formed, so we only consider completely formed columns in this discussion) are forced to align in such a way that, during their combination, the prong of a cap which is incident upon the socket of a neighboring cap will be at a position which corresponds to the value represented by the counter value. In this way, we can allow the prong to slide into an “accepting” gap if and only if the cap type is correct for that value, namely if that counter value should be associated with a or cap and thus a or bit of the number .

To provide this functionality, the socket patterns for a cap of type are the following. treats the units as representing each value for counting downward from the top to bottom. For the th unit, if coincides with a numbered bit position of which has the bit value , there is a gap, otherwise it is filled in. is the exact complement (which is equivalent to designing for bit value ). treats the units as representing one “invalid” value plus each value for , counting upward from the bottom to top with the first position being the invalid, and thus always filled-in, position. Again, for the th unit, if coincides with a numbered bit position of which has the bit value , there is a gap, otherwise it is filled in, and again, is the exact complement (with the exception that for both the invalid location is filled in).

Intuitively, the reason for the north-south reversal and offset of for socket values between the pairs of sockets and is that the prongs that will be validating the combination of counter-to-cap values will be positioned (during the combination of a pair of columns) relative to a single counter value, and thus the sockets need to use that one value to validate the two columns which represent (in the correct case) two consecutive values. Additionally, the motion of the prongs relative to the respective sockets will be vertically reversed due to the fact that they are on opposite sides of the combining columns. (Also, recall that whenever two columns attempt to combine which do not encode consecutive values, the patterns encoded in regions and will prevent their combination.) Essentially, and are designed so that if they are included in a column which encodes the counter value , the positioning of the prong from a complementary column to the right, which would represent the counter value , would align it with holes if and only if the bit value of the th, or th, bit of equals .

e.1.3 Buffer columns and

As previously mentioned, every counter column can form in two versions, one with a -cap and one with a -cap. The design of the glues and geometries is sufficient to guarantee that a fully formed can and will include exactly one version of each column, namely that which will present the correct value for the corresponding bit of . In order to ensure that this construction is directed, and thus has exactly one terminal assembly, the versions of columns which are not included in the formation of must be included somewhere within the eventual square. That is the purpose of .

Intuitively, is a counter of approximately double the length of which incorporates all of the “bad” columns (meaning those with the wrong caps to be included in ), but since they cannot directly combine with each other, each pair is separated by a buffer column that not only allows them to combine but ensures that they are in fact bad columns (and hence the approximate doubling of the length as compared to ).

Each buffer column is formed of two portions, similar to the other columns. However, the bottom portion of buffer columns simply represent a single binary value from the range through , inclusive. This value is represented on both the west and east sides rather than an incremented value appearing on the east side as in the counter columns, and the geometries which represent each bit are the same as those for the counter tiles. The logic provided by the north-south glues must simply ensure that columns representing every binary number from through can form, thus simply excluding a column of all ’s. (This is because the counter column representing encodes the number on its east, and thus the buffer column need never combine with a column representing the number .) Thus, there will be a buffer column which can be sandwiched by every consecutive pair of bad columns.

There is only one version of each of the buffer cap tiles, which can be seen in Figure 14. Similar to the tiles of the counter columns, the only non glues on the west and east edges are strength- glues on the east and west of the buffer counter tiles in the least significant bit position (the southernmost in each column) and the buffer cap tile (the northernmost in each column). As shown, the only “interesting” geometry is that of the prongs on buffer cap tile and . These prongs are positioned so that they must fit into the sockets of complementary counter columns which allow combinations of counter values with cap values that are the opposite of those required for inclusion in . In this way, full buffer columns can combine on both sides with exactly those full counter columns which received the “wrong” cap and in the correct order to count from through and therefore construct .

Figure 14: Dimensions of the features in the geometries of the counter column cap tiles as well as the buffer column cap tiles. White portions indicate areas which are not filled in, while grey areas are filled in (although socket areas , , , and