Simulation of Programmable Matter Systems Using Active Tile-Based Self-Assembly

TL;DR

This paper demonstrates how Tile Automata models can simulate the behavior and movement of programmable matter systems based on the amoebot model, using only local interactions.

Contribution

It introduces a method to simulate amoebot programmable matter systems with Tile Automata, bridging two models of self-assembly and programmable matter.

Findings

TA systems can simulate amoebot local information transmission

TA macrotiles can replicate amoebot particle movement

Simulation maintains properties of amoebot systems using local interactions

Abstract

Self-assembly refers to the process by which small, simple components mix and combine to form complex structures using only local interactions. Designed as a hybrid between tile assembly models and cellular automata, the Tile Automata (TA) model was recently introduced as a platform to help study connections between various models of self-assembly. However, in this paper we present a result in which we use TA to simulate arbitrary systems within the amoebot model, a theoretical model of programmable matter in which the individual components are relatively simple state machines that are able to sense the states of their neighbors and to move via series of expansions and contractions. We show that for every amoebot system, there is a TA system capable of simulating the local information transmission built into amoebot particles, and that the TA "macrotiles" used to simulate its particles are capable of simulating movement (via attachment and detachment operations) while maintaining the necessary properties of amoebot particle systems. The TA systems are able to utilize only the local interactions of state changes and binding and unbinding along tile edges, but are able to fully simulate the dynamics of these programmable matter systems.

Equations

$$\delta :Q\times {\Sigma }^{10}\times T\times E\to \mathcal{P}(Q\times {\Sigma }^{10}\times T\times E\times M).$$

Full text

1 Introduction

Theoretical models of self-assembling systems are mathematical models that allow for the exploration of the limits of bottom-up construction and self-assembly via simple (usually square) tiles. There are a wide variety of tile-based models of self-assembly (e.g., [21, 16, 19, 15, 20, 13, 12]), each with differing constraints and dynamics, resulting in great variations in the relative powers between systems. One of the easiest ways to evaluate their relationships is to use notions of simulation to attempt to simulate one model by another, and this has led to the creation of a “complexity hierarchy” of self-assembly models and categories of systems [22, 11, 7, 14, 17].

Another category of theoretical models attempts to capture the dynamics of so-called programmable matter, in which small and simple, but dynamic and mobile, components are able to interact with each other to form structures, perform tasks and computations, etc. [23, 6].

This paper attempts to bridge the divide between these categories of models, showing how self-assembling tiles can mimic the behaviors of programmable matter. Specifically, we demonstrate how the recently introduced Tile Automata (TA) model [4] can be used to simulate the amoebot model [6]. In the TA model, the fundamental components are unit square tiles which form structures by attaching and forming bonds, and can also change states based on their own states and those of their neighbors, causing them to be able to form new bonds or to remove existing bonds. The basic components in the amoebot model are particles which can also change their states based on the current states of themselves and their neighbors, but which can also move via series of expansions and contractions. While the components of both models rely only upon local information and communication, the design goals of their systems tend to differ fundamentally. The main goal of TA systems is to self-assemble into target structures, but amoebot systems have been used to solve system-level problems of movement and coordination (e.g., shape formation [8], object coating [9], leader election [5], gathering [3], bridging gaps [1], etc.). We present a construction in which constant-sized assemblies of TA tiles, called macrotiles, assemble and disassemble following the rules of the TA model and are able to simulate the behaviors of individual amoebot particles. Via carefully designed processes of building and breaking apart assemblies, they are collectively able to correctly simulate the full dynamics of amoebot systems. We thus show how the dynamics of systems of self-assembling tiles with the ability to form and break bonds can be harnessed to faithfully simulate the dynamics of collections of programmable matter particles capable of local communication and motion. Not only does this provide a way to connect and leverage existing results across models, this also provides a new paradigm for designing systems to accomplish the goals of programmable matter. It additionally allows amoebots to serve as a higher-level abstraction for designing systems exhibiting complex behaviors of programmable matter but with a translation to implementation in TA.

The paper is organized as follows. Section 2 presents a high-level definition of the TA model, and Section 3 provides a full mathematical definition for the amoebot model. (We note that this is the first full mathematical definition for the amoebot model and thus is also a contribution of this paper.) Section 4 gives the formal definition, preliminaries, and overview of the simulation of the amoebot model by TA, while Section 5 gives more of its details. A brief discussion and conclusion are given in Section 6, and a Technical Appendix contains a more rigorous definition of the TA model, as well as low-level technical details about the construction.

2 The Tile Automata Model

The Tile Automata model seeks to connect and evaluate the differences between some of the seemingly disparate models of tile-based self assembly by combining components of the Two Handed Assembly Model (2HAM) of self-assembly with a rule set of local state changes that are similar to asynchronous cellular automata. This section provides an overview of the TA model which is sufficient for the purposes of this paper, however a more thorough and detailed definition of the TA model is available in the technical appendix, which is based on [4].

The Tile Automata Model has many similarities with other tile based self assembly systems. Tiles, the fundamental units of this model that interact with one another, use only local information, in this case the state of their neighbors. Tiles exist as a stateful unit square centered on a point on the square lattice over the integers in two dimensions, so that a tile’s coordinates $(x,y)\in\mathbb{Z}^{2}$. Tiles may form bonds with adjacent neighbors via attaching to one another according to the affinity function, which defines a set of two states and either a vertical or horizontal relative orientation (denoted as $\perp$ and $\vdash$, respectively) as well as an attachment strength. A connection between tiles or groups of connected tiles must have the property of $\tau$ stability to persist. Every TA system has defined an integer stability threshold or $\tau$ that represents the minimum strength bond with which tiles must be bound in order to be $\tau$ stable. Two adjacent tiles of states $s,s^{\prime}$, with the tile of state $s$ directly to the right of the tile of state $s^{\prime}$, will form an attachment if there exists a rule in the affinity function $(s^{\prime}\vdash s\geq\tau)$. An assembly is a $\tau$ stable connected set of TA tiles, with the property that there exists no way to separate the tiles without breaking bonds of at least $\tau$ strength. Further, a pair of tiles may transition according to a transition rule that takes as input two adjacent tiles (oriented by either $\perp$ or $\vdash$) and outputs new states for those tiles. So the tiles in our example of $s^{\prime}\vdash s$ may transition to states $t\vdash s$ if there exists a rule in the set of transition rules provided in the definition of a TA system of the form $(s^{\prime},s,t,s,\vdash)$, where $(s^{\prime},s)$ are the input states, $(t,s)$ are the output states, and $\vdash$ is their relative orientation.

2.1 Wire Transmission

One of the most useful aspects of the Tile Automata model is the tiles’ ability to transition states based on local information. This capability makes communication from one group of tiles to another, non-adjacent group easy, with a structure we will call a wire. A wire in TA is a contiguous line of tiles from one group of tiles to another, usually surrounded by inert filler tiles so as to avoid interference with the signal being transmitted. (See Figure 2 for an example.)

3 The Amoebot Model

Introduced in [10], the amoebot model is an abstract computational model of programmable matter, a substance that can change its physical properties based on user input or stimuli from its environment. The amoebot model envisions programmable matter as a collection of individual, homogeneous computational elements called particles. In what follows, we extend the exposition of the model in [6] to the level of formality needed for our simulation.

Any structure a particle system can form is represented as a subgraph of an infinite, undirected graph $G=(V,E)$ where $V$ is the set of positions a particle can occupy and $E$ is the set of all atomic movements a particle can make. Each node in $V$ can be occupied by at most one particle at a time. This work further assumes the geometric amoebot model where $G=G_{\Delta}$, the triangular lattice with nearest neighbor connectivity (see Fig. 3(a)). This lattice is preferred for work in the 2D plane, as it allows for a maximum of nearest neighbor connectivity for particles moving step wise around the perimeter of the particle swarm. Particles attempting to move around a “corner” of a particle swarm risk disconnection with the neighborhood implied by nearest neighbor connectivity on the square lattice. Each particle occupies either a single node in $V$ (i.e., it is contracted) or a pair of adjacent nodes in $V$ (i.e., it is expanded), as in Fig. 3(b). Two particles occupying adjacent nodes of $G_{\Delta}$ are neighbors. We further will define a group of particles as a particle system.

Each particle keeps a collection of ports — one for each edge incident to the node(s) it occupies — that have unique labels from its own perspective. Contracted particles have six ports while expanded particles have ten (see Fig. 3(c)). The particles are assumed to have a common sense of clockwise direction (a.k.a. chirality), but do not share a coordinate system or global compass. Thus, particles can label their ports in clockwise order starting from a local direction 0, but may have different orientations in $O=\{0,1,...,5\}$ encoding their offsets for local direction 0 from global direction 0 (to the right).

For example, in Fig. 3(c), the particle on the right has orientation 0 (i.e., it agrees with the global compass) while the particle on the left has orientation 4 (i.e., its local direction 0 is global direction 4). When a particle expands, it keeps its port labeling consistent by assigning label 0 to a port facing local direction 0 and then labeling the remaining ports in clockwise order.111Note that there may be ambiguity in choosing a port facing local direction 0; e.g., in Fig. 3(c), both port 0 and port 8 face local direction 0. In this case, the port facing local direction 0 and “away” from the particle is labeled 0. In this way, it can recover its original labeling when it later contracts. A particle $p$ communicates with a neighbor $q$ by placing a flag from the constant-size alphabet $\Sigma$ on its port facing $q$. This can be thought of as $p$ sending a message for $q$ to read when $q$ is next activated. Conversely, $p$ receives information from $q$ by reading the flag $q$ has placed on its port facing $p$. The flag alphabet $\Sigma$ is assumed to contain the “empty flag” $\epsilon$ to be used when no information is being communicated.

Particles move via a series of expansions and contractions: a contracted particle can expand into an unoccupied adjacent node to become expanded, and may then contract to occupy a single node once again. An expanded particle’s head is the node it last expanded into and the other node it occupies is its tail; a contracted particle’s head and tail are the same. If an expanded particle contracts into its head node, it has moved. Otherwise, contracting back into its tail node can be thought of as the particle exploring a potential location to which it could expand but deciding not to over the course of two activations. Neighboring particles can coordinate their movements in a handover, which can occur one of two ways. A contracted particle $p$ can “push” an expanded neighbor $q$ by expanding into one of the nodes occupied by $q$, forcing $q$ to contract. Alternatively, an expanded particle $q$ can “pull” a contracted neighbor $p$ by contracting, forcing $p$ to expand into the node it is vacating. During its movements, each particle maintains a tail port in $T=\{0,1,\dots,9\}\ \cup\{\varepsilon\}$ denoting the port furthest from its head if it is expanded or $\varepsilon$ if it is contracted (see Fig. 3(c)). This information serves as the particle’s memory about whether or not it is expanded, and, if so, what direction its tail is relative to its head.

