Polyominoes Simulating Arbitrary-NeighborhoodZippers and Tilings\tnoterefFNANO,sponsors

Polyominoes Simulating Arbitrary-Neighborhood Zippers and Tilings\tnoterefFNANO,sponsors


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.

DNA computing, self-assembly, tilings, polyominoes

topsep=2pt,parsep=0pt,partopsep=0pt,itemsep=2pt \setlist[1]labelindent= \setlist[2]topsep=0pt \newdefinitiondefinitionDefinition[section] \newdefinitionremarkRemark[section] \newdefinitionexampleExample[section] \newproofproofProof \newproofsproofSketch of proof


[FNANO]Some results in Section 3 of this paper were presented at FNANO 2009 conference [17]. \tnotetext[sponsors]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.


[cor]Corresponding author.

1 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 nano-components, 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 [28]; [30]; [1]. In this framework, self-assembling components were modeled by Wang tiles [26], 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 [26] and cellular automata [16], such as the undecidable problem of the tiling of the plane, and the simulation of a Turing machine by a tile system [8]; [20].

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 [23]2. Only relatively few recent results consider more general cases, such as larger neighborhood [4], or a three-dimensional neighborhood [7]. Even the most well-known experimental incarnation of square tiles, the DNA tiles [30]; [31]; [19]; [22]; [13], 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 [4], it was proved that, for any directed tile system, any von Neumann-neighborhood “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 ribbon-path. 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 [24]; [6], 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 [11]; [10], 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 complex-neighborhood 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 [4], 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 [11]. 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.

2 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.

2.1 Tilings, Ribbons, and Zippers

Historically, Wang tiles [26] 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 [16]; [4], i.e., neighborhoods which can contain other tiles than the North, South, West and East tiles. In this paper, a neighborhood is the set of relative coordinates of the neighboring tiles, such that

  • is finite;

  • (a tile can not be one of its neighbors);

  • (if a tile is a neighbor of a tile , then has to be a neighbor of ).

For example, the usual 4-tile neighborhood (called von Neumann neighborhood [16]) is ; the 8-tile Moore neighborhood is .

For the following definitions, a neighborhood and a finite set of glues are fixed. A tile is a tuple where each . Intuitively, is the glue that will be used to match the neighbor located at position relative to the tile . A tile system is a finite set of tiles, used to build larger structures. A tile sticks at position to a tile if the corresponding glues match, i.e., .

A -tiling using tile system in neighborhood (or -neighborhood tiling, or simply tiling when the tile system and its neighborhood are known without ambiguity) is a mapping , where is a subset of the plane, which associates every position with a tile, such that all tiles stick to their neighbors, i.e., for all , for all such that , . Note that tilings are often referred to as “valid” tilings in the literature. The set of all -tilings is denoted .

When , the tiling is said to be total, otherwise it is partial. In addition, if is finite then the partial tiling is also finite. A tiling is connected if its domain is -connected. As suggested in [24], we call polyomino a finite and connected tiling3.

According to the usual definition, a total tiling is periodic if it admits a horizontal and a vertical period , i.e., for all , . We extend this definition to partial tilings as follows: a tiling is periodic if it admits a horizontal and a vertical period such that for all and for all , implies . Note that with this extended definition, all finite tilings are periodic (the periods should be “larger” than the tiling itself).

A tiling is line convex [resp., column convex] if and [resp., and ] imply that for all [resp., for all ], . A tiling is convex if it is both line and column convex.

Two positions of the plane (or, by extension, tiles of a tiling) are said to be adjacent when they are neighbors in the von Neumann sense, i.e., . A path is a sequence of adjacent positions of the plane. Formally, a path is a function , where is a set of consecutive integers, such that for all , and are adjacent. For a given tile system , a -tiled path using tile system is a sequence of adjacent tiles from , i.e., a pair where is a path and a mapping from positions to tiles. We say that a -tiled path is finite when is finite, and we may also call a finite -tiled path a polyomino since it is connected (by definition of the path).

For a tile system defined in von Neumann neighborhood , a -tiled path is a -ribbon using tile system (simply called ribbon when is known without ambiguity) if is injective (non-self-crossing) and for all , , with . The glue is called the output glue of , while is the input glue of . Informally, a ribbon is a sequence of adjacent tiles which stick to their predecessor and successor only (see Fig. 1LABEL:sub@fig:ribbon). Consequently, is not necessarily a tiling.

A -tiled path is a -zipper using tile system in neighborhood (or -neighborhood zipper, or zipper when and are known) if is injective and is a -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. 1LABEL:sub@fig:zipper). Note that zippers can be defined in arbitrary neighborhoods, since it is not required that adjacent glues match. The set of -ribbons is denoted , the set of -zippers .

