Bruno Durand

Andrei Romashchenko

Alexander Shen

Fixed-point tile sets and their applications *

An aperiodic tile set was first constructed by R. Berger while proving the undecidability of the domino problem. It turned out that aperiodic tile sets appear in many fields, ranging from logic (the Entscheidungsproblem) to physics (quasicrystals).

We present a new construction of an aperiodic tile set that is based on Kleene's fixed-point construction instead of geometric arguments. This construction is similar to J. von Neumann's self-reproducing automata; similar ideas were also used by P. Gács in the context of error-correcting computations.

.

Introduction

In this paper, tiles are unit squares with colored sides. Tiles are considered as prototypes: we may place translated copies of the same tile into different cells of a cell paper (rotations are not allowed). Tiles in the neighbor cells should match (i.e., the common sides should each have the same color).

Formally speaking, we consider a finite set C of colors. A tile is a quadruple of colors (left, right, top, and bottom ones), i.e., an element of C 4 . A tile set is a subset τ ⊂ C 4 . A tiling of the plane with tiles from τ (τ-tiling) is a mapping U : Z 2 → τ that respects the color-matching condition.

A tiling U is periodic if it has a period, i.e., a nonzero vector T ∈ Z 2 such that U(x + T ) = U(x) for all x ∈ Z 2 . Otherwise, the tiling is aperiodic. The following classical result was proved in [START_REF] Berger | The Undecidability of the Domino Problem[END_REF]: Theorem 1. There exists a tile set τ such that τ-tilings exist and all of them are aperiodic.

The construction from the proof of Theorem 1 was used in [START_REF] Berger | The Undecidability of the Domino Problem[END_REF] as the main tool to prove Berger's theorem:

The domino problem (to find out whether or not a given tile set has tilings) is undecidable.

The first tile set of Berger was rather complicated. Later, many other constructions were suggested. Some of them are simplified versions of Berger's construction ( [START_REF] Robinson | Undecidability and Nonperiodicity for Tilings of the Plane[END_REF]; see also the expositions in [START_REF] Allauzen | Appendix A: Tiling Problems[END_REF][START_REF] Durand | Local Rules and Global Order, or Aperiodic Tilings[END_REF][START_REF] Levin | Aperiodic Tilings: Breaking Translational Symmetry[END_REF]). Some others are based on polygonal tilings (including the famous Penrose and Ammann tilings; see [START_REF] Grünbaum | Tilings and Patterns[END_REF]). An ingenious construction suggested in [START_REF] Kari | A Small Aperiodic Set of Wang tiles[END_REF] is based on multiplication in a kind of positional number system and gives a small aperiodic set of 14 tiles (and in [START_REF] Culik | An Aperiodic Set of 13 Wang Tiles[END_REF] an improved version with 13 tiles is presented). Another nice construction with a short and simple proof (based explicitly on ideas of self-similarity) was recently proposed in [START_REF] Ollinger | Two-by-two Substitution Systems and the Undecidability of the Domino Problem[END_REF].

In this paper, we present yet another construction of an aperiodic tile set. It does not provide a small tile set; however, we find it interesting for the following reasons:

• The existence of an aperiodic tile set becomes a simple application of the classical construction used in Kleene's fixed-point (recursion) theorem, in von Neumann's self-reproducing automata [START_REF] Neumann | Theory of Self-reproducing Automata[END_REF], and, more recently, in Gács' reliable cellular automata [START_REF] Gács | Reliable Cellular Automata with Self-Organization[END_REF][START_REF] Gács | Reliable Cellular Automata with Self-Organization[END_REF]; we do not use any geometric tricks. An aperiodic tile set is not only an interesting result but an important tool (e.g., this construction was invented to prove that the domino problem is undecidable); our construction makes this tool easier to use.

• The construction is rather general, so it is flexible enough to achieve some additional properties of the tile set. We illustrate this flexibility by providing new proofs for several known results and proving new results; these new results add robustness (resistance to sparse enough errors) to known results about aperiodic tile sets and tile sets that have only complex tilings.

It is unclear whether this kind of robustness can be achieved for previously known constructions of tile sets. On the other hand, robustness properties appear to be important. For example, mathematical models for processes such as quasicrystal growth or DNA computation should take errors into account. Note that our model (with its independent choice of places where errors are allowed) has no direct physical meaning; it is just a simple mathematical model that can be used as a playground to develop tools for estimating the consequences of tiling errors.

The paper is organized as follows:

• In Section 2, we present the fixed-point construction of an aperiodic tile set (new proof of Berger's theorem), and we illustrate the flexibility of this construction by several examples.

• In Section 3, we show that any "uniform" substitution rule can be implemented by a tile set (thus providing a new proof for this rather old result).

• In Section 4, we use substitutions to show that there are strongly aperiodic tile sets (which means that any tiling is strongly aperiodic, i.e., any shift changes at least some fixed fraction of tiles).

• The fixed-point construction of Section 2 provides a self-similar tiling: Blocks of size n × n ("macrotiles") behave exactly as individual tiles, so on the next level we have n 2 × n 2 blocks made of n × n macro-tiles that have the same behavior, etc. In Section 5, we make some changes in our construction that allow us to get variable zoom factors (the numbers of tiles in macro-tiles increase as the level increases).

Variable zoom factor tilings can be used for simulating computations (with higher levels performing more computation steps); we use them to give a simple proof of the undecidability of the domino problem. The main technical difficulty in the standard proof was to synchronize computations on different levels. In our construction this is not needed. We show also that other undecidability results can be obtained in this way.

• This technique can be used to push the strong aperiodicity to its limits: The distance between every tiling and every periodic configuration (or between every tiling and its nontrivial shift) can be made arbitrarily close to 1, not only separated from 0. This is done in Section 6 using an additional tool: error-correcting codes.

• In [START_REF] Durand | Complex Tilings[END_REF], a tile set was constructed such that every tiling has maximal Kolmogorov complexity of fragments (Ω(n) for n × n squares); all tilings for this tile set are noncomputable (thereby implying a classical result of Hanf [START_REF] Hanf | Nonrecursive Tilings of the Plane, I[END_REF] and Myers [START_REF] Myers | Nonrecursive Tilings of the Plane, II[END_REF] as a corollary). The construction in [START_REF] Durand | Complex Tilings[END_REF] was rather complicated and was based on a classical construction of an aperiodic tile set. In Section 7, we provide another proof of the same result that uses variable zoom factors. It is simpler in some respects and can be generalized to produce robust tile sets with complex tiling, which is our main result (Section 13).

• In Section 8, we use the same technique to give a new proof for some results by Simpson [START_REF] Simpson | Medvedev degrees of 2-dimensional subshifts of finite type[END_REF] and Hochman [START_REF] Hochman | On the Dynamic and Recursive Properties of Multidimensional Symbolic Systems[END_REF] about effectively closed subshifts: Every one-dimensional effectively closed subshift can be obtained as a projection of some two-dimensional subshift of finite type (in an extended alphabet). Our construction provides a solution of Problem 9.1 from [START_REF] Hochman | On the Dynamic and Recursive Properties of Multidimensional Symbolic Systems[END_REF]. (Another solution, based on the classical Robinson-type construction, was independently suggested by Aubrun and Sablik; see [START_REF] Aubrun | Simulation of recursively enumerable subshifts by two-dimensional SFT and a generalization[END_REF].)

• To prove the robustness of tile sets against sparse errors we use a hierarchical classification of the elements of random sets into islands of different levels (a method that goes back to Gács [START_REF] Gács | Reliable Cellular Automata with Self-Organization[END_REF][START_REF] Gray | A Reader's Guide to Gács' Positive Rates Paper[END_REF]). This method is described in Section 9.1. In Section 9.2, we give definitions and establish some probabilistic results about islands that are used later to prove robustness. We show that a sparse random set on Z 2 with probability 1 (for Bernoulli distribution) can be represented as a union of "islands" of different ranks. The higher the rank, the bigger is the size of an island; the islands are well isolated from each other (i.e., in some neighborhood of an island of rank k, there are no other islands of rank ≥ k).

Then, in Section 9.3, we illustrate these tools using standard results of percolation theory as a model example. In Section 9.4, we modify the definition of an island by allowing two (but not three!) islands of the same rank to be close to each other. This more complicated definition is necessary to obtain the most technically involved result of the paper in Section 13 but can be skipped if the reader is interested in the other results.

• In Section 10, we use a fixed-point construction to get an aperiodic tile set that is robust in the following sense: If a tiling has a "hole" of size n, then this hole can be patched by changing only an O(n)-size zone around it. Moreover, we do not need for this a tiling of the entire plane. An O(n) zone (with bigger constant in O notation) around the hole is enough.

• In Section 11, we explain how to get robust aperiodic tile sets with variable zoom factors. Again, this material is used in Section 13 only.

• In Section 12, we combine the developed techniques to establish one of our main results: There exists a tile set such that every tiling of the plane minus a sparse set of random points is far from every periodic tiling.

• Finally, Section 13 contains our most technically difficult result: a robust tile set such that all tilings, even with sparsely placed holes, have linear complexity of fragments. To this end we need to combine all our techniques: fixed-point construction with variable zoom factors, splitting of a random set into doubled islands (we shall call them bi-islands), and "robustification" with filling of holes.

2 Fixed-point aperiodic tile set

Macro-tiles and simulation

Fix a tile set τ and an integer N > 1 (zoom factor). A macro-tile is an N × N square tiled by τ-tiles matching each other (i.e., a square block of N 2 tiles with no color conflicts inside). We can consider macro-tiles as "preassembled" blocks of tiles; instead of tiling the plane with individual tiles, we may use macro-tiles. To get a correct τ-tiling in this way, we need only to ensure that neighbor macro-tiles have matching macrocolors, so there are no color mismatches on the borders between macro-tiles. More formally, by macro-color we mean a sequence of N colors on the side of a macro-tile (i.e., the right macro-color is a sequence of the right colors of the tiles on the right edge of a macro-tile, and the same for the left, the top, and the bottom macro-color). Each macro-tile has four macro-colors (one for each side). We always assume that macro-tiles are placed side to side, so the plane is split into N × N squares by vertical and horizontal lines.

In the following we are interested in the situation when τ-tilings can be split uniquely into macro-tiles that behave like tiles from some other tile set ρ. Formally, let us define the notion of a simulation.

Let τ and ρ be two tile sets, and let N > 1 be an integer. By simulation of ρ by τ with zoom factor N we mean a mapping S of ρ-tiles into N × N τ-macro-tiles such that the following properties hold:

• S is injective (i.e., different tiles are mapped into different macro-tiles).

• Two tiles r 1 and r 2 match if and only if their images S(r 1 ) and S(r 2 ) match. This means that the right color of r 1 equals the left color of r 2 if and only if the right macro-color of S(r 1 ) equals the left macro-color of S(r 2 ), and the same is true in the vertical direction.

• Every τ-tiling can be split by vertical and horizontal lines into N × N macro-tiles that belong to the range of S, and such a splitting in unique.

The second condition guarantees that every ρ-tiling can be transformed into a τ-tiling by replacing each tile r ∈ ρ by its image, macro-tile S(r). Taking into account other conditions, we conclude that every τtiling can be obtained in this way, and the positions of grid lines as well as the corresponding ρ-tiles can be reconstructed uniquely.

Example 1 (negative). Assume that τ consists of one tile with four white sides. Fix some N > 1.

There exists a single macro-tile of size N × N. Does this mean that τ simulates itself (when its only tile is mapped to the only macro-tile)? No. The first and second conditions are true, but the third one is false: The placement of cutting lines is not unique. Example 2 (positive). In this example ρ consists of one tile with all white sides. The tile set τ consists of N 2 tiles indexed by pairs (i, j) of integers modulo N. A tile from τ has colors on its sides as shown on Fig. 1 (each color is a pair of integers modulo N, so set C of all colors consists of N 2 elements). The simulation maps the single ρ-tile to a macro-tile that has colors (0, 0), . . . , (0, N -1) and (0, 0), . . . , (N -1, 0) on its vertical and horizontal borders, respectively (see Fig. 1).

Definition.

A self-similar tile set is a tile set that simulates itself.

The idea of self-similarity is used (more or less explicitly) in most constructions of aperiodic tile sets (but [START_REF] Kari | A Small Aperiodic Set of Wang tiles[END_REF][START_REF] Culik | An Aperiodic Set of 13 Wang Tiles[END_REF] are exceptions). However, not all of these constructions provide literally self-similar tile sets in our sense.

It is easy to see that self-similarity guarantees aperiodicity.

Proposition 1. A self-similar tile set τ may have only aperiodic tilings.

Proof. Let S be a simulation of τ by itself with zoom factor N. By definition, every τ-tiling U can be uniquely split into N × N macro-tiles from the range of S. So every period T of U is a multiple of N (since the T -shift of a cut is also a cut, the shift should respect borders between macro-tiles). Replacing each macro-tile by its S-preimage, we get a τ-tiling that has period T /N. Therefore, T /N is again a multiple of N. Iterating this argument, we conclude that T is divisible by N k for every k, so T .

Note also that every self-similar tile set has arbitrarily large finite tilings. Starting with some tile, we apply S iteratively and get a big tiled square. The standard compactness argument guarantees the existence of a tiling of the entire plane. Therefore, to prove the existence of aperiodic tile sets it is enough to construct a self-similar tile set.

Theorem 2. There exists a self-similar tile set τ.

Theorem 2 was explicitly formulated and proven by Ollinger [START_REF] Ollinger | Two-by-two Substitution Systems and the Undecidability of the Domino Problem[END_REF]; in his proof a self-similar tile set (consisting of 104 tiles) is constructed explicitly. This tile set is then used to implement substitution rules (cf. Theorem 3 below). Another example of a self-similar tile set (with many more tiles) is given in [START_REF] Durand | Local Rules and Global Order, or Aperiodic Tilings[END_REF]. (Note that the definition of self-similarity used in [START_REF] Durand | Local Rules and Global Order, or Aperiodic Tilings[END_REF] is a bit stronger.)

We prefer a less specific and more flexible argument based on the fixed-point idea. Our proof works for a vast class of tile sets (though we cannot provide explicitly an aperiodic tile set of a reasonably small size). The rest of this section is devoted to our proof of Theorem 2. Before we prove this result, we explain a few techniques used in our construction and show how to simulate a given tile set by embedding computations.

Simulating a tile set

Let us start with some informal discussion. Assume that we have a tile set ρ whose colors are k-bit strings (C = {0, 1} k ) and the set of tiles ρ ⊂ C 4 is presented as a predicate R(c 1 , c 2 , c 3 , c 4 ) with four k-bit arguments. Assume that we have some Turing machine R that computes R. Let us show how to simulate ρ using some other tile set τ.

This construction extends Example 2, but it simulates a tile set ρ that contains not a single tile but many tiles. We keep the coordinate system modulo N embedded into tiles of τ; these coordinates guarantee that all τ-tilings can be uniquely split into blocks of size N × N and every tile "knows" its position in the block (as in Example 2). In addition to the coordinate system, now each tile in τ carries supplementary colors (from a finite set specified below) on its sides. These colors form a new "layer" which is superimposed with the old one; i.e., the set of colors is now a Cartesian product of the old one and the set of colors used in this layer.

On the border of a macro-tile (i.e., when one of the coordinates is zero) only two supplementary colors (say, 0 and 1) are allowed. So the macro-color encodes a string of N bits (where N is the size of macro-tiles). We assume that N is much bigger than k and let k bits in the middle of macro-tile sides represent colors from C. All other bits on the sides are zeros. (This is a restriction on tiles: Each tile "knows" its coordinates so it also knows whether nonzero supplementary colors are allowed.)

Now we need additional restrictions on tiles in τ that guarantee that macro-colors on the sides of each macro-tile satisfy relation R. To achieve this, we ensure that bits from the macro-tile sides are transferred to the central part of the tile where the checking computation of R is simulated (Fig. 2).

Turing machine

Figure 2: Wires and processing zones; wires appear quite narrow since N ≫ k.

For that we need to fix which tiles in a macro-tile form "wires" (this can be done in any reasonable way; we assume that wires do not cross each other) and then require that each of these tiles carries equal bits on two sides (so some bit propagates along the entire wire); again this is easy to arrange since each tile knows its coordinates.

Then, we check R by a local rule that guarantees that the central part of a macro-tile represents a timespace diagram of R's computation (with the tape being horizontal, and time increasing upward). This is done in a standard way: The time-space diagram (tableau) of a Turing machine computation can be described by local rules, and these rules can be embedded into a tile set 1 (see details in, e.g., [START_REF] Allauzen | Appendix A: Tiling Problems[END_REF][START_REF] Grünbaum | Tilings and Patterns[END_REF]). We require that computation terminates in an accepting state; if not, the tiling cannot be formed.

To make this construction work, the size of the macro-tile (N) should be large enough; we need enough space for k bits to propagate and enough time and space (= height and width) for all accepting computations of R to terminate.

In this construction the number of supplementary colors depends on the machine R (the more states it has, the more colors are needed in the computation zone). To avoid this dependency, we replace R by a fixed universal Turing machine U that runs a program simulating R. Let us agree that the tape of the universal Turing machine has an additional read-only layer. Each cell carries a bit that is not changed during the computation; these bits are used as a program for the universal machine U . (We may assume that the program bits occupy some part of the reserved read-only layer, e.g., the leftmost bits on this layer; see Fig. 3.) In terms of our simulation, the columns of the computation zone carry unchanged bits (considered as a program for U), and the tile set restrictions guarantee that the central zone represents the record (timespace diagram) of an accepting computation of U (with this program). In this way, we get a tile set τ that simulates ρ with zoom factor N using O(N 2 ) tiles. (Again we need N to be large enough, but the constant in O(N 2 ) does not depend on N.)

Simulating itself

We know how to simulate a given tile set ρ (represented as a program for the universal Turing machine) by another tile set τ with a large enough zoom factor N. Now we want τ to be identical to ρ in which case Proposition 1 guarantees aperiodicity). For this we use a construction that follows the proof of Kleene's recursion (fixed-point) theorem.

