Lila Kari

Benoît Masson

Polyominoes Simulating Arbitrary-Neighborhood Zippers and Tilings 6,66

Keywords: DNA computing, self-assembly, tilings, polyominoes

This paper provides a bridge between the classical tiling theory and the complex neighborhood self-assembling situations that exist in practice.

The neighborhood of a position in the plane is the set of coordinates which are considered adjacent to it. This includes classical neighborhoods of size four, as well as arbitrarily complex neighborhoods. A generalized tile system consists of a set of tiles, a neighborhood, and a relation which dictates which are the "admissible" neighboring tiles of a given tile. Thus, in correctly formed assemblies, tiles are assigned positions of the plane in accordance to this relation.

We prove that any validly tiled path defined in a given but arbitrary neighborhood (a zipper) can be simulated by a simple "ribbon" of microtiles. A ribbon is a special kind of polyomino, consisting of a non-self-crossing sequence of tiles on the plane, in which successive tiles stick along their adjacent edge.

Finally, we extend this construction to the case of traditional tilings, proving that we can simulate arbitrary-neighborhood tilings by simple-neighborhood tilings, while preserving some of their essential properties.

Introduction

Because of the constant miniaturization of components, microscopic elements in the fields of electronics, engineering or even medicine are becoming more and more difficult to construct and to manipulate. A recent approach to work around this problem is self-assembly. It consists in "programming" the nanocomponents, so that when starting from an initial pool of selected components, they automatically aggregate to form bigger and bigger structures, until they eventually form a final complex structure.

The first formal models for self-assembly were introduced a decade ago [START_REF] Winfree | Algorithmic Self-Assembly of DNA[END_REF][START_REF] Winfree | Design and self-assembly of two dimensional DNA crystals[END_REF][START_REF] Adleman | Towards a mathematical theory of self-assembly[END_REF]. In this framework, self-assembling components were modeled by Wang tiles [START_REF] Wang | Proving theorems by pattern recognition -II[END_REF], i.e., unit squares that cannot be rotated and that have "glues" on each of their four edges. Two tiles stick to each other if they have the same glue on their common edge. By carefully designing the glues, and starting with an initial tile called "seed", complex structures can self-assemble.

The use of this simple model as a formalization of the process of self-assembly allowed the application for theoretical studies of dynamical self-assembly of many well-known existing results and techniques concerning "static" tilings [START_REF] Wang | Proving theorems by pattern recognition -II[END_REF] and cellular automata [START_REF] Kari | Theory of cellular automata: A survey[END_REF], such as the undecidable problem of the tiling of the plane, and the simulation of a Turing machine by a tile system [START_REF] Berger | The undecidability of the domino problem[END_REF][START_REF] Robinson | Undecidability and nonperiodicity for tilings of the plane[END_REF].

Most of the theoretical results on self-assembly presume that each tile interacts via glues only with tiles in its so-called von Neumann neighborhood, which includes the four tiles situated at the North, South, East, and West of the tile itself [START_REF] Rothemund | The program-size complexity of selfassembled squares (extended abstract)[END_REF] 1 . Only relatively few recent results consider more general cases, such as larger neighborhood [START_REF] Adleman | The undecidability of the infinite ribbon problem: Implications for computing by self-assembly[END_REF], or a three-dimensional neighborhood [START_REF] Becker | Time optimal self-assembling of 2D and 3D shapes: The case of squares and cubes[END_REF]. Even the most well-known experimental incarnation of square tiles, the DNA tiles [START_REF] Winfree | Design and self-assembly of two dimensional DNA crystals[END_REF][START_REF] Winfree | Universal computation via selfassembly of DNA: Some theory and experiments[END_REF][START_REF] Mao | Logical computation using algorithmic self-assembly of DNA triple-crossover molecules[END_REF][START_REF] Rothemund | Algorithmic self-assembly of DNA Sierpinski triangles[END_REF][START_REF] Fujibayashi | Toward reliable algorithmic self-assembly of DNA tiles: A fixed-width cellular automaton pattern[END_REF], deal only with the von Neumann-sized neighborhood, where the DNA single strands located at the corner of each rectangular DNA tile allow its interaction with four neighbors only. Other experimental situations that could be modeled by self-assembly of tiles, such as atomic or molecular interactions, potentially include more complex scenarios where the neighborhood of a tile is both larger and more complex than the von Neumann neighborhood. At the limit, one can consider the case of an arbitrary neighborhood where tiles that are not physically adjacent to the main tile may be its neighbors, while some adjacent tiles may not.

In [START_REF] Adleman | The undecidability of the infinite ribbon problem: Implications for computing by self-assembly[END_REF], it was proved that, for any directed tile system, any von Neumannneighborhood "zipper" (a tiled rectilinear path) can be simulated by a "ribbon" constructed with tiles from a new tile system. A ribbon is a non-self-crossing rectilinear succession of tiles in the plane, where each tile is required to have glues matching with two tiles only: its predecessor and its successor on the ribbonpath. The construction that simulated a directed von Neumann-neighborhood tiled path by a ribbon, replaced each of the existing tiles by so-called "motifs" which traced the contours of the initial tile but where, in addition, bumps and matching dents along the motif edges simulated both the matching of the glues and the directionality of the path. In other words, geometry of the motifs was used to simulate glue matching. Note that motifs, as well as ribbons, are particular cases of polyominoes [START_REF] Schulman | Programmable control of nucleation for algorithmic self-assembly[END_REF][START_REF] Beauquier | On translating one polyomino to tile the plane[END_REF], i.e., finite and connected sets of DNA tiles.

This polyomino construction led to a conjecture by Jarkko Kari, claiming that it is possible to "simulate" an arbitrary-neighborhood zipper by a simple two-tile-neighborhood ribbon. A first step in this direction was [START_REF] Czeizler | Towards a neighborhood simplification of tile systems: From Moore to quasi linear dependencies[END_REF][START_REF] Czeizler | Geometrical tile design for complex neighborhoods[END_REF], wherein it was proved that a complex-neighborhood zipper, defined for example on the Moore neighborhood (von Neumann plus four diagonal neighbors), can be simulated by a ribbon of irregularly shaped tiles, where the shape was used to simulate the neighborhood relationship.

The aim of this paper is to answer the above conjecture positively for the case of arbitrary-neighborhood zippers, thus providing a bridge between the classical work in tiling theory or cellular automata and the realistic complexneighborhood self-assemblies that exist in practice. We namely prove in Corollary 3.10 that for any neighborhood, zippers can be simulated by simple polyominoes connected to each other end-to-end to form a ribbon that essentially traces the same path. The main idea used in our simulation is that each existing tile can be replaced by a polyomino, where the shape of the polyomino is used to simulate the communication between a tile and its adjacent or distant neighbors. We also show that, by the design of the shapes of the polyominoes, we can transmit information at a distance, sometimes across other information pathways, without violating the non-self-crossing feature of the ribbon. Such situations where information pathways cross are inherent in, for example, Moore neighborhoods where, e.g., the communication channel between a tile and its Northeast neighbor "crosses" the communication channel between its North neighbor and its East neighbor.

We also explain how the simulation of zippers by ribbons can be modified to simulate arbitrary-neighborhood tilings by von Neumann-neighborhood tilings. The idea is to modify the polyominoes, adding new constraints so that the two-tile neighborhood can be replaced by a von Neumann neighborhood (Corollary 4.2). The main significance of this simulation, as opposed to more intuitive ones where some "supertiles" are used to transfer information, is that it applies to all tilings, even when they are partial. Besides, some essential properties of the initial tiling are preserved by the simulation. We prove that this is the case for partial and periodic tilings, and in a more restricted setting, for convex tilings.

The paper is organized as follows. In Sect. 2, we recall basic definitions and give a formal definition of a simulation. Then, Sect. 3 describes our construction in the case of zippers, starting with the general idea of simulating a zipper by a ribbon, by sketching the proof from [START_REF] Adleman | The undecidability of the infinite ribbon problem: Implications for computing by self-assembly[END_REF], in the simple case of a von Neumann neighborhood. We also highlight the technical difficulties related to crossing of information pathways, that prevent this technique from being transferable without modifications to the case of the Moore neighborhood [START_REF] Czeizler | Towards a neighborhood simplification of tile systems: From Moore to quasi linear dependencies[END_REF]. Then, we prove our result for the case of arbitrary linear neighborhoods. This construction is eventually generalized to arbitrary neighborhoods to prove the main result of this section. Finally, in Sect. 4, we adapt the construction to the simulation of regular tilings, and we study how partial, periodic, line or column convex properties are preserved.

Definitions

First, we give some basic definitions on tilings, and then we introduce more technical definitions to describe the principles of simulation by polyominoes. We finally illustrate this on a concrete example, the simulation of total tilings.

Tilings, Ribbons, and Zippers

Historically, Wang tiles [START_REF] Wang | Proving theorems by pattern recognition -II[END_REF] were defined as oriented unit squares, on the border of which were 4 glues (colors) used to stick them to neighboring tiles, provided the glues matched. We generalize this notion to arbitrary neighborhoods [START_REF] Kari | Theory of cellular automata: A survey[END_REF][START_REF] Adleman | The undecidability of the infinite ribbon problem: Implications for computing by self-assembly[END_REF], i.e., neighborhoods which can contain other tiles than the North, South, West and East tiles. In this paper, a neighborhood N ⊂ Z2 is the set of relative coordinates of the neighboring tiles, such that