(a) A ribbon.
(b) A zipper.
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 and are not required to match in the ribbon, while in the zipper they do.

2.2 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 and a vector , we denote the set translated by .


A poly-tiling of scale , using tile system in neighborhood , is a mapping , with , such that

  1. for all , is a finite -tiling;

  2. for all , , ;

  3. for all , and , let ; then implies .

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 are connected and thus polyominoes, since this is what we will construct. In this case, the definition implies that a poly-tiling of scale is

  • a juxtaposition of polyominoes on a grid of size ;

  • such that all these polyominoes do not overlap once shifted to their actual position on the grid, which is achieved by shifting by units to the right and units upwards;

  • neighboring polyominoes stick, i.e., if two tiles of two different polyominoes become neighbors after being shifted, they have to stick.

Figure 2: Poly-tiling of scale seen as a tiling. The dashed line surrounds the tiling . Note that some tiles from may be located outside of the “box” of size situated at , and conversely that some tiles of this box (here, ) may not belong to .

These characteristics allow to consider them as usual “valid” tilings without overlaps, as explained in the following remark.


A poly-tiling of scale can be easily transformed into a “regular” tiling , as depicted in Fig. 2, according to the following formula:

for any which verify , and . Because of condition 2 in the definition of poly-tilings, given any pair , if exist then they are unique. Because of 1 and 3, is indeed a tiling since all glues match.

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


A poly-ribbon of scale , using tile system (in neighborhood ), is a pair where is an injective path and is such that

  1. for all , is a finite -ribbon;

  2. for all , , (where we define , if );

  3. for all , let and be two consecutive ribbons. Let be the last position of , be the first position of , and be their relative position. Then, we must have and .

The new requirement 3 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.2, 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 [resp., ].

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 , 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 , we define as the set of subsets of . Let be a function which associates a tile with a set of finite -tilings of scale , such that for all , for all , (the tile is called the reference tile), and such that if , for all , , , and , then (all tiles from all tilings in are specific to tile ). In our constructions, the finite tilings will be connected polyominoes. Let us introduce one more mapping , which associates any -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 , for some . We obtain which is a restriction of .

  2. Then, discard all the polyominoes in which do not have their reference tile positioned at for some (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).


Given such functions and , a tiling-simulation of a tile system by a tile system is a mapping , such that associates any -tiling with a non-empty subset of poly-tilings (hence tilings) from ; with the additional constraint that for all -tilings , there exists some unique valid -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 -tilings and .

Let us now see how to recover an initial tiling from any -tiling, once a tiling-simulation is defined. Given a poly-tiling , one can restore unambiguously the initial (valid) tiling . Indeed, if denotes the polyomino whose reference tile is located at , then , where is the only image set of containing . 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.2 (since in this case, ).

Moreover, for any other tiling 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 -tiling such that . This tiling can be recovered as explained in the previous paragraph. From the last constraint in Definition 2.2, we also deduce that is valid.

The simulation of a zipper by a ribbon is defined similarly. Let associate a tile with a set of unique finite -ribbons, , such that for all , for all , , and such that if , for all , , , and , then . Also let , which associates any -ribbon with a poly-ribbon as previously, by removing incomplete and misaligned polyominoes.


A zipper-simulation of the tile system by the tile system is a mapping , such that associates any -zipper where with a non-empty subset of poly-ribbons (hence ribbons) from ; with the additional constraint that for all -ribbons , there exists some unique valid -zipper such that .

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

Provided a tiling-simulation exists, we say that simulates if . Similarly, for a zipper-simulation , the ribbon simulates the zipper if . Finally, when no ambiguity is possible, we simply use the term simulation to refer to the simulation of tilings or zippers.

2.3 Total Tilings Constructions

In [3], 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 be a tile system in arbitrary neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any total -tiling can be simulated by a total -tiling.


Let be a -tiling. We replace tiles from by new tiles from called supertiles, each of them encoding all the tiles from and the tile itself. The 4 von Neumann glues encode the neighbors located at (East), (West), (North), and (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 . In this figure, we use the following notation: given a position , let tile . The symbol [resp., , , ] represents the tile [resp., , , ]; and denote the composition of any of the functions .

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

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

The converse is trivial, any total -tiling can be translated back into a unique valid total -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.

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.

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 .

This issue can be partially solved [29], 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.

3 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.

3.1 Preliminary Results

First we recall basic results of simulations of zippers. In [4], 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 be a tile system in neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -zipper can be simulated by a -ribbon.


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 by a unique shape (Figs. 5LABEL:sub@fig:simuVN1 and 5LABEL:sub@fig:simuVN2). 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 -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 , in von Neumann neighborhood and with a new set of glues, which will be used to build the polyominoes simulating the initial tiles from . This leads to a path , 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. 5LABEL:sub@fig:simuVN3). 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 . The path is “filled” by new tiles from the set (we call these microtiles to avoid misunderstandings) using a mapping . The finite -tiled path 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.