More formally, the set of all possible movements is $M=\{\textsf{idle}\}\cup\{\textsf{expand}_{i}:i\in{0,1,\dots,5}\}\cup\{\textsf{contract}_{i}:i\in{0,1,...,9}\}\cup\{\textsf{handover}_{i}:i\in{0,1,...,5}\}$. An idle move simply means the particle does not move. If a particle $p$ performs $\textsf{expand}_{i}$, $p$ expands into the node its $i$-th port faces only if $p$ is contracted and that node is unoccupied. If a particle $p$ performs $\textsf{contract}_{i}$, $p$ contracts out of the node incident to its $i$-th port only if $p$ is expanded. The $\textsf{handover}_{i}$ moves are not push or pull handover specific, nor do they actually perform the handover movements described above. Instead, a particle $p$ performs $\textsf{handover}_{i}$ when it initiates a handover with the neighbor its $i$-th port faces, say $q$. This initiation only succeeds if a neighboring particle $q$ actually exists and $p$ is contracted while $q$ is expanded (or vice versa). To aid in executing the initiated handover — which will be described shortly — each particle keeps an expansion direction in $E={0,1,...,5}\cup\{\epsilon\}$ denoting the local direction it would like to expand in or $\epsilon$ if no expansion is needed.

The amoebot model assumes that particle systems progress by individual particles performing atomic actions asynchronously, where each particle independently and continuously executes its own instance of the given algorithm at potentially varying speeds. Assuming any conflicts that may arise in this concurrent execution are resolved — as is the case in the amoebot model, see [6] — a classical result under the asynchronous model states that there is a sequential ordering of atomic actions producing the same end result. Thus, we assume there is an activation scheduler responsible for activating exactly one particle at a time. This scheduler is assumed to be fair: each particle is assumed to be activated infinitely often. When a particle $p$ is activated by the scheduler, it computes its transition function $\delta$ and applies the results:

[TABLE]

For a given algorithm under the amoebot model, $Q$ is a constant-size set of particle states while the flag alphabet $\Sigma$, the tail ports $T$, the expansion directions $E$, and the movements $M$ are as defined above. The transition function $\delta$ allows a particle to use its state, its neighbors’ flags facing it, its tail port, and its expansion direction to update these values and decide whether to move. If $\delta$ maps a unique input to multiple outputs, one output set is chosen arbitrarily. $\delta$ largely depends on the algorithm being executed; here, we describe a few general rules for $\delta$ our simulation will consider. Suppose that $\delta(q,(f_{0},f_{1},\ldots,f_{9}),t,e)=(q^{\prime},(f_{0}^{\prime},f_{1}^{\prime},\ldots,f_{9}^{\prime}),t^{\prime},e^{\prime},m^{\prime})$.

• •

The movement $m^{\prime}$ must be valid according to the defined movement rules; e.g., if $m^{\prime}=\textsf{expand}_{i}$, particle $p$ must be contracted and the node its $i$-th port faces must be unoccupied.

• •

If $t=\varepsilon$, then $f_{6}=\cdots=f_{9}=\epsilon$; i.e., if particle $p$ is contracted, it cannot set flags for ports it doesn’t have. This holds also for $t^{\prime}$ and $(f_{6}^{\prime},\ldots,f_{9}^{\prime})$.

• •

If $e\neq\epsilon$, then $t=\varepsilon$; i.e., particle $p$ can only intend to expand in local direction $e$ if it is contracted. This holds also for $e^{\prime}$ and $t^{\prime}$.

• •

If $m^{\prime}=\textsf{expand}_{i}$, then $t^{\prime}\neq\varepsilon$ and $e^{\prime}=\epsilon$; i.e., if particle $p$ expands in local direction $i$, it will be expanded (setting $t^{\prime}$ to the label opposite $i$ after expansion) and should not intend to expand again immediately.

• •

If $e\neq\epsilon$, then either $m^{\prime}=\textsf{expand}_{e}$ or $m^{\prime}=\textsf{idle}$. That is, if particle $p$ intends to expand in local direction $e$ this activation, it either does so or has to wait.

• •

If $m^{\prime}=\textsf{contract}_{i}$, then $t^{\prime}=\varepsilon$.

It remains to describe how handovers are executed with respect to $\delta$. In a concurrent execution, a handover is performed as a coordinated, simultaneous expansion and contraction of two neighboring particles. In our sequential setting, however, we instead use a local synchronization mechanism to ensure the contracting particle moves first, followed by the expanding particle. To achieve this, we make one change to the scheduler. Whenever a particle $p$ returns a movement $m^{\prime}=\textsf{handover}_{i}$ as output from $\delta$, the scheduler finds the neighbor $q$ facing the $i$-th port of $p$ and ensures that the next three particles to be activated are $q$, then $p$, then $q$ again.222Note that this forced scheduling is simply a result of our formalism and does not alter or subvert the underlying asynchrony assumed by the amoebot model. We first describe a pull handover initiated by an expanded particle $p$ with a contracted neighbor $q$.

Suppose $p$ is chosen by the scheduler. Based on its state, its neighbors’ flags facing it, its tail port indicating it is expanded, and its (empty) expansion direction, suppose $\delta$ returns $m^{\prime}=\textsf{handover}_{i}$. $\delta$ must also set $f_{i}^{\prime}$ to a handover flag indicating that $p$ has initiated a handover with its neighbor. 2. 2.

On seeing $m^{\prime}=\textsf{handover}_{i}$ returned, the scheduler finds neighbor $q$ (the neighbor faced by the $i$-th port of $p$) and schedules $[q,p,q]$ as the next three particles to be activated. It activates $q$. 3. 3.

Based on the inputs to $\delta$ for particle $q$, and in particular the handover flag $f_{j}$ from $p$ and the fact that it is contracted, $\delta$ must evaluate such that $q$ sets $f_{j}^{\prime}$ as a will-expand flag, sets $e^{\prime}=j$, and sets $m^{\prime}=\textsf{idle}$. 4. 4.

The scheduler now has $[p,q]$, so it activates $p$. 5. 5.

Based on the inputs to $\delta$ for particle $p$, and in particular the will-expand flag $f_{i}$ from $q$, $\delta$ must evaluate such that it clears $f_{i}^{\prime}=\epsilon$ and sets $m^{\prime}=\textsf{contract}_{i}$ (setting $t^{\prime}=\varepsilon$, following the rules above). Thus, it contracts. 6. 6.

The scheduler now has $[q]$, so it activates $q$. 7. 7.

Based on the inputs to $\delta$ for particle $q$, and in particular its expansion direction $e=j$, $\delta$ must evaluate such that $q$ clears $f_{j}^{\prime}=\epsilon$ and sets $m^{\prime}=\textsf{expand}_{e}$ (setting $t^{\prime}$ to the corresponding tail port opposite $e$). 8. 8.

The scheduler has no queued activations, so it chooses arbitrarily but fairly.

A push handover initiated by a contracted particle $p$ with an expanded neighbor $q$ is handled similarly. The first activation of $p$ is the same as Step 1 above, causing the scheduler to do the same queuing as in Step 2. However, in Step 3, $q$ sees the handover flag but also that it is expanded, meaning this is a push handover. Note, however, that a push handover is symmetric to a pull handover with the exception of which particle initiates; i.e., $p$ performing a push handover with $q$ yields the same result as $q$ performing a pull handover with $p$. So, on seeing this is a push handover, $q$ simply proceeds as particle $p$ starting in Step 1, effectively exchanging roles with $p$.

The configuration of a particle $p$ is $C(p)=(\vec{v},o,q,t,e,(f_{0},\ldots,f_{9}))$, where $\vec{v}\in V$ is the coordinates of its head node, $o\in O$ is its orientation, $q\in Q$ is its state, $t\in T$ is its tail port, $e\in E$ is its expansion direction, and each $f_{i}\in\Sigma$ is the flag on its $i$-th port, for $i\in\{0,1,\dots,9\}$. Note that although the configuration of a particle $p$ includes all information needed to reconstruct $p$, particle $p$ itself does not have access to any global information or unique identifiers; in particular, it has no knowledge of $v$ or $o$. The configuration of a particle system $P$ is $C^{*}(P)=\{C(p):p\in P\}$, the set of all configurations of particles in $P$. A system configuration is valid if no two particles in the system occupy a common node in $G_{\Delta}$. We define $\mathcal{C}(P)$ to be the set of all valid system configurations of $P$. An amoebot system is defined as a 5-tuple $\mathcal{A}=(Q,\Sigma,\delta,P,\sigma)$, where $Q$ is a constant-size set of particle states, $\Sigma$ is a constant-size alphabet of flags, $\delta$ is the transition function, $P$ is the particle system, and $\sigma\in\mathcal{C}(P)$ is the initial system configuration of $\mathcal{A}$ mapping each particle to its starting configuration.

For system configurations $\alpha,\alpha^{\prime}\in\mathcal{C}(P)$, where $\alpha\neq\alpha^{\prime}$, we say $\alpha$ yields $\alpha^{\prime}$ (denoted $\alpha\rightarrow^{\mathcal{A}}\alpha^{\prime}$) if $\alpha$ can become $\alpha^{\prime}$ after a single particle activation. We use $\alpha\rightarrow^{\mathcal{A}}_{*}\alpha^{\prime}$ if $\alpha$ yields $\alpha^{\prime}$ in [math] or more activations. A sequence of configurations $(\alpha_{0},\alpha_{1},\ldots,\alpha_{k})$ is a valid transition sequence if for every $i\in[k]$ we have $\alpha_{i}\in\mathcal{C}(P)$, $\alpha_{i}\neq\alpha_{i+1}$, and $\alpha_{i}\to^{\mathcal{A}}\alpha_{i+1}$. A configuration $\alpha\in\mathcal{C}(P)$ is called reachable if there exists a valid transition sequence beginning at the initial configuration $\sigma$ and ending at $\alpha$. A configuration $\alpha\in\mathcal{C}(P)$ is called terminal if there is no configuration $\alpha^{\prime}\in\mathcal{C}(P)$ such that $\alpha\to^{\mathcal{A}}\alpha^{\prime}$. A set of configurations $\Gamma\subseteq\mathcal{C}(P)$ is called terminal if for all $\alpha\in\Gamma$ there is no configuration $\alpha^{\prime}\not\in\Gamma$ such that $\alpha\to^{\mathcal{A}}\alpha^{\prime}$ (i.e., no configuration in $\Gamma$ can transition to any configuration outside of $\Gamma$). An amoebot system $\mathcal{A}=(Q,\Sigma,\delta,P,\sigma)$ is called directed if every transition sequence from $\sigma$ leads to the same terminal configuration, or directed to set $\Gamma$ if every transition sequence from $\sigma$ leads to a configuration in $\Gamma$. Finally, given a shape $S$ (i.e., a connected set of nodes in $G_{\Delta}$), we say that system $\mathcal{A}$ forms shape $S$ if and only if, for some set of configurations $\Gamma\subseteq\mathcal{C}(P)$, $\mathcal{A}$ is directed to $\Gamma$ and for every $\alpha\in\Gamma$, the locations of the particles in $\alpha$ are exactly the locations of $S$ (up to translation and rotation).