• N is finite;

• (0, 0) ∈ N (a tile can not be one of its neighbors);

• (i, j) ∈ N ⇒ (-i, -j) ∈ N (if a tile t ′ is
a neighbor of a tile t, then t has to be a neighbor of t ′ ). For example, the usual 4-tile neighborhood (called von Neumann neighborhood [START_REF] Kari | Theory of cellular automata: A survey[END_REF]) is N vN = {(0, 1), (1, 0), (0, -1), (-1, 0)}; the 8-tile Moore neighborhood is N M = {(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1)}.

For the following definitions, a neighborhood N and a finite set of glues X are fixed. A tile is a tuple t = (t i,j ) (i,j)∈N where each t i,j ∈ X. Intuitively, t i,j is the glue that will be used to match the neighbor located at position (i, j) relative to the tile t. A tile system T is a finite set of tiles, used to build larger structures. A tile t ∈ T sticks at position (i, j) to a tile t ′ ∈ T if the corresponding glues match, i.e., t i,j = t ′ -i,-j . A (T, N )-tiling using tile system T in neighborhood N (or N -neighborhood tiling, or simply tiling when the tile system and its neighborhood are known without ambiguity) is a mapping τ : D → T , where D ⊂ Z 2 is a subset of the plane, which associates every position (x, y) ∈ D with a tile, such that all tiles stick to their neighbors, i.e., for all (x, y) ∈ D, for all (i, j) ∈ N such that (x + i, y + j) ∈ D, τ (x, y) i,j = τ (x + i, y + j) -i,-j . Note that tilings are often referred to as "valid" tilings in the literature. The set of all (T, N )-tilings is denoted T T,N .

When D = Z 2 , the tiling is said to be total, otherwise it is partial. In addition, if D is finite then the partial tiling is also finite. A tiling τ : D → T is connected if its domain D is 4-connected. As suggested in [START_REF] Schulman | Programmable control of nucleation for algorithmic self-assembly[END_REF], we call polyomino a finite and connected tiling 2 .

According to the usual definition, a total tiling τ is periodic if it admits a horizontal and a vertical period p h , p v ∈ N + , i.e., for all x, y ∈ Z, τ (x, y) = τ (x+ p h , y) = τ (x, y + p v ). We extend this definition to partial tilings as follows: a tiling τ : D → T is periodic if it admits a horizontal and a vertical period p h , p v ∈ Z such that for all (x, y) ∈ D and for all α, β ∈ Z, (x+αp h , y +βp v ) ∈ D implies τ (x, y) = τ (x+αp h , y +βp v ). Note that with this extended definition, all finite tilings are periodic (the periods should be "larger" than the tiling itself).

A tiling τ : D → T is line convex [resp., column convex ] if (x 1 , y), (x 2 , y) ∈ D and x 1 < x 2 [resp., (x, y 1 ), (x, y 2 ) ∈ D and y 1 < y 2 ] imply that for all x 1 < x < x 2 [resp., for all y 1 < y < y 2 ], (x, y) ∈ D. A tiling is convex if it is both line and column convex.

Two positions of the plane u, v ∈ Z 2 (or, by extension, tiles of a tiling) are said to be adjacent when they are neighbors in the von Neumann sense, i.e., vu ∈ N vN . A path is a sequence of adjacent positions of the plane. Formally, a path is a function P : I → Z 2 , where I ⊂ Z is a set of consecutive integers, such that for all i, i + 1 ∈ I, P (i) and P (i + 1) are adjacent. For a given tile system T , a T -tiled path using tile system T is a sequence of adjacent tiles from T , i.e., a pair (P, r) where P is a path and r : range(P ) → T a mapping from positions to tiles. We say that a T -tiled path is finite when dom(P ) is finite, and we may also call a finite T -tiled path a polyomino since it is connected (by definition of the path). For a tile system T defined in von Neumann neighborhood N vN , a T -tiled path (P, r) is a T -ribbon using tile system T (simply called ribbon when T is known without ambiguity) if P is injective (non-self-crossing) and for all i, i + 1 ∈ dom(P ), r(P (i)

) v = r(P (i + 1)) -v , with v = P (i + 1) -P (i) ∈ N vN .
The glue r(P (i)) v is called the output glue of r(P (i)), while r(P (i + 1)) -v is the input glue of r(P (i + 1)). Informally, a ribbon is a sequence of adjacent tiles which stick to their predecessor and successor only (see Fig. 1(a)). Consequently, r is not necessarily a tiling.

A T -tiled path (P, r) is a (T, N )-zipper using tile system T in neighborhood N (or N -neighborhood zipper, or zipper when T and N are known) if P is injective and r is a (T, N )-tiling. A zipper can be seen as a tiling with an additional notion of unique input and output for every tile (except the first which has only an output and the last which has only an input), each input being connected to the output of an adjacent tile (see Fig. 1(b)). Note that zippers can be defined in arbitrary neighborhoods, since it is not required that adjacent glues match. The set of T -ribbons is denoted R T , the set of (T, N )zippers Z T,N .

Poly-Tilings and Simulations

In this section, we give the main idea of the simulation of a tiling by another, as well as for the simulation of a zipper by a ribbon. Informally, a simulation is a function which associates each tiling [resp., zipper] using the "initial" tile system in the "initial" neighborhood with a tiling [resp., ribbon] using a "new" tile system in a "new" neighborhood. The simulation must also allow to recover the initial object without ambiguity. To build this new object, we first associate every initial tile with unique polyominoes. Then, we catenate these polyominoes to form the new, bigger, object, called poly-tiling or poly-ribbon. In the sequel, for a set D ∈ Z 2 and a vector u, we denote D + u = {(x, y) + u | (x, y) ∈ D} the set D translated by u. Definition 2.1. A poly-tiling τ of scale s, using tile system T in neighborhood N , is a mapping τ :

D → T T,N , with D ⊂ Z 2 , such that (i) for all u ∈ D, τ (u) is a finite (T, N )-tiling; (ii) for all u, v ∈ D, u = v, [dom(τ (u)) + su] ∩ [dom(τ (v)) + sv] = ∅; (iii) for all u, u ′ ∈ D, v ∈ dom(τ (u)) and v ′ ∈ dom(τ (u ′ )), let w = (su ′ + v ′ ) - (su + v); then w ∈ N implies τ (u)(v) w = τ (u ′ )(v ′ ) -w .
Let us discuss the items in this definition from an informal point of view, as shown in Fig. 2. We refer only to the particular case in which all τ (u) are connected and thus polyominoes, since this is what we will construct. In this case, the definition implies that a poly-tiling of scale s is (i) a juxtaposition of polyominoes on a grid of size s;

(ii) such that all these polyominoes do not overlap once shifted to their actual position on the grid, which is achieved by shifting τ (x, y) by sx units to the right and sy units upwards; (iii) neighboring polyominoes stick, i.e., if two tiles of two different polyominoes become neighbors after being shifted, they have to stick. These characteristics allow to consider them as usual "valid" tilings without overlaps, as explained in the following remark.

Remark 2.1. A poly-tiling τ of scale s can be easily transformed into a "regular" tiling τ ′ , as depicted in Fig. 2, according to the following formula:

τ ′ (i, j) = (τ (x, y))(i ′ , j ′ ) ,
for any x, y, i, j, i ′ , j ′ ∈ Z which verify i = sx + i ′ , j = sy + j ′ and (i ′ , j ′ ) ∈ dom(τ (x, y)). Because of condition (ii) in the definition of poly-tilings, given any pair (i, j), if x, y, i ′ , j ′ exist then they are unique. Because of (i) and (iii), τ ′ is indeed a tiling since all glues match. Note that some tiles from τ (x, y) may be located outside of the "box" of size s situated at (sx, sy), and conversely that some tiles of this box (here, t 12 ) may not belong to τ (x, y).

We can slightly modify this notion to define poly-ribbons. Basically, we replace the property of sticking at the macro-level (iii) by a notion of macropath.

Definition 2.2. A poly-ribbon of scale s, using tile system T (in neighborhood N vN ), is a pair (P, r) where P is an injective path and r : range(P ) → R T is such that (i) for all u ∈ range(P ), r(u) is a finite T -ribbon;

(ii) for all u, v ∈ range(P ), u = v, [dom(r(u)) + su] ∩ [dom(r(v)) + sv] = ∅ (where we define dom(r(u)) = dom(r ′ ), if r(u) = (P ′ , r ′ )); (iii) for all i, i + 1 ∈ dom(P ), let r(P (i)) = (P 1 , r 1 ) and r(P (i + 1)) = (P 2 , r 2 ) be two consecutive ribbons. Let u 1 = P 1 (max(dom(P 1 ))) be the last position of P 1 , u 2 = P 2 (min(dom(P 2 ))) be the first position of P 2 , and v = [u 2 + sP (i + 1)] -[u 1 + sP (i)] be their relative position. Then, we must have v ∈ N vN and r 1 (u

1 ) v = r 2 (u 2 ) -v .
The new requirement (iii) enforces that the ribbon follows a path at the macro-level, "jumping" from one ribbon to the other. Therefore, in a similar way as what was done in Remark 2.1, we can see a poly-ribbon as a ribbon. This explains why in our constructions we build poly-tilings [resp., poly-ribbons] for simplicity, they can in turn be considered as particular tilings [resp., ribbons] from the set T T,N [resp., R T ].