(a) Tile of the original zipper with its four glues.
(b) Coding of the glues into bumps and dents.
(c) Polyomino used to simulate the original tile.
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.

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 , where is the input glue of the initial tile and 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 is a -ribbon. The input and output glues are unique among all the polyominoes, so this polyomino is the only possible ribbon using the tile system , 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 on the West or North sides, on the East or South sides).

For a tile , the set contains the 12 polyominoes described above. Then, obviously, if a -tiled path is a -zipper, one can find a “unique” poly-ribbon consisting of the catenation of polyominoes constructed by , which is a -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 , any -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 -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 exists, Definition 2.2 implies that

  • all polyominoes do not overlap (condition 2), hence that the glues they simulate match on the four sides;

  • the polyominoes stick on their input/output tiles (condition 3), hence that the polyominoes follow a path.

Using this path and these glues, one can uniquely restore the initial -zipper. ∎

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


Let be the equivalence relation which states that two -ribbons are equivalent if they represent the same -zipper. Then, the simulation is a bijection between the set of -zippers and the set of -ribbons quotiented by , .

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.


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 (i.e., adding diagonal communications) is more complex, because diagonal glues cross, as illustrated in Fig. 6.

Figure 6: Communication between tiles in Moore neighborhood.

The consequence is that diagonal bumps would also have to cross each other. This issue is solved in [11] using a method that we summarize here, because it will turn out to be useful in our constructions.

Theorem 3.2 ([11])

Let be a tile system in neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -zipper can be simulated by a -ribbon.


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 . In Figs. 7LABEL:sub@fig:moore1 and 7LABEL:sub@fig:moore2 we present a picture of the shape that can be used to simulate an initial tile of . It differs slightly from the shape described in [11], but the idea is the same and this new shape is an introduction to our results.

(a) A single shape. Next to the communication places is written the neighbor it communicates with.
(b) The shape and its 8 neighbors.
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.

This shape is turned into a polyomino using new microtiles from , 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. 7LABEL:sub@fig:moore2). 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 and its Northwest neighbor , as well as between the tiles and . This can be accomplished by a geometrical construction such as the one in Figs. 8LABEL:sub@fig:cross1a and 8LABEL:sub@fig:cross1b.

(a) Glues matching between and .
(b) Glues not matching: the ribbons overlap.
Figure 8: “Crossing” of information. The top ribbon segment is part of , the bottom ribbon segment is part of , and the space in between can be filled by 2 layers of microtiles for to actually reach .

This construction checks the match between the and in the old-fashioned way, by physically matching the adjacent bump and dent of the corresponding polyominoes. The novelty of this construction is that the glue-match between and is accomplished without the respective polyominoes ever touching. Moreover, this construction works even in the case of partial tilings where the tile 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 , the bump of should be 3 microtiles high, and the dent of should be 8 microtiles wide and 3 microtiles deep. In the sequel, the inner layers of are called bridges.

For any tile , if a polyomino in the set has a bridge, then 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, contains copies of each of the polyominoes given by the above construction, for the possible locations of the bridges (one per glue).

The end of the proof, which consists in restoring a -zipper from any -ribbon, is similar to the proof of Theorem 3.1 and is left to the reader. ∎


A simpler construction [2] 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 polyomino which conveys information to as “information carrier” to transmit information from to . This construction does not work as such in the case of zippers which are partial tilings, because the “carrier” tile might be altogether absent.

Figure 9: “Pitcher-tiles” used to relay diagonal information, for total-tiling zippers only.

This idea is similar to the one suggested in Remark 3.1, 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.

3.2 Simulating Arbitrary Linear Neighborhoods

We call linear neighborhood a neighborhood such that if then . 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 [10], 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 .


For a given set of glues , any tile system defined in linear neighborhood can be replaced by an equivalent tile system in an appropriate connected linear neighborhood . Indeed, let be such that , let be an arbitrary “dummy” glue and a tile system in neighborhood , where is defined for all and by

Then, clearly, is a -tiling if and only if defined by is a -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 layers, the bump must be microtiles high, the dent must be microtiles wide and microtiles deep.


The result is obtained by an immediate generalization of Fig. 8LABEL:sub@fig:cross1a to  white layers instead of . ∎

