Compact Error-Resilient Self-Assembly of Recursively Defined Patterns

TL;DR

This paper presents a method for designing compact error-resilient self-assembly systems for recursively defined patterns, significantly reducing mismatch errors without increasing tile complexity or pattern scale.

Contribution

It introduces a novel technique to create compact error-resilient systems for recursive patterns, maintaining tile count while reducing error rates to  under the independent error model.

Findings

Reduces mismatch error rate to  without increasing tile types

Applies to recursively defined patterns by Kautz and Lathrop

Maintains the same number of tile types as error-prone systems

Abstract

A limitation to molecular implementations of tile-based self-assembly systems is the high rate of mismatch errors which has been observed to be between 1% and 10%. Controlling the physical conditions of the system to reduce this intrinsic error rate $\epsilon$ prohibitively slows the growth rate of the system. This has motivated the development of techniques to redundantly encode information in the tiles of a system in such a way that the rate of mismatch errors in the final assembly is reduced even without a reduction in $\epsilon$. Winfree and Bekbolatov, and Chen and Goel, introduced such error-resilient systems that reduce the mismatch error rate to $\epsilon^k$ by replacing each tile in an error-prone system with a $k \times k$ block of tiles in the error-resilient system, but this increases the number of tile types used by a factor of $k^2$, and the scale of the pattern produced by a factor of $k$. Reif, Sahu and Yin, and Sahu and Reif, introduced compact error-resilient systems for the self-assembly of Boolean arrays that reduce the mismatch error rate to $\epsilon^2$ without increasing the scale of the pattern produced. In this paper, we give a technique to design compact error-resilient systems for the self-assembly of the recursively defined patterns introduced by Kautz and Lathrop. We show that our compact error-resilient systems reduce the mismatch error rate to $\epsilon^2$ by using the independent error model introduced by Sahu and Reif. Surprisingly, our error-resilient systems use the same number of tile types as the error-prone system from which they are constructed.

Equations

$${row}_P^n(x,y)$$

$${block}_P^{w,h}(x,y)$$

$$P(x,y)=f\left(\Pi {block}_P^{w,h-1}(x,y-1)\cdot {row}_P^{w-1}(x-1,y)\right)$$

$${color}_t(\overrightarrow{\text{scw}})=r^h$$

$${color}_t(\overrightarrow{\text{scs}})=block$$

$${color}_t(\overrightarrow{\text{sce}})=r^h\text{mapsfrom}\ell (t)$$

$${color}_t(\overrightarrow{\text{scn}})=block\text{mapsfrom}[r^h\cdot (\ell (t))]$$

$${col}_P^n(x,y)=(P(x,y-n+1),P(x,y-n+2),\dots ,P(x,y))$$

$$b$$

$$row$$

$$col$$

$$block$$

$${color}_{r_t}(\overrightarrow{\text{scw}})$$

$${color}_{r_t}(\overrightarrow{\text{scs}})$$

$${color}_{r_t}(\overrightarrow{\text{sce}})$$

$${color}_{r_t}(\overrightarrow{\text{scn}})$$

$$first({color}_v(\overrightarrow{\text{scn}}))$$

$$first({color}_v(\overrightarrow{\text{scn}}))\upharpoonright second({color}_v(\overrightarrow{\text{scn}}))$$

$$first({color}_w(\overrightarrow{\text{sce}}))\text{mapsfrom}second({color}_w(\overrightarrow{\text{sce}}))$$

$$first({color}_t(\overrightarrow{\text{scw}}))$$

$$\stackrel{\text{(b)}}{\ne }first({color}_v(\overrightarrow{\text{scn}}))$$

$$\stackrel{\text{(c)}}{=}first({color}_w(\overrightarrow{\text{sce}}))$$

$$first({color}_t(\overrightarrow{\text{sce}}))$$

$$\stackrel{\text{(e)}}{\ne }first({color}_v(\overrightarrow{\text{scn}}))\upharpoonright second({color}_v(\overrightarrow{\text{scn}}))$$

$$\stackrel{\text{(f)}}{=}first({color}_v(\overrightarrow{\text{sce}}))\text{mapsfrom}second({color}_v(\overrightarrow{\text{sce}}))$$

$$\stackrel{\text{(g)}}{=}first({color}_p(\overrightarrow{\text{scw}}))\text{mapsfrom}second({color}_p(\overrightarrow{\text{scw}})))$$

$$\stackrel{\text{(h)}}{=}first({color}_p(\overrightarrow{\text{scn}}))$$

$$\stackrel{\text{(i)}}{=}first({color}_q(\overrightarrow{\text{scs}}))$$

$$\stackrel{\text{(j)}}{=}first({color}_q(\overrightarrow{\text{scw}}))$$

$$\stackrel{\text{(k)}}{=}first({color}_t(\overrightarrow{\text{sce}}))$$

$$first({color}_t(\overrightarrow{\text{scs}}))$$

$$\stackrel{\text{(m)}}{\ne }first({color}_w(\overrightarrow{\text{sce}}))$$

$$\stackrel{\text{(n)}}{=}first({color}_v(\overrightarrow{\text{scn}}))$$

$$first({color}_t(\overrightarrow{\text{scn}}))$$

$$\stackrel{\text{(p)}}{\ne }first({color}_w(\overrightarrow{\text{sce}}))\text{mapsfrom}second({color}_w(\overrightarrow{\text{sce}}))$$

$$\stackrel{\text{(q)}}{=}first({color}_w(\overrightarrow{\text{scn}}))\upharpoonright second({color}_w(\overrightarrow{\text{scn}}))$$

$$\stackrel{\text{(r)}}{=}first({color}_r(\overrightarrow{\text{scs}}))\upharpoonright second({color}_r(\overrightarrow{\text{scs}})))$$

$$\stackrel{\text{(s)}}{=}first({color}_r(\overrightarrow{\text{sce}}))$$

$$\stackrel{\text{(t)}}{=}first({color}_s(\overrightarrow{\text{scw}}))$$

$$\stackrel{\text{(u)}}{=}first({color}_s(\overrightarrow{\text{scs}}))$$

$$\stackrel{\text{(v)}}{=}first({color}_t(\overrightarrow{\text{scn}}))$$

$$((t_{1,1},\dots ,t_{1,n},u_1),\dots ,(t_{m,1},\dots ,t_{m,n},u_m)).$$

$$first({color}_v(\overrightarrow{\text{scn}}))$$

$$first({color}_v(\overrightarrow{\text{scn}}))\upharpoonright second({color}_v(\overrightarrow{\text{scn}}))$$

$$first({color}_w(\overrightarrow{\text{sce}}))\text{mapsfrom}second({color}_w(\overrightarrow{\text{sce}}))$$

$$w_r$$

Full text

1 Introduction

