The Complexity of Tiling Problems

TL;DR

This paper reviews key complexity results in tiling problems, introduces a new deterministic tile set concept, and identifies tiling problems complete for LOGSPACE and NLOGSPACE complexity classes.

Contribution

It proposes a new definition for deterministic tile sets and characterizes tiling problems complete for specific computational complexity classes.

Findings

Identifies tiling problems complete for LOGSPACE and NLOGSPACE.

Proposes a formal definition of deterministic tile sets.

Summarizes major complexity results in tiling problems.

Abstract

In this document, we collected the most important complexity results of tilings. We also propose a definition of a so-called deterministic set of tile types, in order to capture deterministic classes without the notion of games. We also pinpoint tiling problems complete for respectively LOGSPACE and NLOGSPACE.

Tables

Table 1. Table 1: Complexities of tiling ( n 𝑛 n is in unary ).

in FO	$TILING(cst,cst)$	Th. 16
LOGSPACE -complete	$rotTILING(n,1)$	Th. 19
	$rotTILING(\ast ,1)$
NLOGSPACE -complete	$TILING(n,1)$	Th. 17
	$TILING(\ast ,1)$
P -complete	$detTILING(n,n)$	Th. 12
NP -complete	$TILING(n,n)$	Th. 1
${\Sigma }_k^P$-complete	$TILING(kn,n,{\exists }^n{\left({\forall }^n{\exists }^n\right)}^{k-1})$	Th. 10
${\Pi }_k^P$-complete	$TILING(kn,n,{\forall }^n{\left({\exists }^n{\forall }^n\right)}^{k-1})$	Th. 10
Pspace -complete	$TILING(2^n,n)$	Th. 4
	$TILING(\ast ,n)$
	$detTILING(2^n,n)$	Th. 13
	$detTILING(\ast ,n)$
	$TILING(n,n,{\left(\exists \forall \right)}^{\ast })$	Th. 6
ApolEXPTIME-complete	$TILING(2\times n\times 2^n,2^n,{\left({\exists }^{2^n}{\forall }^{2^n}\right)}^{\ast })$	Th. 11
$k$Exptime -complete	$TILING(ex{p}_k\left(n\right),ex{p}_{k-1}\left(n\right),{\left(\exists \forall \right)}^{\ast })$	Th. 9
	$TILING(\ast ,ex{p}_{k-1}\left(n\right),{\left(\exists \forall \right)}^{\ast })$
	$detTILING(ex{p}_k\left(n\right),ex{p}_k\left(n\right))$	Th. 14
$k$NExptime -complete	$TILING(ex{p}_k\left(n\right),ex{p}_k\left(n\right))$	Th. 3
$k$Expspace -complete	$TILING(ex{p}_{k+1}\left(n\right),ex{p}_k\left(n\right))$	Th. 5
	$TILING(\ast ,ex{p}_k\left(n\right))$
	$detTILING(ex{p}_{k+1}\left(n\right),ex{p}_k\left(n\right))$	Th. 15
	$detTILING(\ast ,ex{p}_k\left(n\right))$
	$TILING(ex{p}_k\left(n\right),ex{p}_k\left(n\right),{\left(\exists \forall \right)}^{\ast })$	Th. 7

Equations

$$\begin{array}{c}\underbrace{2^{2^{{}^{.{}^{.{}^{.{}^n}}}}}}.\\ k\text{mbox}occurrencesof2\end{array}$$

$$\exists t_1,t_2,t_3,t_4,H(t_1,t_2)\wedge H(t_3,t_4)\wedge V(t_1,t_3)\wedge V(t_2,t_4)$$

Full text

1 Introduction

As advocated by van der Boas [15], tilings are convenient to prove lower complexity bounds. In this document, we show that tilings of finite rectangles with Wang tiles [16] enable to capture many standard complexity classes:

FO (the class of decision problems defined by a first-order formula, see [9]), LOGSPACE , NLOGSPACE , P , NP , Pspace , Exptime , NExptime , $k$-Exptime and $k$-Expspace , for $k\geq 1$.

This document brings together many results of the literature. We recall some results from [15]. The setting is close to Tetravex [13], but the difference is that we allow a tile to be used several times. That is why we will the terminology tile types. We also recall the results by Chlebus [6] on tiling games, but we simplify the framework since we suppose that players alternate at each row (and not at each time they put a tile).

The first contribution consists in capturing deterministic time classes with an existence of a tiling, and without any game notions. We identify a syntactic class of set of tiles, called deterministic set of tiles. For this, we have slightly adapted the definition of the encoding of executions of Turing machines given in [15].

The second contribution is the connection between one-dimensional tilings and the classes LOGSPACE and NLOGSPACE . In particular, we rely on the fact that the reachability problem in directed graphs is NLOGSPACE -complete [10], and the reachability problem in undirected graphs is in LOGSPACE [12]. There are small differences compared to the literature. Note that Grädel (see [8], p. 800 before Th. 7.1) also introduced one-dimensional tilings, more precisely domino games. According to Grädel [8] (Remark p. 802), they were also introduced by J. Toràn in his PhD thesis. Note that we generalize some result of Etzion-Petruschka et al. who also considered one-dimensional tilings (see Th. 2.7 in [7]).

*Outline. * First we recall basic definitions about tilings in Section 2. Then, we recall results about existence of tilings and classes above P in 3. We then continue with tiling games in Section 4. We then show how to get rid off games in order to capture deterministic classes in Section 5. We finish with existence of tilings and classes below P in Section 6.

2 Basic Definitions

A tile type $t$ specifies the four colors of a tile in the left, up, right, down directions.

Formally, let $\mathcal{C}$ be a countable set of colors; a special color being white. A tile type $t$ is an element of $\mathcal{C}^{4}$, written $\langle left(t),up(t),right(t),down(t)\rangle$.

Let $T$ be a finite set of tile types. A $T$-tiling of the finite $H\times W$ rectangle is a function $\tau:{\{1,\dots,H\}}\times{\{1,\dots,W\}}\rightarrow T$ such that:

$left(\tau(i,1))=right(\tau(i,W))=white$ for all $i\in{\{1,\dots,H\}}$; 2. 2.

$top(\tau(1,j))=bottom(\tau(H,j))=white$ for all $j\in{\{1,\dots,W\}}$; 3. 3.

$right(\tau(i,j))=left(\tau(i,j{+}1))$ for all $i\in{\{1,\dots,H\}}$, $j\in{\{1,\dots,W{-}1\}}$; 4. 4.

$bottom(\tau(i,j))=top(\tau(i{+}1,j))$ for all $i\in{\{1,\dots,H{-}1\}}$, $j\in{\{1,\dots,W\}}$.

Constraint 1 means that the left of the left-most tiles and the right of the right-most tiles should be white111As you will see, this constraint is important to identify the beginning of the tape of a Turing machine and to avoid the head to disappear when its head is the left-most cell by triggering a transition moving the head to the left. This constraint will also help to deterministic set of tiles.. Constraint 2 says that the top of the top-most tiles and the bottom of the bottom-most tiles should be white222This constraint will also help to deterministic set of tiles.. Constraint 3 corresponds to the horizontal constraint and constraint 4 to the vertical constraint.

Let $w:\mathbb{N}\rightarrow\mathbb{N}$ and $h:\mathbb{N}\rightarrow\mathbb{N}$. We aim to tile the finite $h(n)\times w(n)$ rectangle, as shown in Figure 1. The top-left tile $t_{0}$ plays the role of a seed and is given.

Definition 1

Let $h:\mathbb{N}\rightarrow\mathbb{N}$ and $w:\mathbb{N}\rightarrow\mathbb{N}$. $TILING(h,w)$ is the following decision problem:

• •

input: an integer $n$ given in unary, a finite set $T$ of tiling types, a tile $t_{0}$;

• •

output: yes, if there is a $T$-tiling $\tau$ of the $h(n)\times w(n)$ rectangle such that $\tau(1,1)=t_{0}$; no, otherwise.

We write directly the expression $w(n)$ instead of the function $w$. For instance, we write $2^{n}$ instead of $n\mapsto 2^{n}$. Same for $h$. We also consider the variant in which the height is arbitrary.

Definition 2

Let $w:\mathbb{N}\rightarrow\mathbb{N}$. $TILING(*,w)$ is the following decision problem:

• •

input: an integer $n$ given in unary, a finite set $T$ of tiling types, a tile $t_{0}$;

• •

output: yes, if there are an integer $h$ and a $T$-tiling $\tau$ of the $h\times w(n)$ rectangle such that $\tau(1,1)=t_{0}$; no, otherwise.

3 Existence of Tilings and Classes above P

3.1 Encoding Executions of Turing Machines

In this section, we explain how to encode an execution of a Turing machine as a tiling. We slightly adapt the normalization of Turing machines given in [15], especially for being able to capture deterministic tilings (see Section 5). As advocated in [15], normalization does not impact on the complexity classes. Without loss of generality, we suppose that the machine is normalized.

Definition 3

A Turing machine $M$ is normalized if its set of states is partitioned in two disjoint subsets $Q$ and $Q^{\prime}$ (see Figure 2)such that:

the initial state $q_{0}^{\prime}$ is in $Q^{\prime}$; 2. 2.

transitions going out from $Q$ go in $Q^{\prime}$ and makes the cursor move right or makes the cursor stay at its current position; 3. 3.

transitions going out from $Q^{\prime}$ go in $Q$ and makes the cursor move left or makes the cursor stay at its current position; 4. 4.

the final (accepting) state $q_{\mathsf{f}}$ is in $Q$; 5. 5.

if the machine reaches the final accepting state $q_{\mathsf{f}}$, then the tape has already been erased (all cells contain the blank symbol ␣). 6. 6.

the final (accepting) state $q_{\mathsf{f}}$ is in $Q$ and has a copy in $q_{\mathsf{f}}^{\prime}$ in $Q^{\prime}$, there are transitions between them, that do not move the cursor, do not change the tape.

We encode an execution almost as in [15]. Let us consider a Turing machine $M$ and an input word $w$. Figure 3 shows the set of tiles $T_{M,w}$. These tiles enable to represent any execution of length $H$ of $M$ on input $w$, that uses at most $W$ cells, with a tiling of the $H\times W$-rectangle. The idea is that we always alternate between $Q$ and $Q^{\prime}$. Being in a state in $Q$ (resp. in $Q^{\prime}$) is tagged at any tile in a row with the absence (pres. presence) of the symbol ’ (prime)333This difference will help to define deterministic set of tiles, see Section 5. States in $Q$ are noted $q$ etc. States in $Q^{\prime}$ are noted $q^{\prime}$, etc. The color $a^{\prime}$ is copy of the symbol $a$, it is used to keep track on the full row whether the current state is in $Q$ or $Q^{\prime}$. Figure 4 shows an example of such an encoding of an execution of a machine on the input word $bba$.

The machine being normalized prevents to have two adjacent tiles that would create two cursor positions

a^{\prime}$$q$$q,a$$q$$b$$q,b

because we would have allowed to enter a state $q$ both with a transition moving the cursor to the left and with another transition moving the cursor to the right.

When the machines reaches $q_{\mathsf{f}}$ it runs forever, and the tiling finishes with a line of white at the bottom. If not, either it runs forever or it gets stuck; there is no line of white at the bottom in the tiling corresponding to the execution. We could have simply assumed that we loop in $q_{\mathsf{f}}$ but the notion of deterministic set of tile types would have been more difficult to define (see Section 5).