We cannot refer here to the statement of the theorem; we need to recall its proof and adapt it to our framework. Kleene's theorem [START_REF] Rogers | The Theory of Recursive Functions and Effective Computability[END_REF] says that for every computable transformation π of programs one can find a program p such that p and π(p) are equivalent, i.e., produce the same output. (For simplicity we consider programs with no input, but this restriction does not really matter.) In other words, there is no guaranteed way to transform a given program p into some other program π(p) that produces different output. As a sketch of the proof, first we note that the statement is language-independent since we may use translations in both directions before and after π. Therefore, without loss of generality, we may assume that the programming language has some special properties. First, we assume that it has a function GetText() that returns the text of the program (or a pointer to a memory address where the program text is kept). Second, we assume that the language contains an interpreter function Execute(string s) that interprets the content of its string argument s as a program written in the same language. It is not difficult to develop such a language and write an interpreter for it. Indeed, the interpreter can access the program text anyway, so it can copy the text into some string variable. The interpreter also can recursively call itself with another program as an argument when it sees the Execute call. If our language has these properties, it is easy to construct the fixed point for π: Just take the program Execute(π(GetText())).

This theorem shows that a kind of self-reference, in which we write the program as if its full text is already given to us, is still acceptable. A classical example is a program that prints its own text. The proof shows a way how to do this by using a computation model where the immutable text of the program is accessible to it.

Constructing a self-similar tiling, we have the same kind of problems. We have already seen how to construct a tile set τ that simulates a given tile set ρ. [Counterpart: It is easy to write a program that prints any given text.] What we need is to construct a tile set that simulates itself. [Counterpart: What we need is to write a program that prints its own text.]

Let us look again at our construction that transforms the description of ρ (a Turing machine that computes the corresponding predicate) into a tile set τ that simulates ρ. Note that most rules of τ do not depend on the program for R, dealing with information transfer along the wires, the vertical propagation of unchanged program bits, and the space-time diagram for the universal Turing machine in the computation zone. Making these rules a part of ρ's definition (by letting k = 2 log N + O(1) and encoding O(N 2 ) colors by 2 log N + O(1) bits), we get a program that checks that macro-tiles behave like τ-tiles in this respect. Macro-tiles of the second level ("macro-macro-tiles") made of them would have the correct structure, wires that transmit bits to the computation zone, and even the record of some computation in this zone, but this computation could have an arbitrary program. Therefore, at the third level all the structure is lost.

What do we need to add to our construction to close the circle and get self-simulation? The only remaining part of the rules for τ (not implemented yet at the level of macro-tiles) is the hard-wired program. We need to ensure that macro-tiles carry the same program as τ-tiles do. For that our program (for the universal Turing machine) needs to access the bits of its own text. As we have discussed, this self-referential action is in fact quite legal: The program is written on the tape, and the machine can read it. The program checks that if a macro-tile belongs to the first line of the computation zone, this macro-tile carries the correct bit of the program.

How should we choose N (hard-wired in the program)? We need it to be large enough so the computation described above (which deals with O(log N) bits) can fit in the computation zone. Note that the computation never deals with the list of tiles in τ or a truth table of the corresponding 4-ary relation on bit strings; all these objects are represented by programs that describe them. The computation needs to check simple things only: that numbers in the 0, . . . , N -1 range on four sides are consistent with each other, that rules for wires and computation time-space diagram are observed, that program bits on the next level coincide with actual program bits, etc. All these computations are rather simple. They are polynomial in the input size, which is O(log N)), so for large N they easily fit in Ω(N) available time and space.

This finishes the construction of a self-similar aperiodic tile set.

Remark. Let us also make a remark that will be useful later. We defined a tile set as a subset of C 4 , where C is a set of colors. Using this definition, we do not allow different tiles to have the same colors on their sides. The only information carried by the tile is kept on its sides. However, sometimes a more general definition is preferable. We can define a tile set as a finite set T together with a mapping of T into C 4 . Elements of T are tiles, and the mapping tells us for each tile which colors it has on its four sides. One can easily extend the notions of macro-tiles and simulation to this case. In fact, macro-tiles are well suited to this definition since they already may carry information that is not reflected in the side macrocolors. The construction of a self-similar tile set also can be adapted. For example, we can construct a self-similar tile set where each tile carries an auxiliary bit, i.e., exists in two copies having the same side colors. Since the tile set is self-similar, every macro-tile at every level of the hierarchy also carries one auxiliary bit, and the bits at different levels and in different macro-tiles are unrelated to each other. Note that the total density of information contained in a tiling is still finite, since the density of information contained in auxiliary bits assigned to high-level macro-tiles decreases with level as a geometric sequence.

Implementing substitution rules

The construction of a self-similar tiling is rather flexible and can be easily augmented to get a self-similar tiling with additional properties. Our first illustration is the simulation of substitution rules.

Let A be some finite alphabet and m > 1 be an integer. A substitution rule is a mapping s : A → A m×m . This mapping can be naturally extended to A-configurations. By A-configuration we mean an integer lattice filled with A-letters, i.e., a mapping Z 2 → A considered modulo translations. A substitution rule s applied to a configuration X produces another configuration s(X) where each letter a ∈ A is replaced by an m × m matrix s(a).

We say that a configuration X is compatible with substitution rule s if there exists an infinite sequence

• • • s → X 3 s → X 2 s → X 1 s → X,
where X i are some configurations. This definition was proposed in [START_REF] Ollinger | Two-by-two Substitution Systems and the Undecidability of the Domino Problem[END_REF]. The classical definition (used, in particular, in [START_REF] Mozes | Tilings, Substitution Systems and Dynamical Systems Generated by Them[END_REF]) is slightly different: Configuration X : Z 2 → A is said to be compatible with a substitution rule s if every finite part of X occurs inside of some s (n) (a) (for some n ∈ N and some a ∈ A). We prefer the first approach since it looks more natural in the context of tilings. However, all our results can be reformulated and proven (with some technical efforts) for the other version of the definition; we do not go into details here. Example 3. Let A = {0, 1}, s(0) = ( 0 1 1 0 ), s(1) = ( 0 1 1 0 ). It is easy to see that the only configuration compatible with s is the chess-board coloring where zeros and ones alternate horizontally and vertically.

Example 4 (Fig. 4). Let A = {0, 1},

s(0) = ( 0 1 1 0 ), s(1) = ( 1 0 0 1 ).
One can check that all configurations that are compatible with this substitution rule (called Thue-Morse configurations in the following) are aperiodic. (In Section 4 we will prove a stronger version of this fact.) One may note, for example, that every configuration compatible with this substitution rule can be uniquely decomposed into disjoint 2 × 2 blocks ( 0 1 1 0 ) and ( 1 0 0 1 ) by vertical and horizontal lines; since neighbor cells of the same color should be separated by one of those lines, the position of the lines is unique. Then, we can apply the argument from Proposition 1 (with N = 2). The following theorem goes back to Mozes [START_REF] Mozes | Tilings, Substitution Systems and Dynamical Systems Generated by Them[END_REF]. It says that every substitution rule can be enforced by a tile set. Theorem 3. Let A be an alphabet and let s be a substitution rule over A. Then, there exist a tile set τ and a mapping e : τ → A such that (a) the e-image of any τ-tiling is an A-configuration compatible with s;

(b) every A-configuration compatible with s can be obtained in this way.

A nice proof of this result for 2 × 2 substitutions is given in [START_REF] Ollinger | Two-by-two Substitution Systems and the Undecidability of the Domino Problem[END_REF], where an explicit construction of a tile set τ for every substitution rule s is provided. We prove this theorem using our fixed-point argument. In this way we avoid the boring technical details; but the tile sets that can be extracted from our proof contain a huge number of tiles.

Proof. . Let us modify the construction of the tile set τ (with zoom factor N) by taking s into account. First consider a very special case when

• the substitution rule maps each A-letter into an N × N matrix (i.e., m = N) and

• the substitution rule is easy to compute: Given a letter u ∈ A and (i, j), we can compute the (i, j)-th letter of s(u) in a time much less than N.

In this case we proceed as follows. In our basic construction every tile knows its coordinates in the macro-tile and some additional information needed to arrange "wires" and simulate calculations of the universal Turing machine. 2 Now, in addition to this basic structure, each tile keeps two letters of A. The first is the label of a tile itself, and the second is the label of the N × N macro-tile it belongs to. This means that we keep additional 2 log |A| bits in each tile, i.e., multiply the number of tiles by |A| 2 . It remains to explain how the local rules work. We add two requirements:

(i) The second letter is the same for neighbor tiles (unless they are separated by a border of some N × N macro-tile). This constraint can be easily enforced by colors on sides of tiles. We multiply the number of colors in our basic construction by |A|; now each color of the new construction is a pair: its first component is a color from the basic construction and its second component is a letter of A. The second component of the new color guarantees that every two neighbor tiles keep the same "father" letter (unless these tiles are separated by a border and do not belong to the same father macro-tile, in which case we do not exhibit the letter to those borders).

(ii) The first letter in a tile is determined by the second letter and the coordinates of the tile inside the macro-tile, according to the substitution rule. Indeed, each tile "knows" its coordinates in a macrotile. Therefore, its first letter must appear in s(second letter) at the corresponding position. We do not need to extend the set of colors to enforce this property. This requirement is only a restriction on tiles. It explains which combinations coordinates in the father macro-tile, first letter, second letter can be combined in one tile of our tile set. 3We want the new tile set to be self-similar. Therefore, we should guarantee that the requirements (i) and (ii) hold also for macro-tiles. Fortunately, both requirements are easy to integrate in our basic selfreferential construction. In each macro-tile, two letters of A are encoded by strings of bits in some specially reserved locations on the tape of the Turing machine (simulated in the computation zone of this macro-tile). Requirement (i) is enforced by adding extra log |A| bits to macro-colors; to achieve (ii), a macro-tile should check that its first letter appears in s(second letter) at the required position. This is possible when s is easy to compute. (Knowing the coordinates and the second letter, the program computes the required value of the first letter and then compares it with the actual value.)

Requirements (i) and (ii) ensure that if we take first letters from A assigned to each tile, we get an Aconfiguration that is an s-image of some other configuration. Also (because of self-similarity) we have the same property on the level of macro-tiles. But this is not enough. We need to guarantee that the first letter on the level of macro-tiles is identical to the second letter on the level of tiles. This is also achievable. The first letter of a macro-tile is encoded by bits in its computation zone, and we can require that those bits match the second letter of the tiles at that place. (Recall that the second letter is the same across the tiles that constitute one macro-tile; note also that each tile "knows" its coordinates and can determine whether it is in the zone for the first letter in the macro-tile and which bit should be there.) By self-similarity, the same arguments work for macro-tiles of all levels. It is easy to see that now the tile set τ has the required properties (each tiling projects into a configuration compatible with s and vice versa).

However, this construction assumes that N (the zoom factor) is equal to the matrix size in the substitution rule, which is usually not the case. In fact, usually the value of m (a parameter of the substitution rule) is fixed in advance, and we have to choose N, which needs to be large enough. To overcome this difficulty, we let N be equal to m k for some k, and we use the substitution rule s k , i.e., the kth iteration of s (a configuration is compatible with s k if and only if it is compatible with s). Now we do not need s to be easily computable: For every s, if k is large enough, the computation of s k will fit into the available space (exponential in k). [START_REF] Berlekamp | Algebraic Coding Theory[END_REF] The Thue-Morse lemma and strongly aperiodic tile sets Let α > 0 be a real number. We say that a configuration U : Z 2 → A is α-aperiodic if for every nonzero vector T ∈ Z 2 there exists N such that in every square whose side is at least N the fraction of points x such that U(x) = U(x + T ) exceeds α.

Remark. If U is α-aperiodic, then the Besicovitch distance between U and any periodic pattern is at least α/2. (The Besicovitch distance between two configurations is defined as lim sup N d N , where d N is the fraction of points where two configurations differ in the N × N centered square. It is easy to see that the distance does not depend on the choice of the center point.) Theorem 4. There exists a tile set τ such that τ-tilings exist and every τ-tiling is α-aperiodic for every α < 1/4.

Proof. The proof is obtained by applying Theorem 3 to the Thue-Morse substitution rule T (Example 4). Let C be a configuration compatible with T . We have to show that C is α-aperiodic for every α < 1/4. It is enough to prove that every configuration compatible with the Thue-Morse substitution rule is α-aperiodic.

Informally, we can reduce the statement to the one-dimensional case, since Thue-Morse substitution is an xor-combination of two one-dimensional substitutions. Here are the details.

Consider a one-dimensional substitution system with two rules, 0 → 01 and 1 → 10. Applying these rules to 0 and 1, we get 0 → 01 → 0110 → 01101001 → . . . , For some n we consider the xor-combination of these strings, where the (i, j)-th bit is xor of the ith bit in the first string and the jth bit in the second string. Since b n is a bitwise negation of a n , we get only two different combinations (one obtained from two copies of a n or two copies of b n , and the other obtained from different strings), which are bitwise opposite. It is easy to see (e.g., by induction) that these two square patterns are images of 0 and 1 after n steps of two-dimensional Thue-Morse substitution.

1 → 10 → 1001 → 10010110 → . . .
To prove the statement for aperiodicity of the Thue-Morse configuration, we start with an estimate for (one-dimensional) aperiodicity of a n and b n : Lemma 1 (folklore). For any integer u > 0 and for any n such that u ≤ |a n |/4 the shift by u steps to the right changes at least |a n |/4 positions in a n and leaves unchanged at least |a n |/4 positions. (Formally, in the range 1, . . . , (2 nu) there exist at least (1/4) • 2 n positions i such that the ith and the (i + u)-th bits in a n coincide and at least (1/4)2 n positions where these bits differ.)

Proof. String a n can be represented as abbabaab, where a = a n-3 and b = b n-3 . One may assume without loss of generality that u ≥ |a| (or otherwise we apply Lemma 1 separately to the two halves of a n ). Note that ba appears in the sequence twice: once preceded by a copy of a and once preceded by a copy of b. Since these copies have opposite bits, the shifted bits match in one of the cases and do not match in the other one. The same is true for ab, which appears preceded both by a and b. Now consider a large N × N square in a two-dimensional Thue-Morse configuration and some shift vector T . We assume that N is much bigger than components of T (since we are interested in the limit behavior as N → ∞). Moreover, we may assume that some power of 2 (let us call it m) is small compared to N and large compared to T . Then, the N × N square consists of a large number of m × m Thue-Morse blocks and some boundary part (which can be ignored by changing α slightly). Then, we can consider each m × m block separately to estimate the fraction of positions that are changed by the T -shift. If T is horizontal or vertical, we can use the statement of the lemma directly: At least 1/4 of all positions are changed. If not (i.e., if the shift has two nonzero components), we are interested in the probability of some event that is an xor combination of two independent events with probabilities in the interval (1/4, 3/4). It is easy to check that such an event also has probability in (1/4, 3/4) (in fact, even in (3/8, 5/8), but we do not need this stronger bound).

Theorem 4 is proved.

In fact, the bound 1/4 can be replaced by 1/3 if we use a more professional analysis of the Thue-Morse sequence (see, e.g., [START_REF] Zaks | On the Correlation Dimension of the Spectral Measure for the Thue-Morse Sequence[END_REF]). However, if we want to get the strongest result of this form and make the bound close to 1, this substitution rule does not work. We can use some other rule (in a bigger alphabet) as Pritykin and Ulyashkina have shown [START_REF] Yu | Aperiodicity Measure for Infinite Sequences, Computer Science-Theory and Applications[END_REF], but we prefer to give another construction with variable zoom factors (see Section 6).

Variable zoom factor

The fixed-point construction of an aperiodic tile set is flexible enough and can be used in other contexts. For example, the "zoom factor" N could depend on the level. This means that instead of one tile set τ we have a sequence of tile sets τ 0 , τ 1 , τ 2 , . . ., and instead of one zoom factor N we have a sequence of zoom factors N 0 , N 1 , . . .. The tile set τ 0 simulates τ 1 with zoom factor N 0 , the tile set τ 1 simulates τ 2 with zoom factor N 1 , etc.

In other words, τ 0 -tilings can be uniquely split (by horizontal and vertical lines) into N 0 × N 0 macro-tiles from some list, and the macro-tiles in this list are in one-to-one correspondence (which respects matching rules) with τ 1 . So τ 0 -tilings are obtained from τ 1 -tilings by replacing each τ 1 -tile by the corresponding τ 0 -macro-tile, and each τ 0 -tiling has a unique reconstruction.