In an algorithmic self-assembly of DNA molecules, information is encoded into the sticky ends of the molecules in such a way that when the molecules are placed in solution, they self-assemble into some target pattern, structure, or computation [15]. Although implementing this process in laboratory experiments is technically challenging [8], it has many applications to nanotechnology [12].

A standard computational model for DNA self-assembly is the abstract Tile Assembly Model (aTAM) introduced in [9]. In this model, a DNA molecule is represented by a tile which is a unit square that can be translated, but not rotated, so that each of its four sides are well-defined. On each side of a tile is a glue that is made up of both a non-negative integer strength (usually 0, 1, or 2), and a string (over some finite alphabet) which is called the glue’s color. Each glue represents the information encoded into a sticky end of the molecule. We say that two tiles are of the same type if they have the identical glues on each of their corresponding sides (in both color and strength). Addtionally, each tile $t$ has a label, denoted by ${\ell}(t)$, that is associated with its tile type, but does not play a role in the assembly process. Several tile types are illustrated in Fig. 1a.

A tile assembly system (TAS) in the aTAM is a triple $(T,\sigma,\tau)$ where $T$ is a finite set of tile types, $\sigma\in T$ is the type of the seed tile, and the temperature $\tau$ is some positive integer which, in this paper, is always 2. There is an unbounded number of tiles of each type in $T$ which self-assemble into an aggregate assembly, represented as a mapping from $\mathcal{Z}^{2}$ to $T\,\dot{\cup}\,\{\bot\}$, by tiles binding, one at a time, to an initial assembly that consists of a single tile of type $\sigma$ placed at the origin. Whether a tile can bind to an assembly at a position $(x,y)$ is determined by how it interacts with the tiles at adjacent locations in the assembly. Two tiles interact precisely when they are located next to each other, and have the same glue (in both color and strength) on their abutting side. The interaction strength of a tile with an assembly at a position $(x,y)$ is the summed strength of the glues on sides of the tile that interact with tiles at positions adjacent to $(x,y)$ in the assembly. A tile can bind to the assembly at a position $(x,y)$ if its interaction strength with the assembly at $(x,y)$ is at least the temperature $\tau$. See Fig. 1b for an illustration of the self-assembly process for a TAS using the tile set in Fig. 1a. When no more tiles can bind to the assembly it is said to be a final assembly of $\mathcal{T}$. All TASs considered in this paper result in a unique final assembly (which is allowed to be infinite) in the aTAM.111It is a straightforward exercise to show that all of the TASs considered here result in a unique final assembly by using the local determinism technique given in [13]. We write $\mathcal{T}[x,y]$ for the tile at position $(x,y)$ in the unique final assembly of the TAS $\mathcal{T}$, or $\bot$ if no such tile exists.

A TAS $\mathcal{T}=(T,\sigma,2)$ is rectilinear if there is a partition $\{B,I\}$ of $T$ where tiles of types in $B$ are used for the boundary of the assembly, and tiles of types in $I$ have only strength 1 glues and are used for the interior of the assembly. A rectilinear TAS has the property that, for every $(x,y)\in\mathcal{Z}^{2}$ where $x,y\!>\!0$, the tile $\mathcal{T}[x,y]$ binds to the assembly by interacting with the tiles $\mathcal{T}[x-1,y]$ and $T[x,y-1]$. This forces the assembly to grow in the northeast direction. For a rectiliner TAS $\mathcal{T}$, we denote by $L_{\mathcal{T}}(x,y)$ the value of ${\ell}(\mathcal{T}[x,y])$, we denote by $H_{\mathcal{T}}(x,y)$ the color of the glue shared by $\mathcal{T}[x-1,y]$ and $\mathcal{T}[x,y]$ on their abutting side, and we denote by $V_{\mathcal{T}}(x,y)$ the color of the glue shared by the tiles $\mathcal{T}[x,y-1]$ and $\mathcal{T}[x,y]$ on their abutting side. When $\mathcal{T}$ is clear, we write $L(x,y)$, $H(x,y)$ and $V(x,y)$ for $L_{\mathcal{T}}(x,y)$, $H_{\mathcal{T}}(x,y)$ and $V_{\mathcal{T}}(x,y)$, respectively. For example, the TAS illustrated in Fig. 1 is a rectilinear TAS where $V(x,y)=L(x,y-1)$, $H(x,y)=L(x-1,y)$, and $L(x,y)=(V(x,y)+H(x,y))\!\!\!\mod 2$.

We are interested in the pattern produced by a rectilinear TAS $\mathcal{T}=(T,\sigma,2)$. A pattern of some finite alphabet $\mathcal{L}$ is a mapping from $\mathcal{Z}^{2}$ to $\mathcal{L}\,\dot{\cup}\,\{\bot\}$. The pattern produced by a TAS $\mathcal{T}$, denoted by $P(\mathcal{T})$, is the pattern of $\cup_{t\in T}{\ell}(t)$ that maps each $(x,y)\in\mathcal{Z}^{2}$ to ${\ell}(\mathcal{T}[x,y])$, or $\bot$ when $\mathcal{T}[x,y]=\bot$. We say that a pattern $P$ self-assembles if there is a TAS $\mathcal{T}$ such that $P=P(\mathcal{T})$. For example, the TAS of Fig. 1 produces the Sierpinski triangle pattern (see Fig. 6a). Several complex patterns have been shown to self-assemble in the aTAM [8, 2, 3, 5, 6].

Although the aTAM is an error-free model of self-assembly, a limitation encountered in molecular implementations of rectilinear TASs [8, 14] is that sometimes a molecule will initially bind to an assembly with interaction strength less than $\tau$, but before it can detach, other molecules bind to the assembly in such a way that the initially weakly bound molecule becomes permanently “locked” into the assembly [8, 14]. We say that there is a mismatch error between two adjacent tiles in an assembly to mean that they do not interact, i.e., they have different glues on their abutting sides. See Fig. 2 for an illustration of a mismatch error. In implementations of rectiliner TASs using DNA double-crossover molecules, the intrinsic rate of mismatch errors $\epsilon$ is observed to range from 1% to 10% [8, 5, 3]. Not only do mismatch errors allow tiles to bind at incorrect locations in an assembly, but they propagate in the sense that an initial mismatch error invites more tiles to bind at incorrect locations even without a further mismatch error, thereby preventing the reliable self-assembly of large target structures with minimal or no defects. Although the physical conditions of the system can be optimized to reduce $\epsilon$, doing so slows the rate at which tiles bind to the assembly to prohibitive levels for most applications.