Let us now formalize the intuition that a simulation is a function ψ which associates tilings with unique poly-tilings [resp., zippers with unique poly-ribbons], by means of a function ϕ transforming every tile into a set of unique polyominoes. These polyominoes will be aligned on a grid of size s, each of them replacing a tile from the initial object at the same position, to form a poly-tiling [resp., poly-ribbon] corresponding to the initial tiling [resp., zipper].

In the following, for a set S, we define P(S) = 2 S as the set of subsets of S. Let ϕ : T → P(T T ′ ,N ′ ) be a function which associates a tile t with a set of finite (T ′ , N ′ )-tilings of scale s, such that for all t ∈ T , for all τ ∈ ϕ(t), (0, 0) ∈ dom(τ ) (the tile τ (0, 0) is called the reference tile), and such that if t = t ′ , for all τ ∈ ϕ(t), τ ′ ∈ ϕ(t ′ ), u ∈ dom(τ ), and u ′ ∈ dom(τ ′ ), then τ (u) = τ ′ (u ′ ) (all tiles from all tilings in ϕ(t) are specific to tile t). In our constructions, the finite tilings ϕ(x, y) will be connected polyominoes. Let us introduce one more mapping χ ϕ : T T ′ ,N ′ → T T ′ ,N ′ , which associates any (T ′ , N ′ )-tiling τ with a poly-tiling χ ϕ (τ ), by removing incomplete or misaligned polyominoes as follows.

1. First, discard all the tiles from τ which do not belong to a complete polyomino ϕ(t), for some t ∈ T . We obtain τ 1 which is a restriction of τ . 2. Then, discard all the polyominoes in τ 1 which do not have their reference tile positioned at (sx, sy) for some x, y ∈ Z (this is to avoid misalignment in non-connected tilings), to obtain χ ϕ (τ ). Note that χ ϕ (τ ) is the empty tiling for infinitely many tilings (for example, all the ones for which the reference tiles are badly positioned). Definition 2.3. Given such functions ϕ and χ ϕ , a tiling-simulation of a tile system T by a tile system T ′ is a mapping ψ : T T,N → P(χ ϕ (T T ′ ,N ′ )), such that ψ associates any (T, N )-tiling τ : D → T with a non-empty subset of polytilings (hence tilings) from {τ ′ : D → T T ′ ,N ′ | τ ′ (x, y) ∈ ϕ(τ (x, y))}; with the additional constraint that for all (T ′ , N ′ )-tilings τ ′ , there exists some unique valid (T, N )-tiling τ such that χ ϕ (τ ′ ) ∈ ψ(τ ).

Note that the constraint on ϕ saying that tiles are specific implies the injectivity of ϕ and of ψ. In fact, we even have the following stronger result:

ψ(τ ) ∩ ψ(τ ′ ) = ∅ for two different (T, N )-tilings τ and τ ′ .
Let us now see how to recover an initial tiling from any (T ′ , N ′ )-tiling, once a tiling-simulation ψ is defined. Given a poly-tiling τ ′ ∈ ψ(τ ), one can restore unambiguously the initial (valid) tiling τ . Indeed, if τ ′ (x, y) denotes the polyomino whose reference tile is located at (sx, sy), then τ (x, y) = ϕ -1 (S), where S = ϕ(τ (x, y)) is the only image set of ϕ containing τ ′ (x, y). This tiling τ must be valid (all glues matching) in order for ψ to be a simulation, which is enforced by the last constraint of Definition 2.3 (since in this case, χ ϕ (τ ′ ) = τ ′ ).

Moreover, for any other tiling τ ′ ∈ T T ′ ,N ′ such that there is no tiling τ with τ ′ ∈ ψ(τ ), the function χ ϕ allows to recover from this situation: as in the previous case, by construction of ϕ, there exists a unique (T, N )-tiling τ such that χ ϕ (τ ′ ) ∈ ψ(τ ). This tiling τ can be recovered as explained in the previous paragraph. From the last constraint in Definition 2.3, we also deduce that τ is valid.

The simulation of a zipper by a ribbon is defined similarly. Let ϕ : T → P(R T ′ ) associate a tile t with a set of unique finite T ′ -ribbons, , such that for all t ∈ T , for all (P, r) ∈ ϕ(t), (0, 0) ∈ dom(r), and such that if t = t ′ , for all (P, r) ∈ ϕ(t), (P ′ , r ′ ) ∈ ϕ(t ′ ), u ∈ dom(r), and u ′ ∈ dom(r ′ ), then r(u) = r ′ (u ′ ). Also let χ ϕ : R T ′ → R T ′ , which associates any T ′ -ribbon with a poly-ribbon as previously, by removing incomplete and misaligned polyominoes. Definition 2.4. A zipper-simulation of the tile system T by the tile system T ′ is a mapping ψ : Z T,N → P(χ ϕ (R T ′ )), such that ψ associates any (T, N )zipper (P, r) where r : range(P ) → T with a non-empty subset of poly-ribbons (hence ribbons) from {(P, r ′ ) | r ′ : range(P ) → R T ′ , r ′ (x, y) ∈ ϕ(r(x, y))}; with the additional constraint that for all T ′ -ribbons (P ′ , r ′ ), there exists some unique valid (T, N )-zipper (P, r) such that χ ϕ ((P ′ , r ′ )) ∈ ψ((P, r)).

The recovery procedure proceeds as previously, by turning a T ′ -ribbon into a poly-ribbon with χ ϕ , and recovering the zipper tiles with ϕ -1 .

Provided a tiling-simulation ψ exists, we say that τ ′ simulates τ if χ ϕ (τ ′ ) ∈ ψ(τ ). Similarly, for a zipper-simulation ψ, the ribbon (P ′ , r ′ ) simulates the zipper (P, r) if χ ϕ ((P ′ , r ′ )) ∈ ψ((P, r)). Finally, when no ambiguity is possible, we simply use the term simulation to refer to the simulation of tilings or zippers.

Total Tilings Constructions

In [START_REF] Adleman | On the decidability of self-assembly of infinite ribbons[END_REF], the authors use a construction which can be adapted to the simulation of total tilings. Their idea is to replace each arbitrary-neighborhood tiles by von Neumann-neighborhood tiles, these new tiles (called supertiles to avoid misunderstandings) being groupings of several of the initial tiles, such that supertiles group all the tiles which belong to the neighborhood of the initial tile. This leads to the following statement.

Proposition 2.1. Let T be a tile system in arbitrary neighborhood N , with set of glues X. There exist a simulation ψ and a tile system T ′ in neighborhood N vN , with set of glues X ′ , such that any total (T, N )-tiling can be simulated by a total (T ′ , N vN )-tiling.

Proof. Let τ be a (T, N )-tiling. We replace tiles from T by new tiles from T ′ = T |N |+1 called supertiles, each of them encoding all the tiles from N and the tile itself. The 4 von Neumann glues encode the neighbors located at N ∩ {(i, j) | i ≥ 0} (East), N ∩{(i, j) | i ≤ 0} (West), N ∩{(i, j) | j ≥ 0} (North), and N ∩{(i, j) | j ≤ 0} (South). Therefore, two supertiles stick if the matching glues encode the same tiles, allowing to transmit information to distant neighbors. Figure 3 illustrates this construction in the case of Moore neighborhood N M . In this figure, we use the following notation: given a position (x, y) ∈ Z 2 , let tile t = τ (x, y) ∈ T . The symbol N (t) [resp., S(t), E(t), W (t)] represents the tile τ (x, y + 1) [resp., τ (x, y -1), τ (x + 1, y), τ (x -1, y)]; and denote XY = X • Y the composition of any of the functions X, Y ∈ {N, S, E, W }.

In this case, the polyominoes simulating the original tiles are made of only one supertile. Besides, for each tile t ∈ T , the set ϕ(t) contains all the one-tile tilings consisting of a supertile centered on t, with all the admissible neighbors of t. The function χ ϕ is the identity, since all polyominoes are made of one supertile, they are necessarily complete and aligned. Any total tiling τ ∈ T T,N is then simulated by an appropriate poly-tiling ψ(τ ), seen as a total (T

′ , N vN )- tiling τ ′ ∈ T T ′ ,NvN .
The converse is trivial, any total (T ′ , N vN )-tiling can be translated back into a unique valid total (T, N )-tiling by selecting only the central symbol. Remark that this technique can not be applied directly to the simulation of total zippers. Indeed, one would need to be able to transfer an arbitrary amount of information when simulating zippers such as the one represented in Fig. 4, since this amount would depend on the length of the zipper before it goes back. Also note that this simulation does not work for partial tilings, since in the absence of intermediate supertiles the information can not be transmitted. For example, in Fig. 3, if the top-right and bottom-left supertiles are omitted, it is not possible to ensure that the bottom-right tile is centered on SE(t).