Further, every τ 1 -tiling can be split into macro-tiles of size N 1 × N 1 that correspond to τ 2 -tiles. So after two steps of zooming out, every τ 0 -tiling looks like a τ 2 -tiling; only a closer look reveals that each τ 2 -tile is in fact a τ 1 -macro-tile of size N 1 × N 1 , and an even closer look is needed to realize that every τ 1 -tile in these macro-tiles is in fact a τ 0 -macro-tile of size N 0 × N 0 .

For such a τ 0 -tiling we can say that it consists of level 1 macro-tiles of size N 0 × N 0 (isomorphic to τ 1 ); at the same time it consists of level 2 macro-tiles of size

N 0 N 1 × N 0 N 1 (isomorphic to τ 2 ), etc.
This is what we want to achieve (together with other things needed to get the tile set with desired properties). How do we achieve this? Each macro-tile should "know" its level: A macro-tile that simulates a τ k -tile and is made of τ k-1 -tiles, should have k in some place on the tape of the Turing machine simulated in this macro-tile. To make this information consistent between neighbors, k is exhibited as a part of the macro-colors at all four sides. The value of k is used for the computations. Macro-colors on the sides of a macro-tile encode the coordinates of this macro-tile inside its father, and the computation should check that they are consistent modulo N k (i.e., the x coordinate on the right side should be equal to the x coordinate on the left side plus 1 modulo N k , etc.). This means that N k should be computable from k; moreover, it should be computable fast enough to fit into the computation zone (which carries only Θ(N k-1 ) steps of computation). After N k is computed, there should be enough time to perform the arithmetic operations modulo N k , and so on.

Let us look at these restrictions more closely. We need to keep both k and the coordinates (modulo N k ) on the tape of level k macro-tiles, and log k + O(log N k ) bits are required for that. Both log k and log N k should be much less than N k-1 , so all the computations could fit in the available time frame. This means that N k should not increase too fast or too slowly. Say, N k = log k is too slow (in this case k occupies almost all available space in macro-tiles of level k -1, and we do not have enough time even for simple computations), and N k = 2 N k-1 is too fast (in this case log N k is too large compared to time and space available on the computation zone of a macro-tile of level k). Also we need to compute N k when k is known, so we assume that not only the size of N k (i.e., log N k ) but also the time needed to compute it (given k) is small compared to N k-1 . These restrictions still allow many possibilities: Say, N k could be proportional to

√ k, k, 2 k , 2 (2 k )
, or k! Note that we say "proportional" since N k needs to be reasonably large even for small k (we need some space in the macro-tile for wires and all our estimates for computation time are not precise but only asymptotic, so we need some reserve for small k).