4 Simulating Amoebot Systems with Tile Automata

In this section, we present our main result, which is a construction that takes as input an amoebot system and which outputs a Tile Automata system that simulates it. However, we must first define what we mean by the term “simulate” in this context.

4.1 Defining simulation

Intuitively, our simulation of an amoebot system by a Tile Automata system will consist of groups of tiles, called macrotiles, which each represent a single amoebot particle. Starting from an assembly which maps (via a mapping function to be described) to the initial configuration of an amoebot system, singleton tiles as well as macrotiles will attach, detach, and change states. Any changes to the assembly, modulo a scale factor, will map to new, valid configurations of the amoebot system. Conversely, for any valid configuration change of the amoebot system, the assembly will be able to change in such a way that it represents the new amoebot configuration, under the mapping function.

A macrotile is a connected, finite region of the plane $\mathbb{Z}^{2}$, whose shape can be any polyomino composed of connected unit squares. For a macrotile shape $M$ to be valid to use for a simulation, it must tessellate. Since we are defining simulation of amoebot systems, which are embedded in the triangular grid, by Tile Automata, which are embedded in the square grid, a further condition is required for macrotile shapes. Let $\mathbb{T}(M)$ be a tessellation of the plane by macrotiles of shape $M$. Let $G$ be the graph formed where every node is a macrotile in $\mathbb{T}(M)$ and there is an edge between a pair of nodes if and only if they are adjacent to each other in $\mathbb{T}(M)$. Then, graph $G$ must be isomorphic to the triangular grid graph (i.e. the graph of the triangular grid where each intersection is a node). This means each macrotile has the same 6-neighbor neighborhood as nodes in the triangular grid graph (see Figure 4).

Let $\vec{v}$ be the coordinates of a node in $G_{\Delta}$, and let $m_{\vec{v}}$ be the macrotile location which corresponds to it. Given Tile Automata system $\Gamma$ and its set of producible assemblies $\texttt{PROD}_{\Gamma}$, for assembly $\mathcal{A}\in\texttt{PROD}_{\Gamma}$, let $\alpha\in A$ be a positioned assembly of $A$, and let $\alpha|m_{\vec{v}}$ be the (possibly empty) subassembly of $\alpha$ contained in the locations of $m_{\vec{v}}$. Given $\Gamma$ and an amoebot system $\mathcal{A}=(Q,\Sigma,\delta,P,\sigma)$, a macrotile representation function $R$, from $\Gamma$ to $\mathcal{A}$, is a function which takes as input the portion of an assembly contained within a single macrotile locations, and which returns either information about the configuration of an amoebot particle from $P$, or $\epsilon$ (which maps to empty space). That is, given some $\alpha|m_{\vec{v}}$, $R(\alpha|m_{\vec{v}})\in\{(t,e,o,q,(f_{0},f_{1},...,f_{9}))$ $|$ $t\in T$, $o\in O$, $q\in Q$, $e\in E$, and $f_{i}\in\Sigma\}\cup\{\epsilon\}$, where $t\in T$ is the relative direction of a particle’s tail from its head, $o\in O$ is its orientation offset, $q\in Q$ is its state, and each $f_{i}\in\Sigma$, for $0\leq i<9$, is the flag in its $i$th port. An assembly representation function, or simply representation function, $R^{*}$ from $\Gamma$ to $\mathcal{A}$ takes as input an entire positioned assembly of $\Gamma$ and applies $R$ to every macrotile location and returns a corresponding amoebot system configuration from $\mathcal{C}(P)$.

For a positioned assembly $\alpha\in\texttt{PROD}_{\Gamma}$ such that $R^{*}(\alpha)=\alpha^{\prime}\in\mathcal{C}(P)$, $\alpha$ is said to map cleanly to $\alpha^{\prime}$ under $R^{*}$ if for all non empty blocks $\alpha|m_{\vec{v}}\in{\rm dom}\;\alpha$, $\vec{v}\in{\rm dom}\;\alpha^{\prime}$ or $\vec{v}^{\prime}\in{\rm dom}\;\alpha^{\prime}$ for some $\vec{v}^{\prime}=\vec{v}+\vec{u}$ where $\vec{u}\in\{(1,0),(0,1),(-1,0),(0,-1),(-1,1),(1,-1)\}$. In other words, $\alpha$ may have tiles in a macrotile location representing a particle in $\alpha^{\prime}$, or empty space in $\alpha^{\prime}$ but only if that position is adjacent to a particle in $\alpha^{\prime}$. We call such growth “around the edges” of $\alpha$ fuzz and thus restrict it to be adjacent to macrotiles representing particles.

Note that the following definitions of follows, models, and simulates, as well as the previous definitions of macrotiles, fuzz, etc. are based upon similar definitions used to prove results about simulation and intrinsic universality in [11, 7, 17, 18] and several other papers.

Definition 1 ($\mathcal{A}$ follows $\Gamma$)

Given Tile Automata system $\Gamma$, amoebot system $\mathcal{A}$, and assembly representation function $R^{*}$ from $\Gamma$ to $\mathcal{A}$, we say that $\mathcal{A}$ follows $\Gamma$ (under $R$), and we write $\mathcal{A}\dashv_{R}\Gamma$, if $\alpha\rightarrow^{\Gamma}\beta$, for $\alpha,\beta\in\texttt{PROD}_{\Gamma}$, implies that $R^{*}(\alpha)\rightarrow^{\mathcal{A}}_{*}R^{*}(\beta)$.

Definition 2 ($\Gamma$ models $\mathcal{A}$)

Given Tile Automata system $\Gamma$, amoebot system $\mathcal{A}=(Q,\Sigma,\delta,P,\sigma)$, and assembly representation function $R^{*}$ from $\Gamma$ to $\mathcal{A}$, we say that $\Gamma$ models $\mathcal{A}$ (under $R$), and we write $\Gamma\models_{R}\mathcal{A}$, if for every $\alpha\in\mathcal{C}(P)$, there exists $\Psi\subset\texttt{PROD}_{\Gamma}$ where $R^{*}(\alpha^{\prime})=\alpha$ for all $\alpha^{\prime}\in\Psi$, such that, for every $\beta\in\mathcal{C}(P)$ where $\alpha\rightarrow^{\mathcal{A}}\beta$, (1) for every $\alpha^{\prime}\in\Psi$ there exists $\beta^{\prime}\in\texttt{PROD}_{\Gamma}$ where $R^{*}(\beta^{\prime})=\beta$ and $\alpha^{\prime}\rightarrow^{\Gamma}\beta^{\prime}$, and (2) for every $\alpha^{\prime\prime}\in\texttt{PROD}_{\Gamma}$ where $\alpha^{\prime\prime}\rightarrow^{\Gamma}\beta^{\prime}$, $\beta^{\prime}\in\texttt{PROD}_{\Gamma}$, $R^{*}(\alpha^{\prime\prime})=\alpha$, and $R^{*}(\beta^{\prime})=\beta$, there exists $\alpha^{\prime}\in\Psi$ such that $\alpha^{\prime}\rightarrow^{\Gamma}\alpha^{\prime\prime}$.

Definition 2 essentially specifies that every time $\Gamma$ simulates an amoebot configuration $\alpha\in\mathcal{C}(P)$, there must be at least one valid growth path in $\Gamma$ for each of the possible next configurations that $\alpha$ could transition into from $\alpha$, which results in an assembly in $\Gamma$ that maps to that next step.

Definition 3 ($\Gamma$ simulates $\mathcal{A}$)

Given Tile Automata system $\Gamma$, amoebot system $\mathcal{A}$, and assembly representation function $R^{*}$ from $\Gamma$ to $\mathcal{A}$, if $\mathcal{A}\dashv_{R}\Gamma$ and $\Gamma\models_{R}\mathcal{A}$, we say that $\Gamma$ simulates $\mathcal{A}$ under $R$.

With the definition of what it means for a Tile Automata system to simulate an amoebot system, we can now state our main result.

Theorem 4.1

Let $\mathcal{A}$ be an arbitrary amoebot system. There exists a Tile Automata system $\Gamma$ and assembly representation function $R^{*}$ from $\Gamma$ to $\mathcal{A}$ such that $\Gamma$ simulates $\mathcal{A}$ under $R$. Furthermore, the simulation is at scale factor 100.

To prove Theorem 4.1, we let $\mathcal{A}=(Q,\Sigma_{\mathcal{A}},\delta,P,\sigma)$ be an arbitrary amoebot system. We will now show how to construct a Tile Automata system $\Gamma=(\Sigma_{\Gamma},\Lambda,\Pi,\Delta,\tau)$ such that $\Gamma$ simulates $\mathcal{A}$ at scale factor 100. The rest of this section contains details of our construction.

4.2 Construction definitions

Neighborhood - In the geometric amoebots model, particles are aware of the occupation of all locations on the lattice adjacent to their own. The neighborhood of a given location on the lattice is the set of its six neighbors. Pertaining to a particle, we say that a particle’s neighborhood is the set all particles occupying adjacent locations on the lattice, defined by $N(p)$, where p is a particle. Note that $|N(p)|\leq 6$ if $p$ is contracted and $10$ if it is expanded.

Macrotile - A $\tau$-stable assembly of TA tiles $g$ such that the macrotile representation function $R$ maps $g$ to a valid particle in ${\cal A}$. This simulation makes use of macrotiles with an approximately hexagonal shape and special tiles within each macrotile used to calculate information about its movement and neighborhood. See Figure 5 for an overview.

Clock Tiles - The tiles at the middle of every particle macrotile used to keep track of state, flags, $T$ value, and neighborhood information. The middle clock tile is responsible for maintaining the particle’s state $q\in Q$, and the surrounding clock tiles (called subordinate clock tiles) combine information from the particle edges and neighbors to pass into the central clock tile.

Wire Tiles - Rows of tiles leading from the bank of clock tiles in the middle of every macrotile to each edge, purposed with transmitting information from the clock to the neighboring tiles and available edges.

Filler Tiles - Tiles that serve no function within a macrotile other than to maintain connectivity with other components and shape the macrotile.

Flag Tiles - Exposed wire ends on each side of the tile responsible for maintaining flag states from $\Sigma$ in $\mathcal{A}$, as well as reading flags from their respective neighbors. Neighboring flags are retrieved via wire transmission.

Timing Tiles - Individual tiles in $\Gamma$ that diffuse into specific slots in the particle macrotiles that “start” that particle’s turn, and disconnect after the turn is finished. Timing tiles are inert except for connecting to a central clock tile, and serve as the “asynchronous clock” for our simulation.