The approach to reducing mismatch errors considered here is to design error-resilient TASs that reduce the rate of mismatch errors in their final assembly without requiring a reduction in the intrinsic error rate $\epsilon$ of the system. An error-resilient tiling scheme transforms a TAS $\mathcal{T}$ into an error-resilient TAS $\mathcal{R}$ such that $P(\mathcal{R})=P(\mathcal{T})$. Such schemes work by redundantly encoding information in the tiles in such a way that mismatch errors become prone to detach [14, 4, 7, 10]. In [11], it is shown that increasing this redundancy can lead to an exponential decrease in the rate of mismatch errors in the final assembly. However, several of these error-resilient tiling schemes [14, 4] replace each tile in the original TAS by a $k\times k$ block of tiles in the error-resilient TAS. This increases the number of tile types (and tiles) used by a factor of $k^{2}$ in the general case, and also increases the scale of the pattern produced by the error-resilient system by a factor of $k$ which is undesirable for many applications. An error-resilient tiling scheme is compact if it results in a TAS that does not increase the scale of the pattern produced.

Compact error-resilient tiling schemes were first introduced in [7, 10] where they were used to design error-resilient TASs that produce Boolean array patterns. A Boolean array TAS is a rectilinear TAS where the tiles are labeled by bits, and there are two binary Boolean operators $op1$ and $op2$ so that $L(x,y)=V(x,y+1)=V(x,y)\ op1\ H(x,y)$, and $H(x+1,y)=V(x,y)\ op2\ H(x,y)$. Initial bits are given for $L(x,y)$, $H(x,y)$ and $V(x,y)$ when $x=0$ or $y=0$. There are 256 such Boolean array TASs, including those that produce the binary counter and the Sierpinski triangle patterns. Each such TAS uses four distinct tile types for the interior of the assembly. The error-resilient TAS produced by the compact error-resilient tiling scheme of [10] reduces the rate of mismatch errors to $\epsilon^{2}$, but uses up to four times as many tile types as the original error-prone TAS in the general case. An additional scheme is given in [10] for the case when $op1$ and $op2$ are pairwise input sensitive in which the error-rate is reduced to $\epsilon^{3}$. Specific error-resilient TASs for the binary counter and the Sierpinski triangle patterns are given in [7].

In this paper, we introduce a compact error resilient tiling scheme for recursively defined patterns. A pattern $P$ is recursively defined if, for each $(x,y)\in\mathcal{Z}^{2}$, $P(x,y)$ is a finite function of all of the other values of $P$ in some fixed-sized rectangle of $\mathcal{Z}^{2}$ whose upper right corner is at $(x,y)$. The self-assembly of recursively defined patterns was introduced in [6]. Such patterns include, as with Boolean arrays, the Sierpinski triangle. However, since the function used in a recursively defined pattern is not required to be a Boolean operator, the recursively defined patterns also include the Sierpinski carpet and the other numerically self-similar fractal patterns, as well as an infinite number of other patterns. A uniform construction is given in [6] that takes a recursively defined pattern $P$, and creates a rectilinear TAS $\mathcal{T}$ such that $P(\mathcal{T})=P$. Our main result in this paper is a compact error-resilient tiling scheme that transforms a TAS $\mathcal{T}$ created by the construction of [6] into an error-resilient TAS $\mathcal{R}$ such that $P(\mathcal{R})=P(\mathcal{T})$. We show that the rate of mismatch errors in the error-resilient TAS created by our construction is reduced to $\epsilon^{2}$ by using the independent error model introduced in [10]. Surprisingly, $\mathcal{R}$ uses the same number of tile types as $\mathcal{T}$. To our knowledge, this is the first example of an error-resilient tiling scheme that does not increase the number of tile types used.

The rest of this paper proceeds as follows: In Section 2, we introduce some general notation and terminology used in the rest of the paper, including some operations on tuples used to simplify several of the notations in our constructions and proofs. In Section 2.1, we introduce some addtional notations with regards to the aTAM and briefly introduce the kinetic Tile Assembly Model (kTAM). In Section 2.2, we review the recursively defined patterns introduced in [6] along with the construction given to create a TAS $\mathcal{T}$ in which a given recursively defined pattern self-assembles. In Section 3, we give our main result: a compact error-resilient tiling scheme that transforms a recursively defined TAS created by the construction of [6] into an error-resilient TAS with the same number of tile types, and producing the same pattern, as the original error-prone TAS, but reduces the rate of mismatch errors to $\epsilon^{2}$. In Section 4, we summarize the results of simulating our error-resilient TASs using the Xgrow software on a few recursively defined test patterns to further verify our results. We conclude in Section 5 with a discussion of our results and some ideas for further research.

2 Preliminaries

We work in the discrete Euclidean plane $\mathcal{Z}^{2}$. We write $U_{2}$ for the set of all unit vectors in $\mathcal{Z}^{2}$, and we refer to the elements of $U_{2}$ by by the cardinal directions: $\vec{\text{\sc n}}=(0,1)$, $\vec{\text{\sc e}}=(1,0)$, $\vec{\text{\sc s}}=(0,-1)$, and $\vec{\text{\sc w}}=(-1,0)$. The neighborhood of a position $(x,y)$ in $\mathcal{Z}^{2}$, denoted by $N(x,y)$, is the set of positions that differ from $(x,y)$ by at most 1 in each direction, i.e., the set of all $(x^{\prime},y^{\prime})\in\mathcal{Z}^{2}$ such that $|x^{\prime}-x|\leq 1$ and $|y^{\prime}-y|\leq 1$. We write $\Sigma^{*}$ for the set of all strings over some finite alphabet $\Sigma$. For a positive integer $n$, $[n]=\{1,2,\ldots n\}$. For an $n$-tuple $t$ and $1\leq i\leq n$, we write $t_{i}$ for the $i$th element of $t$. We also write ${first}(t)$ for $t_{1}$ and ${second}(t)$ for $t_{2}$. When $t$ is a tuple-of-tuples, we write $t_{i,j}$ for the $j$th element of the $i$th element of $t$. We define the following operations on tuples in order to simplify some notation in the constructions and proofs of this paper.

• •

The concatenation operation: $t\cdot u=(t_{1},\ldots,t_{m},u_{1},\ldots,u_{n})$ where $t$ is an $m$-tuple and $u$ is an $n$-tuple. When $t$ is a tuple-of-tuples, $\Pi\,t=t_{1}\cdot\ldots\cdot t_{m}$.

• •

The shift-insert operation: $t\mapsfrom e=(t_{2},\ldots t_{n},e)$ where $t$ is an $n$-tuple and $e$ is any element (possibly a tuple).

• •

The deep-shift-insert operation $t\!\upharpoonright\!u=(t_{1}\mapsfrom u_{1},\ldots,t_{n}\mapsfrom u_{n})$ where $t$ is an $n$-tuple-of-tuples, and $u$ is an $n$-tuple.