This issue can be partially solved [START_REF] Winfree | [END_REF], by introducing a new symbol "no tile" in the supertiles, when a tile is absent. In this case, there will be supertiles at each position of the plane (possibly consisting only of symbols "no tile"). However, this would cause every partial tiling to be simulated by a total tiling, which is not suitable in most applications.

Simulating Arbitrary-Neighborhood Zippers by Ribbons

Here, we prove that there exists a simulation such that any zipper, using a tile system in arbitrary neighborhood, can be simulated by a ribbon using an appropriate tile system in von Neumann neighborhood. The objective of our constructions will be to define the function ϕ, in such a way that the polyominoes it produces are unique and do not overlap if and only if the initial tiles of the zipper stick.

The final construction being quite complex, we introduce the technical difficulties progressively. First, we recall known results which present the basic principles of the simulations, and solve the problem of crossings. Then, we deal with linear neighborhoods (all neighbors are on the same line), and finally we prove the general result in Corollary 3.10.

Preliminary Results

First we recall basic results of simulations of zippers. In [START_REF] Adleman | The undecidability of the infinite ribbon problem: Implications for computing by self-assembly[END_REF], the authors prove a fundamental result on the simulation of zippers by ribbons. They describe a method used to simulate bi-infinite zippers using "directed" tiles in von Neumann neighborhood by ribbons. The result can be extended to arbitrarily long zippers and standard tiles, as recalled here.

Theorem 3.1 ([4]

). Let T be a tile system in neighborhood N vN , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N vN )-zipper can be simulated by a T µribbon.

Proof. The key of the proof is the construction of the simulation ϕ which associates each tile with polyominoes. The basic idea behind these polyominoes is to replace every tile from T by a unique shape (Figs. 5(a) and 5(b)). Glues are replaced by bumps (the tile is raised) and dents (the tile is dug), a different glue leading to a different bump or dent. A way to uniquely code the glues is to change the vertical or horizontal position of the bump or of the dent, depending on the glue. Then, like in a jigsaw puzzle, two shapes stick if their adjacent bump and dent fit into each other. Therefore, a "ribbon" of these shapes would simulate a (T, N vN )-zipper, since the bumps and dents imply that the sides unconstrained by the ribbon have to match.

The second step of the construction of ϕ is the definition of a new tile system T µ , in von Neumann neighborhood and with a new set of glues, which will be used to build the polyominoes simulating the initial tiles from T . This leads to a path P , starting from the middle of the side corresponding to the input direction, and leaving at the middle of the side given by the output direction (Fig. 5(c)). This path draws the contour of the shape, including bumps and dents, while the central part of the path is used to reconnect the input and output sides. Its position is determined by the point at the Southwest corner for example, which we choose as the reference tile located at (0, 0). The path is "filled" by new tiles from the set T µ (we call these microtiles to avoid misunderstandings) using a mapping r : range(P ) → T µ . The finite T µ -tiled path (P, r) is the polyomino associated with the initial tile. Remark that for one initial tile, there can be 12 different polyominoes, corresponding to the same shape but with 4 possible input and 3 possible output directions. The polyomino should be a ribbon, so we should give some details about its construction. The first microtile (called the input microtile) has its input side colored with glue (g, d), where g is the input glue of the initial tile and d the direction of the path (West-to-East, etc.); similarly the output side of the output microtile encodes the glue of the output side of the initial tile and the direction. For all other microtiles, the input matches the output of the previous tile, so that our polyomino (P, r) is a T µ -ribbon. The input and output glues are unique among all the polyominoes, so this polyomino is the only possible ribbon using the tile system T µ , once the input microtile is given. Besides, to ensure that no interference occurs, the two sides which are not colored yet have a glue that matches nothing (for example glue null 1 on the West or North sides, null 2 on the East or South sides).

For a tile t ∈ T , the set ϕ(t) contains the 12 polyominoes described above. Then, obviously, if a T -tiled path is a (T, N vN )-zipper, one can find a "unique" poly-ribbon consisting of the catenation of polyominoes constructed by ϕ, which is a T µ -ribbon. It is not really unique, since at the extremities of a finite zipper, 3 different polyominoes corresponding to the 3 possible input (or output) directions are admissible.

Conversely, because of the careful design of the glues from X µ , any T µ -ribbon can be seen as a poly-ribbon, since the glues forming the polyominoes appear only once and guarantee that only polyominoes can be formed. A T µ -ribbon may have up to two incomplete polyominoes at the extremities, but if we cut them off using χ ϕ , then it can be represented as a unique poly-ribbon. Then, if a poly-ribbon using tile system T µ exists, Definition 2.2 implies that • all polyominoes do not overlap (condition (ii)), hence that the glues they simulate match on the four sides; • the polyominoes stick on their input/output tiles (condition (iii)), hence that the polyominoes follow a path. Using this path and these glues, one can uniquely restore the initial (T, N vN )zipper.

The following remark states an important property of our construction. In fact, the simulation ψ we just constructed can be considered as bijective.

Remark 3.1. Let R be the equivalence relation which states that two T µ -ribbons are equivalent if they represent the same (T, N vN )-zipper. Then, the simulation ψ is a bijection between the set of (T, N vN )-zippers Z T,NvN and the set of T µribbons quotiented by R, R Tµ/R .

In addition, the polyominoes used in the above simulation are rectilinear polyominoes, i.e., a simple sequence of tiles outlining a shape. These are a particular case of general polyominoes, making the simulation more powerful. Remark 3.2. Theorem 3.1 allows to transfer information on a ribbon in all 4 directions. This result, in conjunction with Proposition 2.1, allows a simple construction in the case of arbitrary-neighborhood total zippers, by first reducing to a von Neumann-neighborhood total zipper with the supertiles technique, and then simulating it by a two-tile-neighborhood ribbon.

The simulation of a zipper in Moore neighborhood N M (i.e., adding diagonal communications) is more complex, because diagonal glues cross, as illustrated in Fig. 6. The consequence is that diagonal bumps would also have to cross each other. This issue is solved in [START_REF] Czeizler | Towards a neighborhood simplification of tile systems: From Moore to quasi linear dependencies[END_REF] using a method that we summarize here, because it will turn out to be useful in our constructions.

t N (t) N W (t) W (t)

Theorem 3.2 ([11]

). Let T be a tile system in neighborhood N M , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N M )-zipper can be simulated by a T µribbon.

Proof. The global idea of the simulation is the same as for the proof of Theorem 3.1, we need to define a function ϕ for all tiles from T . In Figs. 7(a) and 7(b) we present a picture of the shape that can be used to simulate an initial tile of T . It differs slightly from the shape described in [START_REF] Czeizler | Towards a neighborhood simplification of tile systems: From Moore to quasi linear dependencies[END_REF], but the idea is the same and this new shape is an introduction to our results.

(0, -1)

(0, 1) (-1, 0) (1, 0) (-1, 1) (1, -1)
(1, 1)

(-1, -1)
(a) A single shape. Next to the communication places is written the neighbor it communicates with.

(b) The shape and its 8 neighbors. This shape is turned into a polyomino using new microtiles from T µ , taking into account the input and output directions. Then, all but one of the communications can be done as previously, by modifying the position of bumps and dents to simulate different glues. The only issue is the communications between the Northwest and Southeast neighbors (circled on Fig. 7(b)). We have to be able to relay information about these diagonal glues without the physical touch between edges of tiles. According to the notation from Fig. 6, we need to check the glue compatibility between the central tile t and its Northwest neighbor N W (t), as well as between the tiles N (t) and W (t). This can be accomplished by a geometrical construction such as the one in Figs. 8(a) and 8(b).

t N W (t) W (t) N (t)
(a) Glues matching between t and N W (t).

t N W (t)

(b) Glues not matching: the ribbons overlap.

Figure 8: "Crossing" of information. The top ribbon segment is part of N W (t), the bottom ribbon segment is part of t, and the space in between can be filled by 2 layers of microtiles for W (t) to actually reach N (t).

This construction checks the match between the W (t) and N (t) in the oldfashioned way, by physically matching the adjacent bump and dent of the corresponding polyominoes. The novelty of this construction is that the glue-match between t and N W (t) is accomplished without the respective polyominoes ever touching. Moreover, this construction works even in the case of partial tilings where the tile W (t) might be missing. This is accomplished by carefully designing the shape and space between the bump and the dent so that, whether or not the tile between these polyominoes is present, their shapes will be compatible and not overlap if and only if the glues of the corresponding tiles were compatible. In order to achieve this and cross the 2 layers of microtiles forming the polyomino W (t), the bump of t should be 3 microtiles high, and the dent of N W (t) should be 8 microtiles wide and 3 microtiles deep. In the sequel, the inner layers of W (t) are called bridges.

For any tile t ∈ T , if a polyomino in the set ϕ(t) has a bridge, then ϕ(t) should contain the same polyomino with the bridge at all possible locations, matching all possible glues. Indeed, the bridges do not participate in a communication, they are just a kind of "relay" which should be able to match any glue. Therefore, ϕ(t) contains |X| copies of each of the 12 polyominoes given by the above construction, for the |X| possible locations of the bridges (one per glue).