3.2 Existence of Tilings in Squares

First we tackle $TILING(n,n)$. Some readers may be surprised by the relevance of that problem, in which $n$ is given in unary. That assumption is quite natural: any tiling requires $\Omega(n^{2})$ memory cells to be stored; memory cells you need to allocate anyway to store that tiling. This is close to the assumption made in bounded planning (called polynomial-length planning problem), for which the bound is also written in unary (see [14]).

Theorem 1

$TILING(n,n)$* is NP -complete.*

Proof.  

A non-deterministic algorithm deciding $TILING(n,n)$ in polynomial-time consists in guessing a function $\tau$ and checking that $\tau$ is indeed a tiling of the $n\times n$-rectangle, and that $\tau(1,1)=t_{0}$.

Let $A$ be a problem in NP. There exists a non-deterministic Turing machine $M$ that decides $A$ in polynomial-time. W.l.o.g. we suppose that the machine is normalized (see Definition 3, and that there is a polynomial $f$ such that any execution on an input $w$ of size $|w|$, either stops in strictly less than $f(|w|)$ steps, or reaches $q_{\mathsf{f}}$ in strictly less than $f(|w|)$ steps and keeps running forever.

$A$ reduces to $TILING(n,n)$ in polynomial-time, even in log-space: the reduction is $tr(w)=\langle T_{M,w},n,t_{0}\rangle$ where $n:=f(|w|)$, $T_{M,w}$ and $t_{0}$ are shown in Figure 3.

We have $w\in A$ iff $tr(w)\in TILING(n,n)$. $\Leftarrow$ If $w\in A$, then there is an accepting execution. Thus, we can tile the $n\times n$-rectangle using that execution as shown in Figure 4. $\Rightarrow$ If there is a tiling of the $n\times n$-rectangle, then the seed enforces the first row to contain the input word. The other tiles enforce the tiling to represent an execution. As the bottoms of the bottom-most tiles are white, it means that the execution reaches $q_{\mathsf{f}}$. So the execution is accepting and $w\in A$. $\blacksquare$

Note that we could define the variant of $TILING(n,n)$ in which no seed $t_{0}$ is given in the input. The problem is to tile the $n\times n$-rectangle without the seed constraint. This problem is called to be the seed-free variant.

Theorem 2

The seed-free variant $TILING(n,n)$ is NP -complete.

Proof.  

For the NP -hardness of the seed-free variant, it suffices to add ”numbers” in colors in order to count. $\blacksquare$

In Theorem 1, the size of the square is $n$. If the size becomes exponential in $n$, double-exponential in $n$, etc., we capture the class NExptime, $2\mbox{\sc NExptime}$, etc. That is why we define $exp_{k}(n)$ inductively on $k$:

• •

$exp_{0}(n):=n$;

• •

$exp_{k}(n):=2^{exp_{k-1}(n)}$ for all $k\geq 1$.

In other words, $exp_{k}(n)$ is

[TABLE]

Theorem 3

$TILING(exp_{k}(n),exp_{k}(n))$* is kNExptime -complete.*

3.3 Existence of Tilings in Rectangles of Arbitrary Height

Theorem 4

$TILING(2^{n},n)$* and $TILING(*,n)$ are Pspace -complete.*

Proof.  

A non-deterministic algorithm deciding $TILING(2^{n},n)$ that runs in polynomial-space consists in guessing the tiling on row by row. We store the previous row, the current row and the $n$-bit index of the current row. For $TILING(*,n)$, we just do not care about the index of the current row.

Let $A$ be a problem in Pspace. There exists a machine $M$ that decides $A$. W.l.o.g. we suppose that the machine is normalized (see Definition 3, and that there is a polynomial $f$ such that any execution on an input $w$ of size $|w|$ uses at most $f(|w|)$ cells and that, either stops in strictly less than $2^{f(|w|)}$ steps, or reaches ${accept}$ in strictly less than $2^{f(|w|)}$ steps and keeps running forever.

The reduction is the same than in the proof of Theorem 1. $\blacksquare$

In the same way, we obtain:

Theorem 5

Let $k\geq 1$. $TILING(exp_{k+1}(n),exp_{k}(n))$ and $TILING(*,exp_{k}(n))$ are kExpspace -complete.

4 Two-player Games

In order to capture alternating classes [4], we introduce two players: $\exists$ and $\forall$. Each row is owned by some player. Each move consists in adding a row below the current one, by choosing tiles among a given finite set of tile types $T$, so the colors match. Figure 5 shows a finished tiling game: player $\exists$ chose the first row, then player $\forall$ chose the second row and player $\exists$ chose the third row.

4.1 Definition

The ownership of rows is described by an abstract sequence $\mathsf{plSeq}$. For instance, if $\mathsf{plSeq}$ is $\exists^{*}$, it means that all rows belong to player $\exists$. If $\mathsf{plSeq}$ is $(\exists\forall)^{*}$, it means that the first, third… rows belong to player $\exists$ while the second, fourth… rows belong to player $\forall$. We will not develop a full theory of abstract sequences, since we will only use simple patterns. Player $\exists$ wins if the rectangle is fully tiled.

Definition 4

Given $h:\mathbb{N}\rightarrow\mathbb{N}$ and $w:\mathbb{N}\rightarrow\mathbb{N}$, and an abstract sequence $\mathsf{plSeq}$, we define $TILING(h(n),w(n),\mathsf{plSeq})$ to be the following decision problem:

• •

input: an integer $n$ given in unary, a finite set $T$ of tiling types, a tile $t_{0}$;

• •

Yes, if there is a winning strategy for player $\exists$ to the game described below, in the $h(n)\times w(n)$ rectangle, using $t_{0}$ as a seed, and respecting the abstract sequence $\mathsf{plSeq}$ of players; no otherwise.

Remark that $TILING(h(n),w(n))$ is $TILING(h(n),w(n),\exists^{*})$.

4.2 Complexity Results

Proofs are fastidious but, if players alternate, we capture alternating classes [4], and thus deterministic classes via Aptime = Pspace and A$k$EXPTIME = $k$Expspace .

Theorem 6

$TILING(n,n,(\exists\forall)^{*})$* is Pspace -complete.*

Theorem 7

$TILING(exp_{k}(n),exp_{k}(n),(\exists\forall)^{*})$* is $k$Expspace -complete.*

In the same way, as $\mbox{\sc APspace}=\mbox{\sc Exptime}$ and \mbox{\sck-AExpspace}=\mbox{\sck-Exptime}.

Theorem 8

$TILING(2^{n},n,(\exists\forall)^{*})$* and $TILING(*,n,(\exists\forall)^{*})$ are Exptime -complete.*

Theorem 9

Let $k\geq 1$. $TILING(exp_{k}(n),exp_{k-1}(n),(\exists\forall)^{*})$ and $TILING(*,exp_{k-1}(n),(\exists\forall)^{*})$ are $k$Exptime -complete.

The polynomial hierarchy is captured as follows.

Theorem 10

Let $k\geq 1$.

• •

$TILING(kn,n,\exists^{n}(\forall^{n}\exists^{n})^{k-1})$* is $\Sigma_{k}^{P}$-complete;*

• •

$TILING(kn,n,\forall^{n}(\exists^{n}\forall^{n})^{k-1})$* is $\Pi_{k}^{P}$-complete.*

Interestingly, we can capture the exotic class ApolEXPTIME(see [3] for instance), the class of problems decided by an alternating Turing machine in exponential time but with a polynomial number of alternations. Our reformulation is very closed from the problem called multi-tiling problem introduced in [2] that consists in tiling several $2^{n}\times 2^{n}$-squares. That tiling problem is used in [1].

Theorem 11

$TILING(2\times n\times 2^{n},2^{n},(\exists^{2^{n}}\forall^{2^{n}})^{*})$* is ApolEXPTIME-complete.*

Proof.  

Let $A$ be a problem in ApolEXPTIME. There is a alternating Turing machine deciding $A$ in exponential time, with at most a polynomial number of alternation. As mentioned in [5], we can suppose that player $\exists$ plays first, that each portion of the execution played by the player $\exists$ and each portion of the execution played by the player $\forall$ are of the same length $2^{f(|w|)}$ where $f$ is a polynomial and $w$ is the input word. We suppose that there are $2\times a(|w|)$ such portions. W.l.o.g, we suppose that $a(|w|)=f(|w|)$. We furthermore suppose that the machine is normalized.

The reduction is $tr(w)=\langle T_{M,w},n,t_{0}\rangle$ where $T_{M,w},t_{0}$ are given in Figure 4 and $n:=f(|w|)$.

$\blacksquare$

5 Deterministic Tilings

In order to capture deterministic classes without games (no alternation between player $\exists$ and $\forall$), we introduce the notion of a deterministic set of tiles.

5.1 Deterministic Set of Tiles

The idea is that a set $T$ of tiles is said to be deterministic if there is at most one tile to complete a tiling, as shown in Figure 6 – the direction depends on the top color. More precisely:

Definition 5

A set $T$ of tiles is deterministic if there is a partition $\mathcal{C}:=Col\sqcup Col^{\prime}$ such that $white\in Col$ and:

• •

for all tiles $t\in T$, $top(t)\in Col$ iff $bottom(t)\in Col^{\prime}$;

• •

for all colors $c\in Col$, for all colors $c^{\prime}\in\mathcal{C}$, there is at most one element $t$ such that $left(t)=c$ and $top(t)=c^{\prime}$;

• •

for all colors $c\in Col^{\prime}$, for all color $c^{\prime}\in\mathcal{C}$, there is at most one element $t$ such that $right(t)=c$ and $top(t)=c^{\prime}$.

In other words, when the set of tiles is deterministic, it means that we can deterministically complete a tiling – if it exists – in the Boustrophedon order, as shown in Figure 7. Note that the fact that $T$ is deterministic can be tested in log-space in the size of $T$. We define $detTILING(h(n),w(n))$ the restriction of $TILING(h(n),w(n))$ to inputs in which $T$ is deterministic.

5.2 Complexity Results

Theorem 12

$detTILING(n,n)$* is P -complete.*

Proof.  

We design a deterministic algorithm that decides $detTILING(n,n)$ in polynomial-time as follows: it tries to construct the tiling of the $n\times n$-rectangle without backtrack, in the Boustrophedon order, since $T$ is deterministic.

Let $A$ be a problem in P. Let $M$ be a Turing machine that decides $A$ in polynomial-time. The reduction is as in the proof of Theorem 1, since $T_{M,w}$ is deterministic.

$\blacksquare$

Theorem 13

$detTILING(2^{n},n)$* and $detTILING(*,n)$ is Pspace -complete.*

Theorem 14

$detTILING(exp_{k}(n),exp_{k}(n))$* is $k$Exptime -complete.*

Theorem 15

Let $k\geq 1$. $detTILING(exp_{k+1}(n),exp_{k}(n))$ and $detTILING(*,exp_{k}(n))$ is $k$-Expspace-complete.

6 Existence of Tilings for Classes below P

6.1 FO

FO is the class of decision problems such that the set of positive instances is described by a logical formula of first-order logic (see the book on descriptive complexity by Immerman, [9]).

Theorem 16

Let $k,\ell$ be two constants. $TILING(k,\ell)$ is in FO.

Proof.  

For instance, $TILING(2,2)$ corresponds to the first-order formula

[TABLE]

where predicates $H$ and $V$ encode respectively the horizontal and vertical constraints. $\blacksquare$

6.2 NLOGSPACE

In this section, the width of rectangles is 1, so left- and right- colors are irrelevant.

Theorem 17

$TILING(n,1)$* and $TILING(*,1)$ are NLOGSPACE -complete.*

Proof.  

The following non-deterministic algorithm decides $TILING(n,1)$ in log-space.

**procedure **algo($T,n,t_{0}$)

Let $t:=t_{0}$

for $k$ := 1 to $n$ **do

**            

choose $t^{\prime}\in T$ such that t$$t^{\prime}

accept

We reduce in log-space the reachability problem ($s-t$-connectivity problem) to $TILING(n,1)$ as follows. Let $\langle G,s,t\rangle$ be an instance of the $s-t$-connectivity problem. We construct in log-space the following instance of $TILING(n,1)$:

• •

$n$ is 2 + the number of nodes in $G$;

• •

$T$ contains exactly the tiles
$s$ ,
s$$s ,
$t$ ,
u$$v whenever there is an edge $(u,v)$ in $G$;

• •

the seed is
$s$ .

There is a path from $s$ to $t$ in $G$ iff we can tile the $n\times 1$-rectangle. $\blacksquare$

In the same way (it refines Th. 2.7 in [7]):

Theorem 18

For all constants $k$ (not part of the input), the variant of $TILING(n,k)$ without seed is NLOGSPACE -complete.

6.3 Rotating tiles and LOGSPACE

In order to capture LOGSPACE , we introduce tile types that can be rotated by 180 degrees. We define $rotTILING(h(n),w(n))$ the restriction of $TILING(h(n),w(n))$ to inputs in which $T$ is such that:

• •

if $\langle left(t),up(t),right(t),down(t)\rangle\in T$ then $\langle right(t),bottom(t),left(t),up(t)\rangle\in T$.

Theorem 19

$rotTILING(n,1)$* and $rotTILING(*,1)$ are LOGSPACE -complete, w.r.t. FO -reductions444Note that LOGSPACE is a too small class for log-space reductions to be meaningful..*

Proof.  

We reduce $rotTILING(n,1)$ in log-space to the reachability problem in undirected graphs, which is in LOGSPACE [12]:

• •

the nodes of the undirected graph are a source, $n$ copies of $T$, a target;

• •

We add edges from the source to all tiles in the first copy of $T$ if its top is white; we add edges between $t$ of the $i^{\text{th}}$ copy of $T$ and $t^{\prime}$ of the $i+1^{\text{th}}$ copy of $T$ whenever t$$t^{\prime} ; we add edges between any tile in the $n^{\text{th}}$ copy of $T$ whose bottom is white and the target.

The reduction given in the proof of Theorem 17 is also a reduction from the reachability problem in undirected graphs to $rotTILING(n,1)$. This reduction is a FO -reduction (you can define the set of tiles via first-order formulas). $\blacksquare$

7 Conclusion

Table 1 sums up the main complexity results for tiling. There are many research avenues, to name a few:

• •

how to define tiling problems with imperfect information in the spirit of [11]?

• •

how to define parameterized tiling problems in the spirit of parameterized complexity?

• •

how to get rid off the seed in some of tiling problems and/or border constraints?

• •

what are the connections between tilings and other classes such as AC (alternating circuits), NC (Nick’s class), the Boolean hierarchy?

• •

is $TILING(cst,cst)$ FO -complete in some sense?

• •

could we have a more natural definition of deterministic tilings?

Acknowledgments.

I would like to thank Sophie Pinchinat for pointing out the class ApolEXPTIME. Thanks to Stephane Demri for the discussions about the class ApolEXPTIME. Thanks to Sasha Rubin and Tristan Charrier for having given me the motivation to write this note. Especially thanks to Sasha Rubin for his comments on a previous version of that document. Thanks to Florian Beau for the discussion about Tetravex.