$\epsilon$* Tiles*** - Individual tiles in $\Gamma$ that attach to the available flag tiles of macrotiles with non-full neighborhoods who are querying or attempting to lock their neighborhood flags. $\epsilon$ tiles can only attach to the exposed end of a wire displaying a lock or query signal flag. After attaching, they serve only to undergo a single state transition, which indicates to the wire end that there exists no neighbor there. After this transition, the wire propagates this information back to its clock bank and the $\epsilon$ tile detaches.

Floating Macrotile - These macrotiles (“floats”), will represent (portions of) particles in ${\cal A}$ but are not connected to the swarm. They attach to valid sites along the perimeter and simulate the “head” of an expanding particle.

Configuration Tile - After macrotiles complete their turn, they combine all values of their configuration of which they are aware $(q\in Q,e\in E,(f_{0},f_{1},...,f_{9}\in\Sigma^{10}),t\in T)$ into a single tile proximal to the clock bank called the Configuration Tile. When a macrotile is engaging in an expansion or handover move, the configuration tile is used by the representation function $R$ to map the active macrotile to its previous configuration, until the transition completes. An active macrotile engaged in these moves will be mapped by its configuration tile until it’s no longer displaying a flag indicating it is engaged in either an expansion or handover on any of its wires, ensuring the simulation of an atomic move. For a more complete explanation, see appendix B, simulation details.

4.3 Simulation Overview

The simulation of ${\cal A}$ by $\Gamma$ is affected with the assistance of the hexagonal macrotiles and the signals implemented via TA state transitions. In [4], since there were only four directions from which signals could come, it was sufficient for each macrotile to have one clock tile, which would transition its own state based on signals received from wires and send its state down the wires. Since the geometric amoebots model exists on the $G_{\Delta}$, signals can come from up to six directions, necessitating the use of multiple clock tiles. Figure 5 contains a high-level depiction of a macrotile in $\Gamma$ that simulates a particle of ${\cal A}$.

Figure 6 illustrates a simple example of simulated particle movement. Macrotiles must be initially arranged into a configuration $\alpha$ that under $R^{*}(\alpha)$ maps to a valid configuration $\alpha^{\prime}\in\mathcal{C}(P)$, with connected edges representing adjacency in $\alpha^{\prime}$. Macrotiles start with their respective states, flags, and $t$ values set to whatever those states are for the corresponding particle in $\alpha^{\prime}$. Swarm macrotiles may then begin to accept timing tiles, starting their turns. We use neighborhood lock signals to ensure that no particles that are in the same neighborhood attempt to move at the same time, avoiding asynchronous conflicts. Expansion is facilitated by the attachment along perimeter sites of floating macrotiles. The authors additionally considered systems where moves progressed by growing a new macrotile wherever a particle wanted to expand, but this construction technique requires a longer wait between neighborhood locks and unlocks. In the interest of minimizing the overhead that simulation requires, we wanted to minimize the amount of time that a neighborhood had to be locked in order to encourage collaborative movement, and decided to use prefabricated floating macrotiles.

Once a particle macrotile has received a timing tile, it only continues its turn if it is not already locked by a neighbor. If the particle is not locked down, then the active macrotile sends signals to all of its neighbors to lock down its neighborhood and it can continue without fear of causing conflict. Should two $lock$ signals be traveling towards each other along a shared wire between two macrotiles, whichever signal is first carried into the other macrotile’s wires via state transitions overwrites the signal originating from the slower macrotile, and the faster propagating signal’s originator locks down the slower. The neighboring flags are needed to simulate the transition function, and are sent from neighbors to the active macrotile via wire transmission. Once the active macrotile has decided its new state, flags, and move, it updates this information and attempts to execute its chosen move. If the move is a simple expansion, it marks the site where it wants to expand with a valid attachment signal and keeps the neighborhood locked until a floating macrotile connects to it, representing the “head” of the expanding particle. If the particle chooses to contract, it sends signals to the tail to detach from the swarm, whereupon it will become another float, and then unlocks its neighborhood. If the particle chose a $\textsf{handover}_{i}$, it performs some additional checks to ensure viability and then sends signals either “taking over” one of a neighboring expanded particle’s macrotiles, or ceding control of one of its macrotiles to a neighboring tile. In the case of $\textsf{handover}_{i}$, an additional state and flags for the subordinate particle are returned from the transition function, to be propagated from the active macrotile to the subordinate macrotile via wire transmissions as control of the macrotile changes hands.

5 Simulation of Movement

Before the simulation begins, given $\mathcal{A}$ with initial configuration $\sigma$, we produce $\Lambda$ for $\Gamma$ which consists of a connected configuration of macrotiles, each macrotile mapping to a corresponding particle in $\sigma$ under $R$. To capture the asynchronous nature of amoebot particle activations, we utilize timing tile diffusion into macrotiles to “activate” them for their turns. After attachment, the tile sends a signal to the central clock to start its turn. After a given macrotile has started its turn and has successfully locked its neighborhood, it gathers all information necessary for its transition function via wire-propagated signals (detailed in the technical appendix). To ensure that the transition function affected by macrotiles is isomorphic to the transition function affected by $\mathcal{A}$, we combine all of the flags, $e$ and $t$ values (resulting in a $|\Sigma^{10}|*|t|*|e|$ increase in state complexity for clock tiles) into the tile to the left of the central clock tile. Once this value is at that tile, the central clock tile, which holds the state, undergoes a state transition defined in the construction of $\Delta$.

Once the new state, flags, and move are produced, the particle propagates its flags down their respective wires and in the case that $\textsf{handover}_{i}$ is returned for the value of $m$, the particle additionally sends a signal (detailed in the technical appendix) to its $i$th neighbor to ensure that the neighbor has the proper orientation to facilitate that move. For $\textsf{expand}_{i}$, the active macrotile sends a signal down the wire in the $i$th direction that allows a float to attach to that edge. After connection of a float, the active macrotile further sends a $CopySignal$ to the newly attached float so the new float can copy the states and relevant flags of the expanding macrotile and fully become the head. The float sends an $AcknowledgementSignal$ after it is displaying the proper state and flags, which tells the newly expanded macrotile that it’s safe to unlock its neighborhood. For $\textsf{contract}_{i}$, the expanded macrotile sends a $Detach$ signal to the macrotile that contains the $i$th port. After detachment, the recently contracted macrotile unlocks its neighborhood. For idle, states and flags may be updated, but no change to the orientation of the simulated particles occurs. Once a macrotile executing an idle move changes its state and sends the new flags to its flag tiles, it unlocks its neighborhood and ends its turn.

5.1 handover

The Amoebots model defines a move called the $\textsf{handover}_{i}$, which allows two neighboring particles, one expanded and one contracted, to simultaneously contract from and expand into the same grid location. This move can be initiated by either particle, and involves the initiating particle’s neighbor in the $ith$ direction. There are four possibilities for handover contracts: A contracted particle can expand into a spot previously occupied by a head, a contracted particle can expand into a spot previously occupied by a tail, an expanded particle can contract and “force” its neighbor into expanding into wherever its head is currently located, and an expanded particle can contract and “force” its neighbor into expanding into wherever its tail is currently located. It’s necessary that both moves happen simultaneously to enable certain actions such as moving a collection of particles through a static tunnel of width one. For any $handoverPull$ movement, the initiating particle must be expanded and the subordinate particle contracted, while for any $handoverPush$ movement, the reverse is true.

All moves involve locking down the active particle’s neighborhood. Since $\textsf{handover}_{i}$ necessarily changes the orientation of both the initiating and subordinate particles, it is necessary to lock down the respective neighborhoods of all particles involved. Thus, the $handoverPull_{i}$ movement requires a $ProgressiveLockdownSignal_{i}$ to be sent to the subordinate particle(s) to be further propagated to their respective neighborhoods. Note, that for the duration of the execution of a handover move, a $\textsf{handover}_{i}$ flag will be displayed, ensuring that the macrotile maps to its previous configuration under the representation function $R$ until the $\textsf{handover}_{i}$ or $\textsf{expand}_{i}$ flags are cleared from the macrotiles’ respective ports. This ensures that we have smooth transitions for macrotiles mapping to the atomic transitions of amoebots.

Handover moves in our simulation occur after the initiating particle has locked down its own neighborhood, checked to ensure move validity with the $\textsf{handover}_{i}$ signal, and further sent a $ProgressiveLockdownSignal_{i}$ to each subordinate particle. The initiating particle ensures that the configuration of expansions and contractions are appropriate for the move it is attempting, and then sends a signal to the macrotile that will be passed from one particle to another. This signal contains the new state and flags for the subordinate macrotile(s). Once these fields are updated, and the $\textsf{handover}_{i}$ flags are cleared from the macrotiles’ wires, the macrotile that changed state is considered to be the head of the newly expanded particle, which sends an acknowledgement signal back to the initiating macrotile. Macrotiles engaged in a $\textsf{handover}_{i}$ move are mapped by $R$ via their configuration tiles until they clear the flags, after which they revert to the normal mode of operation for $R$, which checks a macrotile’s central clock tile and the subordinate clock tile to the immediate west. After receiving the acknowledgement of successful transition, the initiating macrotile sends out unlock signals to its neighborhood (which necessarily propagate from subordinate particles to their respective neighborhoods as well), and finally the initiating macrotile detaches its timing tile, ending the turn.

5.2 Attachment Sites

To avoid potential conflicts between tiles undergoing their state transitions and the floating macrotiles, we only allow the floating macrotiles to attach to valid attachment sites along the perimeter of the swarm. The perimeter of the swarm shares no affinity with the float tiles by default. Only after a perimeter particle undergoes its transition function and returns $M=\textsf{expand}_{i}$ and marks that edge with a state that has affinity with the float can any float attach to the particle that wants to expand. Floats attach to the swarm via a $\tau$-strength attachment along the exposed wire end of the perimeter particle that is attempting to expand. The only time macrotiles can detach from the swarm is when a given expanded macrotile receives a $Detach$ signal from its other end. When this occurs, the detaching macrotile sends signals from its clock bank to all edges to have them change their exposed wire ends to a state with no affinity to the swarm. Once the macrotile is no longer part of the swarm, it sends $query$ signals to all of its edges. In the case that a macrotile receives six $\epsilon$ responses from its wires (that is, it has no neighbors) after a query signal, it undergoes states transitions in the clock and wires that make it a float. The newly contracted macrotile prevents unintentional reattachments of other floats because the $Detach$ signal, after leaving the contracted particle’s wire, leaves the wire in its respective flag state with no affinity with floats. The wire that corresponds to the detached macrotile will not allow attachments again until it receives an $Attach$ signal from the central clock bank again.

6 Conclusion

We have presented a simulation construction in which an amoebots system can be simulated by a collection of Tile Automata macrotiles. The mechanisms by which particle movement is simulated were discussed as well, such as how the atomic actions of the amoebots model were replicated within the simulation without threat of interruption via state transitions. We hope this fits into a larger schema of comparing the power of various computational models by simulation.

Acknowledgements