The end of the proof, which consists in restoring a (T, N M )-zipper from any T µ -ribbon, is similar to the proof of Theorem 3.1 and is left to the reader. Remark 3.3. A simpler construction [START_REF] Adleman | [END_REF] using "pitcher-tiles" (see Fig. 9) solves the problem of information crossing when simulating Moore-neighborhood zippers by ribbons, but only when the zipper is a total tiling. In that case, one could use (with the notation from Fig. 9) the spike of the W (t) polyomino which conveys information to N (t) as "information carrier" to transmit information from t to N W (t). This construction does not work as such in the case of zippers which are partial tilings, because the "carrier" W (t) tile might be altogether absent. This idea is similar to the one suggested in Remark 3.2, since it uses intermediate polyominoes to relay information. The main difference is that the polyomino-based simulation is more general and can be used for arbitrary neighborhoods, while these pitcher-tiles were designed specifically for the Moore neighborhood.

W (t) N W (t) t N (t)

Simulating Arbitrary Linear Neighborhoods

We call linear neighborhood a neighborhood N such that if (i, j) ∈ N then j = 0. Although this is a sub-case of the general case studied in the next section, we will explain it in detail since it lays the base of the general study, and it is much simpler to describe and understand. Also note that this result was already announced in [START_REF] Czeizler | Geometrical tile design for complex neighborhoods[END_REF], but the polyomino used there was not easily generalizable to arbitrary neighborhoods. First, we state an initial remark which allows us to consider only connected linear neighborhoods

N n = (i, 0) ∈ Z 2 | 0 < |i| ≤ n .
Remark 3.4. For a given set of glues X, any tile system T defined in linear neighborhood N can be replaced by an equivalent tile system T in an appropriate connected linear neighborhood N n . Indeed, let n be such that N ⊂ N n , let g ∈ X be an arbitrary "dummy" glue and T ′ = ζ g (T ) a tile system in neighborhood N n , where ζ g : T → T ′ is defined for all t ∈ T and (i, j) ∈ N n by

ζ g (t) i,j = t i,j if (i, j) ∈ N , g otherwise.
Then, clearly, τ :

D → T is a (T, N )-tiling if and only if τ ′ : D → T ′ defined by τ ′ (x, y) = ζ g (τ (x, y)) is a (T ′ , N n )-tiling.
First, we state a lemma which generalizes to an arbitrary number of inner layers the crossing operation detailed in the proof of Theorem 3.2. The gadget introduced in this lemma will be helpful in the next constructions. Lemma 3.3. In order to fit a bump and a dent spaced by k layers, the bump must be k + 1 microtiles high, the dent must be 2k + 4 microtiles wide and k + 1 microtiles deep.

Proof. The result is obtained by an immediate generalization of Fig. 8(a) to k white layers instead of 2.

We now prove the main result of this section for neighborhoods N n . Theorem 3.4. Let T be a tile system in connected linear neighborhood N n , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N n )-zipper can be simulated by a T µ -ribbon.

Proof. As previously, we are going to replace a tile of the (T, N n )-zipper by a shape using a function ϕ, leading to a set of polyominoes. The general shape of the polyominoes is illustrated in Fig. 10. It consists of a spike sent from the original square to the neighbor at distance n.

As shown on the picture, communication bumps can be put on the spike, while dents are located inside the initial square. For matching the glues between one tile and its neighbor (i, 0), the bump will cross i -1 other spikes, we will see later how many layers of microtiles it represents. Indeed, the essential part of

-3 -2 -1 +1 +2 +3
Figure 10: General shape simulating a tile in arbitrary linear neighborhood. In this example, the neighborhood is N 3 = {(-3, 0), (-2, 0), (-1, 0), (1, 0), (2, 0), (3, 0)}. The shape is drawn in thin black, and the vertical thick lines are the communication places with the neighbor whose abscissa is the number indicated above it. These neighbors are drawn in gray. the simulation is the discretization of this shape into a polyomino of microtiles. A final polyomino is represented in Fig. 11. We define the following variables. The height of the polyomino is s microtiles, it is also the width of the initial tile and therefore the scale of the final polyribbon. The vertical space between the top of the polyomino and the beginning of the spike is denoted h, and since the spike is centered, the space between the end of the spike and the bottom is also h. Finally, the spike is a succession of horizontal segments of l microtiles, thus the slope of the spike is ±1/l. Then, the following constraints have to be respected when constructing the polyomino.

• The integer l has to be as large as necessary, leaving enough horizontal space for crossings, as suggested by Lemma 3.3. Similarly, h needs to provide enough vertical space for the dents. Formally, l ≥ α and h ≥ β, where α and β will be given later on. • The polyomino must be at least 3 layers wide everywhere, two for the inner and outer layers of the spike, and one for a potential junction of the path from the input microtile to the output microtile (as in Fig. 5(c)). As a consequence, h ≥ 3 and s ≥ 3l + 3, since the inner layer of the spike must go down by 3 before reaching s -3. The first constraint can be removed (assuming β ≥ 3), while the second one can be replaced by s ≥ 4l (provided l ≥ 3, which is the case if α ≥ 3), so that s can be exactly divided in 4 horizontal segments everywhere on the spike. • The initial tile being a square, the height is s and can also be written h + 2⌊ns/l⌋ + h (the spike goes ns microtiles to the right at slope 1/l). Therefore, after replacing both s by 4l, we have h = 2l -4n. Since h ≥ β, because of the last equation l has to be greater than 2n + β/2. For given n, α, β ∈ N, a solution of the system is then

   l = ⌈max(α, 2n + β/2)⌉ s = 4l h = 2l -4n .
It is quite obvious that translated copies of this polyomino tile the plane with no overlaps, allowing to replace a grid of tiles by a grid of polyominoes 3 .

We now give some details on how the communications take place. For a more convenient description, we split the polyomino into n + 1 horizontal parts of width s = 4l, we denote them from left to right by part 0 (which corresponds to the initial square tile) to part n (end of the spike). Each of these parts is divided into 4 horizontal segments of length l, denoted segment 1 to segment 4. As suggested in Fig. 10, the bumps and bridges are located on the horizontal segments on the top of the spike in parts 1 to n, while the corresponding dents are on the horizontal steps on the top of the hole in part 0. For every 0 < i ≤ n, the glue t i,0 of the initial tile is allocated some space in every part, on one of the four segments. A simple way to do this is to allocate glue t i,0 to segment (i -1 mod 4), hence each segment is used for ⌊n/4⌋ or ⌈n/4⌉ glues. This space is then used in part 0 for a dent, in parts 1 to i -1 for bridges, and in part i for the bump.

Moreover, there are i -1 spikes to cross by the bump encoding t i,0 . Each spike is 4 layers thick, hence there are at most 4(n -1) layers to cross. This number is fixed, so we can apply Lemma 3.3 with k = 4(n -1): each glue needs a horizontal space of (8(n -1) + 4) (width of a dent) + (|X| -1)(4(n -1) + 1) (spacing between different possible glues) microtiles. This gives a lower bound to l, which has to be greater than ⌈n/4⌉ × (|X| (4n -3) + 4n -1). After adding 6 microtiles to separate the dents from the sides of the polyomino, we define α = ⌈n/4⌉ × (|X| (4n -3) + 4n -1) + 6 , as the lower bound for l used previously. On the other hand, the depth of the dents is k + 1 = 4n -3. Consequently, we have another constraint on h which must be greater than β = 4n (space for the biggest dent plus the three original layers). This means l greater than 4n, which is already the case because l ≥ α ≥ 4n. Then,

   l = ⌈n/4⌉ × (|X| (4n -3) + 4n -1) + 6 s = 4l h = 2l -4n .
This ensures that our polyomino can be constructed, using an appropriate set of microtiles which will generate the T µ -ribbon we described. The last step of the construction is the positioning of the input and output microtiles. We can choose to place them at top-left position (path coming from or going to the West), top-right (path from or to the East), middle of the top side (path from or to the North), middle of the bottom side (path from or to the South). Since s is even, the middle of a side is chosen after ⌊s/2⌋ microtiles. Then the inner layer we preserved can be used for joining the input and the output microtiles easily; for example, starting from the input microtile, one can draw the contour of the path from the left, just before reaching the output microtile, the path goes one layer inside and goes back to the input microtile where it draws the contour from the right (see Fig. 12 for examples). Finally, putting the appropriate polyominoes one after the other generates a poly-ribbon which is in fact a T µ -ribbon. As it was shown before, any T µ -ribbon can be transformed into a poly-ribbon with χ ϕ , from which one can restore the original (T, N n )-zipper using ϕ -1 . The poly-ribbon does not overlap if and only if the glues from the (T, N n )-zipper match everywhere, hence ψ is a simulation.

Complexity of the Linear-Neighborhood Construction