Unless the order of evaluation is specified with brackets, all of the above operations on tuples are evaluated in left-to-right order so that $\Pi\,t\cdot u=t_{1}\cdot t_{2}\cdot\ldots\cdot t_{n}\cdot u$, $t\mapsfrom e\mapsfrom f=(t_{3},\ldots t_{n},e,f)$, and $t\!\upharpoonright\!u\!\upharpoonright\!v=(t_{1}\mapsfrom u_{1}\mapsfrom v_{1},\ldots,t_{n}\mapsfrom u_{n}\mapsfrom v_{n})$.

2.1 The Tile Assembly Model

In this paper we use both the abstract and kinetic versions of the Tile Assembly Model, the aTAM and the kTAM. An overview of the aTAM was given in the introduction, but we will use a few additional notations: for a tile $t$ and a side $\vec{u}\in U_{2}$, we write ${strength}_{t}(\vec{u})$ and ${color}_{t}(\vec{u})$, for the strength and color, respectively, of the glue on side $\vec{u}$ of $t$. The kinetic Tile Assembly Model (kTAM) is an augmentation of the aTAM that uses the physical conditions of the system as parameters so that mismatch errors in the assembly process can be modeled. The kTAM models the rate at which tiles bind and detach from a growing assembly as a function of two unitless free energies $G_{se}$ and $G_{mc}$. The value of $G_{se}$ controls the number of base pair bonds that must be broken for a tile to detach from the assembly. The value of $G_{mc}$ measures the concentration of tiles in the system and controls the forward rate of the assembly process. It is suggested in [14] that a value for $G_{mc}$ slightly less than twice the value of $G_{se}$ provides an optimal intrinsic error rate for a TAS with a temperature of $\tau=2$. We refer the reader to [14, 7] for a more complete overview of the kTAM.

2.2 Recursively Defined Patterns

Here, we introduce recursively defined patterns, and note that our recursively defined patterns are equivalent to the recursively defined matrices of [6] where it was shown that all recursively defined matrices self-assemble in the aTAM. Since we use some different notations and terminology, we reproduce the relevant definitions and results of [6] for coherence. Additionally, we remark that although equivalent, our definition of recursively defined patterns is more refined in the sense that the entries in a recursively defined pattern are allowed to depend on the entries in a $w\times h$ block of the pattern, where as in [6], each entry in a recursively defined matrix depends on the entries in an $n\times n$ block of the matrix.

We use the following tuples to specify particular parts of a pattern $P$ defined relative to a particular location $(x,y)\in\mathcal{Z}^{2}$:

[TABLE]

where $n$, $w$, and $h$ are positive integers. Intuitively, ${row}_{P}^{n}(x,y)$ describes the values of $P$ at each of the $n$ positions directly to the left of and including position $(x,y)$, and ${block}_{P}^{w,h}(x,y)$ describes the values of $P$ at each position of the $w\times h$ rectangle of $Z^{2}$ whose upper right corner is at position $(x,y)$.

For integers $w,h\geq 2$, we say that a pattern $P$ of $\mathcal{L}$ is $(w,h)$-recursively defined to mean that there is a function $f:(\mathcal{L}\,\dot{\cup}\,\{\bot\})^{\,wh-1}\rightarrow\mathcal{L}$ such that for all $(x,y)\in\mathcal{Z}^{2}$,

[TABLE]

when $x,y\geq 0$, and $\bot$ otherwise. Note that every $(w,h)$-recursively defined pattern is also both a $(w+1,h)$ and $(w,h+1)$-recursively defined pattern. A pattern is recursively defined if it is $(w,h)$-recursively defined for some $w$ and $h$.

A main result of [6] is that every recursively defined pattern self-assembles.

Theorem 2.1 ([6])

Let $P$ be a $(w,h)$-recursively defined pattern on $\mathcal{L}$. There exists a TAS $\mathcal{T}=(T,\sigma,2)$ where $|T|\leq(|\mathcal{L}|+1)^{mn-1}$ and $P(\mathcal{T})=P$.

Theorem 2.1 is proven in [6] using a uniform construction that creates a TAS $\mathcal{T}=(T,\sigma,2)$ in which a given $(w,h)$-recursively defined pattern $P$ self-assembles. We review this construction here using the notation and terminology given above:

Construction 1** ([6])**

For each $r^{1},r^{2},\ldots,r^{h-1}\in\mathcal{L}_{\bot}^{w}$ and $r^{h}\in\mathcal{L}_{\bot}^{w-1}$ such that both of the following conditions hold:

1. $\forall i\in[h],\forall j,k\in[w]$, $(r^{i}_{j}=\bot$ and $r^{i}_{k}\neq\bot$) implies $j<k$ , and
2. $\forall i,j\in[h],\forall k\in[w]$, $(r^{i}_{k}=\bot$ and $r^{j}_{k}\neq\bot)$ implies $i<j$ ,

let $block=(r^{1},\ldots,r^{h-1})$, and add a tile type $t$ to $T$ where ${\ell}(t)=f_{P}(\Pi block\cdot r^{h})$, the glue color on each side of $t$ is defined by:

[TABLE]

and the glue strength on each side of $t$ is 1 except in the following cases:

1. *Case 1: * $r^{h-1},r^{h}\in\{\bot\}^{*}$. In this case ${strength}(\vec{\text{\sc n}})=2$, ${strength}(\vec{\text{\sc e}})=2$, ${strength}(\vec{\text{\sc s}})=0$, ${strength}(\vec{\text{\sc w}})=0$, and $\sigma=t$.
2. *Case 2: * $r^{h-1}\in\{\bot\}^{*},r^{h}\not\in\{\bot\}^{*}$. In this case ${strength}(\vec{\text{\sc w}})=2$, ${strength}(\vec{\text{\sc e}})=2$, ${strength}(\vec{\text{\sc n}})=1$, ${strength}(\vec{\text{\sc s}})=0$ (i.e., $t$ is used to assemble the horizontal boundary),
3. *Case 3: * $r^{h-1}\not\in\{\bot\}^{*},r^{h}\in\{\bot\}^{*}$. In this case ${strength}(\vec{\text{\sc n}})=2$, ${strength}(\vec{\text{\sc s}})=2$, ${strength}(\vec{\text{\sc e}})=1$, ${strength}(\vec{\text{\sc w}})=0$ (i.e., $t$ is used to assemble the vertical boundary).

Intuitively, the TAS $\mathcal{T}$ created by Construction 1 is a rectilinear TAS where, for each $(x,y)\in\mathcal{Z}^{2}$, $V(x,y)={block}_{P}^{w,h-1}(x,y-1)$, $H(x,y)={row}_{P}^{w-1}(x-1,y)$, and $L(x,y)=f_{P}(\Pi\,V(x,y)\cdot H(x,y))$. For example, the TAS created by Construction 1 for the Sierpinski triangle has $V(x,y)=(L(x-1,y-1),L(x,y-1))$, $H(x,y)=(L(x-1,y))$, and $L(x,y)=L(x,y-1)+L(x-1,y)\!\!\!\mod 2$. See Fig. 3 for an illustration.