There is one more problem: It is not enough to ensure that the value of k is the same for neighbor macrotiles. We also need to ensure that this value is correct, i.e., is 1 for level 1 macro-tiles made of τ 0 -tiles, is 2 for level 2 macro-tiles made of τ 1 -tiles, etc. To guarantee this, we need to compare somehow the level information that is present in a macro-tile and its sons. Using the anthropomorphic terminology, we say that each macro-tile "knows" its level, since it is explicitly written on its tape, and this is, so to say, "conscious" information processed by a computation in the computation region of the macro-tile. One may say also that a macro-tile of any level contains "subconscious" information ("existing in the mind but not immediately available to consciousness" [START_REF]Merriam-Webster's Medical Dictionary[END_REF]). This is the information that is conscious for its sons, grandsons, and so on (all the way down to the ground level). The problem is that the macro-tile cannot check consistency between conscious and subconscious information since the latter is unavailable (the problem studied by psychoanalysis in a different context).

The solution is to check consistency in the son, not in the father. Every tile knows its level and also knows its position in its father. So it knows whether it is in the place where its father should keep level bits, and it can check whether indeed the level bit that its father keeps in this place is consistent with the level information the tile has. (In fact we used the same trick when we simulated a substitution rule: A check that the father letter of a tile coincides with the letter of the father tile is done in the same way.) The careful reader will also note here that now the neighbor tiles will automatically have the same level information, so there is no need to check consistency between neighbors.

This kind of "self-similar" structure with variable zoom factors can be useful in some cases. Though it is not self-similar according to our definition, one can still easily prove that any tiling is aperiodic. Note that now the computation time for the Turing machine simulated in the central part increases with level, and this can be used for a simple proof of undecidability of the domino problem. The problem in the standard proof (based on the self-similar construction with fixed zoom factor) is that we need to place computations of unbounded size into this self-similar structure, and for that we need special geometric tricks (see [START_REF] Allauzen | Appendix A: Tiling Problems[END_REF][START_REF] Berger | The Undecidability of the Domino Problem[END_REF]). With our new construction, if we want to reduce an instance of the halting problem (some machine M) to the domino problem, we add to the program embedded in our construction the parallel computation of M on the empty tape; if it terminates, this destroys the tiling.

In a similar way we can show that the existence of a periodic tiling is an undecidable property of a tile set, and, moreover, the tile sets that admit periodic tilings and tile sets that have no tilings form two inseparable sets (another classical result; see [START_REF] Yu | Remarks of Berger's paper on the domino problem[END_REF]). Recall that two sets A and B are called (computably) inseparable if there is no computable set C such that A ⊂ C and B ∩C = / 0. Here is an example of a more exotic version of the latter result (which probably is of no interest in itself but just serves as an illustration of the technique). We say that a tile set τ is m-periodic if τ-tilings exist and for each of them the set of periods is the set of all multiples of m, in other words, if the group of periods is generated by (0, m) and (m, 0). Let E [respectively O] be all m-periodic tile sets for all even m [respectively odd m].

Theorem 5. The sets E and O are inseparable enumerable sets.

Proof. It is easy to see that the property "to be an m-periodic tile set" is enumerable (both the existence of an m-periodic tiling and enforcing periods (m, 0) and (0, m) are enumerable properties).

It remains to reduce some standard pair of inseparable sets (say, machines that terminate with output 0 and 1) to (E, O). It is easy to achieve this by using the technique explained above. Assume that the numbers N k increase, being odd integers as long as the computation of a given machine does not terminate. When and if it terminates with output 0 [respectively 1], we require periodicity with odd [respectively even] period at the next level.

Another application of a variable zoom factor is the proof of the following result obtained by Lafitte and Weiss (see [START_REF] Lafitte | Computability of Tilings[END_REF]) using a Turing machine simulation inside a Berger-Robinson construction. Theorem 6. Let f be a total computable function whose arguments and values are tile sets. Then, there exists a tile set τ that simulates a tile set f (τ).

Here we assume that some computable encoding for tile sets is fixed. Since there are no restrictions on the computation complexity of f , the choice of the encoding is not important.

Proof. Note that for identity function f this result provides the self-simulating tile set of Section 2.3. To prove it in the general case, we may use the same kind of fixed-point technique. However, there is a problem: The computation resources inside a tile are limited (by its size) while time needed to compute f can be large (and, moreover, depends on the tile size).

The solution is to postpone the simulation to large levels. If a tile set τ 0 simulates τ 1 , which simulates τ 2 , which simulates, etc., up to τ n , then τ 0 simulates τ n , too. Therefore we may proceed as follows.

We use the construction explained above with a variable zoom factor. Additionally, at each level the computation starts with a preliminary step that may occupy up to (say) half of the available time. On this step we read the program that is on the tape and convert it into the tile set. (Recall that each program determines some tile set τ 0 such that τ 0 -tilings can be uniquely split into macro-tiles, and this program is written on a read-only part of the tape simulated in the computation zone of all macro-tiles, as was explained in Section 2.2.) Then, we apply f to the obtained tile set.

This part of the computation checks also that it does not use more than half of the available time and that the output is small enough compared to the macro-tile size. If this time turns out to be insufficient or the output is too big, this part is dropped and we start a normal computation for the variable zoom factor, as explained above. In this case, the zoom factor on the next level should be greater than the zoom factor on the current level (e.g., we may assume N k = Ck for some large enough constant C). However, if the time is large enough and the result (the list of tiles that corresponds to f 's output) is small compared to the macro-tile size, we check that the macro-tile (of the current level) belongs to the tile set computed. The hierarchy of macro-tiles stops at this level. The behavior of macro-tiles at this level depends on f : They are isomorphic to f (τ 0 )-tiles. Since the program is the same at all levels and the computation of f should be finite (though may be very long), at some (big enough) level the second possibility is activated, and we get a macro-tile set isomorphic to f (τ), where τ is the tile set on the ground level.

Another application of the variable zoom factor technique is the construction of tile sets with any given computable density. Assume that a tile set is given and, moreover, that all tiles are divided into two classes, say, A-tiles and B-tiles. We are interested in a fraction of A-tiles in a tiling of an entire plane or its large region. If the tile set is flexible enough, this fraction can vary. However, for some tile sets this ratio tends to a limit value when the size of a tiled region increases. This phenomenon is captured in the following definition: We say that tile set τ divided into A-and B-tiles has a limit density α if for every ε > 0 there exists N such that for any n > N the fraction of A-tiles in any tiling of the n × n square is between αε and α + ε.

Theorem 7. (i) If a tile set has a density α, then α is a computable real number in [0, 1]. (ii) Any computable real number α ∈ [0, 1] is a density of some tile set.
Proof. The first part of the proof is a direct corollary of the definitions. For each n we can consider all tilings of the n × n square and look for the minimal and maximal fractions of A-tiles in them. Let us denote the minimal and maximal fractions by m n and M n respectively. These rational numbers are computable given n. It is easy to see that the limit frequency (if it exists) is in the interval [m n , M n ]. Indeed, in a large square split into squares of size n × n the fraction of A-tiles is between m n and M n , being at the same time arbitrarily close to α. Therefore, α is computable (to get its value with precision ε, we increase n until the difference between M n and m n becomes smaller than ε).

It remains to prove (ii). Since α is computable, there exist two computable sequences of rational numbers l i and r i that converge to α in such a way that

[l 1 , r 1 ] ⊃ [l 2 , r 2 ] ⊃ [l 3 , r 3 ] ⊃ • • • .
Our goal will be achieved if macro-tiles of the first level have density of either l 1 or r 1 , macro-macro-tiles of the second level have density of either l 2 or r 2 , and so on. Indeed, each large square can be split into macro-tiles (and the border that does not change the density much), so in any large square the fraction of A-tiles is (almost) in [l 1 , r 1 ]. The same argument works for macro-macro-tiles, etc.

However, this plan cannot be implemented directly. The main difficulty is that the computation of l i and r i may require a lot of time whereas the computation abilities of macro-tiles of level i are limited. (We use variable zoom factors, e.g., we may let N k = Ck, but they cannot grow too fast.)

The solution is to postpone the switch from densities l i and r i to densities l i+1 and r i+1 to the higher level of the hierarchy where the computation has enough time to compute all these four rational numbers and find out in which proportion l i -and r i -tiles should be mixed in l i+1 -and r i+1 -tiles. (We need the denominators in both fractions l i+1 and r i+1 to be equal to the number of i-level macro-tiles in the (i + 1)-level macro-tile, but this restriction can always be satisfied by a slight change in the sequences l k and r k , which leaves α unchanged.) So, we allocate, say, the first half of the available time for a controlled computation of all these values; if the computation does not finish in time, the densities for the next level are the same as for the current level. (We require that all macro-tiles in the same father tile have the same density, either l i or r i ). If the computation terminates in time, we use the result of the computation to have two types of the next level tiles: one with density l i+1 and one with density r i+1 . They are made by using prescribed amounts of l iand r i -tiles. (Since each tile knows its coordinates, it can find out whether it should be of the first or second type.) This finishes the construction.

Strongly aperiodic tile sets revisited

In Section 4 we constructed a tile set such that every tiling is α-aperiodic for every α < 1/4. Now we want to improve this result and construct a tile set such that every tiling is, say, 0.99-aperiodic (here 0.99 can be replaced by any constant less than 1). It is easy to see that this cannot be achieved by the same argument, with Thue-Morse substitutions, nor with any substitutions in a two-letter alphabet; we need a large alphabet to make the constant close to 1.

It is possible to achieve 0.99-aperiodicity with a carefully chosen substitution rule (in a bigger alphabet), as recently proposed by Pritykin and Ulyashkina [START_REF] Yu | Aperiodicity Measure for Infinite Sequences, Computer Science-Theory and Applications[END_REF], by just applying Theorem 3 (similarly to the argument for the Thue-Morse substitution presented in Section 4). In this section we present an alternative proof of this result. We exploit substitution rules with variable zoom factors (and different substitutions on each level) and use the idea of an error-correcting code.

Instead of one single alphabet, A, we now consider an infinite sequence of finite alphabets, A 0 , A 1 , A 2 , . . .; the cardinality of A k will grow as k grows. Then, we consider a sequence of mappings:

s 1 : A 1 → A N 0 ×N 0 0 , s 2 : A 2 → A N 1 ×N 1 1 , s 3 : A 3 → A N 2 ×N 2 2 , . . . ,
where N 0 , N 1 , N 2 , . . . are some positive integers (zoom factors); N k will increase as k increases.

Then, we can compose these mappings. For example, a letter z in A 2 can be first replaced by an N 1 × N 1 square s 2 (z) filled by A 1 -letters. Then, each of these letters can be replaced by an N 0 × N 0 square filled by A 0 -letters according to s 1 , and we get an N 0 N 1 × N 0 N 1 square filled by A 0 -letters; we denote this square by s 1 (s 2 (z)) (slightly abusing the notation).

We call all this (i.e., the sequence of A k , N k , s k ) a substitution family. Such a family defines a class of A 0 -configurations compatible with it (in the same way as in Section 3). Our plan is to construct a substitution family such that

• every configuration compatible with this family is 0.99-aperiodic, and

• there exists a tile set and projection of it onto A 0 such that only compatible configurations (and all compatible configurations) are projections of tilings.

In other words, we use the same argument as before (proving Theorem 4) but use a substitution family instead of one substitution rule. This substitution family will have two special properties:

A. Symbols used in different locations are different. This means that A k -letters that appear in a given position of the squares s k+1 (z) for some z ∈ A k+1 never appear in any other places of these squares (for any z); thus, set

A k is split into N k × N k disjoint subsets used for different positions in N k × N k squares.
B. Different letters are mapped to squares that are far away in terms of Hamming distance. This means that if z, w ∈ A k+1 are different, then the Hamming distance between images s k+1 (z) and s k+1 (w) is large:

The fraction of positions in the N k × N k square, where s i+1 (z) and s i+1 (w) have equal letters does not exceed ε k .

Here ε i will be a sequence of positive reals such that ∑ i≥0 ε i < 0.01.

This implies that composite images of different letters are also far apart. For example, the fraction of positions in the N 0 N 1 × N 0 N 1 square where s 1 (s 2 (z)) and s 1 (s 2 (w)) coincide does not exceed ε 0 + ε 1 < 0.01. Indeed, in s 2 (z) and s 2 (w) we have at most ε 1 -fraction of matching letters; these letters generate ε 1 -fraction of matching A 0 -letters on the ground level; all other (nonmatching) pairs add ε 0 -fraction. In fact, we get even a stronger bound 1

-(1 -ε 0 )(1 -ε 1 ).
For the same reasons, if we take two different letters in A k and then drop to the ground level and obtain two squares of size

N 0 N 1 • • • N k-1 × N 0 N 1 • • • N k-1 filled by A 0 -letters, the fraction of coincidences is at most ε 0 + • • • + ε k-1 < 0.01.
This property of the substitution family implies the desired property:

Lemma 2. If an A 0 -configuration U is compatible with a substitution family having properties (A) and (B), then U is 0.99-aperiodic.

Proof. Consider a shift vector T . If T is not a multiple of N 0 (one of the coordinates is not a multiple of N 0 ), then property (A) guarantees that the original configuration and its T shift differ everywhere. Now assume that T is a multiple of N 0 . Then, T induces a (T /N 0 )-shift of an A 1 -configuration U 1 that is an s 1 -preimage of U. If T is not a multiple of N 0 N 1 , then T /N 0 is not a multiple of N 1 and for the same reason this (T /N 0 )shift changes all the letters in U 1 . Different letters in A 1 are mapped to N 0 × N 0 squares that coincide in at most ε 0 -fraction of positions.

If T is a multiple of N 0 N 1 but not N 0 N 1 N 2 , we get a T /(N 0 N 1 ) shift of A 2 -configuration U 2 that
changes all its letters, and different letters give squares that are 1 -(ε 0 + ε 1 ) apart. The same argument works for the higher levels.

It remains to construct a substitution family that has properties (A) and (B) and can be enforced by a tile set. Property (B) (large Hamming distance) is standard for coding theory, and the classical tool is the Reed-Solomon code.

Let us recall the idea of the Reed-Solomon code (for details see, e.g., [START_REF] Berlekamp | Algebraic Coding Theory[END_REF]). The codewords of the Reed-Solomon code are tables of (values of) polynomials of bounded degree. More precisely, we fix some finite field F q of size q and an integer d > 0. Let p(x) = a 0 + a 1 x + • • • + a d-1 x d-1 be a polynomial over F q of degree less than d. Then the codeword corresponding to p(x) (i.e., the encoding of the sequence a 0 , . . . , a d-1 ) is a vector in (F q ) q (i.e., a sequence of q elements of the field), which consists of the values of this polynomial computed at all points x ∈ F q . Thus, for given parameters d and q, the code consists of q d codewords. Since two polynomials of degree less than d can coincide in at most (d -1) points, the distance between any two codewords is at least qd + 1. Of course, this construction can be used even if the desired length of the codewords is not a size of any finite field; we can choose a slightly larger field and use only part of its elements. Now we embed these codes in a family of substitution rules. First, let B k be a finite field (the size of which is specified below) and let A k be equal to B k × {0, 1, . . . , N k -1} × {0, 1, . . . , N k -1}; let us agree that we use letters b, i, j only in the (i, j)-position of an s k+1 -image. This trivially implies requirement (A).

Then, we construct a code that encodes each A k+1 -letter w by a string of length N 2 k made of B k -letters (arranged in a square); adding the coordinates, we get the s k+1 -image of w. Thus, we need a sequence of codes:

s 1 : A 1 → B N 0 ×N 0 0 , such that s 1 (w) and s 1 (w ′ ) coincide at most in ε 0 fraction of all positions (if w = w ′ ), s 2 : A 2 → B N 1 ×N 1 1
, such that s 2 (w) and s 2 (w ′ ) coincide at most in ε 1 fraction of all positions (if w = w ′ ), . . . .

To satisfy requirement (B), we need a code with the Hamming distance (between every two codewords) at least (1ε k )N 2 k . The Reed-Solomon code works well here. The size of the field can be equal to the length of the codeword, i.e., N 2 k . Let us decide that N k is a power of 2 and the size of the field B k is exactly N 2 k . (There are fields of size 2 t for every t = 1, 2, 3, . . .; we could also use Z/pZ for prime p of an appropriate size.) To achieve the required code distance, we use polynomials of degree less than ε k N 2 k . The number of codewords (polynomials of degree less than ε k N 2 k ) is at least 2 ε k N 2 k (even if we use only polynomials with coefficients 0 and 1). This is enough if

|A k+1 | ≤ 2 ε k N 2 k .
Recalling that

|A k+1 | = |B k+1 | • N 2 k+1
and that B k+1 is a field of size N 2 k+1 , we get the inequality

N 4 k+1 ≤ 2 ε k N 2 k , or 4 log N k+1 ≤ ε k N 2 k .
Now let N k = 2 k+c for some constant c; we see that for large enough c this inequality is satisfied for ε k with sum less than 0.01 (or any other constant), since the left-hand side is linear in k while the right-hand side is exponential. Now it remains to implement all this scheme using tiling rules. As we have discussed, the zoom factor N k = 2 k+c is acceptable for the construction. This factor leaves enough space to keep on the tape two substitution letters (for the tile itself and its father tile), since these letters require linear size (in k). Moreover, we have enough time to perform the computations in the finite fields needed to construct the error-correction code mappings. Indeed, in a k-level macro-tile we are allowed to use exponential (in the bit size of the field element) time. Recall that one can operate with elements in the field of size 2 r using polynomial (in r) time; to this end, we need to construct some irreducible polynomial p of degree r over the field of two elements and then perform arithmetic operations (on polynomials) modulo p. All these operations can be done by deterministic algorithms in polynomial time (see, e.g., [START_REF] Lidl | Finite Fields[END_REF]). Thus, we can reuse here the construction of the proof of Theorem 3.

The construction above works with every constant α < 1 instead of 0.99. So, we get a stronger version of Theorem 4: Theorem 8. For every α < 1 there exists a tile set τ such that τ-tilings exist and every τ-tiling is α-aperiodic.

Remark. We can also get an α-aperiodic tile set (for every α < 1) as a corollary of the result of the next section; indeed, we construct there a tile set such that any tiling embeds a horizontal sequence with high-complexity substrings, and such a sequence cannot match itself well after a shift (in fact, to get αaperiodicity we would need to replace a binary alphabet by a larger finite alphabet in this argument). We can superimpose this with a similar 90 • -rotated construction; then, any nonzero translation will shift either a vertical or a horizontal sequence and therefore change most of the positions. Note that in this way we can also get a tile set that is α-far from every periodic pattern (a slightly different approach to defining "strong aperiodicity"). However, the arguments used in Section 7 are more complicated than the proof of this section. So we preferred to present here a simpler and more direct proof of Theorem 8.

Tile sets with only complex tilings

In this section we provide a new proof of the following result from [START_REF] Durand | Complex Tilings[END_REF]: Theorem 9. There exist a tile set τ and constants c 1 > 0 and c 2 such that τ-tilings exist and in every τ-tiling T every N × N square has Kolmogorov complexity at least c 1 Nc 2 .

Here Kolmogorov complexity of a tiled square is the length of the shortest program that describes this square. We assume that programs are bit strings. Formally speaking, Kolmogorov complexity of an object depends on the choice of programming language. (Consult [START_REF] Shen | Algorithmic Information Theory and Kolmogorov Complexity[END_REF] for the definition and properties of Kolmogorov complexity.) However, in our case the choice of programming language does not matter, and you may think of Kolmogorov complexity of an object as the length of the shortest program in your favorite programming language that prints out this object. We need to keep in mind only two important properties of Kolmogorov complexity. First, the Kolmogorov complexity function is not computable, but it is upper semicomputable. This means that there is an algorithm that for a given n enumerates all objects that have complexity less than n. The enumeration can be done by a brute force search over all short descriptions. We cannot say in advance which programs stop with some output and which do not, but we can run all programs of length less than n in parallel, and enumerate the list of their outputs, as some programs terminate. Second, any computable transformation (e.g., the change of encoding) changes Kolmogorov complexity at most by O [START_REF] Allauzen | Appendix A: Tiling Problems[END_REF]. We refer to [START_REF] Durand | Complex Tilings[END_REF] for a discussion of Theorem 9 (why it is optimal, why the exact value of c 1 does not matter, etc.) and other related results.

A biinfinite bit sequence

Proof. We start the proof in the same way as in [START_REF] Durand | Complex Tilings[END_REF]: We assume that each tile keeps a bit that propagates (unchanged) in the vertical direction. Then, any tiling contains a biinfinite sequence of bits ω i (where i ∈ Z). Any N × N square contains an N-bit substring of this string, so if (for large enough N) every N-bit substring of ω has complexity at least c 1 N for some fixed c 1 , we are done.

We say that a sequence ω has Levin's property if every N-bit substring x of ω has complexity Ω(N). Such a biinfinite sequence indeed exists (see [START_REF] Durand | Complex Tilings[END_REF]; another proof can be obtained by using the Lovasz local lemma; see [START_REF] Rumyantsev | Forbidden Substrings, Kolmogorov Complexity and Almost Periodic Sequences[END_REF]). So our goal is to formulate tiling rules in such a way that a correct tiling "ensures" that the biinfinite sequence embedded in it indeed has this property.

The set of all "forbidden" binary strings, i.e., strings x such that K(x) < c 1 |x|c 2 (where K(x) denotes the Kolmogorov complexity of x, and |x| denotes the length of x) is enumerable: There is an algorithm that generates the list of all forbidden substrings. It would be nice to embed into the tiling a computation that runs this algorithm and compares its output strings with the substrings of ω; such a computation blows up (creates a tiling error) if a forbidden substring is found.

However, there are several difficulties.

• Our self-similar tiling contains only finite computations. The higher is rank k, the bigger are the k-level macro-tiles, and the longer computations they can contain. But at any level the computation remain finite. This is a problem since for a given string x we do not know a priori how much time the shortest program for x uses, so we never can be sure that the Kolmogorov complexity of x is large. Hence, each substring of ω should be examined in computations somehow distributed over infinitely many macro-tiles.

• The computation at some level deals with bits encoded in the cells of that level, i.e., written on the computation tape. So the computation cannot access the bits of the sequence (that are "deep in the subconscious") directly and some mechanism to dig them out is needed.

Let us explain how to overcome these difficulties.

Delegation of bits

A macro-tile of level k is a square whose side is

L k = N 0 • N 1 • • • N k-1
, so there are L k bits of the sequence that intersect this macro-tile. Let us delegate each of these bits to one of the macro-tiles of level k it intersects.

(We do it for every k.) Note that the macro-tile of the next level is made of N k × N k macro-tiles of level k. We assume that N k is much bigger than L k (see the end of this subsection for more details on the choice of N k ); this guarantees that there are enough macro-tiles of level k (in the next level macro-tile) to serve all bits that intersect them. Let us decide that the ith (from bottom to top) macro-tile of level k in a (k + 1)-level macro-tile serves (consciously knows, so to say) the ith bit (from the left) in its zone (see Fig. 5). Since N k ≫ L k , we have many more macro-tiles of level k (inside some macro-tile of level k + 1) than needed to serve all bits. So some k-level macro-tiles remain unused.

• • • • • • • • • • • • N k tiles of size L k × L k Figure 5: Bit delegation.
Thus, each bit (each vertical line) has a representative on every level-a macro-tile that consciously knows this bit. However, we need some mechanisms that guarantee that this information is indeed true (i.e., consistent on different levels). On the bottom level this is easy to achieve, since the bits are available directly.

To guarantee the consistency we use the same trick as in Section 3: At each level a macro-tile keeps not only its own bit but also its father's bit, and makes necessary consistency checks. Namely, each macro-tile knows (has on its computation tape):

• the bit delegated to this macro-tile;

• the coordinates of this macro-tile in its father macro-tile (which are already used in the fixed-point construction); note that the y-coordinate is at the same time the position of the bit delegated to this macro-tile (relative to the left boundary of the macro-tile);

• the bit delegated to the father of this macro-tile; and

• the coordinates of the father macro-tile in the grandfather macro-tile.

This information is subject to consistency checks:

• The information about the father macro-tile should coincide with the same information in the neighbor tiles (unless they have a different father, i.e., one of the coordinates is zero).

• If the bit delegated to the father macro-tile is from the same vertical column as the bit delegated for this macro-tile, these two bits should match.

• If the macro-tile occupies a place in its father macro-tile where the bit delegated to the father or some bits of the father's coordinates (inside the grandfather macro-tile) are kept, then this partial information on the father level should be should be consistent with the information about father coordinates and bit.

These tests guarantee that the information about the father is the same in all brothers, and some of these brothers (which are located on the father tape) can check it against actual father information; at the same time some other brother (that has the same delegated bit as the father) checks the consistency of the delegated bits information.

Note that this scheme requires that not only log N k but also log N k+1 is much less than N k-1 . This requirement, together with the inequality

L k = N 0 N 1 • • • N k-1 ≤ N k (discussed earlier), is satisfied if N k = Q c k ,
where Q is a large enough constant (which is needed also to make macro-tiles of the first level large enough) and c > 2 (so 1

+ c + c 2 + • • • + c k-1 < c k ).
Later, in Section 13, the choice of c has to be reconsidered: We need 2 < c < 3 to achieve error correction, but for our current purposes this does not matter.

Checking bit blocks

We explained how macro-tile of any level can have true information about one bit (delegated to it). However, we need to check not bits but substrings (and artificially introduce a tiling error if a forbidden string appears). Note that it is acceptable to test only very short substrings compared to the macro-tile size (N k ). If this test is done on all levels, this restriction does not prevent us from detecting any violation. (Recall that short forbidden substrings can appear very late in the generation process, so we need computation at arbitrary high levels for this reason, too.) So we need to provide more information to macro-tiles. This can be done in the following way. Let us require that a macro-tile contains not one bit but a group of bits to check: a group of bits that starts at the delegated bit and has length depending on the level k (and growing very slowly with k; e.g., log log log k is slow enough). If this group is not completely inside a macro-tile (i.e., it extends out of the region occupied by the macro-tile), we ignore the outstanding part.

Similarly, a macro-tile should have this information for the father macro-tile (even if the bits are outside its own region). This information about the father macro-tile should be the same for brothers (which is checked by matching macro-colors of neighboring brothers). Also each macro-tile checks (on its computational zone) that the value of its own delegated bit is coherent with its father's string of bits to check: A macro-tile knows its coordinate in the father macro-tile and the coordinates of the father tile in the grandfather, so it knows whether its delegated bit makes a part of the father's bits to check.

The computation in the computation zone generates the list of all forbidden strings (strings that have too small Kolmogorov complexity) and checks the generated forbidden strings against all the substrings of the group of bits available to this macro-tile. This process is bounded in time and space, but this does not matter since every string is considered on a high enough level.

Our construction has a kind of duplication: We first guarantee the consistency of information for individual bits, and then, we do the same for substrings. The first part of the construction is still needed, since we need arbitrarily long substrings to be checked by macro-tiles (of high enough level); thus delegation of substrings cannot start from the ground level where the tile size is limited, so we need to deal with bits separately.

• • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • •

Last correction

The argument just explained still needs some correction. We claim that every forbidden string will be detected at some level where it is short enough compared to the level parameters. However, some strings may never become a part of one macro-tile. Imagine that there is some vertical line that is a boundary between macro-tiles of all levels (so we have bigger and bigger tiles on both sides, and this line is still the boundary between them; see Fig. 6). Then, a substring that crosses this line will never be checked and therefore we cannot guarantee that it is not forbidden.

There are several ways to get around this problem. One can decide that each macro-tile contains information not only about blocks inside its father macro-tile but in a wider region (say, three times wider, including "uncle" macro-tiles); this information should be checked for consistency between "cousins", too. This trick (extending zones of responsibility for macro-tiles) will be used later in Section 8.

But to prove Theorem 9 a simpler solution is enough. Note that even if a string on the boundary is never checked, its parts (on both sides of the boundary) are, so their complexity is proportional to their length. One of the parts has length at least half of the original length, so we still have a complexity bound, though the constant will be twice smaller.

This finishes the proof of Theorem 9.

Subshifts

The analysis of the proof in the previous section shows that it can be divided into two parts. We defined forbidden strings as bit strings that are sufficiently long and have complexity at most α • (length). We started by showing that biinfinite strings without forbidden factors (substrings) exist. Then, we constructed a tile set that embeds such a biinfinite string in every tiling.

The second part can be separated from the first one, and in this way we get new proofs for some results of Simpson [START_REF] Simpson | Medvedev degrees of 2-dimensional subshifts of finite type[END_REF] and Hochman [START_REF] Hochman | On the Dynamic and Recursive Properties of Multidimensional Symbolic Systems[END_REF] about effectively closed subshifts.

Fix some alphabet A. Let F be a set of A-strings. Consider a set S F of all biinfinite A-sequences that have no factors (substrings) in F. This set is a closed one-dimensional subshift over A, i.e., a closed shift-invariant subset of the space of all biinfinite A-sequences. If the set F is (computably) enumerable, S F is called an effectively closed one-dimensional subshift over A. If F is finite, S F is called a subshift of finite type.

We can define two-dimensional subshifts in a similar way. More precisely, let F be a set of twodimensional patterns (squares filled with A-letters). Then, we can consider a set S F of all A-configurations (= mappings Z 2 → A) that do not contain any pattern from F. This is a closed shift-invariant set of Aconfigurations (= two-dimensional closed subshift over A). If F is (computably) enumerable, S F is called a two-dimensional effectively closed subshift over A. If F is finite, S F is called a two-dimensional subshift of finite type.

As we have mentioned, subshifts of finite type (interpreted as local rules) are closely related to tilings. Each tile set determines a subshift where A is the set of tiles and forbidden patterns are pairs of neighbor nonmatching tiles. Going in the other direction, we should be more careful. A tile set in our definition cannot contain two different tiles with exactly the same colors. This leads to some problems. For example, the full shift over a two-letter alphabet (i.e., the set of all biinfinite sequences over a two-letter alphabet) cannot be represented by a set of two tiles. However, any subshift of finite type can be represented by some tile set. More precisely, for any subshift S of finite type over alphabet A there is a tile set τ and some mapping E : τ → A such that E induces a bijection between the set of all τ-tilings and the set of all configurations of the subshift S: we apply E pointwise to a τ-tiling and get some A-configuration from the subshift; for each configuration in the subshift there exists exactly one τ-tiling in the E-preimage of this configuration. Such a tile set can be constructed as follows: Tiles are squares of large enough size filled by A-letters (a square with no patterns forbidden for this subshift); each tile represents a part of the configuration, and side colors are used to ensure that neighbor tiles overlap correctly. The mapping extracts (say) the central letter from a square.

Thus, subshifts of finite type and tilings are essentially the same kind of objects. On the other hand, the effectively closed subshifts of dimension make a more general class of objects than subshifts of finite type. E.g., every nonempty one-dimensional subshift of finite type must contain a periodic configuration; for onedimensional effectively closed subshifts this is not the case. However, the following theorem shows that twodimensional subshifts of finite type are powerful enough to simulate any effectively closed one-dimensional subshift in the following sense (i.e., to simulate an effectively closed subshift, we need a subshift of finite type of dimension higher by 1):

Theorem 10. Let A be some alphabet and let S be a one-dimensional effectively closed subshift over A. Then, there exist an alphabet B, a mapping r : B → A, and a two-dimensional subshift S ′ of finite type over B such that r-images of configurations in S ′ are (exactly) elements of S extended vertically (vertically aligned cells contain the same A-letter).

(As we have mentioned, this result was independently obtained by Aubrun and Sablik using Robinsonstyle aperiodic tilings [START_REF] Aubrun | Simulation of recursively enumerable subshifts by two-dimensional SFT and a generalization[END_REF].)

Proof. The proof uses the same argument as in Theorem 9. Each cell now contains an A-letter that propagates vertically. Computation zones in macro-tiles generate (in available space and time) elements of the enumerable set of forbidden A-substrings and compare them with A-substrings that are made available to them. It remains to note that tiling requirements (matching colors) are local; that is, they define a finite type two-dimensional subshift.

Note that now the remark of Section 7.4 (the trick of extension of zones of responsibility for macrotiles) becomes crucial, since otherwise the image of a configuration from S ′ may be a concatenation of two sequences (a left-infinite one and a right-infinite one); neither sequence contains forbidden patterns but forbidden patterns may appear at the point of concatenation.

A similar argument shows that every two-dimensional effectively closed subshift can be represented as an image of a three-dimensional subshift of finite type (after a natural extension along the third dimension), any three-dimensional effectively closed subshift is an image of a four-dimensional subshift of finite type, etc.

This result is an improvement of a similar one proved by Hochman (Theorem 1.4 in [START_REF] Hochman | On the Dynamic and Recursive Properties of Multidimensional Symbolic Systems[END_REF], where the dimension increases by 2), thus providing a solution of Problem 9.1 from [START_REF] Hochman | On the Dynamic and Recursive Properties of Multidimensional Symbolic Systems[END_REF]. Note also that it implies the result of Simpson [START_REF] Simpson | Medvedev degrees of 2-dimensional subshifts of finite type[END_REF] where one-dimensional sequences are embedded into two-dimensional tilings but in some weaker sense (defined in terms of Medvedev degrees).

One can ask whether a dimension reduction is essential here. For example, is it true that every twodimensional effectively closed subshift is an image of some two-dimensional subshift of finite type? The answer to this question (as well as related questions in higher dimensions) is negative. This follows from an upper bound in [START_REF] Durand | Complex Tilings[END_REF] saying that every tile set (unless it has no tilings at all) has a tiling such that all n × n squares in it have complexity O(n) (a result that immediately translates for subshifts of finite type) and a result from [START_REF] Rumyantsev | Forbidden Substrings, Kolmogorov Complexity and Almost Periodic Sequences[END_REF] that shows that some nonempty effectively closed two-dimensional subshift has n × n squares of complexity Ω(n 2 ). Therefore the latter cannot be an image of the first one (complexity can only decrease when we apply an alphabet mapping). 9 Random errors

Motivation and discussion

In what follows we discuss tilings with faults. This means that there are some places (faults) where colors of neighbor tiles do not match. We are interested in "robust" tile sets: those that maintain some structure (for example, can be converted into an error-free tiling by changing a small fraction of tiles) if faults are sparse.

There are two almost equivalent ways to define faulty tilings. We can speak about errors (places where two neighbor tiles do not match) or holes (places without tiles). Indeed, we can convert a tiling error into a hole (by deleting one of two nonmatching tiles) or convert a one-tile hole (one missing tile) into a small number of errors (at most 4) by placing an arbitrary tile there. Holes look more natural if we start with a set of holes and then try to tile the rest; however, if we imagine some process similar to crystallization when a tiling tries to become correct by some trial-and-error procedure, it is more natural to consider tiling errors. Since it makes little difference from the mathematical point of view, we use both metaphors.

We use a hierarchical approach to hole patching that can be traced back to Gács, who used it in a much more complicated situation [START_REF] Gács | Reliable Cellular Automata with Self-Organization[END_REF]. This means that first we try to patch small holes that are not too close to each other (by changing small neighborhoods around them). This (if we are lucky enough) makes larger (and still unpatched) holes more isolated since there are fewer small holes around. Some of these larger holes (which are not too large and not too close to each other) can be patched again. Then, the same procedure can be repeated again for the next level. Of course, we need some conditions (that guarantee that holes are not too dense) to make this procedure successful. These conditions are described later in full detail, but the important question is the following: How do we ensure that these conditions are reasonable (i.e., general enough)? Our answer is as follows: We prove that if holes are generated at random (with each position becoming a hole independently of other positions with small enough probability ε), then the generated set satisfies these conditions with probability 1.

From the physics viewpoint, this argument sounds rather weak. If we imagine some crystallization process, errors in different positions are not independent at all. However, this approach could be a first approximation until a more adequate one is found.

Note that patching holes in a tiling could be considered as a generalization of percolation theory. Indeed, let us consider a simple tile set made of two tiles: one with all black sides and the other with all white sides. Then, the tiling conditions reduce to the following simple condition: Each connected component of the complement to the set of holes is either completely black or completely white. We want to make small corrections in the tiling that patch the holes (and therefore make the entire plane black or white). This means that initially either we have small black "islands" in a white ocean or vice versa, which is exactly what percolation theory says (it guarantees that if holes are generated at random independently with small probability, the rest consists of one large connected component and many small islands.)

This example shows also that simple conditions such as low density (in the Besicovitch sense) of the hole set are not enough. A regular grid of thin lines can have low density but still splits the plane into nonconnected squares; if half of these squares are black and the others are white, no small correction can patch the holes.

One can define an appropriate notion of a sparse set in the framework of algorithmic randomness (Martin-Löf definition of randomness) by considering individual random sets (with respect to the Bernoulli distribution B ε ) and their subsets as "sparse." Then, we can prove that any sparse set (in this sense) satisfies the conditions that are needed to make the iterative patching procedure work. This algorithmic notion of "sparseness" is discussed in [START_REF] Bienvenu | Sparse Sets, Journées Automates Cellulaires[END_REF]. However, in the current paper we do not assume that the reader is familiar with algorithmic randomness and restrict ourselves to classical probability theory.

So our statements become quite lengthy and use probabilistic quantifiers "for almost all" (= with probability 1). The order of quantifiers (existential, universal, and probabilistic) is important here. For example, the statement "a tile set τ is robust" means that there exists some ε > 0 such that for almost all E (with probability 1 with respect to the distribution where each point independently belongs to E with probability ε) the following is true: For every (τ, E)-tiling U there exists a τ-tiling U ′ (of the entire plane) that is "close" to U. Here by (τ, E)-tiling we mean a tiling of Z 2 \ E (where existing pairs of neighbor tiles match).

Islands of errors

In this section we develop the notion of "sparsity" based on the iterative grouping of errors (or holes) and prove its properties.

Let E ⊂ Z 2 be a set of points; points in E are called dirty; other points are clean.

Let β ≥ α > 0 be integers. A nonempty set X ⊂ E is an (α, β )-island in E if
(1) the diameter of X does not exceed α and (2) in the β -neighborhood of X there is no other point from E.

(The diameter of a set is a maximal distance between its elements; the distance d is defined as l ∞ , i.e., the maximum of distances along both coordinates; the β -neighborhood of X is a set of all points y such that d(y, x) ≤ β for some x ∈ X.)

It is easy to see that two (different) islands are disjoint (and the distance between their points is greater than β ).

Let (α 1 , β 1 ), (α 2 , β 2 ), . . . be a sequence of pairs of integers and α i ≤ β i for all i. Consider the following iterative "cleaning" procedure. At the first step we find all (α 1 , β 1 )-islands (rank 1 islands) and remove

E n E n-1 E n-2 x x 0 x 1
x 00 x 01 x 10 x 11 . . . all their elements from E (thus getting a smaller set E 1 ). Then, we find all (α 2 , β 2 )-islands in E 1 (rank 2 islands); removing them, we get E 2 ⊂ E 1 , etc. The cleaning process is successful if every dirty point is removed at some stage.

At the ith step we also keep track of the β i -neighborhoods of islands deleted during this step. A point x ∈ Z 2 is affected during the ith step if x belongs to one of these neighborhoods.

The set E is called sparse (for a given sequence α i , β i ) if the cleaning process is successful, and, moreover, every point x ∈ Z 2 is affected at finitely many steps only (i.e., x is far from islands of sufficiently large ranks).

The values of α i and β i should be chosen in such a way that for sufficiently small ε > 0 a B ε -random set is sparse with probability 1. (As we have said, this justifies that our notion of sparsity is not unreasonably restrictive.) The sufficient conditions are provided by the following statement:

Lemma 3. Assume that 8 ∑ k<n β k < α n ≤ β n for every n and ∑ i log β i 2 i < ∞.
Then, for all sufficiently small ε > 0 a B ε -random set is sparse with probability 1.

Proof. Let us estimate the probability of the event "x is not cleaned after n steps" for a given point x (the probability of this event does not depend on x). If x ∈ E n , then x belongs to E n-1 and is not cleaned during the nth step (when (α n , β n )-islands in E n-1 are removed; by definition we let E 0 = E). Then, x ∈ E n-1 and, moreover, there exists some other point x 1 ∈ E n-1 such that d(x, x 1 ) is greater than α n /2 but not greater than β n + α n /2 (note that β n + α n /2 < 2β n ). Indeed, if there were no such x 1 in E n-1 , then the (α n /2)neighborhood of x in E n-1 would be an (α n , β n )-island in E n-1 and x would be removed. Further, we apply the same argument on level (n -1). Each of the points x 1 and x (we use notation x 0 for x, to make the notation more uniform) belongs to E n-1 ; therefore it belongs to E n-2 together with some other point (at a distance greater than α n-1 /2 but not exceeding 2β n-1 ). Denote these two other points in E n-2 by x 01 (which exists because x 0 ∈ E n-1 ) and x 11 (which exists because x 1 ∈ E n-1 ) respectively. Thus, we have at least four points denoted by x 00 = x 0 = x, x 01 , x 10 = x 1 , and x 11 in E n-2 . Then, we repeat the same argument for levels (n -2), (n -3), etc. In this way we get a tree (Fig. 7) that "explains" why x belongs to E n .

The distance between x 0 and x 1 in this tree is at least α n /2 whereas the diameter of the subtrees starting at x 0 and x 1 does not exceed ∑ i<n 2β i . Therefore, the lemma's assumption guarantees that these subtrees cannot intersect. Since it is true on all levels, all the leaves of the tree are different. Note that all 2 n leaves of the tree belong to E = E 0 . As every point appears in E independently of other points, each "explanation tree" is valid with probability ε 2 n . It remains to estimate the number of possible explanation trees for a given point x.

To specify x 1 we need to specify the difference (vertical and horizontal distances) between x 0 and x 1 . Neither distance exceeds 2β n ; therefore we need about 2 log(4β n ) bits to specify them (including the sign bits). Then, we need to specify the difference between x 00 and x 01 as well as the difference between x 10 and x 11 ; this requires at most 4 log(4β n-1 ) bits. To specify the entire tree we therefore need

2 log(4β n ) + 4 log(4β n-1 ) + 8 log(4β n-2 ) + • • • + 2 n log(4β 1 )
bits. Reversing the sum and taking out the factor 2 n , we can rewrite this expression as

2 n (log(4β 1 ) + log(4β 2 )/2 + • • • ).
Since the series ∑ log β n /2 n converges by assumption, the total number of explanation trees for a given point (and given n) does not exceed 2 O(2 n ) , so the probability for a given point x to be in E n for a B ε -random E does not exceed ε 2 n 2 O(2 n ) , which tends to 0 (even super-exponentially fast) as n → ∞, assuming that ε is small enough.

We conclude that the event "x is not cleaned" (for a given point x) has zero probability; the countable additivity guarantees that with probability 1 all points in Z 2 are cleaned.

It remains to show that every point with probability 1 is affected at finitely many steps only. Indeed, if x is affected at step n, then some point in its β n -neighborhood belongs to E n , and the probability of this event is at most

O(β 2 n )ε 2 n 2 O(2 n ) = 2 2 log β n +O(2 n )-log(1/ε)2 n ;
the convergence conditions guarantees that log β n = o(2 n ), so the first term is negligible compared to the others, the probability series converges (for small enough ε) and the Borel-Cantelli lemma gives the desired result.

For our next step, we note that by definition a sparse set is split into a union of islands of different ranks. Now we prove that these islands together occupy only a small part of the plane. To formalize this statement, we use the notion of Besicovitch size (density) of a set E ⊂ Z 2 . Let us recall the definition. Fix some point O of the plane and consider squares of increasing size centered at O. For each square consider the fraction of points in this square that belong to E. The lim sup of these frequencies is called the Besicovitch density of E. (Note that the choice of the center point O does not matter, since for any two points O 1 and O 2 large squares of the same size centered at O 1 and O 2 share most of their points.)

By definition the distance between two rank k islands is at least β k . Therefore the (β k /2)-neighborhoods of these islands are disjoint. Each of the islands contains at most α 2 k points (it can be placed in a rectangle that has sides at most α k ). Each neighborhood has at least β 2 k points (since it contains a β k × β k square centered at any point of the island). Therefore the union of all rank k islands has Besicovitch density at most (α k /β k ) 2 . Indeed, for a large square the islands near its border can be ignored, and all other islands are surrounded by disjoint neighborhoods where their density is bounded by (α k /β k ) 2 , see Fig. 8.

One would like to conclude that the overall density of all islands (of all ranks) does not exceed ∑ k (α k /β k ) 2 . However, the Besicovitch density is in general not countably semiadditive (for example, the union of finite sets having density 0 may have density 1), but in our case we are helped by the second requirement of the definition of a sparse set (each point is covered by only finitely many neighborhoods of islands).

β k /2 β k /2
(∑(α k /β k ) 2 ).
Proof. Let O be a center point used in the definition of Besicovitch density. By definition of sparsity, this point is not covered by β k -neighborhoods of rank k islands if k is greater than some K. Now we split the set E into two parts: one (E ≤ ) formed by islands of rank at most K and the other (E > ) formed by all islands of bigger ranks. As we have just seen, in a large square the share of E ≤ is bounded by ∑ k≤K (α k /β k ) 2 up to negligible (as the size goes to infinity) boundary effects (where we consider each k ≤ K separately and then sum over all k ≤ K). A similar bound is valid for rank k islands with k > K, though the argument is different and a constant factor appears. Indeed, the β k -neighborhood of every island I does not contain the center point O. Therefore, any square S centered at O that intersects the island also contains a significant part of its (β k /2)-neighborhood N: The intersection of N and S contains at least (β k /2) 2 elements, see Fig. 9. Therefore, the share of E > in S is bounded by 4

∑ k>K (α k /β k ) 2 .
Remark. It is easy to choose α k and β k satisfying the conditions of Lemma 3 and having arbitrarily small ∑(αk/βk) 2 (by taking geometric sequences that grow fast enough). Therefore we get the following well-known result as a corollary of Lemmas 3 and 4: For every α > 0 there exists ε > 0 such that with probability 1 a B ε -random set has Besicovitch density less than α. (In fact, a much stronger result is well known: By the strong law of large numbers a B ε -random set has Besicovitch density ε with probability 1.)

In fact we will need a slightly more complicated version of Lemma 4. We are interested not only in the Besicovitch density of a sparse set E but also in the Besicovitch density of a larger set: the union of γ k -neighborhoods of rank k islands in E. Here γ k are some parameters; in most applications we set γ k = cα k for some constant c. The same argument gives the bound 4 ∑((αk

+ 2γ k )/β k ) 2 . Assuming that γ k ≥ α k , we can rewrite this bound as O(∑(γ k /β k ) 2
). So we arrive at the following statement: Lemma 5. Let E be a sparse set for a given family of α k and β k and let γ k ≥ α k be some integers. Then, the union of γ k -neighborhoods of level k islands (over all k and all islands) has Besicovitch density O(∑(γ k /β k ) 2 ).

β k /2 β k /2 O S part of the β k /2-neighborhood of an island part of the β k /2-neighborhood
of the island that is guaranteed to be inside S Figure 9: Together with a point in a rank k island, every square S contains at least (β k /2) 2 points of its (β k /2)-neighborhood.

Islands as a tool in percolation theory

Let us show how some basic results of percolation theory can be proved using the island technique.

Theorem 11. For some α k and β k satisfying the requirements of Lemma 3 the complement of any sparse set E contains exactly one infinite connected component C; the complement of C has Besicovitch density

O(∑ α k /β k ) 2 .
Proof. Let γ k = 2α k . (The choice of α k and β k will be discussed later.) For every k and for every rank k island fix a point in this island and consider the γ k -neighborhood of this point. It is a square containing the entire island plus an additional "security zone" of width α k , contained in the γ k -neighborhood of the island, see Fig. 10. It is enough to prove the following three statements:

α k γ k γ k
• The union U of all these squares (for all ranks) contains the set E and has Besicovitch density O(∑(α k /β k ) 2 ).

• The complement of U is connected.

• There are no other infinite connected component in the complements of E.

The first statement is a direct corollary of Lemma 5 above.

To prove the second statement, consider two points x and y outside U. We need to prove that x and y can be connected by a path that is entirely outside U. Let us connect x and y by some path (say, one of the shortest paths) and then push this path out of U. Consider squares of maximal rank that intersect this path. For each of them, consider the first moment when the path gets into the square and the last moment when the path goes out, and connect these two points by a path outside the square, see Fig. 11. Now the new path is α k -separated from this island of rank k. Provided β kγ k > α k , the path after the correction is α k -separated from all other islands of rank greater than k -1. Indeed, the "modified" part of the corrected path (the points of the path involved into the correction procedure) remains at a distance of at most γ k from the given k level island; hence, it must remain at a distance at least α k from all other islands of rank k and higher. Note also that the shift (the distance between the original path and the corrected one) does not exceed 2γ k .

α k γ k γ k
Then, we can do the same for islands of rank k -1 (pushing the path out of surrounding squares). Note that since at each step the drift is bounded by 2γ k-1 , we will not bump into islands of rank k.

Repeating this process for decreasing k, we finally get a path that connects x and y and goes entirely outside U. For this we need only the total drift on the smaller levels (which is bounded by 2 ∑ i<k γ i ) to be less than α k . This is easy to achieve if α k , β k , and γ k are suitable geometric sequences.

It remains to show that every infinite connected set intersects the complement of U. To show this, let us take a big circular path centered at the origin and then push it out of U as described above. Since the center is outside the β k -neighborhoods of islands for large enough k, we may assume that the sizes of islands that intersect this circle are small compared to its radius (say, less than 1% of it, which can be guaranteed if the geometric sequences α k , β k , and γ k grow fast enough). Then, after the change the circle will still encircle a large neighborhood of the origin, so any infinite connected component should cross such a circle.

Bi-islands of errors

In the proof of our main result (Section 13) we need a more delicate version of the definition of islands. In fact we need such a definition that some counterpart of Lemma 3 could be applied even if the sequence log β n grows much faster than 2 n (e.g., for β n = c (2.5) n ). In this section we define bi-islands (a generalization of the notion of islands from Section 9.2) and prove bi-island versions of Lemmas 3, 4, and 5. The reader can safely skip this section for now and return here before reading Section 13.

Let E ⊂ Z 2 be a set of points. As in Section 9.2, we call points in E dirty, and the other points clean. Let β ≥ α > 0 be integers. A nonempty set X ⊂ E is an (α, β )-bi-island in E if X can be represented as the union of some sets X 0 , X 1 such that (1) in the β -neighborhood of X = X 0 ∪ X 1 there are no points from E \ X;

(2) the diameters of X 0 and X 1 do not exceed α; and

(3) the distance between X 0 and X 1 does not exceed β . (See Fig. 12.) In particular, an (α, β )-island is a special case of an (α, β )-bi-island (by letting X 1 be empty).

≤ α ≤ α ≤ α ≤ α β β β
Figure 12: A bi-island, a union of two "islands" that are close to each other.

Note that one may split the same bi-island into X 0 and X 1 in different ways. Obviously, every two different bi-islands are disjoint. Moreover, the distance between them is greater than β . The diameter of a bi-island is at most (2α + β ).

Let (α 1 , β 1 ), (α 2 , β 2 ), . . . be a sequence of pairs of integers and α i ≤ β i for all i. We define an iterative cleaning procedure for bi-islands. At the first step we find all (α 1 , β 1 )-bi-islands and remove all their elements from E (getting a smaller set E 1 ). Then, we find in E 1 all (α 2 , β 2 )-bi-islands; removing them, we get E 2 ⊂ E 1 , etc. The cleaning process is successful if every dirty point is removed at some stage.

Similarly to the case of islands, we say that a point x ∈ Z 2 is affected during step i if x belongs to the β i -neighborhood of one of the bi-islands of rank i.

The set E is called bi-sparse (for a given sequence α i , β i ) if the cleaning process defined above is successful, and, moreover, every point x ∈ Z 2 is affected at finitely many steps only (which means that x is far from bi-islands of sufficiently large ranks).

We choose the values of α i and β i in such a way that for sufficiently small ε > 0 a B ε -random set is bi-sparse with probability 1. The main achievement here is that the convergence condition is now weaker than in the corresponding statement for islands (Lemma 3):

Lemma 6. Assume that 12 ∑ k<n β k < α n ≤ β n for every n, and ∑ i log β i 3 i < ∞.
Then, for all sufficiently small ε > 0, a B ε -random set is bi-sparse with probability 1.

Proof. The proof of Lemma 6 is very similar to the proof of Lemma 3. At first we estimate the probability of the event "x is not cleaned after n steps" for a given point x. If x ∈ E n , then x belongs to E n-1 and is not cleaned during the nth step (when (α n , β n )-bi-islands in E n-1 are removed). Then, x ∈ E n-1 . Moreover, we show that there exist two other points x 1 , x 2 ∈ E n-1 such that the three distances d(x, x 1 ), d(x, x 2 ), and d(x 1 , x 2 ) are all greater than α n /2 but not greater than 2β n + 2(α n /2) < 3β n .

However, this statement is not enough for us. In Section 13 we will need a kind of "closure" of the γ k -neighborhood of a bi-island:

Definition. Let S be a k-level bi-island. We say that (x, y) ∈ Z 2 belongs to the extended γ-neighborhood of S if there exist two points (x, y ′ ), (x, y ′′ ) ∈ Z 2 (with the same first coordinate) such that dist(S, (x, y ′ )) ≤ γ, dist(S, (x, y ′′ )) ≤ γ, and y ′ ≤ y ≤ y ′′ (see Fig. 13). The meaning of the last definition is quite simple: We take not only the points that are close to S but also those points that are placed somehow between the neighborhoods of S 0 and S 1 .

Lemma 8. Let E be a bi-sparse set for a given family of α k and β k satisfying the conditions of Lemma 6. Let γ k be a sequence of numbers such that α k < γ k , and the series ∑(γk/βk) converges. Then, the Besicovitch density of the union of extended γ k -neighborhoods of rank k bi-islands in E is bounded by O(∑(γ k /β k )).

Proof. The arguments are similar to the proof of Lemma 5. An extended γ k -neighborhood of a k-level island can be covered by a rectangle of width O(γ k ) and height O(β k + γ k ); so its area is O(γ k β k ) (since γ k ≤ β k ). The distance between any two bi-islands of rank k is at least β k . Hence, the fraction of extended γ k -neighborhoods of islands is O(∑ γ k /β k ) (this is similar to the bound O(∑(γ k /β k ) 2 ), which holds for simple γ n -neighborhoods).

Lemmas 6-8 will be used in Section 13. (The arguments of Sections 10-12 do not refer to bi-islands.) These lemmas will be used for α k , β k such that log α k ∼ q k for q > 2, β k ∼ α k+1 , and

γ k = O(α k ) or γ k = O(α 2 k
). Note that we cannot apply Lemmas 3 and 4 (about islands) for these parameters because log β k grows faster than 2 k . So we need to deal with bi-islands.

In the definition of sparse sets in Section 9.2 each single island of rank k must be isolated from other islands of rank k. In this section we modified this definition and allowed an island to be close to at most one other island of the same rank. In a similar way, we could define s-islands for any s ≥ 2, assuming that clusters of s islands of rank k (rather close to each other) are authorized. A set that can be represented as a union of s-islands of different ranks can be called s-sparse. A generalization of Lemmas 6 can be proven: A random set is s-sparse with probability 1 if ∑(log β i )/(s + 1) i converges. However, we do not develop here the general theory of s-sparse sets. The concept of bi-islands and bi-sparsity (i.e., the case s = 2) is enough for all our applications in Section 13. large enough. It remains to explain that "5-robustness" (in the sense described above) implies also (c 1 , c 2 )robust for some c 1 and c 2 . (The values of c 1 and c 2 depend on N, but N is fixed.) Indeed, assume that a tiling of a large enough neighborhood around a ∆×∆ hole is given. Denote by k the minimal integer such that N k ≥ ∆ (so the k-level macro-tiles are greater than the hole under consideration). Note that the size of the k-level macro-tiles is linear in O(∆) since N k ≤ N • ∆.

In the tiling around the hole, an N × N block structure is correct except for the N-neighborhood of the central ∆ × ∆ hole. Indeed, the colors encode coordinates, so in every connected tiled region the coordinates are consistent. For similar reasons an N 2 × N 2 structure is correct except for the (N + N 2 )-neighborhood of the hole, etc. Hence, for the chosen k we get a k-level structure that is correct except for (at most) 9 = 3 × 3 squares of level k, so we can delete everything in these squares and use 5-robustness to replace them with macro-tiles that correspond to replacement tiles.

To start this procedure (and fill the hole), we need a correct tiling only in the O(N k ) neighborhood of the hole. (Technically, we need to have a correct tiling in the (3N k )-neighborhood of the hole; as 3N k ≤ 3N∆, we let c 2 = 3N.) The correction procedure involves changes in another O(N k )-neighborhood of the hole. (Technically, the changes touch (2N k )-neighborhood of the hole; 2N k ≤ 2N∆, so we let c 1 = 2N.)

Robust tile sets with variable zoom factors

The construction from the previous section works only for self-similar tilings with a fixed zoom factor. It is enough for simple applications, as we will see in Section 12. However, in the proof of our main result in Section 13 we need a variable zoom factor. So here we develop a technique suitable for this case. This section can be skipped now but it should be read before Section 13. Now we explain how to get "robust" fixed-point tilings with variable zoom factors N 1 , N 2 , . . .. As well as in the case of a fixed zoom factor, the idea is that k-level macro-tiles are "responsible" for healing holes of size comparable with these macro-tiles.

Let ∆ 0 ≤ ∆ 1 ≤ ∆ 2 ≤ . . . be a sequence of integers. Let c 1 < c 2 be positive integers. We say that a tile set τ is (c 1 , c 2 )-robust against holes of size ∆ 0 , ∆ 1 , . . . if the following holds: For every n and for every τ-tiling U of the c 2 ∆ k neighborhood of a square ∆ k × ∆ k excluding the square itself there exists a tiling V of the entire c 2 ∆ k neighborhood of the square (including the square itself) that coincides with U outside of the c 1 ∆ k neighborhood of the square. The difference from the definition of Section 10 is that we take only values ∆ ∈ {∆ 0 , ∆ 1 , . . .} instead of holes of arbitrary size. Lemma 9. Assume a sequence of zoom factors N k grows not too fast and not too slow (it is enough to assume that N k ≥ C log k and C log N k+1 < N k for a large enough C; cf. the discussion in Section 5). Then, there exists a tile set with variable zoom factors N k (k-level macro-tiles of size

L k = N 0 • • • N k-1 ) that is (c 1 , c 2 )
-robust (for some c 1 and c 2 ) against holes of size L 0 , L 1 , . . .. Proof. First, we apply the fixed-point construction from Section 5 and get a tile set that is "self-similar" with variable zoom factors N 1 , N 2 , . . .. Denote by µ k the family of k-level macro-tiles corresponding to this tile set.

Further we make a "robustified" version of this tile set. To this end we basically repeat the arguments from Section 10 (the proof of Theorem 12). The difference in the argument is that now we deal with variable zoom factors, and sizes of holes are taken from the sequence L 0 , L 1 , . . ..

Denote by µ ′ k the family of k-level macro-tiles for the new tiling. We need that there exists a mapping δ : µ ′ k → µ k such that (a) δ -images of µ ′ k -tilings are exactly µ k -tilings and (b) µ ′ k is "5-robust": Every µ ′ k -tiling of a 5 × 5 square minus a 3 × 3 hole (see again Fig. 15) can be uniquely extended to the tiling of the entire 5 × 5 square.

To get such a robustification, it is enough to keep in every µ ′ k -macro-tile the information about the 5 × 5 square in the µ k -tiling and use the colors on the borders to ensure that this information is coherent in neighbor macro-tiles.

As usual, this robustification can be combined with the fixed-point construction. We get 5-robust macrotiles for all levels of our construction. "Self-similarity" guarantees that the same property holds for macrotiles of all levels, which implies the required property of generalized robustness.

Indeed, assume that a tiling of a large enough neighborhood around a ∆ × ∆ hole is given, and ∆ ≤ L k for some k. In the tiling around the hole, an (L 1 × L 1 ) block structure, is correct except for only the L 1 neighborhood of the hole. For similar reasons an (L 2 × L 2 ) structure is correct except for the (L 1 + L 2 ) neighborhood, etc. So we get a k-level structure that is correct except for (at most) 9 = 3 × 3 squares of size L k × L k . Because of 5-robustness, this hole can be filled with k-level macro-tiles. Note that reconstruction of groundlevel tiles inside a high-level macro-tile is unique after we know its "conscious known" information, i.e., the content of the tape of the Turing machine simulated on the computation zone of this macro-tile. (This information is reconstructed from the consciously known information of the neighbor macro-tiles.) [For the maximal complexity tile set (Section 7) it is not the case, and the absence of this property will become a problem in Section 13 where we robustify it. To solve this problem, we will need to use error-correcting codes.]

To implement the patching procedure (and fill the hole) we need to have a correct tiling in the O(L k ) neighborhood of the hole. The correction procedure involves changes in another O(L k ) neighborhood of the hole. More technically, we need to have a correct tiling in the (3L k )-neighborhood of a hole of size L k , so we let c 2 = 3. Since the correction procedure involves changes in the (2L k )-neighborhood of the hole, we let c 1 = 2.

We can robustify tiling not only against holes but against pairs of holes. To this end we slightly modify our definition of robustness. Let ∆ 0 ≤ ∆ 1 ≤ ∆ 2 ≤ . . . be an increasing sequence of integers, and let c 1 < c 2 be positive integers. We say that a tile set τ is (c 1 , c 2 )-robust against pairs of holes of size ∆ 0 , ∆ 1 , . . . if the following holds: Let us have two sets H 1 , H 2 ⊂ Z 2 , each of them of diameter at most ∆ k (for some k > 0). For every τ-tiling U of the c 2 ∆ k neighborhood of the union (H 1 ∪ H 2 ) excluding H 1 and H 2 themselves there exists a tiling V of the entire c 2 ∆ k neighborhood of (H 1 ∪ H 2 ) (including H 1 and H 2 themselves) that coincides with U outside of the c 1 ∆ k neighborhood of (H 1 ∪ H 2 ).

A robustification against pairs of holes can be done in the same way as the robustification against a single isolated hole. Indeed, if these two holes are far apart from each other, we can "correct" them independently; if they are rather close to each other, we correct them as one hole of (roughly) doubled size. So we can employ the same robustification technique as before; we need only to take a large enough "radius of multiplication" D (and use D-robustness instead of 5-robustness). So we get the following generalization of Lemma 9: Lemma 10. Assume a sequence of zoom factors N k grows not too fast and not too slow (e.g., N k ≥ C log k and C log N k+1 < N k for a large enough C). Then, there exists a tile set with zoom factors N k (i.e., with k-level macro-tiles of size L k = N 0 • • • N k-1 ) that is (c 1 , c 2 )-robust (for some c 1 and c 2 ) against pairs of holes of size L 0 , L 1 , . . . for some c 1 and c 2 .

Of course, similar propositions can be also proven for triplets, quadruplets, and any other sets of holes of bounded cardinality. However, in this paper we consider only pairs of holes; this is enough for our argument in Section 13.

The main difficulties and ways to circumvent them

We want to combine the construction from Section 7 with error-correcting methods based on the idea of "islands" of errors. There are two main difficulties in this plan: fast growing zoom factors and gaps in vertical columns. Let us discuss these two problems in some detail.

The first problem is that our construction of tiling with high Kolmogorov complexity from Section 7 requires variable zoom factors. What is even worse is that zoom factors N k must increase very fast (with logarithms growing faster than 2 k ). Hence, we cannot directly apply the technique of islands from Section 9.2 since it works only when ∑ log β k 2 k < ∞ (where β k is the parameter from the definition of islands, which, in our construction, must be of the same order as the size of k-level macro-tiles). To overcome this obstacle, we replace islands by bi-islands (the technique developed in Section 9.4).

The second problem is that now we cannot reconstruct a macro-tile from the information "consciously known" to this macro-tile. The missing information is the sequence of bits assigned to the vertical columns (with each vertical column of tiles carrying one bit of a high-complexity sequence ω). Random errors make gaps in vertical columns, so now the columns are split into parts, which a priori can carry different bits. To overcome this problem we organize additional information flows between macro-tiles to guarantee that each infinite vertical column carries in most of its tiles one and the same bit value.

General scheme

Here we explain the general ideas of our proof. First, we use macro-tiles with variable zoom factors N k = Q ⌊2.5 k ⌋ for a large enough integer Q > 0. This means that every k-level macro-tile is an (N k-1 × N k-1 ) array of (k -1)-level macro-tiles. So the size (the number of columns and the number of rows) of a k-level macrotile is

L k = N 0 • • • N k-1
, and L k < N k . (The constant 2.5 in our construction can be replaced by any rational number between 2 and 3.)

To get tilings with high Kolmogorov complexity, we reuse the construction from Section 7 with the zoom factors defined above. Let us recall the idea of that construction (proof of Theorem 9). In a correct tiling, in the ith column all tiles keep some bit ω i , and we want every N-bit substring in the corresponding biinfinite sequence ω to have Kolmogorov complexity Ω(N). To enforce this property we organize our computation on macro-tiles of all levels. The crucial point of the construction is propagation of bits ω i to the computation zones of macro-tiles of high levels. Let us recall the main points of this construction (following the argument from Section 7):

• We say that for each (infinite) column of tiles in a tiling there is an assigned bit ω i , which is "known" to each tile in the column. (In other words, there is a mapping that attributes to each tile the corresponding bit ω i ; vertically neighboring tiles must keep the same value of the bit.)

• For a k-level macro-tile (of size L k × L k ) its zone of responsibility is the sequence of L k bits ω i assigned to all columns of this macro-tile. Vertically aligned macro-tiles of the same level have the same zone of responsibility.

• For some k-level macro-tile M there is one delegated bit; this is a bit ω i from the zone of responsibility of this macro-tile. This bit must be known to the "consciousness" of the macro-tile; that is, it must be presented explicitly on the tape in the computation zone of this macro-tile. For technical reasons, we decide that the position of the delegated bit ω i in the zone of responsibility of M (this position is an integer between 0 and L k -1) is equal to the position (vertical coordinate) of M in its father macro-tile (see Fig. 5). The father is a macro-tile of level k + 1, which consists of N k × N k macro-tiles of level k (thus, the vertical coordinate of a k-level macro-tile in its father ranges over 0, . . . , N k -1). In our settings, N k > L k-1 . If a k-level macro-tile M has a vertical coordinate in its father greater than N k , then M does not have a delegated bit.

• If a k-level macro-tile M has a delegated bit in its computation zone, it also contains a group of bits to check that starts at the delegated bit and has rather small length (say, log log log k). If this group of bits leaves the responsibility zone, we truncate it. The Turing machine simulated in the computation zone of M enumerates the forbidden strings of "too small Kolmogorov complexity" and verifies that the checked group of bits does not contain any of them. This process is bounded by time and space allocated to the computation zone of a k-level macro-tile.

The last item requires additional comments. Technically, we fix constants α ∈ (0, 1) and c and check that for every string x in zones of responsibility of all macro-tiles K(x) ≥ α|x|c. To check this property, a macro-tile enumerates all strings x of complexity less than α|x|c. This enumeration requires infinite time, though computations in each macro-tile are time-bounded. However, this is not a problem since every such x is checked in macro-tiles of arbitrarily high levels (i.e., if x is covered by a macro-tile of level k, then it is also covered by macro-tiles of all levels greater than k). Thus, we guarantee the following property:

For every k-level macro-tile M (k = 1, 2, . . .), and for every substring x of ω that is contained in M's zone of responsibility (its horizontal projection), it holds that K(x) ≥ α|x|c.

( * )

Notice that K(x) ≥ α|x|c holds only for strings x covered by some macro-tile (i.e., strings that belong to some macro-tile's zone of responsibility). In "degenerate" tilings there can exist an infinite vertical line that is a border line for macro-tiles of all levels (see Fig. 6). A string x that intersects this line is not covered by any macro-tile of any level. Hence, ( * ) does not guarantee for such a string x that its Kolmogorov complexity is greater than α|x|c. However, as we noticed in Section 7.4, the parts of x on both sides of the boundary are covered by some macro-tile. Hence, it follows from ( * ) that K(x) ≥ α 2 |x| -O(1) = Ω(|x|) for all factors x of the biinfinite string ω.

Thus, we reuse the argument from Section 7, and it works well if there are no errors, but when we introduce random errors, the old construction is broken. Indeed, vertical columns can be damaged by islands of errors. Now we need to make an effort to enforce that copies of ω i consciously kept by different macrotiles are coherent (at least for macro-tiles that are not seriously damaged by local errors). To this end we will use some checksums, which guarantee that neighbor macro-tiles keep coherent conscious and subconscious information. We discuss this topic in the next section.

To deal with random errors we use the technique of bi-islands (see Section 9.4). Our arguments work if diameters of k-level bi-islands are comparable with the size of k-level macro-tiles. Technically, we set α k = 26L k-1 and β k = 2L k . (In the following we will see that this choice of β k is important for the error-correcting procedure; α k is set to 13β k-1 , so that lemmas on bi-islands can be applied.) Recall that

N k = Q ⌊2.5 k ⌋ and L k = N 0 • • • N k-1 .
Note that Lemmas 6 and 7 can be used with these values of parameters α, β . We will also employ Lemma 8 with γ k = O(α k ).

The new construction of the tile set

We take the construction from Section 7 as the starting point and superimpose some new structures on k-level macro-tiles. We introduce these supplementary structures in several steps.

First step (introducing checksums):

Every k-level macro-tile M (in a correct tiling) consists of an N k-1 × N k-1 array of (k -1)-level macro-tiles; each of these (k -1)-level macro-tiles may keep one delegated bit. Let us take one horizontal row (bits assigned to N k-1 macro-tiles of level k -1) in this twodimensional array of size N k-1 × N k-1 . Denote the corresponding sequence of bits by η 1 , . . . , η N k-1 . We introduce a sort of erasure code for this string of bits. In other words, we will calculate some checksums for this sequence. These checksums should be suitable to reconstruct all bits η 1 , . . . , η N k-1 if at most D of these bits are erased (i.e., if we know values η i for only N k-1 -D positions); here D > 0 is a constant (to be fixed later). We want the checksums to be easily computable. Here we use again the checksums of the Reed-Solomon code (discussed in Section 6).

Let us explain this technique in more detail. We take a finite field F k of large enough size (greater than N k-1 + D). Then, we calculate a polynomial of degree less than N k-1 that takes values η 1 , . . . , η N k-1 at some N k-1 points of the field. Further, we take as checksums the values of this polynomial at some other D points from F k (where all (N k-1 + D) points of the field are fixed in advance). Two polynomials of degree less than N k-1 can coincide in at most (N k-1 -1) points. Hence, if D bits from the sequence η 1 , . . . , η N k-1 are erased, we can reconstruct them given the other (nonerased) bits η j and the checksums defined above.

These checksums contain O(log N k-1 ) bits of information. We next discuss how to compute them.

Second step (calculating checksums): First, we explain how to compute the checksums, going from left to right along the sequence η 1 , . . . , η N k-1 . This can be done in a rather standard way as follows.

Let η 1 , . . . , η N k-1 be the values of a polynomial p(x) (of degree less than N k-1 ) at points x 1 , . . . , x N k-1 . Assume we want to reconstruct all coefficients of this polynomial. We can do this by the following iterative procedure. For i = 1, . . . , N k-1 we calculate polynomials p i (x) and q i (x) (of degree ≤ (i -1) and i, respectively) such that p i (x j ) = η j for j = 1, . . . , i

and q i (x) = (x -x 1 ) • • • (x -x i ).
It is easy to see that for each i, polynomials p i+1 and q i+1 can be computed from polynomials p i and q i and the values x i+1 and η i+1 . If we do not need to know the resulting polynomial p = p N k-1 (x) but want to get only the value p(a) at some particular point a, then we can perform all these calculations modulo (xa). Thus, to obtain the value of p(x) at D different points, we run in parallel D copies of this process. At each step of the computation we need to keep in memory only O(1) elements of F k , which is O(log N k-1 ) bits of temporary data (with the multiplicative constant in this O(•) notation depending on the value of D).

This calculation can be simulated by a tiling. We embed the procedure just explained into the computation zones of (k -1)-level macro-tiles. The partial results of the calculation are transferred from one (k -1)-level macro-tile to another one, from the left to the right (in each row of length N k-1 in a k-level macro-tile). The final result (for each row) is embedded into the conscious information (bits on the tape of the Turing machine in the computation zone) of the rightmost (k -1)-level macro-tile of the row.

To organize these computations, we need to include into conscious information kept by (k -1)-level macro-tiles additional O(log N k-1 ) bits and add the same number of bits to their macro-colors. This fits well our fixed-point construction since zoom factors N k grow fast, and we have enough room in the computation zone.

Third step (consistency of checksums between macro-tiles): So far, every k-level macro-tile contains O(N k-1 log N k-1 ) bits of checksums and O(log N k-1 ) bits for every row. We want these checksums to be the same for every two vertical neighbor macro-tiles. It is inconvenient to keep the checksums for all rows only in the rightmost column (since it would create too much traffic in this column if we try to transmit the checksums to the neighbor macro-tiles of level k). So we propagate the checksums of the ith row in a k-level macro-tile M (i = 1, . . . , N k-1 ) along the entire ith row and along the entire ith column of M. In other words, these checksums must be "consciously" known to all (k -1)-level macro-tiles in the ith row and in the ith column of M. In Fig. 16 we show the area of propagation of checksums for two rows (the ith and the jth rows). On the border of two neighbor k-level macro-tiles (one above another) we check that in each column i = 1, . . . , N k-1 all the corresponding checksums computed in both macro-tiles coincide. This check is redundant if there are no errors in the tiling: The checksums are computed from the delegated bits (which come from the sequence of bits ω encoded into tiles of the ground level), so the corresponding values for all vertically aligned macro-tiles must be equal to each other. However, this redundancy is useful to resist errors, as we show in the following.

Fourth step (robustification): The features just explained organized in every k-level macro-tile (bit delegation, computing and propagating checksums, and all the computations simulated in the computation zone of a macro-tile) are simulated by means of bits kept in the "consciousness" (i.e., in the computation zone) of (k -1)-level macro-tiles. Now we fix some constant C and "robustify" this construction in the following sense: Each (k -1)-level macro-tile M keeps in its consciousness not only "its own" data but also the bits previously assigned to (k -1)-level macro-tiles from its (C • L k-1 )-neighborhood (i.e., the (2C + 1) × (2C + 1) array of (k -1)-level macro-tiles centered at M). So, the content of the consciousness of each macro-tile is multiplied by some constant factor. Neighbor macro-tiles check that the data in their consciousness are coherent.

We choose the constant C so that every k-level bi-island (which consist of two parts of size α k ) and even the γ k = O(α k )-neighborhood of every k-level bi-island (where we specify γ k below) can involve only a small part of the (CL k-1 )-neighborhood of any (k -1)-level macro-tile. (Note that here we talk about neighborhoods, not about extended neighborhoods of bi-islands defined in Section 9.4.) This robustification allows us to reconstruct the conscious information of a k-level macro-tile and of its (k -1)-level sons when this macro-tile is damaged by one k-level bi-island (assuming there are no other errors).

The last remark (the number of bits in the consciousness of a macro-tile): The construction explained above requires that we put into the computation zones of all (k -1)-level macro-tiles additional poly(log N k-1 ) bits of data. (The most substantial part of the data is the information used to compute the checksums.) Again, this fits our fixed-point construction because poly(log N k-1 ) is much less than N k-2 , so Bits of field [A] in a small isolated group of (k -1)-level macro-tiles are trivially reconstructed from the surrounding macro-tiles of the same level. Fields [B], [C], [D], and [E] can be reconstructed because of the robustification on the level of (k -1)-level macro-tiles. (We organized the robustification on the level of (k -1)-level macro-tiles in such a way that we are able to reconstruct these fields for any C × C group of missing or corrupt (k -1)-level macro-tiles.) So far the correcting procedure follows the exactly the same steps as in Section 11.

To reconstruct fields [F] of (k -1)-level macro-tiles in M, we need to reconstruct all bits of ω from the zone of responsibility of M. We can extract these bits from the neighbor k-level tiles above or below M. (Recall that bi-island S touches only O(1) k-level macro-tiles, and there is a "healthy" zone of k-level macro-tiles around them.) However, a problem remains since we are not sure that the ω bits above M, below M, and inside M are consistent. Now we show that this consistency is guaranteed by checksums.

Denote by M u and M d the k-level macro-tiles just above and below S. Since the distance between S and other k-level bi-islands is greater than β k = 2L k , we know that M u and M d must be free of errors (where we assume that errors of ranks less than k are already corrected). See Fig. 17. In what follows, our explanations refer to Fig. 17, where bi-island S touches only one k-level macro-tile; if S touches several k-level macrotiles, substantially the same arguments work. It is enough to prove that the bits ω i assigned to corresponding columns of M u and in M d are equal to each other. The macro-tiles M u and M d are error free; therefore, the sequences of L k bits ω i corresponding to the vertical lines intersecting these k-level macro-tiles are well defined. Since there are no errors, the conscious information (including checksums) in all macro-tiles of all levels inside M u and M d is consistent with these bit sequences. So, the L k bits assigned to the vertical columns are correctly delegated to the corresponding (k -1)-level macro-tiles inside M u and M d . However, it is not evident that the sequences of L k bits embedded in M u and M d are equal to each other.

In fact, it is easy to see that bit sequences for M u and M d coincide with each other at most positions. They must be equal for all columns (from the range 0, . . . , L k -1) that do not intersect bi-island S (i.e., in nondamaged columns of tiles on the ground level, the assigned bits ω i correctly spread though macro-tiles M u , M, and M d ). Hence, the bits delegated to the corresponding (k -1)-level macro-tiles in M u and M d are equal to each other, except for only (k -1)-level macro-tiles in the "gray zone" of Fig. 17, which contains the (k -1)-level macro-tiles involved in the correction of S and all vertical stripes touching the involved sites. (The width of this gray stripe is only O(1) macro-tiles of level (k -1).) Hence, for i = 0, . . . , (N k-1 -1), in the ith rows of (k -1)-level macro-tiles in M u and M d , the sequences of delegated bits are equal to each other except possibly for only O(1) bits (delegated to (k -1)-level macro-tiles in the "gray zone").

The robustness property guarantees that all checksums are correctly transmitted through M. Hence, checksums for corresponding rows in M u and in M d must be equal to each other.

Thus, for every two corresponding rows of (k -1)-level macro-tiles in M u and in M d we know that (a) all except O(1) delegated bits in the corresponding positions are equal to each other and (b) the checksums are equal to each other. From the property of our erasure code it follows that in fact all delegated bits in these rows are equal to each other (with every ith bit in M u being equal to the ith bit in M d ). Therefore, all bits ω i in M u and M d are the same (on the ground level). We can use these bits to reconstruct subconsciousness of M and get a consistent tiling in M.

We are almost done. Bi-island S is corrected; we reconstructed conscious information for the k-level macro-tile M and for all its (k -1)-level sons. Now we can reconstruct fields [F] in the damaged (k -1)level macro-tiles inside M. This is simple to do. We just take the corresponding bits ω i from the zone of responsibility (shared by M, M u , and M d ). It remains only to explain why the checking procedure does not fail for these groups of bits (i.e., (k -1)-level macro-tiles do not discover in these bit strings any factors of low Kolmogorov complexity). But this is true because macro-tiles of levels (k -1) (and also below (k -1)) inside M apply exactly all the same checks to exactly the same groups of bits ω i as the macro-tiles in the corresponding positions in M u and M d . Since there is no errors in M u and M d , these computations do not lead to a contradiction.

Let us inspect again the correction procedure just explained; we should notice which tiles are involved in the error-correcting process around bi-island S. In the (k -1)-level macro-tiles outside the "gray zone" we change nothing. Moreover, not all the gray zone needs to be changed-only the part between two clusters of S (and their small neighborhoods) is affected. Indeed, in all tiles of M that are above S the assigned bits ω i are the same as in the corresponding columns of M u ; in the tiles of M that are below S the assigned bits ω i are the same as in the corresponding columns of M d . Hence, there is no need to correct "subconscious information" of (k -1)-level macro-tiles that are above or below S. Only the area between two clusters of S requires corrections. More precisely, the area involved in the correcting procedure is inside the extended neighborhood of S. (In fact, this argument is the motivation of our definition of extended neighborhood.) Thus, we have proven that this step-by-step correcting procedure eliminates all bi-islands of errors and only extended γ k -neighborhoods of k-level bi-islands are involved in this process. Now Theorem 14 (part 3) follows from Lemma 8. It remains only to prove part 4 of the theorem. We do this in the next section.

Levin's property for ω embedded into a (τ, E)-tiling

It remains to prove part (4) of Theorem 14. In the previous section we proved that if the set of errors E is bi-sparse, then a (τ, E)-tiling T can be converted into a τ-tiling T ′ of the entire plane, and the difference between T and T ′ is covered by extended γ k neighbors of k-level bi-islands from E (k = 0, 1, . . .). Now we want to show that, in the initial tiling T , the Kolmogorov complexity of centered squares of size N × N was Ω(N).

Fix a point O. Since E is bi-sparse, O is covered by β k -neighborhoods of only finitely many bi-islands. Hence, for large enough ∆, the ∆ × ∆ square Q ∆ centered at O intersects extended γ k -neighborhoods of klevel bi-islands only if β k < ∆. (If the extended γ k -neighborhood of some bi-island intersects Q ∆ and β k ≥ ∆, then β kγ k > ∆/2 and O is covered by the β k -neighborhood of this bi-island.) Therefore, to reconstruct T ′ in Q ∆ it is enough to correct there all bi-islands of bounded levels (such that β k < ∆).

To reconstruct T ′ in Q ∆ we need to know the original tiling T in Q ∆ and some neighborhood around it (i.e., in some centered O(∆) × O(∆) square Q ∆ ′ , which is only greater than Q ∆ by a constant factor). Indeed, given the tiling T restricted on Q ∆ ′ , we can locally correct there bi-islands of levels 1, 2, . . . , k (such that β k < ∆) one by one. Correcting a bi-island of errors in Q ∆ ′ we obtain the same results as in the errorcorrecting procedure on the entire plane Z 2 unless this bi-island is too close to the border of Q ∆ ′ (and the local correction procedure should involve information outside Q ∆ ′ ). Thus, we can reconstruct T ′ -tiling not in the entire Q ∆ ′ but in points that are far enough from the border of this square. If ∆ ′ = c∆ for large enough c, then Q ∆ ′ provides enough information to reconstruct T ′ in Q ∆ .

We know that Kolmogorov complexity of error-free tiling T ′ in Q ∆ is Ω(∆). Therefore, the Kolmogorov complexity of the original T -tiling in the greater square Q ∆ ′ is also Ω(∆). Since ∆ ′ is only greater than ∆ by a constant factor, we get that the Kolmogorov complexity of the (τ, E)-tiling T restricted to the centered (∆ ′ × ∆ ′ ) square is Ω(∆ ′ ).

Theorem 14 is proven.

NFigure 1 :

 1 Figure 1: Tiles and macro-tiles for Example 2.

Figure 3 :

 3 Figure 3: Checking tiles with a universal Turing machine.

Figure 4 :

 4 Figure 4: Three steps of Thue-Morse substitution.

  Let a n and b n be the nth terms in these sequences (a 0 = 0, a 1 = 01, . . . , b 0 = 1, b 1 = 10, etc.); it is easy to see that a n+1 = a n b n and b n+1 = b n a n .

Figure 6 :

 6 Figure 6: Degenerate case: An infinite vertical line is a boundary between macro-tiles of all levels.

Figure 7 :

 7 Figure 7: Explanation tree; vertical lines connect different names for the same points.

Figure 8 :

 8 Figure 8: Rank k islands form a set of low density. (In this picture each island is shown as a rectangle, which is not always the case.)

Figure 10 :

 10 Figure 10: A point in a rank k island, its γ k -neighborhood, and the security zone of width α k .

Figure 11 :

 11 Figure 11: Pushing a path out of the square.

Figure 13 :

 13 Figure13: An extended neighborhood of a bi-island consists of the neighborhoods of its two parts and a zone between them.

Figure 16 :

 16 Figure 16: Propagation of checksums inside of a macro-tile.

  macro-tile M u without errors macro-tile M d without errors macro-tile M with an error bi-island

Figure 17 :

 17 Figure 17: Bi-island of errors in a macro-tile.

Speaking about local rules, we mean that one can check the correctness of the time-space diagram by looking through a O(1)size window; in the standard representation width 3 and height

2 is enough. However, our definition of a tile set is even more local: We compare colors on matching sides only. It is easy to see that we can still simulate any local rules by tiles. Each tile keeps the contents of the corresponding window, and colors are used to ensure that overlapping windows are consistent.

We use this anthropomorphic terminology in the hope it makes the proof more intuitive. By saying "each tile knows its coordinates," we mean that the tile set is split into N 2 disjoint groups; each group corresponds to tiles that appear in one of N 2 positions in the macro-tiles. The correct positioning of the tiles is ensured (as we have seen) by side colors. The self-similarity guarantees that the same is true for macro-tiles, where the group (i.e., the coordinates in a macro-tile of the next level) is determined by the content of the computation zone and corresponding bits (macro-colors) on the sides.

A natural question arises: What does it mean to add a letter that is determined by other information? Adding a letter means that we create |A| copies of the same tile (with different letters); but then, the restriction prohibits all of them except one, so is there any change at all? In fact, the actual change is occurring on higher levels: We want the macro-tiles to have both letters written on the tape as binary strings (in some prearranged places). This is important for checking consistency between levels.

Acknowledgments

The results included in this paper were discussed with many colleagues, including Peter Gács, Leonid Levin, and our french collaborators Meghyn Bienvenu, Laurent Bienvenu, Emmanuel Jeandel, Gregory Lafitte, Nicolas Ollinger, and Michael Weiss. We are grateful to all of them and to the participants of seminars (the Kolmogorov seminar at Moscow State University, the IITP seminars, and the FRAC seminar) and conferences (DLT 2008 and ICALP 2009) where some of these results were presented. We appreciate the detailed comments and many useful suggestions given by the anonymous referee.

* Supported in part by ANR EMC ANR-09-BLAN-0164-01, NAFIT ANR-08-EMER-008-01, and RFBR 09-01-00709-a grants. 1

Let X 0 be the (α n /2)-neighborhood of x in E. If X 0 were an island, it would be removed. Since this does not occur, there is a point x 1 outside X 0 but in the β n -neighborhood of X 0 .

Let X 1 be the (α n /2)-neighborhood of x 1 in E. Again X 0 and X 1 do not form a bi-island. Both sets X 0 and X 1 have diameter at most α n , and the distance between them is at most β n . So the only reason why they are not a bi-island is that there exists a point x 2 ∈ E outside X 0 ∪ X 1 but in the β n -neighborhood of it. The points x 1 and x 2 have the required properties (the distances d(x, x 1 ), d(x, x 2 ), and d(x 1 , x 2 ) are greater than α n /2 but not greater than 3β n ).

To make the notation uniform, we denote x by x 0 . Each of the points x 0 , x 1 , x 2 belongs to E n-1 . This means that each of them belongs to E n-2 together with a pair of other points (at a distance greater than α n-1 /2 but not exceeding 3β n-1 ). In this way we get a ternary tree that "explains" why x belongs to E n .

The distance between every two points among x 0 , x 1 , and x 2 in this tree is at least α n /2 whereas the diameters of the subtrees starting at x 0 , x 1 , and x 2 do not exceed ∑ i<n 3β i . Thus, the lemma's assumption guarantees that these subtrees cannot intersect and that all the leaves of the tree are different. The number of leaves in this ternary tree is 3 n , and they all belong to E = E 0 . Every point appears in E independently of other points; hence, one such "explanation tree" is valid with probability ε 3 n . It remains to count the number of all explanation trees for a given point x.

To specify x 1 and x 2 we need to specify horizontal and vertical distances between x 0 and x 1 , x 2 . These distances do not exceed 3β n ; therefore we need about 4 log(6β n ) bits to specify them (including the sign bits). Then, we need to specify the distances between x 00 and x 01 , x 02 as well as the distances between x 10 and x 11 , x 12 and between x 20 and x 21 , x 22 . This requires at most 12 log(6β n-1 ) bits. To specify the entire tree we therefore need

The series ∑ log β n /3 n converges by assumption; so, the total number of explanation trees for a given point (and given n) does not exceed 2 O(3 n ) . Hence, the probability for a given point x to be in E n for a B ε -random E does not exceed ε 3 n 2 O(3 n ) , which tends to 0 as n → ∞ (assuming that ε is small enough).

We conclude that the event "x is not cleaned" (for a given point x) has zero probability; hence, with probability 1 all points in Z 2 are cleaned.

It remains to show that every point with probability 1 is affected by finitely many steps only. Indeed, if x is affected by step n, then some point in its β n -neighborhood belongs to E n , and the probability of this event is at most

From the convergence conditions we have log β n = o(3 n ), so the first term is negligible compared to others. The probability series converges (for small enough ε) and the Borel-Cantelli lemma gives the result.

By definition, a bi-sparse set is split into a union of bi-islands of different ranks. Such bi-islands occupy only a small part of the plane: Lemma 7. Let E be a bi-sparse set for a given family of α k and β k . Then, the Besicovitch

Proof. The proof of Lemma 7 repeats the proofs of Lemma 4.

Recalling Lemma 5, we may consider a sequence of numbers γ k such that γ k ≥ α k . Then, the Besicovitch density of the union of γ k -neighborhoods of rank k bi-islands (for all k and for all islands) is bounded by

Robust tile sets

In this section we construct an aperiodic tile set where isolated defects can be healed. Let c 1 < c 2 be positive integers. We say that a tile set τ is (c 1 , c 2 )-robust if the following holds: For every ∆ and for every τ-tiling U of the (c 2 ∆)-neighborhood of a square ∆×∆ excluding the square itself there exists a tiling V of the entire (c 2 ∆)-neighborhood of the square (including the square itself) that coincides with U outside of the (c 1 ∆)-neighborhood of the square (see Fig. 14).

Theorem 12. There exists a self-similar tile set that is (c 1 , c 2 )-robust for some c 1 and c 2 .

Proof. For every tile set µ it is easy to construct a "robustified" version µ ′ of µ, i.e., a tile set µ ′ and a mapping δ : µ ′ → µ such that (a) δ -images of µ ′ -tilings are exactly µ-tilings and (b) µ ′ is "5-robust": Every µ ′ -tiling of a 5 × 5 square minus 3 × 3 hole (see Fig. 15) can be uniquely extended to the tiling of the entire 5 × 5 square. Indeed, it is enough to keep in one µ ′ -tile the information about the 5 × 5 square in µ-tiling. Matching rules will guarantee that the information about the intersection (4 × 5 rectangle) is consistent in neighbor tiles. Then, a 3 × 3 hole (as shown in the picture) is not fatal. It is easy to see that the tiles at its border (gray) are consistent and contain all the information the missing tiles should have. (In fact, using more careful estimates one can replace in our argument the 5 × 5 squares by 4 × 4 squares; but we do not care much about constants.)

This robustification can be easily combined with the fixed-point construction. In this way we can get a "5-robust" self-similar tile set τ if the zoom factor N (which is considered to be fixed in this argument) is 12 Strongly aperiodic robust tile sets Now we are ready to apply the islands technique to construct a robust strongly aperiodic tile set. We start with a formal definition of a tiling with errors (see the motivation and discussion in Section 9.1).

Definition. For a subset E ⊂ Z 2 and a tile set τ we call by a (τ, E)-tiling any mapping T : (Z 2 \ E) → τ such that for every two neighbor cells x, y ∈ Z 2 \ E, tiles T (x) and T (y) satisfy the tiling rules (colors on adjacent sides match). We may say that T is a τ-tiling of the plane with holes at points of E.

Theorem 13. There exists a tile set τ with the following properties: (1) τ-tilings of Z 2 exist and (2) for all sufficiently small ε for almost every (with respect to B ε ) subset E ⊂ Z 2 every (τ, E)-tiling is at least 1/10 Besicovitch apart from every periodic mapping F : Z 2 → τ.

Remark 1. Since the tiling contains holes, we need to specify how we treat the holes when defining the Besicovitch distance. We do not count points in E as points where two mappings differ; this makes our statement stronger.

Remark 2. The constant 1/10 is not optimal and can be replaced by any other constant α < 1.

Proof. Consider a tile set τ such that (a) all τ-tilings are α-aperiodic for every α < 1/4 and (b) τ is (c 1 , c 2 )robust for some c 1 and c 2 . Such a tile set can be constructed by combining the arguments used for Theorems 12 and 4. More precisely, we take as the "basic" construction the tile set from the proof of Theorem 4 (which simulates the Thue-Morse substitution). Then, we "robustify" it by the procedure from the proof of Theorem 12. For the robustified tile set we know that each macro-tile in a tiling keeps the conscious information that was given (in the "basic" tile set) to all macro-tiles in its 5 × 5-neighborhood; so the new tiling is not only strongly aperiodic but also 5-robust. It remains to show that this construction implies claim (2) of the theorem. We want to apply our probabilistic lemmas concerning "island of errors". We need to choose α k and β k such that

• the conditions of Lemma 3 (p. 28) are satisfied, and therefore a random error set with probability 1 is sparse with respect to these α k and β k ;

• for every sparse set E ⊂ Z 2 , every (τ, E)-tiling can be iteratively corrected (by changing it in the neighborhoods of islands of all ranks) into a τ-tiling of the entire plane; and

• the Besicovitch distance between the tilings before and after correction is small.

Then, we conclude that the original (τ, E)-tiling is strongly aperiodic since the corrected tiling is strongly aperiodic and close to the original one.

To implement this plan, we use the following lemma that describes the error-correction process.

Lemma 11. Assume that a tile set τ is (c 1 , c 2 )-robust, β k > 4c 2 α k for every k, and a set E ⊂ Z 2 is sparse (with parameters α k , β k ). Then, every (τ, E)-tiling can be transformed into a τ-tiling of the entire plane by changing it in the union of (2c 1 α k )-neighborhoods of rank k islands (for all islands of all ranks).

Proof. Note that (β k /2)-neighborhoods of rank k islands are disjoint and large enough to perform the error correction of rank k islands, since β k > 4c 2 α k . The definition of a sparse set guarantees also that every point is changed only finitely many times (so the limit tiling is well defined) and that the limit tiling has no errors.

The Besicovitch density of the changed part of a tiling can be estimated using Lemma 4. Here γ k = 2c 1 α k is proportional to α k , so the Besicovitch distance between the original and corrected tilings (in Lemma 11) is O(∑ k (α k /β k ) 2 ). (Note that the constant in O notation depends on c 1 .)

It remains to choose α k and β k . We have to satisfy all the inequalities in Lemmas 3, 4, and 11. To satisfy Lemmas 4 and 11, we may let β k = ckα k for large enough c. To satisfy Lemma 3, we may let

Then, α k and β k grow faster than any geometric sequence (like k! multiplied by some exponent in k), but still log β k is bounded by a polynomial in k and the series in Lemma 3 converges.

With these parameters (and taking c large enough) we guarantee that the Besicovitch distance between the original (τ, E)-tiling and the corrected τ-tiling does not exceed, say, 1/100. Now assume that some (τ, E)-tiling V is at a distance less than 1/10 from some periodic configuration W (with a period v). As we just explained, the original (τ, E)-tiling V must be at a distance at most 1/100 from some correct τ-tiling V ′ . Let us consider the v-shift of both configurations V and V ′ (W is shifted to itself). It is easy to see that the distance between the initial and the shifted copies of configuration V ′ is not greater than the sum dist(V ′ ,V ) + dist(V,W ) taken twice. Since the corrected tiling V ′ must be 1/4-aperiodic, and 1/4 > 2(1/10 + 1/100), we get a contradiction.

Robust tile sets that enforce complex tilings

In this section we prove the main result of the paper. We construct a tile set that guarantees large Kolmogorov complexity of every tiling and that is robust with respect to random errors. Theorem 14. There exists a tile set τ and constants c 1 , c 2 > 0 with the following properties:

(1) a τ-tiling of Z 2 exists;

(2) for every τ-tiling T of the plane, every N × N square of T has Kolmogorov complexity at least c 1 N -C 2 ;

(3) for all sufficiently small ε for almost every (with respect to the Bernoulli distribution B ε ) subset E ⊂ Z 2 , every (τ, E)-tiling is at most 1/10 Besicovitch apart from some τ-tiling of the entire plane Z 2 ;

(4) for all sufficiently small ε for almost every B ε -random subset E ⊂ Z 2 , for every (τ, E)-tiling T the Kolmogorov complexity of centered squares of T of size N × N is Ω(N).

The rest of the section is devoted to the proof of this theorem. It combines almost all technique developed in this paper: self-similar tile sets with variable zoom factors, embedding a sequence with Levin's property (i.e., with linear Kolmogorov complexity of all factors) into tilings, bi-sparse sets, incremental error correcting, and robustness against doubled holes.

In this section the basic idea of incremental error correcting is applied in a slightly modified form. Here we cannot apply directly the technique of (c 1 , c 2 )-robustness from Section 10. Instead we use the idea of robustness against holes of some sequence of sizes ∆ 0 , ∆ 1 , ∆ 2 , . . ., as explained in Section 11. More precisely, we do it as follows: We split the set of random errors into bi-islands of different ranks. Then, we eliminate them one by one, starting from lower ranks. When we correct an isolated bi-island of rank k, we need a precondition (similarly to the argument in Section 10): In a large enough neighborhood of this bi-island there are no other errors. Elimination of a k-level bi-island involves corrections in its extended O(∆ k )-neighborhood (with all parameters as specified below).

we have enough room to keep and process all these data.

The tile set τ is thus defined. Since there exists an ω with Levin's property, it follows that τ-tiling exists, and every N × N square of such a tiling has Kolmogorov complexity Ω(N). Further, we prove that this τ satisfies also statement (3) of Theorem 14.

Error-correcting procedure

Denote by τ the tile set described in Section 13.3. Let ε > 0 be small enough. Lemma 12 says that a B εrandom set with probability 1 is bi-sparse. Now we assume that E ⊂ Z 2 is a bi-sparse set (for the chosen values of α i and β i ), and T is a τ-tiling of Z 2 \ E. Further, we explain how to correct errors and convert T into a tiling T ′ of the entire plane (where T ′ should be close to T ).

We follow the usual strategy. The set E is bi-sparse; that is, it can be represented as a union of isolated bi-islands of different ranks. We correct them one by one, starting from bi-islands of low ranks. To prove that the correction procedure converges, we need to explain one step of this process: how to correct one bi-island S of rank k assuming that it is well isolated, i.e., in the β k -neighborhood of this bi-island there are no other (still noncorrected) errors.

Let us recall that a k-level bi-island S is a union of two "clusters" S 0 , S 1 ; the diameters of both S 0 and S 1 are at most α k = O(L k-1 ). Hence the clusters S 0 and S 1 touch only O(1) macro-tiles of level (k -1). The distance between S 0 and S 1 is at most β k , and the β k -neighborhood of S is free of other bi-islands of rank k and higher (so we can assume that the β k -neighborhood of S is already cleaned of errors). Our correction procedure around S will involve only points in the extended γ k -neighborhood of S, where γ k = 2α k .

Let M be one of k-level macro-tiles intersecting the extended γ k -neighborhood of the k-level bi-island S. Basically, we need to reconstruct all (k -1)-level macro-tiles in M destroyed by S. First, we will reconstruct the conscious information in all (k -1)-level macro-tiles in M. This is enough to get all bits of ω from the "zone of responsibility" of M. Then, we will reconstruct in a consistent way all n-level macro-tiles inside M for all n < k.

Thus, we start with reconstructing the consciousness of all (k -1)-level macro-tiles M ′ in M. First, we recall that the consciousness (the content of the computation zone) of every (k -1)-level macro-tile M ′ consists of several groups of bits (cf. the outline of the construction in Section 13.2, p. 41):

[A] the binary representation of the number (k -1) and coordinates (integers from the range 0, . . . , N k-1 -1) of M ′ in the father macro-tile M;

[B] the bits used to simulate a Turing machine on the computation zone of M and the bits used to implement "wires" of M;

[C] the bit (from the sequence ω) delegated to M ′ ;

[D] the bit (from ω) delegated to M;

[E] the bits used to calculate and communicate the checksums for the corresponding row of (k -1)-level macro-tiles in M; and

[F] a group of bits to check from the zone of responsibility of M ′ ; these bits are checked by the macro-tile: M ′ checks on its computation zone that this "group of bits to check" does not contain any factor of low Kolmogorov complexity.