The authors would like to thank Schloss Dagstuhl – Leibniz Center for Informatics and the organizers and participants of Dagstuhl Seminar 18331 “Algorithmic Foundations of Programmable Matter” [2]. The initial brainstorming and work for this paper began during that workshop and was inspired by many interesting discussions with the participants.

Technical Appendix

Appendix 0.A The Tile Automata Model

0.A.1 States, tiles, and assemblies

Tiles and States Let $\Sigma$ be an alphabet of state types. A tile $t$ is a unit square centered at a point of the discrete plane, denoted by $L(t)\in\mathbb{Z}^{2}$. Each tile is assigned a state, $S(t)\in\Sigma$. Two tiles $t_{1}$ and $t_{2}$ are said to have the same tile type if $S(t_{1})=S(t_{2})$.

Affinity Function Let $D=\{\perp,\vdash\}$, where $\perp$ and $\vdash$ represent above-below and side-by-side orientations of a pair of tiles, respectively. An affinity function $\Pi:\Sigma^{2}\times D\rightarrow\mathbb{N}$, where the output is the affinity strength between tiles with the input pair of states and the relative positions specified by the given direction $d\in D$.

Transition Rules Transition rules allow the states of tiles to change based on their neighbors. A transition rule is a 5-tuple $(S_{ia},S_{2a},S_{1b},S_{2b},d)$, with each $S_{ia},S_{2a},S_{1b},S_{2b}\in\Sigma$ and $d\in D$, that specifies that if two tiles are in states $S_{1a}$ and $S_{2a}$ and adjacent to each other in orientation $d$, then they can transition into states $S_{2a}$ and $S_{2b}$, respectively. A transition rule is considered to be a single-transition rule if either $S_{1a}=S_{1b}$ or $S_{2a}=S_{2b}$, and a double-transition rule otherwise.

Assemblies A positioned shape is any connected subset of $\mathbb{Z}^{2}$. A positioned assembly is a set of tiles at unique coordinates in $\mathbb{Z}^{2}$, which can be represented as a mapping from locations to tile states (or empty locations), $\alpha:\mathbb{Z}^{2}\rightarrow\Sigma\cup\{\epsilon\}$. The positioned shape of a positioned assembly $\alpha$ is the set of coordinates of its tiles, denoted as $\texttt{SHAPE}_{\alpha}$. For a positioned assembly $\alpha$, let $\alpha(x,y)$ denote the state of the tile with location $(x,y)\in\mathbb{Z}^{2}$ in $\alpha$.

For a given positioned assembly $\alpha$ and affinity function $\Pi$, define the bond graph $G_{\alpha}$ to be the weighted grid graph in which:

each tile of $\alpha$ is a vertex 2. 2.

no edge exists between non-adjacent tiles 3. 3.

the weight of an edge between adjacent tiles $t_{1}$ and $t_{2}$ with locations $(x_{1},y_{1})$ and $(x_{2},y_{2})$, respectively, is:

1. (a)

$\Pi(S(t_{1}),S(t_{2}),\perp)$ if $y_{1}>y_{2}$ 2. (b)

$\Pi(S(t_{2}),S(t_{1}),\perp)$ if $y_{1}<y_{2}$ 3. (c)

$\Pi(S(t_{1}),S(t_{2}),\vdash)$ if $x_{1}<x_{2}$ 4. (d)

$\Pi(S(t_{2}),S(t_{1}),\vdash)$ if $x_{1}>x_{2}$

A positioned assembly $\alpha$ is said to be $\tau$-stable for positive integer $\tau$ provided the bond graph $G_{\alpha}$ has min-cut at least $\tau$.

For a positioned assembly $\alpha$ and integer vector $\vec{v}=(v_{1},v_{2})$, let $\alpha_{\vec{v}}$ denote the positioned assembly obtained by translating each tile in $\alpha$ by $\vec{v}$. An assembly is a set of all translations $\alpha_{\vec{v}}$ of a positioned assembly $\alpha$. A shape is the set of all integer translations for some subset of $\mathcal{Z}^{2}$, and the shape of an assembly $A$ is defined to be the set of positioned shapes of all positioned assemblies in $A$. The size of either an assembly or shape $X$, denoted as $|X|$, refers to the number of tiles in any positioned assembly of $X$.

Breakable Assemblies An assembly is $\tau$-breakable if it can be split into two assemblies along a cut whose total affinity strength sums to less than $\tau$. Formally, an assembly $C$ is breakable into assemblies $A$ and $B$ if the bond graph $G_{C}$ for some positioned assembly $\gamma\in C$ has a cut $(\alpha,\beta)$ for positioned assemblies $\alpha\in A$ and $\beta\in B$ of affinity strength less than $\tau$. We call assemblies $A$ and $B$ pieces of the breakable assembly $C$.

Combinable Assemblies Two assemblies are $\tau$-combinable provided they may attach along a border whose strength sums to at least $\tau$. Formally, two assemblies $A$ and $B$ are $\tau$-combinable into an assembly $C$ provided that $G_{\gamma}$ for any $\gamma\in C$ has a cut $(\alpha,\beta)$ of strength at least $\tau$ for some positioned assemblies $\alpha\in A$ and $\beta\in B$. We call $C$ a combination of $A$ and $B$.

Transitionable Assemblies Let $\Delta$ be a set of transition rules. An assembly $A$ is transitionable, with respect to $\Delta$, into assembly $B$ if and only if there exist $\alpha\in A$ and $\beta\in B$ such that for some pair of adjacent tiles $t_{i},t_{j}\in\alpha$:

$\exists$ a pair of adjacent tiles $t_{h},t_{k}\in\beta$ with $L(t_{i})=L(t_{h})$ and $L(t_{j})=L(t_{k})$ 2. 2.

$\exists$ a transition rule $\delta$ in $\Delta$ such that $\delta=(S(t_{i}),S(t_{j}),S(t_{h}),S(t_{k}),\perp)$ or $\delta=(S(t_{i}),S(t_{j}),S(t_{h}),S(t_{k}),\vdash)$ 3. 3.

$\mathcal{A}-\{t_{i},t_{j}\}=\mathcal{B}-\{t_{h},t_{k}\}$

0.A.2 Tile Automata (TA) model

A tile automata system is a 5-tuple $(\Sigma,\Pi,\Lambda,\Delta,\tau)$ where $\Sigma$ is an alphabet of state types, $\Pi$ is an affinity function, $\Lambda$ is a set of initial assemblies with each tile assigned a state from $\Sigma$, $\Delta$ is a set of transition rules for states in $\Sigma$, and $\tau\in\mathbb{N}$ is the stability threshold. When the affinity function and state types are implied, we let $(\Lambda,\Delta,\tau)$ denote a tile automata system. An example tile automata system can be seen in Figure 1.

Definition 4 (Tile Automata Producibility)

For a given tile automata system $\Gamma=(\Sigma,\Lambda,\Pi,\Delta,\tau)$, the set of producible assemblies of $\Gamma$, denoted $\texttt{PROD}_{\Gamma}$, is defined recursively:

(Base) $\Lambda\subseteq\texttt{PROD}_{\Gamma}$ 2. 2.

(Recursion) Any of the following:

1. (a)

(Combinations) For any $A,B\in\texttt{PROD}_{\Gamma}$ such that $A$ and $B$ are $\tau$-combinable into $C$, then $C\in\texttt{PROD}_{\Gamma}$ 2. (b)

(Breaks) For any $C\in\texttt{PROD}_{\Gamma}$ such that $C$ is $\tau$-breakable into $A$ and $B$, then $A,B\in\texttt{PROD}_{\Gamma}$ 3. (c)

(Transitions) For any $A\in\texttt{PROD}_{\Gamma}$ such that $A$ is transitionable into $B$ (with respect to $\Delta$), then $B\in\texttt{PROD}_{\Gamma}$

For a tile automata system $\Gamma=(\Sigma,\Lambda,\Pi,\Delta,\tau)$, we say $A\rightarrow^{\Gamma}_{1}B$ for assemblies $A$ and $B$ if $A$ is $\tau$-combinable with some producible assembly to form $B$, if $A$ is transitionable into $B$ (with respect to $\Delta$), if $A$ is $\tau$-breakable into $B$ and some other assembly, or it $A=B$. Intuitively, this means that $A$ may grow into assembly $B$ through one or fewer combinations, transitions, or breaks. We define the relation $\rightarrow^{\Gamma}$ to be the transitive closure of $\rightarrow^{\Gamma}_{1}$, i.e. $A\rightarrow^{\Gamma}B$ means that $A$ may grow into $B$ through a sequence of combinations, transitions, and/or breaks.

Definition 5 (Terminal Assemblies)

A producible assembly $A$ of tile automata system $\Gamma=(\Sigma,\Lambda,\Pi,\Delta,\tau)$ is terminal provided that $A$ is not $\tau$-combinable with any producible assembly of $\Gamma$, $A$ is not $\tau$-breakable, and $A$ is not transitionable (with respect to $\Delta$) to any producible assembly of $\Gamma$. We use $\texttt{TERM}_{\Gamma}\subseteq\texttt{PROD}_{\Gamma}$ denote the set of producible assemblies of $\Gamma$ which are terminal.

Appendix 0.B Simulation Details

In this section, we give more technical details of how $\Gamma=(\Sigma_{\Gamma},\Lambda,\Pi,\Delta,\tau)$ is constructed to simulate $\mathcal{A}=(Q,\Sigma_{\mathcal{A}},\delta,P,\sigma)$.

State Complexity: In ${\cal A}$, particles are allowed to know their states and the respective flags of all of their neighbors. Wires are responsible for transmitting signals necessary to coordinate turns between macrotiles. In addition, they must be able to simultaneously transmit signals from their respective clock tiles to neighboring macrotiles, as well as pass any flags or states needed from their respective neighbor to their respective clock tiles. The mechanism with the greatest state complexity(maximal combination of states and flags in $\mathcal{A}$) utilized by tiles takes place during the state transition period of a macrotile’s turn, which combines the macrotile’s flags, $e$ value, $t$ value, and state. Should this transition return $m=handover_{i}$, it is similarly responsible for its own flags and the flags of subordinate particle(s). In that case, the results of the state transition in $\Gamma$ that simulates the transition function $\delta$ in $\mathcal{A}$ need to account for up to sixteen flags, two states, one $e$ value, and two $t$ values. The maximal complexity utilized during this procedure occurs within the $handoverPush_{i}$ signal (detailed in 0.B.2), which requires all sixteen flags for all three particles, two states, and two $t$ values to be fully formed, resulting in a maximal tile state complexity of $(\Sigma^{10}\times Q^{2}\times e\times t+1)$. The constant 1 in the previous expression refers to the $\epsilon$ symbol which is necessarily the $t$ value of the newly contracted subordinate particle.