We now prove the main result of this section for neighborhoods .

Theorem 3.4

Let be a tile system in connected linear neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -zipper can be simulated by a -ribbon.


As previously, we are going to replace a tile of the -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 .

Figure 10: General shape simulating a tile in arbitrary linear neighborhood. In this example, the neighborhood is , , , , , . 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.

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 , the bump will cross other spikes, we will see later how many layers of microtiles it represents. Indeed, the essential part of the simulation is the discretization of this shape into a polyomino of microtiles. A final polyomino is represented in Fig. 11.

Figure 11: Detail of the polyomino used for arbitrary linear-neighborhood zippers. Here, , , and . The dark gray contour is filled by microtiles, the light gray area is filled for clarity and does not necessarily contain microtiles.

We define the following variables. The height of the polyomino is microtiles, it is also the width of the initial tile and therefore the scale of the final poly-ribbon. The vertical space between the top of the polyomino and the beginning of the spike is denoted , and since the spike is centered, the space between the end of the spike and the bottom is also . Finally, the spike is a succession of horizontal segments of microtiles, thus the slope of the spike is . Then, the following constraints have to be respected when constructing the polyomino.

  • The integer has to be as large as necessary, leaving enough horizontal space for crossings, as suggested by Lemma 3.3. Similarly, needs to provide enough vertical space for the dents. Formally, and , 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. 5LABEL:sub@fig:simuVN3). As a consequence, and , since the inner layer of the spike must go down by before reaching . The first constraint can be removed (assuming ), while the second one can be replaced by (provided , which is the case if ), so that can be exactly divided in 4 horizontal segments everywhere on the spike.

  • The initial tile being a square, the height is and can also be written (the spike goes microtiles to the right at slope ). Therefore, after replacing both by , we have .

Since , because of the last equation has to be greater than . For given , a solution of the system is then

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 polyominoes4.

We now give some details on how the communications take place. For a more convenient description, we split the polyomino into horizontal parts of width , we denote them from left to right by part  (which corresponds to the initial square tile) to part  (end of the spike). Each of these parts is divided into  horizontal segments of length , denoted segment  to segment . As suggested in Fig. 10, the bumps and bridges are located on the horizontal segments on the top of the spike in parts  to , while the corresponding dents are on the horizontal steps on the top of the hole in part . For every , the glue 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 to segment , hence each segment is used for or glues. This space is then used in part  for a dent, in parts  to  for bridges, and in part  for the bump.

Moreover, there are spikes to cross by the bump encoding . Each spike is  layers thick, hence there are at most layers to cross. This number is fixed, so we can apply Lemma 3.3 with : each glue needs a horizontal space of microtiles. This gives a lower bound to , which has to be greater than . After adding microtiles to separate the dents from the sides of the polyomino, we define

as the lower bound for used previously. On the other hand, the depth of the dents is . Consequently, we have another constraint on which must be greater than (space for the biggest dent plus the three original layers). This means greater than , which is already the case because . Then,

This ensures that our polyomino can be constructed, using an appropriate set of microtiles which will generate the -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 is even, the middle of a side is chosen after 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).

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

Finally, putting the appropriate polyominoes one after the other generates a poly-ribbon which is in fact a -ribbon. As it was shown before, any -ribbon can be transformed into a poly-ribbon with , from which one can restore the original -zipper using . The poly-ribbon does not overlap if and only if the glues from the -zipper match everywhere, hence is a simulation. ∎

3.3 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.

Lemma 3.5

A polyomino used to simulate a tile of a -zipper contains bridges.


When , there is one bridge between the neighbors at and at ; when , there are in addition two bridges between neighbors and , and and . In general, there are bridges between and for , plus bridges between and for , and so on. Hence there are bridges. ∎

Lemma 3.6

A polyomino used to simulate a tile of a -zipper is constituted by microtiles.


Drawing the contour of a shape requires:

  • microtiles for the  horizontal segments in part ;

  • microtiles for all  vertical portions;

  • microtiles for the 2 spikes ( for the horizontal segments, for the steps down and up);

  • at most microtiles for joining input and output microtiles (worst case when joining left to bottom);

  • bumps and dents of height at most microtiles;

  • (Lemma 3.5) bridges of height at most microtiles, each one at most  layers thick.

Since and we can choose , after summing all of the above we obtain the result. ∎

Lemma 3.7

Every tile of the initial -zipper is simulated by different polyominoes.


For each tile , there are (number of input positions) (number of output positions) (number of different possible bridges) different paths, where is the number of bridges on the path. Since (Lemma 3.5), there are different polyominoes for one tile when . When , there are no bridges and there are only 12 different polyominoes. ∎