We now give results on the "size" of this simulation, which underline the fact that the generated polyominoes can be very complex. All the results refer to the construction described in the proof of Theorem 3.4. Proof. When n = 2, there is one bridge between the neighbors at (-1, 0) and at (1, 0); when n = 3, there are in addition two bridges between neighbors (-2, 0) and (1, 0), and (-1, 0) and (2, 0). In general, there are n -1 bridges between (in, 0) and (i, 0) for 1 ≤ i ≤ n -1, plus n -2 bridges between (in -1, 0) and (i + n -1, 0) for 1 ≤ i ≤ n -2, and so on. Hence there are

B = n-1 i=1 i = 1
2 n(n -1) bridges.

Lemma 3.6. A polyomino used to simulate a tile of a (T, N n )-zipper is constituted by O(|X| n 3 ) microtiles.

Proof. Drawing the contour of a shape requires:

• s microtiles for the 2 horizontal segments in part 1;

• 4h microtiles for all 4 vertical portions;

• 4(ns + 4n) microtiles for the 2 spikes (ns for the horizontal segments, 4n for the steps down and up); • at most s + 2h + 2(ns + 4n) + s/2 microtiles for joining input and output microtiles (worst case when joining left to bottom); • 2n bumps and dents of height at most O(n) microtiles; ) different microtiles. Since a polyomino is a ribbon which has to be uniquely built, microtiles (except for the input and output ones) have 2 glues which can be found only on one other microtile. Therefore each of these microtiles introduce a new glue, and reuse another: there are at least

• B = O(n 2 ) (Lemma 3.
|X µ | = O(|T µ |) = O(|T | • |X| 2 n 5 ) glues.
The other two glues are null 1 and null 2 , and the input and output glues microtiles use glues from X, which does not change the order of magnitude of |X µ |.

Simulating Arbitrary Neighborhoods

In this section, we prove the first of the two main results of this paper, namely that zippers in any neighborhood can be simulated by ribbons (Corollary 3.10). First, note that in a similar way to Remark 3.4, any neighborhood N can be replaced by an equivalent rectangular neighborhood N m,n = {(i, j) ∈ Z 2 | 0 ≤ |i| ≤ m, 0 ≤ |j| ≤ n and (i, j) = (0, 0)} containing N . Theorem 3.9. Let T be a tile system in rectangular neighborhood N m,n , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N m,n )-zipper can be simulated by a T µ -ribbon.

Proof. The key of the proof is the generalization of the ϕ simulation from the proof of Theorem 3.4 to rectangular neighborhoods. The idea is to have a vertical succession of n + 1 spikes of length m, each of them being a "sheath" for the next one (Fig. 13).

m n A B C 1, 0 2, 0 3, 0 0, -1 0, -2 1, -1 2, -1 3, -1 1, - 2 2, -2 3, -2 1, 1 2, 1 3, 1 1, 2 2, 2 3, 2
Figure 13: Shape simulating a tile defined in a rectangular neighborhood Nm,n of size (2m + 1) × (2n + 1) (here m = 3 and n = 2). The initial tile is the light gray square, while the path is filled with darker gray.

The bumps used for communications are put all along the spikes, at the places indicated on the picture. The difficulty is to find places for the dents, so that they can be contained in a place where enough space can be reserved. This is achieved as follows.

• North (from (0, j), for 0 < j ≤ n) and West (from (i, 0), for -m ≤ i < 0) communications are received in the area marked B on the picture. This works very similarly to the linear-neighborhood case. • Northwest communications (from (i, j), for -m ≤ i < 0 and 0 < j ≤ n) are received in A. Again, it is not difficult to see how the information crosses the layers. • Southwest communications (from (i, j), for -m ≤ i < 0 and -n ≤ j < 0) are received in C. This is slightly more complicated to understand, since these dents are not located inside the initial square. Putting the dent at the bottom of the polyomino allows to simulate the Southwest communications by Northwest communications, which is then easily achieved by positioning bumps on the spike. The key point is that the areas marked A, B, and C (in dark gray on Fig. 13) are scalable, both vertically and horizontally, so they can be made as big as needed for the dents. Indeed, we can denote as previously by s the width and height of the initial tile, hence the scale of the poly-ribbon. Let x be the width of A, B, C and of all the other horizontal subdivisions of s. Since there are two of these blocks for each of the first n vertical spikes, plus one for the last spike, it holds that s = (2n + 1)x. As in Theorem 3.4, we need the spike to be 3 layers wide, hence the slope 1/l of the spikes is defined by l such that x ≥ 3l + 3. Again it is possible to decide that x = 4l, i.e., a block is made of four descending horizontal segments. Finally, let h be the left height of the A-B-C areas. The fact that the initial tile is a square is expressed by s = 2h + 2⌊ms/l⌋. We have the following equations:

   x = 4l s = (2n + 1)x s = 2h + 2⌊ms/l⌋ .
Besides, to ensure enough space for the bumps and dents, we want to make sure that x and h are as big as necessary, i.e., x ≥ α and h ≥ β (the exact values of α and β will be given later). Once solved, the system gives h = (2n + 1)(2l -4m). Since h should be greater than β and x greater than α, l needs to be greater than max(α/4, β/(4n + 2) + 2m). Thus, a solution to the system which guarantees that the polyomino can be constructed is

       l = ⌈max(α/4, β/(4n + 2) + 2m)⌉ x = 4l h = (2n + 1)(2l -4m) s = 4(2n + 1)l .
A last technical difficulty is the description of how the spikes shrink to fit into the previous one. The general way to do this is illustrated on Fig. 14, which zooms on the rightmost part of the first spike of a polyomino.

The outer spike does not shrink because it does not need to, since the shrinking will happen at the bottom of the initial tile (see Fig. 13). This is not necessary, but it allows a tiling of the plane without any holes between polyominoes. The other spikes shrink by x microtiles on the left and on the right by going down 4 tiles (remember that the slope of the spikes is 1/l = 4/x). Remark the slight asymmetry of the shrinking, which has to take place after reaching height s/2 on the left, and just before on the right. With all these conditions respected, it should be clear that vertically and horizontally translated copies of this polyomino tile the plane with no overlaps.

It remains to determine the bounds α and β. An application of Lemma 3.3 to all the spikes and dents gives us the maximal size of bumps and dents. It is 5x 3x obtained for the diagonal communication between a tile and its neighbor located at (m, -n), which crosses n+(m-1)(2n+1) spikes of thickness 4 layers, hence a total number of k = 4(2mn+m-n-1) layers. It follows that β = k+3 to ensure a free layer between the top of a dent and the upper side of the polyomino. The bound α is more complicated to express. As for Theorem 3.4, a communication bump-dent needs 2k+4 horizontal space, plus an extra (|X|-1)(k+1) microtiles for the different glues. The size x has to allow m + n dents in B, mn dents in A and C. Hence, after adding 6 microtiles for preserving the borders of the block, α = max(mn, m+n)×(2k+4+(|X|-1)(k+1))+6, with k = 4(2mn+m-n-1).

The rest of the proof (positioning and joining the input and output microtiles, bijection between a (T, N m,n )-zipper and a set of unique poly-ribbons) is unchanged from the proof of Theorem 3.4. Corollary 3.10. Let T be a tile system in arbitrary neighborhood N , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N )-zipper can be simulated by a T µ -ribbon. Remark 3.1 can be extended to the general case, hence any T µ -ribbon represents a unique (T, N )-zipper. Also note that a result similar to Proposition 3.8 could be stated, but it would be more complex and of little interest since the number of tiles would be a lot bigger.

To illustrate the achievability (and the complexity) of this construction, Fig. 15 gives a complete example of a polyomino for the simulation of a linearneighborhood (T, N 2 )-zipper, with |X| = 2.

The general case is by far more complicated and a detailed picture would be difficult to understand. We put in Fig. 16 the shape from Fig. 13, surrounded by 8 other shapes (colored alternatively in light and medium gray). The communication places between the central shape simulating the tile located at (0, 0) and the 8 other shapes are shown, one of them is detailed at the bottom of the picture.

, 0 -1, 0 0, -1 0, 1 1, -1 -1, 1 1, 1 -1, -1 τ (-1, 1) τ (0, 1) τ (1, 1) τ (-1, 0) τ (0, 0) τ (1, 0) τ (-1, -1) τ (0, -1) τ (1, -1) τ (0, 0) τ (1, 0) τ (1, 1) τ (1, 2) τ (1, 1)
τ (1, 0) bump bridges dent

Extension to Arbitrary-Neighborhood Tilings

We now explain how the above construction can be modified, in order to simulate arbitrary-neighborhood tilings by von Neumann-neighborhood polytilings, to obtain our second main result (Corollary 4.2). Before that, we describe a simpler construction used in [START_REF] Adleman | On the decidability of self-assembly of infinite ribbons[END_REF], which can be adapted to do such a simulation, but only in the case of total tilings. We finally study some properties of the tilings which are preserved by our simulation technique.

Polyomino Construction

The construction described in Sect. 3 transforms a tile into a polyomino of microtiles, keeping the path unchanged at the macro-level. Hence, a similar construction can be used to prove another result, which states that arbitraryneighborhood tilings can be simulated by von Neumann-neighborhood tilings. As usual, we first prove the result for rectangular neighborhoods, and deduce the general case from that. Theorem 4.1. Let T be a tile system in rectangular neighborhood N m,n , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N m,n )-tiling can be simulated by a (T µ , N vN )-tiling.