Macrotile Mapping: Each particle $p$ in $\mathcal{A}$ has a unique configuration $C(p)=(\vec{v},t,e,o,q,(f_{0},f_{1},...,f_{9}))$ that we must be able to represent with our macrotiles. For particle $p$, there exists in $\Gamma$ a macrotile with state $q$ in its central clock tile, flags $(f_{0},f_{1},...f_{9})$ are represented by the tiles on the extreme ends of the wires extending from the clock bank to each edge, with the value of $f_{0}$ being represented $o$ faces in the clockwise direction from the northern edge. (A brief note: In our simulation, we define the default orientation $o=0$ to start labeling pointing north because the grid ($G_{\Delta}$) on which our macrotiles connect to one another is rotated $30^{\circ}$ from the default orientation of the $(G_{\Delta})$ in the geometric Amoebots model. This results in two changes to the neighborhood of a particle on our graph. On our graph, a particle has neighbors in the following directions: (N, NE, SE, S, SW, NW). Tiles on the geometric Amoebots grid have neighbors (E, SE, SW, W, NW, NE), resulting in a replacement of the (E,W) connections with (N,S) in our simulation. Because we couldn’t set the default orientation to $o=0=E$, we chose another direction in the set of local connections, N.) If the $t$ value of $p\neq\epsilon$, the macrotile corresponding to $p$ is expanded, and has a macrotile in direction $t$ representing its tail. This tail macrotile has the same state $q$ in its central clock tile, and displays on its wire ends whichever subset of five flags corresponds to its relative location.

Initial Assemblies and Representation Functions: Our simulation works as follows with regards to initial assemblies: for every particle $p\in P$, there exists a macrotile in $\Gamma$ that represents $p$ under $R$. This section will show that initial configurations for both systems are isomorphic with respect to $R^{*}$ and the Simulating Dynamics section ahead will show that ${\cal A}$ follows $\Gamma$ and that $\Gamma$ models ${\cal A}$.

For initial configuration $\sigma$ of ${\cal A}$, we define the initial configuration $\Lambda$ of $\Gamma$ to consist of one large macrotile, itself a connected collection of particle macrotiles, representing $\sigma$ under $R^{*}$, a number of float tiles equal to at least half of the number of macrotiles in the connected configuration, a number of singleton $\epsilon$ tiles equal to $(6\times|\mathcal{P}|)$, used to represent empty space in response to query signals, and finally an infinite amount of singleton timing tiles to allow for particle activations. Additional floats above half of the number of positioned particles are fine, more floats simply serve only to relatively speed up perimeter expansion. For every particle $p\in\sigma$, there exists some macrotile in the initial macrotile configuration of $\Gamma$ which maps to an identical configuration $(q\in Q,(f_{0},f_{1},...,f_{9}\in\Sigma),e\in E,t\in T,o\in O)$ (i.e. it has an identical location and neighborhood, and its state, set of flags, etc. are the same when mapped under $R$).

The macrotile representation function $R$ is defined so that it operates as follows. Given a macrotile $p$, it first checks for the existence of a flag indicating that $p$ is engaged in either a handover or expand move. This is determined by checking the states $p$’s clock and wire tiles. If it is not, $R(p)$ determines the state $q$ from the macrotile mapping to $p$’s central clock tile, values $t$ and $e$ from a subordinate clock tile proximal to the central clock tile, and the flags $(f_{0},f_{1},...,f_{9})$ from the subordinate clock tile. In the case that particle $p$ is engaged in either a handover or expand move, $R$ instead reads all configuration information from the configuration tile, to the west of the clock bank, which holds the particle’s previous configuration. This is utilized so that a particle attempting to execute one of these moves will cleanly map to $\alpha$ for the duration of the move, and after the move is completed and the flag removed, will immediately and cleanly map to $\beta$, thus representing it as an atomic move.

Macrotile Turn: The simulation of ${\cal A}$ by $\Gamma$ is scaled in both space (by a factor of 100 - the macrotile size) and time. What this means is that, for each atomic asynchronous round of ${\cal A}$, which consists of one particle executing a turn (and in the case of it initiating a handover contract, a series of 4 or 5 turns between it and the subordinate particle depending on whether it is a push or pull), one or two macrotiles of $\Gamma$ go through a series of tile state transitions, additions, and detachments which in total can be considered one atomic operation and represent the round of ${\cal A}$.

A turn is the set of operations a macrotile undergoes in order to simulate a turn for an amoebot particle. In order to capture the asynchronous nature of particle activations within $\mathcal{A}$, we use timing tiles to begin a macrotile’s turn. Timing tiles float around the simulation and can only interact with an inactive macrotile via a hole in its subordinate clock bank waiting for a timing tile. Upon connection, a timing tile changes the state of the central clock tile from $(q\in Q)\times inactive$ to the same $(q\in Q)\times active$. This state tells the central clock tile to send out $lock$ signals to all of its neighbors in an attempt to begin its move. Should it receive no indication that another particle in its neighborhood is attempting to move, the particle begins to collect the flags of its neighbors indexed to the active particle. In the other case, there must be a neighboring particle attempting to lock down its neighborhood. This will be indicated when the two competing $lock$ signals collide along a wire, either both in one of the tiles’ wire, or both will meet on their respective ends of exposed wires from both macrotiles. The resolution of this collision is determined by where the collision takes place. Given macrotiles $\alpha$ and $\beta$, both trying to lock down their neighborhoods with a $lock$ signal somewhere along their shared wire, we will examine possible cases of signal collision. Once a $lock$ signal reaches the end of the wire from which it originated, it is up to the neighboring clock tile to transmit that signal via wire transmission to the neighboring clock tiles. If $lock_{\alpha}$ were to meet $lock_{\beta}$, both along $\alpha$’s wire, then the $lock_{\beta}$ signal would overwrite the $lock_{\alpha}$ signal, which would “bounce” off of the collision and return the central clock tile, returning a negative for $\alpha^{\prime}s$ $lock$ attempt. The inverse would be true should the signals meet while both are in $\beta^{\prime}s$ wire. If both signals meet while both are at the extremis of the wire from which they originated, then both are susceptible to a state transition that would overwrite their own respective signal and allow the neighbor to proceed with their $lock$. If $\alpha^{\prime}s$ $lock$ attempt is overwritten by $\beta^{\prime}s$ $lock$ signal, then upon receipt of $\beta^{\prime}s$ signal, $\alpha$ will send signals the rest of its edges (and by wire transmission, its neighbors) to cancel its own $lock$ order.

Assuming macrotile $\alpha$ may safely continue its turn, it begins to collect the flags indexed to it by its neighbors via query signals sent to its edges. The purpose of these signals is to copy the flag exposed by each of $\alpha$’s neighbors on the exposed wire ends of their shared edges. If $\alpha$ has any empty positions in its neighborhood, the query signals sent down the wires corresponding to these unoccupied locations activate an affinity with the previously mentioned $\epsilon$ tiles, which bind to the exposed wire ends, undergo transitions to indicate that there exists no neighbor at that location, and the signal bounces back from the wire end to the clock. The $\epsilon$ tile changes to a state with no affinity to swarm macrotiles after undergoing its state transition, and so detaches after signalling to the wire end that that location is unoccupied. These signals flow from each wire end back to the clock, where they are successively combined into the subordinate flags/$t$ value signal that represents one half of the tiles that affect the macrotile’s simulated amoebot state transition. Once all of this information is combined into a single subordinate clock tile, it undergoes a state transition with the central clock tile, defined in $\Delta$, to produce the new state, flags, and move for the active macrotile.

If $m=idle$, the macrotile updates its state and flags and then unlocks its neighborhood. After that, it changes its state from $(q\in Q)\times active$ to the same $(q\in Q)\times inactive$, and detaches its timing tile, ending the turn. If $m=Expand_{i}$, the active macrotile sends a signal to its $i$th edge to allow strength = $\tau$ binding along the exposed wire ends with a float. Only after a float attaches and copies the flags, state, and $t$ value for its new tail does the active tile send out an unlock signal to its neighborhood and ends the turn. Should $m=Contract_{i}$, assuming the macrotile is expanded in the $i$th direction, it sends a detachment signal to whichever of its ends is detaching and then unlocks its neighborhood after receiving an acknowledgement. Handover contracts are handled in detail in section 5.1, but suffice to say they similarly undergo the $lock$ and check procedures, and similarly exchange information between initiating and subordinate macrotiles before unlocking the affected neighborhood and ending the turn. For greater detail on the signals used in this section, refer to Section 0.B.2

Simulating Dynamics: A turn of ${\cal A}$ is simulated in $\Gamma$ via a series of operations which are officially begun once a particle has succeeded in locking its neighborhood. If it receives a timing tile but fails to lock its neighborhood, this does not map to a turn and is the same as if no timing tile had been received (it is an aborted turn). However, at the moment at which it first has officially locked its neighborhood, the series of operations (transitions, tile attachments, and tile detachments) that occur before it unlocks its neighborhood, will map to a single turn in ${\cal A}$.

Consider configurations $A^{\prime},B^{\prime}$ of $\mathcal{A}$ such that $A^{\prime},B^{\prime}\in\mathcal{C}(P)$ and $A^{\prime}\rightarrow^{\mathcal{A}}_{*}B^{\prime}$. Any TA system assembly $A\in\texttt{PROD}_{\Gamma}$ such that under the representation function, $R^{*}(A)=A^{\prime}$, must contain a macrotile that maps to each particle in $A^{\prime}$. Suppose $A^{\prime}\rightarrow^{\mathcal{A}}B^{\prime}$. This means that a single atomic move $m\in M$ from an amoebot is sufficient to change configuration $A^{\prime}$ to $B^{\prime}$. Since $\Gamma$ must model ${\cal A}$, it must be the case that there is a pathway for $A$ to transition via the simulation of a turn into $B\in\texttt{PROD}_{\Gamma}$ such that $R^{*}(B)=B^{\prime}$. We will inspect the transitions possible in $A^{\prime}$ and show how they are modeled in $\Gamma$, so assume $A^{\prime}$ represents a configuration in between turns and $A$ is an assembly with no macrotiles that are in the middle of a turn (the base case is the initial configuration). Now, let some particle $p$ be selected for the next turn in $A^{\prime}$. Since $R^{*}(A)=A^{\prime}$, we know that whichever macrotile maps to $p$ must represent its configuration, and it also must be able to receive a timing tile. Since no other particle is in the midst of a turn, it will be able to lock its neighborhood and begin simulation of the turn, which will then proceed following the protocol previously described. Interior particles, that is, particles with no exposed edges can only choose $m=idle|\textsf{handover}_{i}|contract_{i}$, assuming the particle has an expanded neighbor or is itself expanded in the $i$th direction. Any macrotile that maps to an interior particle under $R$ is similarly only capable of these moves, since they have no exposed edges to which they could allow floats to attach. $Contract_{i}$ is only allowed in the case that the particle is expanded.