Proposition 3.8

In our construction, a -ribbon simulating a -zipper needs microtiles and glues.


A -zipper can use at most tiles, according to our construction each of them is simulated by different polyominoes (Lemma 3.7) constituted by unique microtiles (Lemma 3.6). Hence the simulation needs 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 glues. The other two glues are and , and the input and output glues microtiles use glues from , which does not change the order of magnitude of . ∎

3.4 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.2, any neighborhood can be replaced by an equivalent rectangular neighborhood containing .

Theorem 3.9

Let be a tile system in rectangular neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -zipper can be simulated by a -ribbon.


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 spikes of length , each of them being a “sheath” for the next one (Fig. 13).

Figure 13: Shape simulating a tile defined in a rectangular neighborhood of size (here and ). 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 , for ) and West (from , for ) communications are received in the area marked  on the picture. This works very similarly to the linear-neighborhood case.

  • Northwest communications (from , for and ) are received in . Again, it is not difficult to see how the information crosses the layers.

  • Southwest communications (from , for and ) are received in . 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 , and  (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 the width and height of the initial tile, hence the scale of the poly-ribbon. Let be the width of  and of all the other horizontal subdivisions of . Since there are two of these blocks for each of the first vertical spikes, plus one for the last spike, it holds that . As in Theorem 3.4, we need the spike to be  layers wide, hence the slope of the spikes is defined by such that . Again it is possible to decide that , i.e., a block is made of four descending horizontal segments. Finally, let be the left height of the -- areas. The fact that the initial tile is a square is expressed by . We have the following equations:

Besides, to ensure enough space for the bumps and dents, we want to make sure that and are as big as necessary, i.e., and (the exact values of and will be given later). Once solved, the system gives . Since should be greater than and greater than , needs to be greater than . Thus, a solution to the system which guarantees that the polyomino can be constructed is

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.

Figure 14: Illustration of how spikes shrink from width to . The darkest gray corresponds to the spike of the initial tile, lighter grays represent the spike of farther North neighbors.

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 microtiles on the left and on the right by going down tiles (remember that the slope of the spikes is ). Remark the slight asymmetry of the shrinking, which has to take place after reaching height 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 obtained for the diagonal communication between a tile and its neighbor located at , which crosses spikes of thickness layers, hence a total number of layers. It follows that 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 horizontal space, plus an extra microtiles for the different glues. The size has to allow dents in , dents in  and . Hence, after adding microtiles for preserving the borders of the block, , with .

The rest of the proof (positioning and joining the input and output microtiles, bijection between a -zipper and a set of unique poly-ribbons) is unchanged from the proof of Theorem 3.4. ∎

Corollary 3.10

Let be a tile system in arbitrary neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -zipper can be simulated by a -ribbon.

Remark 3.1 can be extended to the general case, hence any -ribbon represents a unique -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 linear-neighborhood -zipper, with .

Figure 15: Rotated polyomino simulating a tile of a -zipper, with , , , , 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.

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 and the 8 other shapes are shown, one of them is detailed at the bottom of the picture.

Figure 16: In dark gray is represented the shape from Fig. 13, simulating tile . 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 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.

4 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 poly-tilings, to obtain our second main result (Corollary 4.2). Before that, we describe a simpler construction used in [3], 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.

4.1 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 arbitrary-neighborhood 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 be a tile system in rectangular neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -tiling can be simulated by a -tiling.


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 -ribbon into a -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 . For North and East glues, 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 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 , since it has to match with the top-right tile of the polyomino adjacent on the right. Note that and (see Fig. 13), therefore the number of these glues is bounded, once and are fixed. These glue do not need to encode any information from the original set of glues , since this matching will be enforced by the shape of the polyominoes. Their role is only to align properly the polyominoes.

Then, each -tiling is associated with a set of -tilings by this construction. Conversely, any -tiling can be turned into a poly-tiling using the tile system in neighborhood , by discarding incomplete and misaligned polyominoes using a function . Then, starting from the poly-tiling , one can recover the initial tiles at their respective positions, with the help of the function applied to the unique sets containing each of the complete polyominoes. By construction, this -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 [10]. 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 be a tile system in arbitrary neighborhood , with set of glues . There exist a simulation and a tile system in neighborhood , with set of glues , such that any -tiling can be simulated by a -tiling.

4.2 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 -tiling is simulated by a partial -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 be a tile system in arbitrary neighborhood , with set of glues . There exists a simulation such that every -tiling is total if and only if all -tilings in are total.

Note that when is total, is a singleton. Indeed, the polyominoes of 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