Proof. Only a few modifications have to be done to the general polyomino represented in Fig. 13, in the construction of Theorem 3.9, to transform the T µ -ribbon into a (T µ , N vN )-tiling. First, the inner layer used to join the input and output microtiles can be removed, allowing thinner spikes.

The main difference is that now, all 4 glues of the microtiles have to match with their neighbors, if present. The glues towards the inside of the polyomino (i.e., the glues used for adjacent microtiles from the same polyomino) can be chosen as previously, uniquely for each tile of each polyomino. For the glues used to match with other polyominoes, things are slightly more complex, since they will be used to enforce the correct position of the adjacent polyomino, to avoid misalignment. These glues can be chosen as pairs (x, y) ∈ N 2 . For North and East glues, (x, y) represents the position of the microtile inside the polyomino, counting from the bottom-left part of the polyomino for example (hence, the microtile at the top-left of the polyomino will have glue (1, s(n + 1)) on the North side). For South and West glues, this pair should be the position of the microtile on the neighboring polyomino, to ensure proper match. Therefore, the West glue of the top-left microtile will be (s, s(n + 1)), since it has to match with the top-right tile of the polyomino adjacent on the right. Note that 1 ≤ x ≤ s(m + 1) and 1 ≤ y ≤ s(n + 1) (see Fig. 13), therefore the number of these glues is bounded, once T and N m,n are fixed. These glue do not need to encode any information from the original set of glues X, since this matching will be enforced by the shape of the polyominoes. Their role is only to align properly the polyominoes.

Then, each (T, N m,n )-tiling is associated with a set of (T µ , N vN )-tilings by this construction. Conversely, any (T µ , N vN )-tiling τ ′ can be turned into a polytiling τ ′′ using the tile system T µ in neighborhood N vN , by discarding incomplete and misaligned polyominoes using a function χ ϕ . Then, starting from the polytiling τ ′′ , one can recover the initial tiles at their respective positions, with the help of the function ϕ -1 applied to the unique sets containing each of the complete polyominoes. By construction, this (T, N )-tiling τ is the only valid tiling such that χ ϕ (τ ′ ) ∈ ψ(τ ), therefore ψ is a simulation.

Remark that instead of increasing the number of glues to force a correct alignment of the polyominoes, one could have worked on their shape, adding more bumps and dents as in [START_REF] Czeizler | Geometrical tile design for complex neighborhoods[END_REF]. We made the choice of a shape as simple as possible, even if it increases the number of glues used.

As explained at the beginning of Sect. 3.4, any neighborhood can be replaced by an equivalent rectangular neighborhood, hence the following corollary. Corollary 4.2. Let T be a tile system in arbitrary neighborhood N , with set of glues X. There exist a simulation ψ and a tile system T µ in neighborhood N vN , with set of glues X µ , such that any (T, N )-tiling can be simulated by a (T µ , N vN )-tiling.

Properties Preserved by the Simulation

The main interest of this construction is that it guarantees that some properties of the initial tiling are preserved, and still verified in the final poly-tiling. For example, unlike what happens with the simple construction explained in Sect. 2.3, a partial (T, N )-tiling is simulated by a partial (T µ , N vN )-tiling. The converse is also true, as well as some other important properties like periodicity and convexity, as explained in this section. Partial tilings. Clearly, from our construction, a partial tiling is simulated by partial tilings. For the converse, remark that our construction creates "holes" in a poly-tiling, because the polyominoes we build are hollow. Then, provided we fill the polyominoes by new tiles with unique glues, we obtain the following immediate result. Theorem 4.3. Let T be a tile system in arbitrary neighborhood N , with set of glues X. There exists a simulation ψ such that every (T, N )-tiling τ is total if and only if all (T µ , N vN )-tilings in ψ(τ ) are total.

Note that when τ is total, ψ(τ ) is a singleton. Indeed, the polyominoes of ϕ(t) differ only by the position of the bridges. When the tiling is total, all bridges are constrained by the neighboring polyominoes, hence only one element of the set ϕ(t) is possible. The final poly-tiling is therefore uniquely defined. Remark 4.1. Similarly, remark that a tiling is finite [resp., connected] if and only if all the poly-tilings which simulate it are finite [resp., connected]. As a consequence, the simulation of polyominoes is achieved by polyominoes only.

Periodic tilings. Periodicity is an essential notion in the classical tiling theory [START_REF] Berger | The undecidability of the domino problem[END_REF][START_REF] Robinson | Undecidability and nonperiodicity for tilings of the plane[END_REF], it should be preserved by a meaningful simulation. The following result shows that this is the case with our construction. Theorem 4.4. Let T be a tile system in arbitrary neighborhood N , with set of glues X. There exists a simulation ψ such that every (T, N )-tiling τ is periodic if and only if at least one of the (T µ , N vN )-tilings in ψ(τ ) is periodic.

Proof. Clearly, if a (T µ , N vN )-tiling as constructed in Theorem 4.1 is periodic, restricting it to a poly-tiling preserves its periodicity, and then the (T, N )-tiling it simulates is also periodic.

Conversely, if a (T, N )-tiling is periodic, then one of the poly-tilings which simulate it according to Theorem 4.1 has to be periodic. In the case of a total (T, N )-tiling, this fact is obvious. In the case of a partial tiling, it suffices to choose the poly-tiling with the correct bridge constraints at the borders, so that the periodic pattern of the tiling repeats all over.

Note that if the periods of a tiling τ are p v , p h ∈ N + , the periods of the periodic poly-tiling in ψ(τ ) are sp v , sp h ∈ N + , where s is the scale of the polytiling.

Convex tilings. The different convexity notions (line, column, or both) are important when dealing with polyominoes [START_REF] Barcucci | Reconstructing convex polyominoes from horizontal and vertical projections[END_REF][START_REF] Chrobak | Reconstructing HV-convex polyominoes from orthogonal projections[END_REF], which are a particular case of tilings. Our construction does not preserve the convexity of a tiling, but it is possible to modify it in order to preserve line convexity in the case of linear neighborhoods. Proposition 4.5. Let T be a tile system in arbitrary linear neighborhood N , with set of glues X. There exists a simulation ψ such that every (T, N )-tiling τ is line convex if and only if all (T µ , N vN )-tilings in ψ(τ ) are line convex. Sketch of proof. First, polyominoes should be filled as in the proof of Theorem 4.3. Then, the construction needs to be modified again, for one reason visible on Fig. 8: the bumps, dents and bridges create horizontal holes.

The idea is to replace these "holes" by two sets of stairs, using again the position of the stairs to ensure the glue matching, as represented in Fig. 17. In this figure, the integer g is the position of the dent, as induced by some glue. In order for the top and bottom polyominoes to match, the bump has to be located at position g + k + 1, where k is the number of layers crossed. In the new construction, the glue matching is enforced by the fact that in the bottom polyomino, if g is too big then there is an overlap on the left stairs, and if g is too small then there is an overlap on the right stairs.

The problem with this technical step is that crossing k layers implies that the spike goes down by 2(k + 1). If γ is the number of communication places in a segment of length l, and δ is the maximum number of layers which can be crossed, then each segment of length l in the spike would go down by 2γ(δ + 1) g + 3 instead of 1. This imposes new constraints on h and s, but the discretization system is still solvable, at the additional cost of increasing l by a factor 2γ(δ+1).

Then, obviously, all polyominoes from the sets ϕ(t) are line convex. Moreover, all polyominoes in any set ϕ(t) have the same height s and are assumed to have the same reference microtile, so that ψ transforms a line of tiles into a block of microtiles of height s. This block is formed by the horizontal juxtaposition of polyominoes, which, by construction, do not leave holes between them (otherwise, there is a glue mismatch somewhere, leading to some overlap somewhere else, see Fig. 17). Thus, this block is made of s lines of microtileswithout holes, and is therefore line convex. Since a line convex tiling is a vertical superposition of lines, its image by ψ is a vertical superposition of line convex blocks, hence another line convex tiling. Finally, the converse is trivial, if a (T µ , N vN )-tiling is line convex then it simulates a line convex (T, N )-tiling.

A similar result can be stated for column convex tilings, provided the initial tiling uses tiles in a vertical neighborhood N : if (i, j) ∈ N then i = 0. The proof follows the same sketch as for Proposition 4.5, with everything rotated by 90°. Proposition 4.6. Let T be a tile system in arbitrary vertical neighborhood N , with set of glues X. There exists a simulation ψ such that every (T, N )-tiling τ is column convex if and only if all (T µ , N vN )-tilings in ψ(τ ) are column convex.

Conclusions and Perspectives

In this paper, we proved that any zipper formed with tiles defined in an arbitrarily complex neighborhood can be simulated by a ribbon obtained by the catenation of simple polyominoes. Each of the new microtiles used for the simulation has, when placed on a ribbon, only two neighbors: its predecessor and its successor on the path. A similar construction can be achieved for tilings, in order to replace arbitrary neighborhoods by the simpler von Neumann neighborhood, and at the same time preserve some properties of the tiling.