Any perimeter particle, with exposed wire edges, is capable of any move $m\in M$, assuming the particle’s configuration allows for it. This is reflected in the $A$, where perimeter macrotiles are allowed to expand by creating a valid attachment site in the desired direction by changing their exposed wire end in the $i$th direction to a state that has affinity with floats. This, in addition to the moves already available to the interior particles, ensures that any atomic action affected by configuration $A^{\prime}$ can be represented by a corresponding move in $A$, and the protocol previously described ensures that it can correctly complete, updating all necessary configuration information, before unlocking its neighborhood and thus ending its simulation of the turn. In this way, $\Gamma$ models ${\cal A}$, scaled in space and time, using series of operations that are forced to be atomic are represent all possible atomic moves of ${\cal A}$.

To see that ${\cal A}$ follows $\Gamma$, we refer to the previously described protocol to show that for any $\alpha,\beta\in\texttt{PROD}_{\Gamma}$ where $\alpha\rightarrow^{\Gamma}\beta$, then $R^{*}(\alpha)\rightarrow^{\cal A}_{*}R^{*}(\beta)$ and, for idle and contract moves, until the simulation of the turn completes, $R^{*}(\alpha)=R^{*}(\beta)$. For cases where $R^{*}(\alpha)\rightarrow^{\mathcal{A}}R^{*}(\beta)$ via an expansion or handover move, we will explain the steps taken to ensure a clean change from $R^{*}(\alpha)=R^{*}(\beta)$ to $R^{*}(\alpha)\neq R^{*}(\beta)$. Section 4.2 defines the configuration tile, a tile that is updated with a macrotile’s configuration information every turn after a successful move. This tile provides configuration information to the representation function instead of the normal central clock tile and subordinate clock tile that contain a particle’s configuration in the case that the active macrotile is engaged in either an expansion or $handover_{i}$ move. $R$ is aware of this because to engage in either of those moves, our construction requires a $handover_{i}$ or $expansion$ flag to be displayed along the flag tiles of the wire in the $i$th direction.

Only after the simulation of the transition function, for moves $(m=idle,contract_{i})$ does $R^{*}(\alpha)\neq R^{*}(\beta)$. For moves $(m=expand_{i},handover_{i})$, $R$ will recognize the intention to expand or handover from the value $m$, and for any particle engaged in these moves, $R$ reads the configuration information from that particle’s configuration tile instead of clock tiles, which contains last turn’s configuration, until the flags for the move are cleared and the move is complete. In this way, the moves are simulated as atomic operations, and in the case of $handover$s, both atomic and synchronized between the representation of the initiating particle and that of the subordinate particle. $R^{*}(\alpha)$ and $R^{*}(\beta)$ will remain equal until cases of amoebot system “configuration level changes”. Throughout the simulation of a particle’s turn, it may need to send and receive a number of signals from its own wire ends and neighbors’ wire ends to ensure that the state transition affected by the central clock tile has all of the information necessary. These signal changes, which are affected by state changes along the wires and subordinate clock tiles, do not change the mapping of configuration $\alpha$, and so $R^{*}(\alpha)=R^{*}(\beta)$. However, after a particle undergoes its transition function and changes its state, flags, or makes a move, this is an amoebot system configuration level action. At the moment that these complete and a macrotile begins to idle or contract, the representation of the macrotile changes to $R^{*}(\beta)$. On the other hand, particles engaged in expansion or handover moves are mapped to $R^{*}(\alpha)$ until they clear the flag indicating their move from their wires, which takes place after the new states and flags have been distributed and displayed by all particles involved in the move. Every macrotile is capable only of simulating the moves available to the corresponding particle under $R$, since the moves available to a particle depend only on the state, flags, and neighborhood, which must match to be a valid representation under $R^{*}$.

We further note that float particles which are detached from the rest of the assembly map to empty space and therefore do not impact the represented state of $\Gamma$. A float functions as a generic “head” for any particle that wants to expand. Since the amoebots model operates asynchronously and particles are only concerned with local information, they can be simulated with macrotiles similarly concerned only with local information. Since the float tiles do not interact with one another, they effectively float around the configuration which represents amoebot particles, and attach to any site to which a particle which is attempting to expand. Then, upon the next activation, or turn, of that simulated particle, should the particle decide to contract to its new (head) location, the float macrotile stays where it is and the tail macrotile of the particle detaches and becomes another float. Upon detachment, the macrotile queries all of its edges to determine its neighborhood status. Upon recognition that the macrotile has no neighbors, it transitions internally to a default float state, inactive with other tiles with the exception of explicitly labeled valid attachment sites along the perimeter of the swarm. Thus, float tiles simply map to empty space via $R$ unless and until they attach to the assembly representing the swarm and are turned into particle heads or tails.

Since $\Gamma$ models ${\cal A}$ and ${\cal A}$ follows $\Gamma$, $\Gamma$ simulates ${\cal A}$.

0.B.1 Signals Between macrotiles

The following section details all of the signals utilized by macrotiles to accurately simulate amoebot behavior. With the exceptions of the Start Turn Signal and End Turn Signal, which are propagated via state transitions within the clock, these signals are propagated via wire transmission from one central clock bank of a macrotile to a neighboring clock bank via wire transmission. With the exception of any signals pertaining to $handover_{i}$, these signals do not have the capability to change the state, flags, or $t$ value of any particle macrotile from which they did not originate.

0.B.2 List of Signals

Lock $Signal_{i}$: To prevent conflicts, we have macrotiles engaged in their turn send signals to all particles that may be affected by the turn that “lock” the tiles into their current configuration. A locked macrotile will not activate even if it receives a timing tile until it receives an unlock signal from the same direction that sent the lock signal. If two lock signals from different macrotiles collide along a shared wire, the resolution depends on where they collide. If neighboring macrotiles $a$ and $b$ both send lock signals to each other, and these signals meet along $a$’s half of the shared wire, then the signal from $b$ will overwrite the lock signal from $a$. The opposite is true should they meet inside $b$’s wire. If both signals are in the respective extreme tiles of their own wires, then both are subject to a state transition that will allow either $a$’s signal to propagate into $b$’s wire, allowing $a$ to expand, or $b$’s signal into $a$’s wire, in which case $b$ would be safe to expand. Should an expanded neighbor of a macrotile receive a $lock$ signal, it further propagates this signal to its other half, to prevent it from attempting to move and conflict with the active particle.

Let us represent the lock signal as state $L$ in $\Gamma$, which both clock and wire tiles utilize in addition to the states in $\Sigma$ for the system they are simulating. In order to enable these tiles to maintain both their respective states in $\Sigma$ and any signals they need to pass, we cross the set of states representing signals utilized in our construction of $\Gamma$ by the set of signals and states $(\Sigma,Q)$ in $\mathcal{A}$. When a clock tile undergoes a transition with a wire tile to indicate that the wire should start propagating a lock signal, the wire tile adjacent to the subordinate clock tile changes states from its previous state $f\in\Sigma$ to $Lf$, a cross of signal $L$ and any potential flag $f\in\Sigma$. This signal is propagated down the wire until it hits the exposed flag tile at the end of the wire. If the exposed flag tile at the end of a wire is not connected to a neighbor, the state displayed $Lf$ has at least $\tau$ strength affinity with $\epsilon$ tiles, enabling connection. If an epsilon tile attaches to an exposed wire end displaying $Lf$, both tiles undergo a directed double state transition which indicates to the flag tile that there is no neighbor at that location, and simultaneously transitions the $\epsilon$ tile to a state without affinity to anything else, leaving it inert and detaching it from the flag tile at the perimeter of the swarm. If a flag tile of macrotile $a$ displaying a lock signal is connected to a flag tile of neighboring macrotile $b$, it waits as is until it receives a confirmation signal $L^{\prime}f^{\prime}$ from $b$’s respective flag tile. Upon receiving the $Lf$ signal from $a$’s flag tile, $b$’s flag tile starts to propagate a cross of its flag $f^{\prime}\in\Sigma$ and a state indicating that a neighbor has sent a lock signal, $Lnf^{\prime}$. When this signal propagates all the way to $b$’s clock bank, the innermost wire tile undergoes a double transition with its respective subordinate clock tile, leaving the wire tile in state $Ln^{\prime}f^{\prime}$, and the clock tile in its previous state crossed with the neighbor lock signal state $Ln$. The clock tile that received the $Ln$ signal further propagates it to the rest of $b$’s clock, so that $b$ will not respond to timing tiles should they attach for the duration of the $a$’s move. The new state $Ln^{\prime}$ crossed with the wire’s existing state $f^{\prime}$ indicates that the clock bank of $b$ has received the lock signal, and is propagated from $b$’s clock bank back to the $b$’s flag tile facing $a$. Once $a$’s flag tile observes the response $Ln^{\prime}f^{\prime}$ from $b$’s flag tile, it propagates the confirmation signal $L^{\prime}f$ back along the wire to $a$’s clock bank. The central clock tile in $a$ maintains a state indicating how many responses to its lock signal it has received. Once $a$ has received six or ten responses (depending on whether it is contracted or expanded), it continues its move by sending out a $query$ signal to all of its wires, to find out the flags displayed to it by its neighbors. 2. 2.

Progressive Lock $Signal_{i}$ This signal is functionally identical to the preceding $lockSignal_{i}$, except that when macrotile $a$ sends this signal to macrotile $b$, $b$ further propagates $lock$ signals to its own respective neighborhood. $b$’s neighborhood remains locked down until it receives the $UnlockSignal_{i}$ from $b$, itself contingent upon receiving the $UnlockSignal_{i}$ from $a$. This is utilized in $handoverPull_{i}$ moves, which require the initiating particle to lock down both its own and the subordinate particle’s neighborhoods. 3. 3.

Unlock $Signal_{i}$: The other half of the Lock Signal, this tells a neighborhood that they may begin their turns upon receiving a timing tile. This does not require a response from any macrotile receiving it, as any macrotile unlocking its neighborhood is done with its turn and will not attempt to move until its next turn. 4. 4.

Copy Signal: When a float attaches to the swarm, it attaches via a single bond to a specific tile that is actively trying to expand. In order for the float to become the head of the particle to which it is attaching, it needs to display the proper flags and state. In the cases where an active macrotile is attempting to expand along any port other than its [math]th port, the copy signal consists of the active macrotile’s state $(q\in Q)$ and the flags pertinent to the new head $(f_{i},f_{i+1},...,f_{i+4})$. We know which flags are important to the new head because the new head will always be in the $i$th direction, and we only need that direction’s flag as well as the next four, as the particles consume two of their potential edges via their connection. This heuristic for which flags to send (i.e. sending the $i$th flag and the next four) to the new head breaks down if a particle is attempting to expand along its [math]th port. In this case, the copy signal consists of the active macrotile’s state $(q\in Q)$ and flags $(f_{0},f_{1},f_{2},f_{8},f_{9})$. In this case we make the edge of the head corresponding to the [math]th port in the expanding macrotile the new [math]th port, since we can’t start labeling available edges along the shared edge of an expanded macrotile. These states and flags are propagated via wire transmission and stored in the new central clock tile, wire extremities, and subordinate clock tiles, respectively. 5. 5.