2.2.1 A note on optimizing size of a tile set created by Construction 1.

For $(2,2)$-recursively defined patterns $P$ in which the value of $P(x,y)$ does not depend on $P(x-1,y-1)$, the size of the tile set in a TAS produced by Construction 1 for $P$ is not optimal. For example, the tile set for the Sierpinski triangle pattern given in Fig. 3c uses 3 tile types for the boundary and 8 tile types for the interior. However, the tile set for the Sierpinski triangle given in Fig. 1 uses 3 tile types for the boundary and only 4 tile types for the interior. Another construction is given in [6] that creates a smaller tile set for such patterns. We stress here, that the error-resilient tiling scheme we introduce in Section 3 requires as input the tile set created exactly as specified by Construction 1.

3 Main Results

In this section, we give our main result: a compact error-resilient tiling scheme that transforms a recursively defined TAS created by Construction 1 given in [6] (and reviewed in Section 2.2) for a recursively defined pattern $P$, into an error-resilient TAS that produces the pattern $P$ and uses the same number of tile types, but the rate of mismatch errors in the final assembly is reduced to $\epsilon^{2}$. We analyze the error-rate of the TAS created by our error-resilient tiling scheme using the error model introduced in [10].

Theorem 3.1 (Main Theorem)

There exists a compact error-resilient tiling scheme that, given a TAS $\mathcal{T}=(T,\sigma_{\mathcal{T}},2)$ created by Construction 1, creates a TAS $\mathcal{R}=(R,\sigma_{\mathcal{R}},2)$ such that $P(\mathcal{R})=P(\mathcal{T})$, $|R|=|T|$, and the rate of mismatch errors in the final assembly of $\mathcal{R}$ is $\epsilon^{2}$, where $\epsilon$ is the intrinsic error rate of the system.

Our proof of Theorem 3.1 uses Construction 2, given below, which takes as input a TAS $\mathcal{T}$ created by the construction of [6] (Construction 1 in Section 2.2), and creates such a TAS $\mathcal{R}$. We will need one additional part of a pattern $P$ relative to a particular location $(x,y)\in\mathcal{Z}^{2}$ to use in Construction 2, along with the parts ${row}_{P}^{n}(x,y)$ and ${block}_{P}^{w,h}(x,y)$ defined in Section 2.2:

[TABLE]

where $n$ is some positive integer. Intuitively, ${col}_{P}^{n}(x,y)$ describes the values of $P$ at each of the $n$ positions directly below and including position $(x,y)$.

Construction 2

Let $\mathcal{T}=(T,\sigma_{\mathcal{T}},2)$ be the TAS created for a $(w,h)$-recursively defined pattern $P$ by the construction in the proof of Theorem 2.1. We construct a TAS $\mathcal{R}=(R,\sigma_{\mathcal{R}},2)$ as follows: For each tile type $t\in T$, let

[TABLE]

and add a tile type $r_{t}$ to $R$ where ${\ell}(r_{t})={\ell}(t)$, ${strength}_{r_{t}}(\vec{u})={strength}_{t}(\vec{u})$ for each $\vec{u}\in U_{2}$, and the glues of $r_{t}$ are set in the following way:

[TABLE]

After adding a tile type $r_{t}$ to $R$ for each $t\in T$, we set $\sigma_{\mathcal{R}}=r_{\sigma_{\mathcal{T}}}$. **