A few research directions can extend this work. For example, the simulation relies on the fact that zippers and ribbons are not self-crossing. Although this is the standard way to define them, they could be generalized to other, selfcrossing, notions. It would be interesting to see if similar results could be obtained in this case, using new constructions. Another interesting topic would be to study how this construction behaves in three-dimensions, since crossings might be avoided with spikes turning around each other. However, new problems occur and would have to be solved by original techniques.

Another possible improvement is justified by the observation that our constructions are not yet adapted to practical dynamical implementations, such as DNA self-assembly. Theoretically, our constructions could be used for practical purposes: for example, as mentioned in [START_REF] Rothemund | Theory and Experiments in Algorithmic Self-Assembly[END_REF], the construction of Theorem 3.1 can be used to simulate a Turing machine at temperature 1 (i.e., DNA tiles attach to the growing assembly whenever one glue matches). But this produces a lot of "garbage" consisting of many blocked polyominoes, for a limited number of correct assemblies. Indeed, there are many dynamical scenarios wherein, for example, the self-assembly of a "bad" polyomino is started, that blocks any further aggregation. This issue could be solved by adding the possibility to recover from a wrong start, for example by allowing tiles to "unstick", as suggested in [START_REF] Winfree | Algorithmic Self-Assembly of DNA[END_REF][START_REF] Adleman | Towards a mathematical theory of self-assembly[END_REF]. Further modifications would then be necessary to guarantee that, also in this setting, our constructions can self-assemble fully and correctly in finite time.

Also remark that in our constructions, we emphasized the regularity of the polyominoes, to provide easier general constructions and aggregation. This led however to a blow-up in the number of new microtiles necessary to simulate a zipper, potentially leading to more experimental issues. The next step would be to optimize the construction according to some of the following criteria: number of polyominoes associated with a tile, number of microtiles appearing in a polyomino, number of glues used to build the polyominoes, etc.

An alternative solution to these two problems would be the use of staged self-assembly [START_REF] Demaine | Staged self-assembly: Nanomanufacture of arbitrary shapes with O(1) glues[END_REF] for experiments. This formalism would allow to add an initial stage to construct the polyominoes in separate bins, before mixing them in the final solution, preventing the formation of "bad" assemblies. Besides, staged self-assembly would dramatically decrease the number of required glues (hence the number of microtiles), by adding even more initial stages to produce the polyominoes. This would offer more control on the order in which microtiles attach, thus removing the necessity for unique glues. However, this would be achieved at the cost of increased control by an external operator during the selfassembly process. This trade-off between external control and tile complexity is often encountered in DNA self-assembly (see, e.g., [START_REF] Kao | Reducing tile complexity for self-assembly through temperature programming[END_REF][START_REF] Demaine | Staged self-assembly: Nanomanufacture of arbitrary shapes with O(1) glues[END_REF]), and is currently being investigated by the authors.

The authors would like to thank Shinnosuke Seki for his useful suggestion simplifying the construction in Fig. 13, and Leonard Adleman, Jarkko Kari, and Erik Winfree for discussions.

Figure 1 :

 1 Figure 1: A ribbon, and a von Neumann-neighborhood zipper. The underlying path is drawn in gray. The only difference occurs at the bottom-right where glues f and n are not required to match in the ribbon, while in the zipper they do.

  t

Figure 2 :

 2 Figure2: Poly-tiling τ of scale s = 4 seen as a tiling. The dashed line surrounds the tiling τ (x, y). Note that some tiles from τ (x, y) may be located outside of the "box" of size s situated at (sx, sy), and conversely that some tiles of this box (here, t 12 ) may not belong to τ (x, y).

Figure 3 :

 3 Figure 3: Supertiles assembly for simulating neighborhood N M . The glues consist of the circled elements, they are used to transmit the information diagonally, as indicated by the arrows.

Figure 4 :

 4 Figure 4: Von Neumann-neighborhood zipper, going backwards. The longer it is, the more information (represented by the circles) would need to be encoded in the supertiles.

  Tile of the original zipper with its four glues. Coding of the glues into bumps and dents. (c) Polyomino used to simulate the original tile.

Figure 5 :

 5 Figure 5: Simulation of a von Neumann-neighborhood zipper using a ribbon of microtiles. The three steps of the simulation of a single tile are represented, in each one the gray arrow indicates the direction of the underlying path of the zipper.

Figure 6 :

 6 Figure 6: Communication between tiles in Moore neighborhood.

Figure 7 :

 7 Figure 7: Shape used to simulate a tile in Moore neighborhood, filled with gray for clarity sake. The communication bumps and dents are represented by short thick lines.

Figure 9 :

 9 Figure9: "Pitcher-tiles" used to relay diagonal information, for total-tiling zippers only.

Figure 11 :

 11 Figure11: Detail of the polyomino used for arbitrary linear-neighborhood zippers. Here, n = 2, l = 7, s = 28 and h = 6. The dark gray contour is filled by microtiles, the light gray area is filled for clarity and does not necessarily contain microtiles.

Figure 12 :

 12 Figure 12: The three different paths when the input direction is West.

Lemma 3 . 5 .

 35 A polyomino used to simulate a tile of a (T, N n )-zipper contains B = O(n 2 ) bridges.

Proposition 3 . 8 .

 38 5) bridges of height at most O(n) microtiles, each one at most 3 layers thick. Since s = 4l and we can choose l = ⌈α⌉ = O(|X| n 2 ), after summing all of the above we obtain the result. Lemma 3.7. Every tile of the initial (T, N n )-zipper is simulated by O(|X| n 2 ) different polyominoes. Proof. For each tile t ∈ T , there are 4 (number of input positions)×3 (number of output positions) × B |X| (number of different possible bridges) different paths, where B is the number of bridges on the path. Since B = O(n 2 ) (Lemma 3.5), there are O(|X| n 2 ) different polyominoes for one tile when n ≥ 2. When n = 1, there are no bridges and there are only 12 different polyominoes. In our construction, a T µ -ribbon simulating a (T, N n )-zipper needs |T µ | = O(|T | • |X| 2 n 5 ) microtiles and |X µ | = O(|T | • |X| 2 n 5 ) glues. Proof. A (T, N n )-zipper can use at most |T | tiles, according to our construction each of them is simulated by O(|X| n 2 ) different polyominoes (Lemma 3.7) constituted by O(|X| n 3 ) unique microtiles (Lemma 3.6). Hence the simulation needs |T µ | = O(|T | • |X| 2 n 5

Figure 14 :

 14 Figure 14: Illustration of how spikes shrink from width ax to (a -2)x. The darkest gray corresponds to the spike of the initial tile, lighter grays represent the spike of farther North neighbors.

Figure 15 :

 15 Figure 15: Rotated polyomino simulating a tile of a (T, N 2 )-zipper, with |X| = 2, l = 23, L = 92, h = 38, input direction is West and output direction is South. The microtiles are located in the gray layer, the input and output directions are indicated by the black arrows.

1

 1

Figure 16 :

 16 Figure[START_REF] Kari | Theory of cellular automata: A survey[END_REF]: In dark gray is represented the shape from Fig.13, simulating tile τ (0, 0). It is surrounded by 8 other shapes corresponding to 8 neighboring tiles. Below is a detailed view of the circled communication place, with a bump crossing 4 bridges of width 4. Since the tile at position (1, 2) is absent, one bridge is missing. The other bridges contain either 2 or 3 layers of microtiles, depending on how the input and output microtiles are joined.

Figure 17 :

 17 Figure 17: Replacing bumps and dents by two stairs. Here, there are k = 2 layers to be crossed.

  1 t 2 t 3 t 4 t 5 t 6 t 7 t 8

	(y + 1)s	t 11	t 12
		t 9	t 10
	τ (x, y)
	ys
	xs		(x + 1)s	(x + 2)s

Total tilings can also be seen as bidimensional subshifts of finite type, and studied as such in the field of symbolic dynamics (see[START_REF] Lind | An Introduction to Symbolic Dynamics and Coding[END_REF] for a complete introduction, in dimension 1). In this settings, the "neighborhood" is arbitrary, by definition of the subshift. Although some results exist for subshifts in dimensions greater than 1[25,

[START_REF] Ward | Automorphisms of Z d -subshifts of finite type[END_REF][START_REF] Hochman | On the dynamics and recursive properties of multidimensional symbolic systems[END_REF], they do not apply to partial tilings.

The usual definition of a polyomino (see for example[START_REF] Beauquier | On translating one polyomino to tile the plane[END_REF]) refers to a domain D ⊂ Z 2 , while here we add to this notion a mapping to tiles. Besides, polyominoes are often defined as simply connected sets of squares, i.e., without holes, which is not required in this paper.

A formal proof of this fact could be made using the characterization of polyominoes tiling the plane given in[START_REF] Beauquier | On translating one polyomino to tile the plane[END_REF]. Indeed, the contour word of our polyominoes (without bumps and dents, and filled to match the definition in[START_REF] Beauquier | On translating one polyomino to tile the plane[END_REF]) would prove them to be pseudo-squares.

This research was supported by a Natural Sciences and Engineering Research Council of Canada discovery grant, and by a Canada Research Chair award to L.K.