Attachment Signal: Given macrotile $a$ and an adjacent unoccupied location $a^{\prime}$ on $G_{\Delta}$, this signal is sent from the clock bank of macrotile $a$ to the wire corresponding to the edge shared between $a$ and $a^{\prime}$. Upon reaching the exposed end of the wire, this signal compels the flag tile to change states to a state with $\tau$-strength affinity for a float tile’s exposed wire ends. $a$ does not send the $UnlockSignal$ signal corresponding to the $LockSignal$ that preceded its expansion until the float assumes its flags and state, facilitated by a $CopySignal$. The $AcknowledgeSignal$ following this $CopySignal$ causes a state change in the flag tile of the newly connected wire which is propagated back to $a$’s clock bank, allowing it to safely unlock its neighborhood and end its turn. 6. 6.

Detachment Signal: This signal is sent to the macrotile of an expanded particle that is not the macrotile occupying the $G_{\Delta}$ location to which the particle is contracting. It tells the macrotile to switch its internal state and flags to the default state and flags, which will necessarily detach it from the swarm, as the default flag has no affinity with the swarm. After detaching, the detached macrotile will query its neighborhood and transition its state and flags to those of a float after receiving an $\epsilon$ response from all of its edges. 7. 7.

$HandoverConfirm_{i}$: This signal is sent from an initiating macrotile in the $i$th direction to check to ensure that the $i$th neighbor matches the orientation necessary to complete the move (i.e. a macrotile isn’t trying to $handoverPull_{i}$ with a neighbor that is already expanded, as that would violate the constraint of a particle occupying at most two locations on $G_{\Delta}$). This requires an acknowledgement signal containing the subordinate macrotile’s $t$ value to ensure validity. After receipt of a valid response from the subordinate macrotile, the signal sent next by the initiating supertile depends on whether the initiating particle is executing a $handoverPush_{i}$ or a $handoverPull_{i}$. This signal persists at the threshold of the wire shared between the subordinate particle and the particle changing hands until all necessary state and flag information has been passed successfully, ensuring the tiles engaged in this move are mapped to their previous configurations. This ensures a clean mapping from one configuration for a macrotile to another under $R$, which will take place instantaneously after the $handover_{i}$ flag is cleared from the macrotiles’ respective wires. 8. 8.

$HandoverPull_{i}$: Consider an expanded macrotile $a$ executing a $HandoverPull_{i}$ move with a contracted macrotile neighboring its tail $b$. After $b$ sends a valid $AcknowledgementSignal$ containing its $t$ value and $a$ decides to continue its turn, $a$ sends a $NewHeadSignal$ to the macrotile of which it is ceding control. $a$ then sends the ten flag values $(f^{\prime}_{0},f^{\prime}_{2},...f^{\prime}_{9})\in\Sigma$ and new state $q^{\prime}\in Q$ combined into a single signal to $b$. Upon receiving this signal, $b$ sends out a query signal to each of its edges to determine which of its neighbors is its new head. After discovering its new $t$ value, $b$ updates its $t$ value, state, and sends its new flags to their respective ports. $b$ then sends an $AcknowledgementSignal$ to $a$ indicating that it has assumed control of the macrotile that changed hands, and $a$ sends out an $Unlock$ signal, which is further propagated out to all of $a$ and $b$’s neighborhoods. 9. 9.

$HandoverPush_{i}$: Given a contracted macrotile $a$ executing a $HandoverPush_{i}$ move with an expanded neighboring macrotile $b$, assuming both are the proper configurations, $a$ sends to its newly acquired head the following bundled into a single $HandoverPush_{i}$ signal: its own flags $(f_{i},f_{i+1},...f_{i+4}\in\Sigma)$, its state $(q\in Q)$, and the new $t$ value for the newly acquired head; new flags $(f^{\prime}_{0},f^{\prime}_{1},...f^{\prime}_{5}\in\Sigma)$, a new state $(q^{\prime}\in Q)$, and $t=\epsilon$ for the subordinate macrotile $b$. The subordinate macrotile strips the information pertinent to itself and propagates the rest of the signal further on to its other half. After the other half sends back an $AcknowledgmentSignal$ indicating that it has updated, $a$ sends out an unlock signal which is further propagated out to all of $a$ and $b$’s neighborhoods. 10. 10.

$NewHeadSignal$: In $handoverPull$ moves, part of an expanded particle is ceded to an inactive, contracted particle, thereby simultaneously contracting the initiating particle and expanding the subordinate particle. This signal is sent to the macrotile segment of an expanded particle that is changing owners, telling it to display a special flag on all ports indicating that it is a newly acquired “head” particle, allowing the subordinate macrotile to identify which of its neighbors now serves as its head. 11. 11.

Query Signal: This signal is sent by the clock tiles to the ends of their wires to collect the flags displayed by each of the originating macrotile’s neighbors. Naturally, its domain is $\Sigma\cup\{\epsilon\}$, with the empty flag returning in the case that that edge has no neighbor via the usual mechanism of singleton $\epsilon$ tiles. 12. 12.

Acknowledgement Signal: Used by particles to respond to requests for information not displayed on the flags, such as state or $t$ value. Additionally used as a confirmation signal with certain $handover$ operations. 13. 13.

Start Turn Signal: Any macrotile that is inactive and is not locked down by a neighbor has an empty tile in its clock bank waiting for the attachment of a timing tile. Once this timing tile attaches, it uses state transitions to “activate” the central clock tile, which in turn propagates this signal down all of its wires so that it can read its neighbors’ flags indexed to it. 14. 14.

End Turn Signal: After a macrotile unlocks its neighborhood after a move, it sends a signal from the central clock tile to the timing tile to detach, deactivating the particle until next time a timing tile diffuses into its slot and it is not locked down. This constitutes the End Turn signal.

Appendix 0.C Communication Protocol

This section explores an example turn where contracted macrotile $a$ executes a $handoverPush$ with the tail of its expanded neighbor $b$. We will list all signals that will be sent and received by all macrotiles involved, in order. We chose to use a $handover$ move as our example because they require the greatest number of signals as well as the greatest signal complexity of any moves available to particles. For the purposes of this illustration, assume particles start in an inactive state, with their proper flags displayed on their respective flag tiles. Figure 8 shows some condensed snapshots from the turn explored in the following section.

0.C.1 Example turn

Timing tile attaches to $a$’s clock bank and precipitates a transition, sending the Start Turn Signal to $a$’s central clock tile and changing it from $(q\times inactive)$ to $(q\times active)$. 2. 2.

The central clock tile of $a$ checks its $t$ value held in the state of the tile to its immediate west to determine how many responses it should expect and then sends out the lock signal to all of its wires. $a$ is contracted, and so its $t$ value = $\epsilon$, meaning that it should expect six responses from its wires. The central clock tile maintains both $q$ and a response counter for the duration of this signal. 3. 3.

After $a$ has received six responses indicating that none of its neighborhood has sent a competing lock signal, it sends out a query signal to gather the flags indexed to it by $a$’s neighbors. This information is necessary for $a$ to affect the transition function $\delta$ in $\mathcal{A}$. 4. 4.

When the query signal reaches the end of each of $a$’s wires, it causes the flag tiles at the extreme end to change to a state receptive to reading the state displayed on its neighbor’s flag tile. If a flag tile has no neighbor, the query signal state also enables connection with $\epsilon$ tiles, which will connect and undergo a transition to indicate that the wire corresponds to an unoccupied edge. 5. 5.

After six flags or $\epsilon$’s are propagated back to the tile to the west of $a$’s clock bank, the central clock tile undergoes a double transition with the subordinate clock tile to its immediate west. $a$’s state contains the macrotile’s state, $q$, and the subordinate tile to the west’s state contains the combined six flags of $a$’s wires as well as the $t$ value. 6. 6.

After the state transition effecting both the central clock tile and the subordinate clock tile to its west, the central clock tile contains the new state, $q\in Q$, as well as the move $m=handoverPush_{i}$, where $i$ is the port in the direction of $b$’s tail. The tile to the west contains the new flags for $a$, $(f_{0},f_{1},...,f_{9})\in\Sigma^{10}$, particle $a$’s $E$ value = $i$, the new flags for $b$, $(f^{\prime}_{0},f^{\prime}_{1},...,f^{\prime}_{5})\in\Sigma^{6}$, $b$’s new state $q^{\prime}\in Q$, and the new $t$ value for $b=\epsilon$. 7. 7.

Because $m=handoverPush_{i}$, $a$ needs to check its neighbor in the $i$th direction to ensure that they have the proper configuration to enable to move. It sends a $handoverConfirm_{i}$ signal to the neighbor in its $i$th direction and waits for an Acknowledgement signal in response containing $b$’s $t$ value. 8. 8.

$b$’s tail responds by sending $b$’s $t$ value in an Acknowledgement Signal to $a$. 9. 9.

Since $b$’s $t$ value $\neq\epsilon$, b is a valid neighbor with which $a$ can execute the $handoverPush_{i}$ movement. $a$ continues by sending a $handoverPush_{i}$ signal along its $i$th port, to $b$’s tail. This signal contains five new flags $(f_{i},f_{i+1},...f_{i+4})\in\Sigma$, as well as a copy of $a$’s state $q$ and the new $t$ value for $b$’s tail, soon to become $a$’s head. It additionally contains six flags $(f^{\prime}_{0},f^{\prime}_{1},...,f^{\prime}_{5})$ as well as the new $t$ value = $\epsilon$ for $b$’s head. 10. 10.

After receiving the $handoverPush_{i}$ signal from $a$, at least one of $b$’s wires will display a flag indicating that it is engaged with a handover move, additionally, $b$’s tail updates its state, $t$ value and flags. It further propagates the $handoverPush_{i}$ signal to $b$’s head. $b$’s tail will continue to map to $b$ until the final signal ending the move clears the any flags indicating to the representation function that the macrotile displaying that flag is undergoing an expansion or handover move. 11. 11.

Once $b$’s head receives the $handoverPush_{i}$ signal from its tail, it updates its state, flags, and $t$ value as well. After doing so, it sends an Acknowledgement signal to $b$’s tail, indicating that it has updated its state, flags, and $t$ value. 12. 12.

$b$’s tail propagates $b$’s head’s Acknowledgement signal back to $a$. This acknowledgement signal clears any flags indicating a macrotile’s partaking in an expansion or handover move, and so after it passes through what was formerly $b$’s head and tail, those tiles respectively map to $b$ and $a$’s head. 13. 13.

Upon receiving the Acknowledgment signal indicating that the move has been completed, $a$ sends out an unlock signal to its neighborhood. 14. 14.

The newly expanded macrotile $a$ detaches the its timing tile by the central clock tile transitioning the timing tile from an active state to an inactive state, which has no affinities.