Intuitively, the TAS $\mathcal{R}$ created by Construction 2 is a rectilinear TAS in which, for each $(x,y)\in\mathcal{Z}^{2}$, $V(x,y)$ represents the pair $({block}_{P}^{w-1,h-1}(x-1,y-1),{col}_{P}^{h-1}(x,y-1))$, $H(x,y)$ represents the pair $({row}_{P}^{w-1}(x-1,y),{block}_{P}^{w-1,h-1}(x-1,y-1)$, and $L(x,y)=f_{P}(\Pi\,{block}_{P}^{w,h-1}(x,y-1)\cdot{row}_{P}^{w-1}(x-1,y))$. Note that ${block}_{P}^{w-1,h-1}(x-1,y-1)$ is encoded redundantly in both $V(x,y)$ and $H(x,y)$. See Figure 4 for an illustration.

The following lemma shows that the TAS $\mathcal{R}$ created by Construction 2 for a given TAS $\mathcal{T}$ created by Construction 1 produces the same pattern as $\mathcal{T}$ and uses the same number of tile types.

Lemma 1

Let $\mathcal{T}=(T,\sigma_{\mathcal{T}},2)$ be a TAS created by Construction 1, and let $\mathcal{R}=(R,\sigma_{\mathcal{R}},2)$ be the TAS created by Construction 2 given $\mathcal{T}$. Then $P(\mathcal{R})=P(\mathcal{T})$ and $|R|=|T|$.

The proof of Lemma 1 is straightforward and given in the technical appendix.

3.1 Error Analysis

We analyze the error rate of a TAS $\mathcal{R}$ created by Construction 2 by using the independent error model introduced in [10]. In this model, $\epsilon$ represents the probability of the event that there is a mismatch error between a pair of tiles, and they stay connected in the equilibrium. It is assumed that $\epsilon$ is independent of any other mismatch errors, or lack thereof. We refer the reader to [10] for more on the independent error model.

Theorem 3.2

[10]** Let $\mathcal{R}$ be a rectilinear TAS, and let $(x,y)\in\mathcal{Z}^{2}$. Under the independent error model, if a mismatch error between the tiles $\mathcal{R}[x,y]$ and $\mathcal{R}[x,y-1]$ or between the tiles $\mathcal{R}[x,y]$ and $\mathcal{R}[x-1,y]$ forces $k$ further mismatch errors between tiles in $N(x,y)$, then the rate of mismatch errors in the final assembly of $\mathcal{R}$ is reduced to $\epsilon^{k+1}$.

We will show that an initial mismatch error in a TAS $\mathcal{R}$ created by Construction 2 forces at least one additional mismatch error in the neighborhood of the initial mismatch error, thereby reducing the rate of mismatch errors in the final assembly to $\epsilon^{2}$. We emphasize here that a mismatch error is between the entire glues on the abutting sides of two tiles. In our case, each glue color represents a pair of tuples $(u,v)$, and so a mismatch between any of the respective elements of the two glue colors on the abutting sides of two tiles constitutes a mismatch error between those two tiles. We will need the following lemma.

Lemma 2

Let $\mathcal{R}$ be a TAS created by Construction 2 and let $(x,y)\in\mathcal{Z}^{2}$ where $x>0$ and $y>0$. Let $u=\mathcal{T}[x-1,y-1]$, $v=\mathcal{T}[x,y-1]$ and $w=\mathcal{T}[x-1,y]$. If there is no mismatch error between $u$ and $v$, and no mismatch error between $u$ and $w$, then all of the following equalities hold:

[TABLE]

The proof of Lemma 2 is straightforward and given in the technical appendix.

Theorem 3.3

Let $\mathcal{R}$ be a TAS created by Construction 2, and let $(x,y)\in\mathcal{Z}^{2}$. A mismatch error between the tiles $\mathcal{R}[x,y]$ and $\mathcal{R}[x,y-1]$ or between the tiles $\mathcal{R}[x,y]$ and $\mathcal{R}[x-1,y]$, forces a further mismatch error between tiles in $N(x,y)$.

Proof

We refer to the tiles in $N(x,y)$ by $t=\mathcal{R}[x,y]$, $u=\mathcal{R}[x-1,y-1]$, $v=\mathcal{R}[x,y-1]$, $w=\mathcal{R}[x,y-1]$, $p=\mathcal{R}[x+1,y-1]$, $q=\mathcal{R}[x+1,y]$, $r=\mathcal{R}[x-1,y+1]$, $s=\mathcal{R}[x,y+1]$, and $x=\mathcal{R}[x+1,y+1]$. By assumption, the initial mismatch error is either between the tiles $t$ and $v$, or between the tiles $t$ and $w$. We can further assume that there are no mismatch errors between the tiles $u$ and $v$, or between the tiles $u$ and $w$, otherwise the theorem is trivially true. Hence, the equalities (1), (2) and (3) given in Lemma 2 hold. Our goal is to show that, given an initial mismatch error either between the tiles $t$ and $v$ or between the tiles $t$ and $w$, there is a further mismatch error in $N(x,y)$. We separate into two cases:

Case 1: The initial mismatch error is between the tiles $t$ and $v$. Then, either ${first}({color}_{t}(\vec{\text{\sc s}}))\neq{first}({color}_{v}(\vec{\text{\sc n}}))$ or ${second}({color}_{t}(\vec{\text{\sc s}}))\neq{second}({color}_{v}(\vec{\text{\sc n}}))$.

Case 1a: In this case we assume that the mismatch error between the tiles $t$ and $v$ is because ${first}({color}_{t}(\vec{\text{\sc s}}))\neq{first}({color}_{v}(\vec{\text{\sc n}}))$. Then,

[TABLE]

where (a) follows from Construction 2; (b) follows from the assumption of Case 1a; and (c) follows from Lemma 2(1). So we have shown that in Case 1a, ${first}({color}_{t}(\vec{\text{\sc w}}))\neq{first}({color}_{w}(\vec{\text{\sc e}}))$, and hence, there is a further mismatch error between the tiles $t$ and $w$.

Case 1b: In this case we assume that Case 1a does not hold, and so the mismatch error between the tiles $t$ and $v$ is because ${second}({color}_{t}(\vec{\text{\sc s}}))\neq{second}({color}_{v}(\vec{\text{\sc n}}))$. For sake of contradiction, suppose that there are no mismatch errors between the tiles $t$ and $q$, between the tiles $q$ and $p$, and between the tiles $p$ and $v$. Then,

[TABLE]

where (d), (h) and (j) follow from Construction 2; (e) follows from the assumption of Case 1b; (f) follows from Lemma 2(2); (g) follows from the assumption that there is no mismatch error between $p$ and $v$; (i) follows from the assumption that there is no mismatch error between $q$ and $p$; and (k) follows from the assumption that there is no mismatch error between $t$ and $q$. Thus, under the supposition that there are no mismatch errors between $t$ and $q$, between $q$ and $p$, and between $p$ and $v$, we have that ${first}({color}_{t}(\vec{\text{\sc e}}))\neq{first}({color}_{t}(\vec{\text{\sc e}}))$ which is a contradiction. Hence, there must be a further mismatch error either between the tiles $t$ and $q$, or between the tiles $q$ and $p$, or between the tiles $p$ and $v$.

Case 2: The initial mismatch error is between the tiles $t$ and $w$. Then, either ${first}({color}_{t}(\vec{\text{\sc w}}))\neq{first}({color}_{w}(\vec{\text{\sc e}}))$ or ${second}({color}_{t}(\vec{\text{\sc w}}))\neq{second}({color}_{w}(\vec{\text{\sc e}}))$.

Case 2a: In this case we assume that the mismatch error between the tiles $t$ and $w$ is because ${first}({color}_{t}(\vec{\text{\sc w}}))\neq{first}({color}_{w}(\vec{\text{\sc e}}))$. Then,

[TABLE]

where (l) follows from Construction 2; (m) follows from the assumption of Case 2a; and (n) follows from Lemma 2(1). So we have shown that in Case 2a, ${first}({color}_{t}(\vec{\text{\sc s}}))\neq{first}({color}_{v}(\vec{\text{\sc n}}))$, and hence, there is a further mismatch error between the tiles $t$ and $v$.

Case 2b: In this case we assume that Case 2a does not hold, and so the mismatch error between the tiles $t$ and $w$ is because ${second}({color}_{t}(\vec{\text{\sc w}}))\neq{second}({color}_{w}(\vec{\text{\sc e}}))$. For sake of contradiction, suppose that there are no mismatch errors between the tiles $t$ and $s$, between the tiles $s$ and $r$, and between the tiles $r$ and $w$. Then,

[TABLE]

where (o), (s) and (u) follow from Construction 2; (p) follows from the assumption of Case 2b; (q) follows from Lemma 2(3); (r) follows from the assumption that there is no mismatch error between $r$ and $w$; (f) follows from the assumption that there is no mismatch error between $s$ and $r$; and (v) follows from the assumption that there is no mismatch error between $t$ and $s$. Thus, under the supposition that there are no mismatch errors between $t$ and $s$, between $s$ and $r$, and between $r$ and $w$, we have that ${first}({color}_{t}(\vec{\text{\sc n}}))\neq{first}({color}_{t}(\vec{\text{\sc n}}))$ which is a contradiction. Hence, there must be a further mismatch error either between the tiles $t$ and $s$, or between the tiles $s$ and $r$, or between the tiles $r$ and $w$.

In all cases, there is a further mismatch error between tiles in $N(x,y)$. ∎

See Figure 5 for an illustration of the proof of Theorem 3.3. Theorems 3.2 and 3.3 immediately give the following corollary.

Corollary 1

The rate of mismatch errors in the final assembly of a TAS $\mathcal{R}$ created by Construction 2 is $\epsilon^{2}$.

4 Simulations

In this section, we summarize the results of computer simulations we performed using the Xgrow simulator [14] to further verify the performance of the compact error-resilient scheme of Construction 2. Our simulations were run on three recursively-defined test patterns: the Sierpinski triangle pattern $\mathcal{S}$, the Sierpinski carpet pattern $\mathcal{C}$, and a more complicated pattern which we call Pattern $\mathcal{W}$. See Fig. 6 for an illustration of each of these patterns which are defined formally as follows:

• •

The Sierpinski triangle pattern, denoted by $\mathcal{S}$ and illustrated in Fig. 6a, is the $(2,2)$-recursively defined pattern on $\{0,1\}$ where $\mathcal{S}(x,y)=(\mathcal{S}(x,y\text{\,-}1)+\mathcal{S}(x\text{\,-}1,y))\!\!\!\mod 2$ when $x,y>0$; $1$ when $x=0$ or $y=0$; and $\bot$ otherwise.

• •

The Sierpinski carpet pattern, denoted by $\mathcal{C}$ and illustrated in Fig. 6b, is the $(2,2)$-recursively defined pattern on $\{0,1,2\}$ where $\mathcal{C}(x,y)=(\mathcal{C}(x\text{\,-}1,y\text{\,-}1)+\mathcal{C}(x,y\text{\,-}1)+\mathcal{C}(x\text{\,-}1,y))\!\!\!\mod 3$ when $x,y>0$; 1 when $x=0$ or $y=0$; and $\bot$ otherwise.

• •

Pattern $\mathcal{W}$, illustrated in Fig. 6c, is the $(3,3)$-recursively defined pattern on $\{0,1\}$ where $\mathcal{W}(x,y)=(\mathcal{W}(x\text{\,-}2,y\text{\,-}2)+\mathcal{W}(x,y\text{\,-}2)\ +\mathcal{W}(x\text{\,-}1,y\text{\,-}1)+\mathcal{W}(x\text{\,-}2,y))\!\!\!\mod 2$ when $x,y>0$; 1 when $x=0$ and $y$ is even or $x$ is even and $y=0$; 0 when $x=0$ and $y$ is odd or $x$ is odd and $y=0$; and $\bot$ otherwise.

For each of these patterns $P$, we ran simulations of the TAS created by Construction 1, denoted by $\mathcal{T}_{P}$, and the TAS created by Construction 2, denoted by $\mathcal{R}_{P}$. For the Sierpinski triangle, we also ran simulations for the TAS created by the compact error-resilient scheme introduced in [7], denoted by $\mathcal{B}_{\mathcal{S}}$. Each simulation used a target assembly of $512\times 512$ tiles, and was allowed to run until the assembly reached 75% of the target size. For each simulation, we computed the number of tiles $N$ in the largest $m\times n$ aggregate assembled (including the origin) without any permanent error. Fig. 7 shows, for each TAS and each $G_{se}$ value in the range $4.9,5.2,\ldots,8.2$, the median value of $N$ for 101 simulations. As suggested in [14], we used a value for $G_{mc}$ slightly less than $2G_{se}$. As can be seen from the figure, our results for the Sierpinski triangle pattern are comparable to the results of [7], and our results for the Sierpinski carpet and $\mathcal{W}$ patterns also show a dramatic improvement over their non error-resilient counterparts. We refer the reader to the website [1] for more information on our simulations.

5 Discussion

We leave open the question of whether there exists a redundancy-based compact error-resilient tiling scheme for recursively defined patterns that reduces the mismatch error rate to $\epsilon^{3}$. Such a scheme exists for Boolean patterns where $op1$ and $op2$ are pairwise input sensitive [10], but it is also conjectured in [10] that no such scheme exists when the operations are not pairwise input sensitive. The conjecture is proven for the case when $op_{1}$ and $op_{2}$ are allowed to be arbitrary Boolean operations.

We remark here that any rectilinear TAS $\mathcal{T}$ can be transformed into a $(2,2)$-recursively defined TAS $\mathcal{T}^{\prime}$ that can then be transformed into an error resilient TAS using Construction 2 given in Section 3 by allowing the label of a tile in $\mathcal{T}^{\prime}$ to be a pair whose first element represents the label of the original tile in $\mathcal{T}$, and whose second element represents the tile type of the original tile in $\mathcal{T}$. The first element is the value used to determine the pattern of $\mathcal{T}^{\prime}$, and the second element is the value that is communicated in the $V$ and $H$ values of the rectilinear TAS. However, with this approach, the number of tile types used by $\mathcal{T}^{\prime}$ can be as high as $n^{3}$ in the general case, where $n$ is the number of distinct tile types used by $\mathcal{T}$, making this approach impractical for TASs with even modestly sized tile sets.

Although our error-resilient TASs performed well in the simulations summarized in Section 4, further inspection of the data showed that many of the errors in the simulations were caused by boundary tiles attaching in the interior of the assembly. It is likely that better error-resiliency would result from implementing our error-resilient TASs in two stages, one stage for assembling the boundary using only the boundary tile types, and one stage for assembling the interior using only the interior tile types, thereby preventing boundary tiles from attaching in the interior of the assembly.

Appendix 0.A Technical Appendix

0.A.1 Proof of Lemma 1.

Before proving the lemma, we first define an operation on tuples. Let $t$ be an $m$-tuple of $n$-tuples, and let $u$ be an $m$-tuple. Then, $t\wedge u$ is the $m$-tuple of $(n+1)$-tuples defined by

[TABLE]

We now prove Lemma 1. For completeness, it is restated here.

Lemma 1

Let $\mathcal{T}=(T,\sigma_{\mathcal{T}},2)$ be a TAS created by Construction 1, and let $\mathcal{R}=(R,\sigma_{\mathcal{R}},2)$ be the TAS created by Construction 2 given $\mathcal{T}$. Then $P(\mathcal{R})=P(\mathcal{T})$ and $|R|=|T|$.

Proof (of Lemma 1)

Consider a tile type $t\in T$, and the tile type $r_{t}\in R$ created by Construction 2 to replace $t$. By Construction 2, ${\ell}(t)={\ell}(r_{t})$, ${color}_{t}(\vec{\text{\sc s}})={first}({color}_{r_{t}}(\vec{\text{\sc s}}))\wedge{second}({color}_{r_{t}}(\vec{\text{\sc s}}))$, and ${color}_{t}(\vec{\text{\sc w}})={second}({color}_{r_{t}}(\vec{\text{\sc w}}))$.

We first show that the function $f:T\to R$ defined by $f(t)=r_{t}$ for all $t\in T$ is a bijection and hence $|T|=|R|$. Since each tile type $r\in R$ is created from a tile type $t\in T$, it is clear that $f$ is onto. To see that $f$ is 1-1, let $t_{1},t_{2}\in T$ such that $f(t_{1})=f(t_{2})=r$. Then, ${\ell}(t_{1})={\ell}(t_{2})={\ell}(r)$, ${color}_{t_{1}}(\vec{\text{\sc s}})={color}_{t_{2}}(\vec{\text{\sc s}})={first}({color}_{r}(\vec{\text{\sc s}}))\wedge{second}({color}_{r}(\vec{\text{\sc s}}))$, and ${color}_{t_{1}}(\vec{\text{\sc w}})={color}_{t_{2}}(\vec{\text{\sc w}})={second}({color}_{r}(\vec{\text{\sc w}}))$. It follows by Construction 1 that $t_{1}$=$t_{2}$. Hence, $f$ is 1-1.

To see that $P(\mathcal{R})=P(\mathcal{T})$, we can assume that $\mathcal{T}$ was created by Construction 1 for a $(w,h)$-recursively defined pattern $P$ for some integers $w,h\geq 2$. Now let $(x,y)\in\mathcal{Z}^{2}$ such that $x\geq 0$ and $y\geq 0$, and let $t=\mathcal{T}[x,y]$. It suffices to show that $\mathcal{R}[x,y]=r_{t}$. Since $t=\mathcal{T}[x,y]$, by Construction 1, ${color}_{t}(\vec{\text{\sc w}})={row}^{w-1}_{P}(x-1,y)$ and ${color}_{t}(\vec{\text{\sc s}})={block}^{w,h-1}_{P}(x,y-1)$. Then, by Construction 2, $\mathcal{R}[x,y]$ is the tile $r\in R$ such that ${block}^{w,h-1}_{P}(x,y-1)={first}({color}_{r}(\vec{\text{\sc s}}))\wedge{second}({color}_{r}(\vec{\text{\sc s}}))$ and ${row}^{w-1}_{P}(x-1,y)={second}({color}_{r}(\vec{\text{\sc w}}))$. Since the function $f$ is 1-1, there is only one such tile, namely $r_{t}$. ∎

0.A.2 Proof of Lemma 2.

Here we prove Lemma 2. For completeness, it is restated here.

Lemma 2

Let $\mathcal{R}$ be a TAS created by Construction 2 and let $(x,y)\in\mathcal{Z}^{2}$ where $x>0$ and $y>0$. Let $u=\mathcal{T}[x-1,y-1]$, $v=\mathcal{T}[x,y-1]$ and $w=\mathcal{T}[x-1,y]$. If there is no mismatch error between $u$ and $v$, and no mismatch error between $u$ and $w$, then all of the following equalities hold:

[TABLE]

Proof (of Lemma 2)

We use the following tuples encoded into the glues on the “input” sides of the tiles $u$, $v$ and $w$:

[TABLE]

See Fig. 8 for an illustration. We then have that

[TABLE]

where equalities (a), (c), (d), (e), (g), (h), (j), (k), (m), (n), (p), (q), (s) and (t) follow from Construction 2; equalities (b), (f) and (g) follow from the assumption that there is no mismatch error between $u$ and $v$; and equalities (i), (o) and (r) follow from the assumption that there is no mismatch error between $u$ and $w$.

We can assume, w.l.o.g., that the TAS $\mathcal{R}$ is created by Construction 2 from a TAS $\mathcal{T}$ created by Construction 1 for a $(m,n)$-recursively defined pattern $P$ for some fixed integers $m,n\geq 2$, and hence, we can further define $u_{r}$, $u_{b}$, $u_{c}$, $v_{c}$ and $w_{r}$ as follows:

[TABLE]

Proof of equality (1): We must show that ${first}({color}_{v}(\vec{\text{\sc n}}))={first}({color}_{w}(\vec{\text{\sc e}}))$. By equality (a) above, ${first}({color}_{v}(\vec{\text{\sc n}}))=[u_{b}\!\upharpoonright\!u_{c}]\!\mapsfrom\![u_{r}\!\mapsfrom\!{\ell}(u)]$. By equality (s) above, ${first}({color}_{w}(\vec{\text{\sc e}}))=[u_{b}\!\mapsfrom\!u_{r}]\!\upharpoonright\![u_{c}\!\mapsfrom\!{\ell}(u)]$. Thus, it suffices to show that $[u_{b}\!\upharpoonright\!u_{c}]\!\mapsfrom\![u_{r}\!\mapsfrom\!{\ell}(u)]=[u_{b}\!\mapsfrom\!u_{r}]\!\upharpoonright\![u_{c}\!\mapsfrom\!{\ell}(u)]$. This is a straightforward exercise, using the definitions of  $\!\upharpoonright\!$  and  $\!\mapsfrom\!$  given in Section 2:

[TABLE]

and

[TABLE]

Proof of equality (2): We must show that ${first}({color}_{v}(\vec{\text{\sc n}}))\!\upharpoonright\!{second}({color}_{v}(\vec{\text{\sc n}}))={first}({color}_{v}(\vec{\text{\sc e}}))\!\mapsfrom\!{second}({color}_{v}(\vec{\text{\sc e}}))$. By equalities (c) and (d) above, we have that

[TABLE]

and, by equalities (g) and (j) above, we have that

[TABLE]

Thus, it suffices to show that $[[u_{b}\!\upharpoonright\!u_{c}]\!\mapsfrom\![u_{r}\!\mapsfrom\!{\ell}(u)]]\!\upharpoonright\![v_{c}\!\mapsfrom\!{\ell}(v)]=[[u_{b}\!\upharpoonright\!u_{c}]\!\upharpoonright\!v_{c}]\!\mapsfrom\![[u_{r}\!\mapsfrom\!{\ell}(u)]\!\mapsfrom\!{\ell}(v)]$. This is a straightforward exercise, using the definitions of  $\!\upharpoonright\!$  and  $\!\mapsfrom\!$  given in Section 2:

[TABLE]

and

[TABLE]

Proof of equality (3): We must show that ${first}({color}_{w}(\vec{\text{\sc e}}))\!\mapsfrom\!{second}({color}_{w}(\vec{\text{\sc e}}))={first}({color}_{w}(\vec{\text{\sc n}}))\!\upharpoonright\!{second}({color}_{w}(\vec{\text{\sc n}}))$. By equlities (s) and (t) above, we have that

[TABLE]

and, by equalities (m) and (p) above, we have that

[TABLE]

Thus, it suffices to show that $[[u_{b}\!\mapsfrom\!u_{r}]\!\upharpoonright\![u_{c}\!\mapsfrom\!{\ell}(u)]]\!\mapsfrom\![w_{r}\!\mapsfrom\!{\ell}(w)]=[[u_{b}\!\mapsfrom\!u_{r}]\!\mapsfrom\!w_{r}]\!\upharpoonright\![[u_{c}\!\mapsfrom\!{\ell}(u)]\!\mapsfrom\!{\ell}(w)]$. This is a straightforward exercise, using the definitions of  $\!\upharpoonright\!$  and  $\!\mapsfrom\!$  given in Section 2:

[TABLE]

and

[TABLE]

∎