Building a Nest by an Automaton

TL;DR

This paper presents a finite automaton-based robot that efficiently reorganizes bricks on an infinite grid to form a compact nest, minimizing the overall span in optimal time for any initial connected configuration.

Contribution

It introduces a deterministic finite automaton algorithm that constructs the most compact brick structure in optimal time, a novel approach for autonomous structure building.

Findings

The automaton achieves optimal $O(sz)$ time complexity.

It guarantees construction of the most compact structure from any connected initial field.

The method is applicable to infinite grid environments with connectivity constraints.

Abstract

A robot modeled as a deterministic finite automaton has to build a structure from material available to it. The robot navigates in the infinite oriented grid $\mathbb{Z} \times \mathbb{Z}$. Some cells of the grid are full (contain a brick) and others are empty. The subgraph of the grid induced by full cells, called the field, is initially connected. The (Manhattan) distance between the farthest cells of the field is called its span. The robot starts at a full cell. It can carry at most one brick at a time. At each step it can pick a brick from a full cell, move to an adjacent cell and drop a brick at an empty cell. The aim of the robot is to construct the most compact possible structure composed of all bricks, i.e., a nest. That is, the robot has to move all bricks in such a way that the span of the resulting field be the smallest. Our main result is the design of a deterministic finite automaton that accomplishes this task and subsequently stops, for every initially connected field, in time $O(sz)$, where $s$ is the span of the initial field and $z$ is the number of bricks. We show that this complexity is optimal.

Figures

Full text

Our main result is the design of a deterministic finite automaton that accomplishes this task and subsequently stops, for every initially connected field, in time $O(sz)$, where $s$ is the span of the initial field and $z$ is the number of bricks. We show that this complexity is optimal.

Keywords: finite automaton, plane, grid, construction task, brick, mobile agent, robot.

1 Introduction

The problem. A mobile agent (robot) modeled as a deterministic finite automaton has to build a structure from material available to it. The robot navigates in the infinite oriented grid $\mathbb{Z}\times\mathbb{Z}$ represented as the set of unit square cells in the two-dimensional plane, with all cell sides vertical or horizontal. The robot has a compass enabling it to move from a currently occupied cell to one of the four cells (to the North, East, South, West) adjacent to it. Some cells of the grid contain a brick, i.e., are full, other cells are empty. The subgraph of the grid induced by full cells, called the field, is initially connected. The (Manhattan) distance between the farthest cells of the field is called its span. Notice that the span of any current field may be much smaller than its diameter as a subgraph of the grid. In fact, this diameter may be sometimes undefined, if the field becomes disconnected. The robot starts at a full cell. It can carry at most one brick at a time. At each step, the robot can pick a brick from the currently occupied full cell (if it does not carry any brick at this time), moves to an adjacent cell, and can drop a brick at the currently occupied empty cell (if it carries a brick). The robot has no a priori knowledge of the initial field, of its span or of the number of bricks.

The aim of the robot is to construct the most compact possible structure composed of all bricks, i.e., a nest. That is, the robot has to move all bricks in such a way that the span of the resulting field be the smallest. The above task has many real applications. In the natural world, animals use material scattered in a territory (pieces of wood, small branches, leaves) to build a nest, and minimizing the span is important to better protect it. A mobile robot may be used to clean a territory littered by hazardous material, in which case minimizing the span of the resulting placement of contaminated pieces facilitates subsequent decontamination. A more mundane example is the everyday task of sweeping the floor, whose aim is to gather all trash in a small space and then get rid of it.

Our results. Our main result is the design of a deterministic finite automaton that accomplishes the task of building a nest and subsequently stops, for every initially connected field, in time $O(sz)$, where $s$ is the span of the initial field and $z$ is the number of bricks. The time is defined as the number of moves of the robot. We show that this complexity is optimal.

The essence of our nest building algorithm is to instruct the robot to make a series of trips to get consecutive bricks, one at a time, and carry them to some designated compact area. This approach ensures the optimal complexity. (In order to show where the problem is, we also sketch a much simpler algorithm that uses another approach but has significantly larger complexity). There are two major difficulties to carry out this plan. The first is that the span of the initial field may be much larger than the memory of the robot, and hence the robot that already put several bricks in a compact area and goes for the next brick cannot remember the way back to the area where it started building. Thus we need to prepare the way, so that the robot can recognize the backtrack path locally at each decision point. The second problem is that, while we temporarily disconnect the field during the execution of the algorithm, special care has to be taken so that the connected components of intermediary fields be close to each other, to prevent the robot from getting lost in large empty spaces.

To the best of our knowledge, the task of constructing structures from available material using an automaton, has never been studied before in the algorithmic setting. It is interesting to compare this task to that of exploration of mazes by automata, that is a classic topic with over 50 years of history (see the section “Related work”). It follows from the result of Budach [9] (translated to our terminology) that if an automaton can only navigate in the field without moving bricks then it cannot explore all connected fields, even without the stop requirement, i.e., it cannot even see all bricks. By contrast, it follows from our result that the ability of moving bricks enables the automaton not only to see all bricks but to build a potentially useful structure using all of them and stop, and to accomplish all of that with optimal complexity.

The model. We consider the infinite oriented grid $\mathbb{Z}\times\mathbb{Z}$ represented as the set of unit square cells tiling the two-dimensional plane, with all cell sides vertical or horizontal. Each cell has 4 adjacent cells, North, East, South and West of it. Some cells of the grid contain a brick, i.e., are full, other cells are empty. The subgraph of the grid induced by full cells is initially connected. At each step of the algorithm this subgraph can change, due to the actions of the robot, described below. At each step, the subgraph induced by the full cells is called the current field. Any maximal connected subgraph of the current field is called a component. Throughout the paper, the distance between two cells $(x,y)$ and $(x^{\prime},y^{\prime})$ of the grid is the Manhattan distance between them, i.e., $|x-x^{\prime}|+|y-y^{\prime}|$. The number of cells of a field is called its size, and the distance between two farthest cells of a field is called its span. A nest of size $z$ is a field that has the minimum span among all fields of size $z$.

We are given a mobile entity (robot) starting in some cell of the initial field and traveling in the grid. The robot has a priori no knowledge of the field, of its size or of its span. The robot is formalized as a finite deterministic Mealy automaton ${\cal{R}}=(X,Y,\S,\delta,\lambda,S_{0},S_{\textup{f}})$. $X=\{e,f\}\times\{l,h\}$ is the input alphabet, $Y=\{N,E,S,W\}\times\{e,f\}\times\{l,h\}$ is the output alphabet. $\S$ is a finite set of states with two special states: $S_{0}$ called initial and $S_{\textup{f}}$ called final. $\delta:\S\times X\to\S$ is the state transition function, and $\lambda:\S\times X\to Y$ is the output function.

The meaning of the input and output symbols is the following. At each step of its functioning, the robot is at some cell of the grid and has some weight: it is either light, denoted by $l$ (does not carry a brick) or heavy, denoted by $h$ (carries a brick). Moreover, the current cell is either empty, denoted by $e$ or full, denoted by $f$. The input $x\in\{e,f\}\times\{l,h\}$ gives the automaton information about these facts. The robot is in some state $S$. Given this state and the input $x$, the robot outputs the symbol $\lambda(x,S)\in\{N,E,S,W\}\times\{e,f\}\times\{l,h\}$ with the following meaning. The first term indicates the adjacent cell to which the robot moves: North, East, South or West of the current cell. The second term determines whether the robot leaves the current cell empty or full, and the third term indicates whether the robot transits as heavy or as light to the adjacent cell. Since the robot can only either leave the current cell intact and not change its own weight, or pick a brick from a full cell leaving it empty (in case when the robot was previously light), or drop a brick on an empty cell leaving it full (in case when the robot was previously heavy), we have the following restrictions on the possible values of the output function $\lambda$:

$\lambda(S,e,l)$ must be $(\cdot,e,l)$

$\lambda(S,e,h)$ must be either $(\cdot,e,h)$ or $(\cdot,f,l)$

$\lambda(S,f,l)$ must be either $(\cdot,f,l)$ or $(\cdot,e,h)$

$\lambda(S,f,h)$ must be $(\cdot,f,h)$

Seeing the input symbol $x$ and being in a current state $S$, the robot makes the changes indicated by the output function (it goes to the indicated adjacent cell, possibly changes the filling of the current cell as indicated and possibly changes its own weight as indicated), and transits to state $\delta(x,S)$. The robot starts light in a full cell in the initial state $S_{0}$ (hence its initial input symbol is $(f,l)$) and terminates its action in the final state $S_{\textup{f}}$.

Related work. Problems concerning exploration and navigation performed by mobile agents or robots in an unknown environment have been studied for many years (cf. [21, 26]). The relevant literature can be divided into two parts, according to the environment where the robots operate: it can be either a geometric terrain, possibly with obstacles, or a network modeled as a graph in which the robot moves along edges.

In the geometric context, a closely related problem is that of pattern formation [12, 15, 29]. Robots, modeled as points freely moving in the plane have to arrange themselves to form a pattern given as input. This task has been mostly studied in the context of asynchronous oblivious robots having full visibility of other robots positions.

The graph setting can be further specified in two different ways. In [1, 3, 4, 13, 20] the robot explores strongly connected directed graphs and it can move only in the tail-to-head direction of an edge, not vice-versa. In [2, 7, 9, 14, 16, 17, 25, 27] the explored graph is undirected and the robot can traverse edges in both directions. Graph exploration scenarios can be also classified in another important way. It is either assumed that nodes of the graph have unique labels which the robot can recognize (as in, e.g., [13, 17, 25]), or it is assumed that nodes are anonymous (as in, e.g., [3, 4, 9, 10, 27]). In our case, we work with the infinite anonymous grid, hence it is an undirected anonymous graph scenario. The efficiency measure adopted in papers dealing with graph exploration is either the completion time of this task, measured by the number of edge traversals, (cf., e.g., [25]), or the memory size of the robot, measured either in bits or by the number of states of the finite automaton modeling the robot (cf., e.g., [14, 19, 20]). We are not concerned with minimizing the memory size but we assume that this memory is finite. However we want to minimize the time of our construction task.

The capability of a robot to explore anonymous undirected graphs has been studied in, e.g., [5, 9, 14, 19, 23, 27]. In particular, it was shown in [27] that no finite automaton can explore all cubic planar graphs (in fact no finite set of finite automata can cooperatively perform this task). Budach [9] proved that a single automaton cannot explore all mazes (that we call connected fields in this paper). Hoffmann [22] proved that one pebble does not help to do it. By contrast, Blum and Kozen [5] showed that this task can be accomplished by two cooperating automata or by a single automaton with two pebbles. The size of port-labeled graphs which cannot be explored by a given robot was investigated in [19].

Recently a lot of attention has been devoted to the problem of searching for a target hidden in the infinite anonymous oriented grid by cooperating agents modeled as either deterministic or probabilistic automata. Such agents are sometimes called ants. It was shown in [18] that 3 randomized or 4 deterministic automata can accomplish this task. Then matching lower bounds were proved: the authors of [11] showed that 2 randomized automata are not enough for target searching in the grid, and the authors of [8] proved that 3 deterministic automata are not enough for this task. Searching for a target in the infinite grid with obstacles was considered in [24].

Our present paper adopts the same model of environment as the above papers, i.e., the infinite anonymous oriented grid. However the task we study is different: instead of searching for a target, the robot has to build some structure from the available material. To the best of our knowledge, such construction tasks performed by automata have never been studied previously in the algorithmic setting.

2 Terminology and preliminaries

In the description and analysis of our algorithm we will categorize full cells. A full cell is said to be a border cell if it is adjacent to an empty cell. A full cell that has only one full adjacent cell is called a leaf. A full cell is called special, if it is either a leaf, or has at least two full cells adjacent to it, sharing a corner.

A finite deterministic automaton may remember a constant number of bits by encoding them in its states. We will use this fact to define several simple procedures and simplifications that we use in the sequel. The first simplification is as follows. We formulate the actions of the robot based on the configuration of bricks in its neighborhood. More precisely, at any step, the robot knows whether each cell at distance at most $r=8$ from its current cell is full or empty. This can be achieved by performing a bounded local exploration with return, after each move of the robot.

We will use the notion of current orientation of the robot. At the beginning of its navigation, the robot goes in one of the four cardinal directions. Then its orientation is determined in one of the two ways: either by its last step (North, East, South or West) or by a turn: we say that the robot turns left (respectively right) meaning that it changes its orientation in the appropriate way while remaining at the same cell. Clearly the robot can remember its orientation, using its states. We refer to cardinal directions with respect to this current orientation. Thus, e.g., if the robot is oriented East then we say that its adjacent North (resp. East, South or West) cell is left (resp. in front, right, back) of it.

Whenever we say that the robot located at a cell $c$ and not carrying a brick brings a brick from a full cell $c^{\prime}$ to $c$ we mean that the robot moves from $c$ to $c^{\prime}$, picks the brick from $c^{\prime}$, moves back to $c$ and restores its original orientation. Whenever we say that the robot located at a cell $c$ and carrying a brick places it at an empty cell $c^{\prime}$ we mean that the robot moves from $c$ to $c^{\prime}$, drops the brick at $c^{\prime}$, moves back to $c$ and restores its original orientation.

Whenever the robot selects a cell according to some condition that is fulfilled by more than one cell, the robot selects the cell that is minimal with respect to the following total order $\prec$ on the set of all cells. For cells $c=(x,y)$ and $c^{\prime}=(x^{\prime},y^{\prime})$, $c\prec c^{\prime}$ holds if and only if either $y<y^{\prime}$, or $y=y^{\prime}$ and $x\leq x^{\prime}$. We denote by $|S|$ the number of cells in a sequence or a set $S$ of cells.

We define a disc of radius $r\geq 0$ with center $c$ to be the set of all cells at distance at most $r$ from $c$, see Fig. 1. A disc of radius $r$ contains $z_{r}=2(1+3+5+\cdots+(2r-1))+(2r+1)=2r^{2}+2r+1$ cells and has span $2r$. A rough disc of size $z$, where $z_{r}\leq z<z_{r+1}$ is defined as follows. If $z=z_{r}$, then the rough disc is the disc of radius $r$. Otherwise, let $F$ be the set of cells not belonging to the disc $D$ of radius $r$ but adjacent to some cell of it. Add to $D$ exactly $z-z_{r}$ cells belonging to $F$, starting from the North neighbor of the East-most cell of $D$ and going counterclockwise. If $z_{r}<z\leq z_{r}+2r+2$ then the rough disc of size $z$ has span $2r+1$ and if $z_{r}+2r+2<z<z_{r+1}$ then the rough disc of size $z$ has span $2r+2$, the same as the disc of radius $r+1$ that has size $z_{r+1}$.

Proposition 2.1**.**

Any rough disc is a nest.

Proof.

We write $d(a,b)$ to denote the distance between two cells $a$ and $b$. For a given span $s$, consider a field $C_{s}$ that has span $s$ and a maximum number of cells among fields of this span. Consider three consecutive full cells $f_{1},f_{2}$ and $f_{3}$ of $C_{s}$ in a row or in a column. Let $c_{1},c_{2}$ and $c_{3}$ be three consecutive cells such that $c_{i}$ is adjacent to $f_{i}$, $i\in\{1,2,3\}$. We prove that $c_{2}$ is full. We proceed by contradiction, i.e., suppose that $c_{2}$ is empty. Consider the field $C^{\prime}$ obtained from $C_{s}$ by adding a brick to the cell $c_{2}$. By definition of $C_{s}$, the span of $C^{\prime}$ is larger than $s$. Thus, there exists a shortest path $\mathcal{W}=(w_{1},\ldots,w_{s+2})$ in the grid, that connects two full cells $w_{1}$ and $w_{s+2}$ of $C^{\prime}$. If $c_{2}$ is different from $w_{1}$ and $w_{s+2}$ then $C_{s}$ has span larger than $s$, which is a contradiction. Thus, without loss of generality, we can assume $c_{2}=w_{s+2}$. We have $d(w_{1},f_{2})\geq s$ because the length of $\mathcal{W}$ is $s+1$ and $f_{2}$ and $c_{2}$ are neighbors. Thus, since $f_{2}$ is a neighbor of both $f_{1}$ and $f_{3}$, we have either $d(f_{1},w_{s+2})\geq s+1$ or $d(f_{3},w_{s+2})\geq s+1$. Since $f_{1},f_{3}$ and $w_{s+2}$ are in $C_{s}$, this gives a contradiction with the span of $C_{s}$ being at most $s$. Hence $c_{2}$ is full.

This implies that $C_{s}$ has the following property: each border cell of $C_{s}$ is adjacent to two or three empty cells. Define an extremity to be an East-most, West-most, North-most or South-most cell of a field. Thus, either there exists a single East-most (respectively West-most, North-most or South-most) extremity, or there are two adjacent such extremities. Moreover, each border cell of $C_{s}$ that is not an extremity does not have an adjacent border cell. (Intuitively, the border is composed of “staircases”). Denote by $\mathcal{F}_{s}$ the class of fields with the above two properties. Note that $C_{s}$ which has maximum size among fields of span $s$ belongs to $\mathcal{F}_{s}$.

We will compute the number of cells in any field $C$ in the class $\mathcal{F}_{s}$. Partition the cells of $C$ into rows $R_{1},\ldots,R_{t}$ counted from North to South. We have proved that $|R_{1}|\in\{1,2\}$ and $|R_{l}|\in\{1,2\}$ because these sets consist of extremities only. We first consider the case when there is a total of four extremities in $C$. Thus, in particular, $|R_{1}|=|R_{t}|=1$. (Note that, in the considered case, $s$ must be even). Let $j$ be the maximal index such that $|R_{j}|<|R_{j+1}|$ and let $j^{\prime}$ be the minimal index such that $|R_{j^{\prime}-1}|\leq|R_{j^{\prime}}|$. Since for each $i\in\{2,\ldots,j\}$, $|R_{i}|=|R_{i-1}|+2$, we obtain $\sum_{i=1}^{j}|R_{i}|=j^{2}$. By symmetry, $\sum_{i=j^{\prime}}^{t}|R_{i}|=j^{2}$. Denote $m=j^{\prime}-j-1$. The span of $C$ equals $s=t+m-2=2j+2m-2$, and hence $m=s/2-j+1$. We have $|R_{i}|=2j+1$ for each $i\in\{j+1,\ldots,j^{\prime}-1\}$. This implies $\sum_{i=j+1}^{j^{\prime}-1}|R_{i}|=m(2j+1)=j(s+1)-2j^{2}+s/2+1$. Thus, the size of $C$ is $z(j)=\sum_{i=1}^{t}|R_{i}|=j(s+1)+s/2+1$. It follows that for a field of maximum size in $\mathcal{F}_{s}$ that has a total of four extremities, the index $j$ must be as large as possible, i.e., $j=s/2$. Hence such a field is a disc of span $s$, i.e., of radius $r=s/2$.

Now consider all other fields in the class $\mathcal{F}_{s}$, i.e., those in which some of the extremities are pairs of adjacent cells. Every such field $F^{\prime}$ can be obtained from a field $F$ in $\mathcal{F}_{s-1}\cup\mathcal{F}_{s-2}$ with exactly four extremities, by adding bricks in some cells adjacent to the border of $F$. The number of cells in each such field $F^{\prime}$ equals $|F|+c_{1}x+c_{2}y$ for some nonnegative constants $c_{1}$ and $c_{2}$, where $x$ is the span of $F$ and $y$ is the index $j$ in the preceding paragraph, for the field $F$. Consider a field $F^{\prime}$ of maximum size among all fields in $\mathcal{F}_{s}$. Hence the corresponding field $F$ has maximum size among all fields in $\mathcal{F}_{s-1}$ or in $\mathcal{F}_{s-2}$ that have exactly four extremities. As proved above, such a field $F$ must be a disc. Denote by $h(s)$ the maximum size of a field in $\mathcal{F}_{s}$. In particular we have that $h(s)=\max\{z_{s/2},z_{(s-2)/2}+2s-1\}=z_{s/2}$ for even $s$, and $h(s)=z_{(s-1)/2}+s$ for odd $s$.

Let $z$ be such that $z_{r}\leq z<z_{r+1}$ and consider a nest $N$ of size $z$. Denote its span by $s_{z}$. We have three cases depending on the possible values of $z$.

First suppose that $z=z_{r}$. We have $s_{z}\geq 2r$ because otherwise, for a maximum-size field $M$ in $\mathcal{F}_{2r-1}$, we would have $|M|\geq|N|$, and $|M|=h(2r-1)=z_{r-1}+2r=2r^{2}+1<z_{r}$, which would imply $|N|<z$, contradicting the definition of $N$. Thus, the disc of size $z=z_{r}$ has span at most $s_{z}$ and thus it is a nest.

Next suppose that $z_{r}<z\leq z_{r}+2r+2$. We have $s_{z}\geq 2r+1$ because otherwise, for a maximum-size field $M$ in $\mathcal{F}_{2r}$, we would have $|M|\geq|N|$, and $|M|=h(2r)=z_{r}<z$, which would imply $|N|<z$, contradicting the definition of $N$. Hence, the rough disc of size $z$ has span at most $s_{z}$ and thus it is a nest.

Finally suppose that $z_{r}+2r+2<z<z_{r+1}$. We have $s_{z}\geq 2r+2$ because otherwise, for a maximum-size field $M$ in $\mathcal{F}_{2r+1}$, we would have $|M|\geq|N|$, and $|M|\leq h(2r+1)=z_{r}+2r+1<z$, which would imply $|N|<z$, contradicting the definition of $N$. This proves that the rough disc of size $z$ has span at most $s_{z}$ and thus it is a nest. ∎

The nests built by our automaton will be discs or rough discs, depending on the number of available bricks. The following proposition shows that the complexity of our nest-building algorithm is optimal, regardless of the relation between the size of the initial field and its span (recall that, by definition, the span must be smaller than the size $z$ and it must be in $\Omega(\sqrt{z})$). Our lower bound on complexity follows from geometric properties of the grid, and hence it holds regardless of the machine that builds the nest, i.e., even if the robot is a Turing machine knowing a priori the initial field.

Proposition 2.2**.**

Let $s^{\prime}<z$ be positive integers such that $s^{\prime}\in\Omega(\sqrt{z})$. There exists an initial field of size $z$ and span $s\in\Theta(s^{\prime})$, such that any algorithm that builds a nest starting from this field must use time $\Omega(sz)$.

Proof.

The proposition is proved by considering an appropriate initial field that requires large time to be transformed to a nest. We define a rough rectangle of size $z$ and sides $a\leq b$, such that $z-ab<b$, to be the following set of cells: there is a grid $a\times b$ of cells (with $a$ rows and $b$ columns), and the remaining $z-ab$ cells are attached to the North-most cells of the $z-ab$ West-most columns.

Case 1. $s^{\prime}\geq 10\sqrt{z}$.

Take the rough rectangle $R$ with sides $b=s^{\prime}$, $a=\lfloor z/b\rfloor$ as the initial field. The span of $R$ is $s\in\Theta(s^{\prime})$. There exist subsets $A$ and $B$ of $R$ of size at least $z/3$ at distance at least $s^{\prime}/4$: $A$ is composed of the $\lceil z/(3a)\rceil$ West-most columns of the grid and $B$ is composed of the $\lceil z/(3a)\rceil$ East-most columns of the grid. Since the span of a nest of size $z$ is smaller than $2\sqrt{z}\leq s^{\prime}/5$, in order to transform $R$ into a nest, at least $z/3$ bricks have to be moved at distance at least $s^{\prime}/40$. Hence the time of building a nest from the initial field $R$ is at least $s^{\prime}z/120\in\Omega(sz)$.

Case 2. $s^{\prime}<10\sqrt{z}$.

In this case we have $s^{\prime}\in\Theta(\sqrt{z})$. Take the rough rectangle $R$ with sides $b=\lceil 10\sqrt{z}\rceil$, $a=\lfloor z/b\rfloor$ as the initial field. The span of $R$ is $s\in\Theta(\sqrt{z})=\Theta(s^{\prime})$ and $s\geq 10\sqrt{z}$. There exist subsets $A$ and $B$ of $R$ of size at least $z/3$ at distance at least $s/4$. Since the span of a nest of size $z$ is smaller than $2\sqrt{z}\leq s/5$, in order to transform $R$ into a nest, at least $z/3$ bricks have to be moved at distance at least $s/40$. Hence the time of building a nest from the initial field $R$ is at least $sz/120\in\Omega(sz)$. ∎

3 The algorithm

The robot will move bricks from the original field and build two special components. One of them will be a rough disc that will be gradually extended. The second one will be a one-cell component whose only cell is called the marker. The robot will periodically get at large distances from the rough disc being built, and the role of the marker will be to indicate to the robot that it got back in the vicinity of the rough disc. Any component that is different from the rough disc and from the marker will be called a free component.

During the execution of the entire algorithm, the robot will not ensure that the full cells outside of the rough disc and of the marker form one component — they may form several components — but after adding a new brick to the rough disc these components will be always at a bounded distance, i.e., at distance $O(1)$, from the rough disc that the robot is constructing.

We are now ready to sketch the high-level idea of the algorithm, whose pseudo-code is presented at the end of this section as algorithm 5. First the robot performs some preliminary actions by establishing the marker and the initial rough disc and by calling procedure 1, which together result in constructing the first rough disc $D$ (of size one), placing the marker next to it and ensuring that no full cells other than the marker are at distance at most $7$ from $D$. Then each iteration of the main loop of algorithm 5 performs three actions. First, it executes procedure 2 that allows the robot to find a brick in a free component $\mathcal{C}$. This brick must be carefully chosen. For example, greedily picking the closest available brick would soon result in creating large empty spaces between components of the field, in which the robot could get lost. This brick will be later used to extend the rough disc. However, this procedure may lead the robot far from the rough disc and may also disconnect $\mathcal{C}$ into many components. Disconnecting $\mathcal{C}$ is one of the main tools in our construction. It is done by the robot on purpose to allow it to find its way back to the marker and so that it is possible to recover the connectivity of $\mathcal{C}$ on the way back. Such a walk back to the marker is the second action performed in the main loop and described as procedure 3. The third action is done once the robot is back at the marker, and it is given as procedure 4. This procedure extends the rough disc, ensuring the property that there are no full cells at a prescribed bounded distance from the rough disc, except the marker. While restoring this property, the robot may again disconnect some components but all of them are at a bounded distance from the rough disc and thus the robot will be able to find them easily. Additionally, it may happen that the cell brought to the rough disc was the last cell of $\mathcal{C}$. In such a case, as the last part of procedure 4, the robot places the marker near another component close to the rough disc, if one exists. This will be the new free component $\mathcal{C}$ in which the robot will find the next brick in the next iteration of the main loop. If no such $\mathcal{C}$ exists, then the robot adds the brick from the marker to the rough disc, thus completing the construction of the nest.

Many of the difficulties described above come from our desire to keep the complexity of the algorithm optimal, i.e., $O(sz)$. If complexity were not an issue, the following much simpler algorithm would be sufficient. The robot first builds a horizontal line at the level of a South-most cell of the initial field, by gradually squeezing down the field, keeping it connected at all times. Then it transforms the line into a nest. The squeezing down can be performed by iteratively repeating the following steps. First, the robot makes sure that it is not on the lowest level (if the line is not yet constructed, this can be done by finding a full cell with a full South neighbor). Then the robot goes to some North-West extremity of the field. Then it picks the brick from this cell and drops it one level down, ensuring the connectivity. When the field is squeezed down to a line, the robot will recognize this and easily transform it into a nest.

This idea potentially requires time $\Theta(z)$ to lower a brick by one level. Since there are $z$ bricks possibly on $\Theta(s)$ levels, the entire time would be $\Theta(sz^{2})$ in the worst case, which is suboptimal. Thus we proceed with the detailed description of the optimal algorithm 5 whose high-level idea was described before.

3.1 Moving bricks out of the way

One of the challenges in constructing the rough disc is to have enough room so that, while expanding, it does not merge with the remainder of the field. This is one of the goals of procedure 1. Its high-level idea is the following. It ensures an invariant that has to hold whenever the agent goes to retrieve the next brick in order to extend the rough disc. This invariant is that there are no full cells, other than the cell $M$ that is the marker, within a given bounded distance from the current rough disc $D$. This procedure is called when the robot is at the marker, in two situations. The first one is right before the main loop: in this case the marker, the rough disc (of size one) and its corresponding neighborhood occupy a constant number of cells and hence in this case the robot is able to decide whether a given cell is in $D\cup\{M\}$. The second situation occurs after each extension of the rough disc. In this case, the size of $D$ may be unbounded but a walk around its border (which can be done with stop, using the marker) allows to determine if there is a full cell $c$ within a bounded distance from $D$, that does not belong to the rough disc itself. Whenever such a full cell $c$ is found, the robot picks the brick from $c$ and searches for an empty cell at distance at least $7$ from the rough disc. This searching walk is done in such a way as to ensure the return to the rough disc. At the end of the procedure, the robot places the marker next to some free component. Below is the pseudo-code of procedure 1. In this pseudo-code, we use the notion of the robot going in direction away from the rough disc $D$. This is the direction which strictly increases the distance between the robot and the rough disc. In the case where there are two such directions, we use the priority North, East, South, West.

3.2 Finding the next brick

The high-level idea of procedure 2 is the following. In may happen that the cells that belong to a free component $\mathcal{C}$ and are close to the marker cannot be rearranged in such a way that the robot be able to obtain a brick that it can then use to extend the rough disc and at the same time keep the connectivity of $\mathcal{C}$ and ensure that $\mathcal{C}$ remains close to the marker. Thus, the robot has to retrieve the needed brick by following a potentially long walk; we will call it a search walk and formally define it in Section 3.2.1. The search walk needs to be carefully chosen to ensure that it ends at a location where it is possible to find the desired brick and so that the robot be able to return to the marker. Moreover, this walk has to be sufficiently short to guarantee the time $O(sz)$ of the algorithm, i.e., the length of each walk must be $O(s)$. We ensure the latter as follows: each search walk $\mathcal{W}$ leads alternately in two non-opposite directions, e.g., North and West. The return is guaranteed by repeatedly performing an action called switch while walking along $\mathcal{W}$, which we formally describe in Section 3.2.2. Intuitively speaking, the switch eliminates the cells adjacent to $\mathcal{W}$ at which the robot may incorrectly turn on its way back to the marker. The switch potentially disconnects the component but the robot is able to recover the connectivity while backtracking along $\mathcal{W}$. Finally, in Section 3.2.3, we describe how the desired brick can be found at the end of $\mathcal{W}$.

3.2.1 Search walks

Suppose that the robot is currently at a full cell and there is a full cell in front of the robot. A left-free (respectively right-free) segment consists of all full cells that will be visited by the robot that moves without changing its direction until one of the following conditions holds:

1. (S1)

the robot arrives at a full cell that has an empty cell in front of it and has an empty cell to the left (respectively right) of it; such a segment is called terminal, 2. (S2)

the robot arrives at the first special cell such that the cell to the left (respectively right) of the robot is full.

Whenever the orientation is not important or clear from the context we will refer to a left-free or right-free segment by saying segment. Note that not every special cell terminates the above sequence of moves.

We now define a search walk $\mathcal{W}$ of the robot in an arbitrary component $\mathcal{C}$ (cf. the example in Fig. 2). A search walk depends on the initial position of the robot in $\mathcal{C}$ and on its orientation. We make two assumptions in the definition: the robot is initially located at a full cell of $\mathcal{C}$ and, if $|\mathcal{C}|>1$, then there is a full cell in front of the robot. The search walk $\mathcal{W}$ is a concatenation of segments. The first segment is both left-free and right-free. If the cell $c$ at the end of this segment is a leaf, then the construction of $\mathcal{W}$ is completed. Otherwise, note that there is a full cell to the left of the robot located at $c$ or to the right of it. In the former case, the search walk is called left-oriented and in the latter it is right-oriented. Intuitively, a left-oriented search walk prescribes going straight until it is possible to go left, then going straight until it is possible to go right, and so on, alternating directions, until a stop condition is satisfied. A similar intuition concerns right-oriented search walks.

More formally, if $|\mathcal{C}|>1$, then the search walk $\mathcal{W}$ consists of a single cell. Otherwise, in a right-oriented (respectively left-oriented) search walk, the segments are sequentially added to $\mathcal{W}$, cyclically alternating the following construction steps.

1. (W1)

The robot traverses a right-free (respectively left-free) segment, adding it to $\mathcal{W}$. This segment becomes the last segment in $\mathcal{W}$ if it is a terminal. If the segment is not the last one, then the robot turns right (respectively left). 2. (W2)

The robot traverses a left-free (respectively right-free) segment, adding it to $\mathcal{W}$. This segment becomes the last segment in $\mathcal{W}$ if it is a terminal. If the segment is not the last one, then the robot turns left (respectively right).

3.2.2 Ensuring the return from a search walk

We start with a high-level idea of the mechanism that will ensure the return from a search walk. Whenever the robot follows a search walk $\mathcal{W}$, it may a priori not be able to return to the origin of $\mathcal{W}$. This is due to the fact that, e.g., if $\mathcal{W}$ is left-oriented, then any segment that is right-free may have an unbounded number of special cells such that each of them is adjacent to a cell that does not belong to $\mathcal{W}$. Thus, the returning robot is not able to remember, using its bounded memory, which of such cells does not belong to the search walk and should be skipped. To overcome this difficulty, the robot will make small changes in the field close to the search walk while traversing it for the first time. These changes may disconnect the component in which the robot is walking, and this may result in creating many new components. While doing so, we will ensure two properties. First, thanks to the modifications in the field performed while traversing $\mathcal{W}$, the robot is able to return to the first cell of this search walk. Second, while backtracking on $\mathcal{W}$, the robot is able to undo earlier changes and recover the connectivity of the component.

Each cell $c$ at which the robot stops to perform the above-mentioned modification will be called a break point and is defined as follows. First, we require that $c$ be an internal cell of a segment $S$, i.e., neither the first nor the last cell of $S$. Second, if $S$ is left-free (respectively right-free), then when the robot traversing $S$ is at $c$, then there is a full cell $f$ to the right (respectively left) of it. Clearly, the cell $e$ to the left (respectively right) of the robot is empty. The following couple of actions performed by the robot located at such a cell $c$ are called a switch: if the robot is not carrying a brick, then the robot brings the brick from $f$ and then places it at $e$, and if the robot is carrying a brick, then the robot places it at $e$ and then brings the brick from $f$. Note that the switch may disconnect the component in which the robot is located thus creating two new components. One new component is the one in which the robot is located and this is the component that contains the search walk. The second new component is the one that contains the cell $f^{\prime}$ adjacent to $f$ and at distance two from $c$, if $f^{\prime}$ is full. If the cell $f^{\prime}$ is full and belongs to a separate component, then this second component containing $f^{\prime}$ will be called a switch-component. Whenever the robot traversing a segment performs the switch at each internal special cell of the segment, we say that this is a switch-traversal (cf. the example in Fig. 3).

3.2.3 Obtaining a brick at the end of a search walk

Informally, the purpose of traversing the entire search walk by a robot is to arrive at a location in the current component $\mathcal{C}$ of the robot, where the robot can start a procedure aimed at obtaining a brick whose removal will not disconnect $\mathcal{C}$. We will say that such a brick is free. In our algorithm, we check the condition (S1) to learn if the last segment is terminal. According to the condition, the terminal segment may end with a leaf, and in such a case the robot is at a cell with a free brick. If the terminal segment does not end with a leaf, then there need not exist a free brick located in a close neighborhood of the robot. However, we will prove that it is possible to perform a series of changes to the field that results in creating a configuration of bricks that does contain a free brick.

We now define the behavior of the robot that ended the switch-traversal of the last segment $S$ of a search walk $\mathcal{W}$ and arrived at a cell that is not a leaf. The following series of moves is called shifting (cf. Fig. 4). Suppose that the cell to the right (respectively left) of the robot is full. Note that this implies that $S$ is left-free (respectively right-free). First the robot changes its direction so that a cell of $S$ is in front of it (i.e., the robot turns back). The following three actions are performed until the stop condition specified in the third action occurs. First, the robot picks the brick from the currently occupied cell. Second, the robot moves one step forward — thus backtracking along $S$. Third, when the robot is at a special cell, then the shifting is completed, and otherwise the robot places the brick at the cell to the left (respectively right) of it. Note that when the robot arrives at a special cell, it is carrying a brick and this is the desired free brick.

We now give a pseudo-code of procedure 2 that obtains this brick.

3.3 Back to the marker

Before presenting the high-level idea of procedure 3 that takes the robot carrying a brick back to the marker, we need the following definitions. If $S$ is a segment, then the reversal of $S$, denoted by $\varphi(S)$, is the segment composed of the same cells as $S$ but in the reversed order. For a search walk $\mathcal{W}$ that is a concatenation of segments $S_{1},\ldots,S_{l}$, define the reversal of $\mathcal{W}$, denoted by $\varphi(\mathcal{W})$, to be the walk that is the concatenation of segments $\varphi(S_{l}),\varphi(S_{l-1}),\ldots,\varphi(S_{1})$, in this order. Thus, following $\varphi(\mathcal{W})$ means backtracking along $\mathcal{W}$, and in this section we give a procedure performing it, that reconnects the previous free component on the way. We also define the orientation of $\varphi(\mathcal{W})$ as follows. If the last segment of $\mathcal{W}$ is left-free, then $\varphi(\mathcal{W})$ is left-oriented, and otherwise $\varphi(\mathcal{W})$ is right-oriented. Thus, if $\mathcal{W}$ ended with a left-free (respectively right-free) segment, then $\varphi(\mathcal{W})$ also starts with a left-free (respectively right-free) segment.

At a high level, the robot will perform a switch-traversal along $\varphi(\mathcal{W})$, stopping at each break point to reconnect the corresponding switch-component with the component in which the robot is walking. However, we need to ensure that, at the end, the robot stops at the right point, i.e., at the marker. In order to ensure this, we define the following condition:

1. (S1’)

the robot arrives at a cell at distance at most $4$ from the marker.

We define a return switch-traversal of $\varphi(\mathcal{W})$ to be a switch-traversal of $\varphi(\mathcal{W})$ in which each verification of condition (S1) is replaced by the verification of condition (S1’). Recall that the condition (S1) is checked in the definition of a switch-traversal to determine the termination of a segment and consequently the termination of the entire search walk. Intuitively, by replacing condition (S1) with (S1’) we change the behavior of the robot so that it is looking for the marker while backtracking along $\mathcal{W}$, i.e., going along $\varphi(\mathcal{W})$.

A high-level sketch of procedure 3 is the following. As indicated earlier, the robot essentially follows $\varphi(\mathcal{W})$ and, as the return switch-traversal dictates, reconnects the switch components. However, there is one special case in which the robot should not perform a switch while being at a cell $c^{\prime}$ of $\varphi(\mathcal{W})$, although $c^{\prime}$ satisfies the definition of a break point. This case occurs if the shifting moved all internal cells of the last segment of $\mathcal{W}$. In this case, it is enough for the robot to move to the next cell after $c^{\prime}$ and start the return switch-traversal of $\varphi(\mathcal{W})$ from there. This is feasible because the cell $c$ and its neighbors are at a bounded distance from the robot when the shifting is completed. Below is the pseudo-code of procedure 3.

3.4 Extending the rough disc

The aim of procedure 4 is triple: it adds a new brick to the current rough disc in a specific place, and it calls procedure 1 to extend, if necessary, the empty space around the rough disc and to ensure that the marker is close to some free component. Whenever procedure 4 is called, the following conditions will be satisfied: the robot is at the marker and it is carrying a brick. Below is the pseudo-code of procedure 4.

Now the pseudo-code of the entire algorithm can be succinctly formulated as follows.

The following is the main result of this paper.

Theorem 3.1**.**

Algorithm 5 builds a nest starting from any connected field of size $z$ and span $s$ in time $O(sz)$. This time is worst-case optimal.

4 Analysis of the algorithm

This section is devoted to the proof of Theorem 3.1.

4.1 Search walks

The first three observations provide simple properties of search walks that will be used in the sequel.

Observation 4.1**.**

Suppose that $\mathcal{W}$ is the search walk from procedure 2. After performing the switch-traversal in line 2 of the procedure, the robot is at the end of $\mathcal{W}$. ∎

Observation 4.2**.**

A left-free (respectively right-free) segment becomes right-free (respectively left-free) as a result of a switch-traversal. ∎

Observation 4.3**.**

Let $\mathcal{W}$ be a search walk whose last segment $S$ is left-free (respectively right-free). Upon completion of a switch-traversal of $\mathcal{W}$, if the robot is not at a leaf, then the cell to the right (respectively left) of the robot is full and the cells in front of it and to the left (respectively right) of it are empty. ∎

We will need some additional notation. Let $\mathcal{W}$ be a search walk in a component $\mathcal{C}$ and $b$ be the last break point of $\mathcal{W}$. All cells of $\mathcal{W}$ starting at $b$ are called the prefix of $\varphi(\mathcal{W})$. Note that, at each point of the execution of procedure 2, some parts of $\mathcal{C}$ become the switch-components. The other component, namely the one that overlaps with $\mathcal{W}$ will be called the $\mathcal{W}$-component. (Note that we specify that it overlaps with $\mathcal{W}$ and not contains $\mathcal{W}$ since, after the shifting, some cells of $\mathcal{W}$ that are in the prefix of $\varphi(\mathcal{W})$ are empty and thus are not a part of the $\mathcal{W}$-component.) Upon completion of shifting, each component that contains a brick placed during shifting will be called a shift-component.

Lemma 4.1**.**

Upon completion of shifting performed in procedure 2, we have the following properties.

1. (i)

The shift-component is unique. 2. (ii)

Let $c^{\prime}$ be the cell adjacent to the cell occupied by the robot and also adjacent to the cell on which the last brick has been placed during shifting. If $c^{\prime}$ is full, then it belongs to the shift-component and it belongs to $\mathcal{W}$. If $c^{\prime}$ is empty, then it is adjacent to a cell of the shift-component. 3. (iii)

The robot is located at the penultimate special cell of $\mathcal{W}$ and is carrying a brick.

Proof.

Consider a shifting that occurs after a switch-traversal of $\mathcal{W}$. Let $S$ be the last segment of $\mathcal{W}$. The segment $S$ is either left-free or right-free, by the definition of a search walk. We consider the former case (cf. the example in Fig. 5); the latter one is analogous and will be skipped.

By Observation 4.1 and the formulation of procedure 2, when the shifting starts the robot is at the last cell of $S$. Denote this cell by $c_{1}$. Let $c_{2},\ldots,c_{l}$ be the cells of $S$ such that $c_{i}$ is adjacent to $c_{i-1}$ for each $i\in\{2,\ldots,l\}$, $c_{l}$ is a special cell in $\mathcal{W}$ and $c_{2},\ldots,c_{l-1}$ are not special cells in $\mathcal{W}$. Note that the latter sequence may be empty if two last cells of $S$ are special cells. Denote by $c_{i}^{\prime}$ the cell that is to the left of the robot when it is at $c_{i}$ during shifting.

According to the definition of shifting, the following occurs: for each $i\in\{1,\ldots,l-1\}$, the brick from $c_{i}$ is moved to the cell $c_{i+1}^{\prime}$. We argue that shifting is feasible, i.e., that the cell $c_{i}$, $i\in\{1,\ldots,l-1\}$, is full when the robot picks the brick from it and that the cell $c_{i+1}^{\prime}$, $i\in\{1,\ldots,l-2\}$, is empty when the robot then drops the brick at it, for $i\in\{1,\ldots,l-1\}$. The former is due to the fact that $c_{i}$ belongs to a segment which by definition is a sequence of full cells. The latter holds because $c_{2},\ldots,c_{l-1}$ are not special cells, i.e., their neighbors outside of $S$, in particular the cells $c_{2}^{\prime},\ldots,c_{l-1}^{\prime}$, are empty.

We now analyze what types of components are created during shifting from the component $\mathcal{C}$ in which it started. Consider the components $\mathcal{C}_{1},\ldots,\mathcal{C}_{t}$ obtained from $\mathcal{C}$ by making the cells $c_{1},\ldots,c_{l-1}$ empty. These are all cells from which the robot picked the bricks during shifting. First observe that there are exactly two components as above, i.e., $t=2$. The first one, say $\mathcal{C}_{1}$, contains the cell $c_{1}^{\prime}$ because, according to the ‘if’ statement in line 2 of procedure 2, $c_{1}$ is not a leaf and hence, due to Observation 4.3, the cell $c_{1}^{\prime}$ is full. The second component, let it be $\mathcal{C}_{2}$, contains $c_{l}$, which is full because it belongs to $\mathcal{W}$ and has not been emptied during shifting. To finish the argument that $t=2$, note that by definition of shifting, the cells $c_{2},\ldots,c_{l-1}$ are not special cells and thus have no full neighbors outside of $S$, and by Observation 4.3, the cell $c_{1}$ has no other full neighbors in $\mathcal{C}$ except $c_{2}$ and $c_{1}^{\prime}$. Observe that making the cells $c_{2}^{\prime},\ldots,c_{l-1}^{\prime}$ full during shifting glues these cells to $\mathcal{C}_{1}$, resulting in a single component. This is the unique shift-component. Thus property (i) is proved.

The cell that is to the right of the robot upon completion of shifting is $c_{l}^{\prime}$. Note that $c^{\prime}=c_{l}^{\prime}$ and this cell is adjacent to $c_{l-1}^{\prime}$. Hence, if $c_{l}^{\prime}$ is empty, then (ii) holds. Suppose that $c_{l}^{\prime}$ is full. The shift-component $\mathcal{C}_{1}$ and the $\mathcal{W}$-component $\mathcal{C}_{2}$ are the same: $c_{l}^{\prime}$ is adjacent to the full cell $c_{l-1}^{\prime}$ of $\mathcal{C}_{1}$ and is also adjacent to the full cell $c_{l}$ that belongs to $\mathcal{C}_{2}$. Since $S$ is left-free, by the definition of switch-traversal we obtain that the brick located at $c_{l}^{\prime}$ has not been dropped at $c_{l}^{\prime}$ as a result of a switch. Moreover, it cannot be a neighbor of an internal cell of $S$. Since this is not the last cell of $S$ because $l>1$, we have that $c_{l}$ is the first cell of $S$. Hence $c_{l}^{\prime}$ is the penultimate segment of $\mathcal{W}$. This proves property (ii).

Finally, the brick picked from $c_{l-1}$ is carried by the robot at the end of shifting. At the end of shifting, after picking the brick, the robot moves to $c_{l}$ which is the penultimate special cell of $\mathcal{W}$ because the cells $c_{2},\ldots,c_{l-1}$ are not special cells by definition. This proves property (iii) and completes the proof of the lemma. ∎

We say that the rough disc has a gap of width $k$ if each free component is at distance $k+1$ from the rough disc. We say that a field is structured if it satisfies the following conditions:

1. (F1)

the marker is at distance $3$ from the rough disc and at distance $4$ from some free component, 2. (F2)

the rough disc has a gap of width $7$.

The next lemma characterizes the situation upon completion of procedure 2.

Lemma 4.2**.**

Suppose that the field is structured at the beginning of an execution of procedure 2. Let $\mathcal{W}$ be the search walk traversed by the robot in a free component $\mathcal{C}$ during this execution. At the end of this execution we have the following properties:

1. (i)

the robot is located in the prefix $\varphi(\mathcal{W})$ and carries a brick. 2. (ii)

each brick that belongs to $\mathcal{C}$ at the beginning of the execution is either in a switch-component, in the shift-component or in the $\mathcal{W}$-component, 3. (iii)

if $\mathcal{W}$ starts with a cell at distance $7$ from the rough disc, then the rough disc has a gap of width at most $7$ and at least $5$.

Proof.

Consider the robot at the end of the execution of procedure 2. We consider two cases depending on the execution of the ‘if’ instruction in line 2 of procedure 2. In the first case, suppose that the instruction in line 2 is executed. The robot is at the last cell $c$ of $\mathcal{W}$ and carries a brick that it picked from $c$. This proves (i) in this case. Since $c$ was a leaf upon arrival of the robot at $c$, picking $c$ did not disconnect the $\mathcal{W}$-component, which implies that the shift-component equals the $\mathcal{W}$-component and consequently proves (ii) of the lemma.

In the second case, suppose that instruction in line 2 of procedure 2 is executed, i.e., the robot performed shifting. Then, statement (i) follows from Lemma 4.1(iii), since, by definition, the prefix $\varphi(\mathcal{W})$ contains all cells between the last special cell and the penultimate special cell of $\mathcal{W}$, inclusively. Again by Lemma 4.1(i), the shift-component is unique which implies statement (ii) in this case.

We now prove (iii). Since the field is structured at the beginning of the execution of procedure 2, it has a gap of width $7$. The first cell of $\mathcal{W}$ does not change its position and since its distance from the rough disc is $7$, we have that the gap is not larger than $7$ at the end of the execution. Now we analyze how much the gap can decrease. During the execution of procedure 2, the robot performs two types of changes in the field. The first one is a switch, which places each brick next to a full cell of the component. Thus, this can decrease the gap by at most one. The second one is the shifting, which moves each brick to a cell at distance $2$ from its origin, which may decrease the gap by at most $2$. The bricks moved during a switch do not belong to $\mathcal{W}$ and the bricks moved during shifting belong to it. This proves (iii) and concludes the proof of the lemma. ∎

4.2 Reversals of search walks

If a component is at distance larger than $7$ from the rough disc, then it is called a lost component. Recall the definition of a switch, in which the robot located at a cell $c$ brings a brick from a full cell $f$ and places it at an empty cell $e$. The cell $e$ will be called a switch-cell. If, during a return switch-traversal, the robot is backtracking on a segment $S$, which was added to the walk using condition (W1) or (W2), and it checks, upon arrival at a special cell $c$ of $S$, whether the cell to the left (respectively right) of $c$ is full, then we say that the robot is looking for left (respectively right) turn during this traversal of $S$. Suppose that the robot is located at a cell $c$ of a segment $S$ during backtracking. We say that the robot is oriented on $\varphi(S)$ if it is directed towards the beginning of $S$. When the robot backtracks on $S$, then all cells that belong to $S$ and are located between $c$ (inclusively) and the beginning of $S$ (exclusively) are called the leftover of $S$. In other words, these cells are the ones to be yet visited by the robot backtracking on $S$.

In the three following lemmas we prove that procedure 3 can be correctly executed by the robot.

Lemma 4.3**.**

The robot can correctly execute lines 3-3 of procedure 3.

Proof.

Note that lines 3 and 3 result in no actions of the robot and only introduce notation for the description of the remaining steps of the procedure. The condition in the ‘if’ statement in line 3 can be checked using Lemma 4.1(ii): the robot tests whether the cell $c^{\prime}$ in the lemma is full or not and it is full if and only if the robot is at the first cell of $S_{l}$. Now we analyze the instructions within the ‘if’ statement. In line 3, the penultimate cell of $S_{l-1}$ is the above cell $c^{\prime}$ and hence the robot can perform the correct turn. The value of $|S_{l-1}|$, may be large and thus unknown to the robot. However, for calculating $\min\{2,|S_{l-1}|-1\}$ it is enough to know whether $|S_{l-1}|=2$ or $|S_{l-1}|>2$. This can be remembered by the robot while performing the traversal of a search walk in procedure 2 (although the robot does not know whether the current segment is penultimate, it may always remember the information about the two recently traversed segments). To execute the instruction in line 3, the robot can remember whether $l>2$, and it turns in the opposite direction to the turn just made in line 3, which follows from the definition of a search walk. ∎

Lemma 4.4**.**

Suppose that the robot is oriented on $\varphi(S)$, where $S$ is a left-free (respectively right-free) segment of some search walk. If:

1. (i)

the robot previously performed a switch-traversal along $S$, 2. (ii)

the robot is looking for a left (respectively right) turn while traversing $\varphi(S)$,

then, during the return switch-traversal, the robot arrives at the end of $\varphi(S)$ and turns left (respectively right).

Proof.

Assume that the robot is looking for a left turn. The other case is analogous and we omit it. Thus, $S$ is left-free prior to the switch-traversal performed in (i). By Observation 4.2, $\varphi(S)$ is also left-free after the switch-traversal. Let $S^{\prime}$ be the maximal sequence of cells that the robot traversed during the return switch-traversal while looking for a left turn, before it turned left. Since $\varphi(S)$ is left-free, this implies that the robot reaches the end of $\varphi(S)$, i.e., $S^{\prime}$ contains the endpoint of $\varphi(S)$. Let $c^{\prime}$ be the cell at which the robot finishes the traversal of $S^{\prime}$. Let $c$ be the first cell of $S$. We need to show that $c=c^{\prime}$, i.e., that the robot does make a turn when located at $c$. By the definition of a search walk, the first cell of $S$ is a special cell. By the definition of a switch-traversal, the robot does not perform a switch at the end nor at the beginning of a segment. Thus, in particular, no switch occurred when the robot was located at $c$ during the traversal of $S$ while performing the search walk $\mathcal{W}$. This means that a neighbor of $c$ that is not in $S$ is full during the traversal of $S$ in $\mathcal{W}$ if and only if this neighbor is full during the traversal of $S^{\prime}$. Thus, $c$ is a special cell when the robot arrives at $c$ while traversing $S^{\prime}$. Moreover, this special cell ends the segment $p(S)$ that precedes $S$ in $\mathcal{W}$. Since $p(S)$ is not a terminal segment, we have that it ended by satisfying condition (S2). Since $S$ is left-free, the segment $p(S)$ is right-free by the definition of a search walk. This implies that when the robot arrived at $c$ during the search walk $\mathcal{W}$, it had a full cell to its right. This full cell belongs to $S$ and therefore, when the robot arrives at $c$ while traversing $S^{\prime}$, it has a full cell to its left. Since the robot is looking for a left turn, $c$ becomes the last cell of $S^{\prime}$ proving that $c=c^{\prime}$, and moreover, the robot turns left at $c$, as required by the lemma. ∎

The following lemma shows that, while executing procedure 3, the robot does not loose its way during the backtrack on a previously traversed search walk.

Lemma 4.5**.**

Let $\mathcal{W}$ be a search walk. Suppose that the robot traversed $\mathcal{W}$ by executing procedure 2 and then executed procedure 3. These two executions ensure that the robot traverses $\varphi(\mathcal{W})$ after the traversal of $\mathcal{W}$.

Proof.

Denote by $S_{1},\ldots,S_{l}$ the segments whose concatenation, in this order, gives the search walk $\mathcal{W}$. By definition, a return switch-traversal is a walk that traverses a sequence of segments denoted by $S_{1}^{\prime},\ldots,S_{l^{\prime}}^{\prime}$. We argue by induction on $i\in\{1,\ldots,l^{\prime}\}$ that:

1. (a)

$S_{i}^{\prime}=\varphi(S_{l-i+1})$, and 2. (b)

upon arrival at the end of $S_{i}^{\prime}$, the robot becomes oriented on $S_{l-i}$.

Before giving the inductive proof we note that property (a) implies that the return switch traversal is a concatenation of segments $\varphi(S_{l}),\ldots,\varphi(S_{1})$ and thus it is the walk $\varphi(\mathcal{W})$ as required by the lemma. We note that property (b) is used for technical reasons to conduct the inductive argument.

For the base case of $i=1$ we need to argue that the robot traverses the segment $\varphi(S_{l})$ and makes the turn after which the traversal of $\varphi(S_{l-1})$ will start. By Lemma 4.2(i), the robot is at a cell $c^{\prime}$ in the segment $\varphi(S_{l})$ at the end of execution of procedure 2. Thus, the robot is in $\varphi(S_{l})$ when procedure 3 starts. The segment $S_{l}$ has been appended to $\mathcal{W}$ in construction step (W1) or (W2) as a left-free or a right-free segment. We assume that $S_{l}$ is left-free. The proof for a right-free segment $S_{l}$ is analogous and will be omitted. If shifting did not occur during the execution of procedure 2 then, according to line 2, the robot is at the end of the search walk $\mathcal{W}$, i.e., at the end of $S_{l}$. If shifting did occur in line 2 of procedure 2, then $c^{\prime}$ is not the last cell of $S_{l}$.

If $c^{\prime}$ is the first cell of $S_{l}$ (which is the last cell of $\varphi(S_{l})$), then by Lemma 4.3, the robot can correctly verify this in line 3 of procedure 3. Moreover, this implies that (a) holds for $i=1$. Then, the robot performs the turn in line 3 which proves (b).

Now suppose that $c^{\prime}$ is not the first cell of $S_{l}$. The assumption (i) of Lemma 4.4 is satisfied, where we take $S=S_{l}$ in the lemma. By the definition of return switch-traversal, the fact that $\mathcal{W}$ ended with a left-free segment (recall that $S_{l}$ is left-free) implies that, when the robot starts its walk in line 3 of procedure 3, it follows a left-oriented walk. The traversal of $S_{1}^{\prime}$ is thus determined by the first construction step in (W1) for this left-oriented walk. Thus, the robot traverses a left-free segment as the first segment $S_{1}^{\prime}$, i.e., it is looking for a left turn. This implies that the assumption (ii) of Lemma 4.4 is satisfied. Then, (a) and (b) follow from Lemma 4.4. This completes the proof of the base case.

For the proof of the inductive step suppose that assertions (a) and (b) hold for some $i\in\{1,\ldots,l-1\}$ and we prove them for $i+1$. By the inductive assumption, the robot is at the end of $\varphi(S_{l-i+1})$ when procedure 3 starts. We consider three cases.

Case 1. $i+1=2$, $S_{l-1}$ is of length $2$, and the robot is at the beginning of $S_{l}$ upon completion of shifting performed in line 2 of procedure 2.

By Lemma 4.3, the condition in the ‘if’ statement in line 3 of procedure 3 is correctly verified by the robot, and by inductive assumption, it is oriented on $\varphi(S_{l-1})$. Since the length of $S_{l-1}$ is $2$, the robot makes one step forward (see line 3) and makes a turn (see line 3). This ensures claims (a) and (b) in this case.

Case 2. $i+1=2$, $S_{l-1}$ is of length larger than $2$, and the robot is at the beginning of $S_{l}$ upon completion of shifting performed in line 2 of procedure 2.

By the inductive assumption, the robot is oriented on $S_{l-1}$. By Lemma 4.3, the robot makes two steps along $\varphi(S_{l-1})$ by executing instruction in line 3 of procedure 3 and thus it is at the third cell of $\varphi(S_{l-1})$ when the return switch-traversal in line 3 starts. Thus, since the robot is at a cell of $S_{l-1}$, condition (i) of Lemma 4.4 is satisfied. By arguments analogous to the ones in the base case of induction, condition (ii) holds as well. Thus by Lemma 4.4, claims (a) and (b) hold for $i+1$.

Case 3. $i+1>2$ or ($i+1=2$ and the robot is not at the beginning of $S_{l}$ upon completion of shifting performed in line 2 of procedure 2).

The robot is at the beginning of $S_{l-1}$ when the return switch-traversal starts. As before, conditions (i) and (ii) of Lemma 4.4 are satisfied. Thus by Lemma 4.4, claims (a) and (b) hold for $i+1$. ∎

We say that the field is strongly structured if the following conditions are satisfied:

1. (T1)

the field is structured, 2. (T2)

there are no lost components, and 3. (T3)

the robot is at the marker.

We will show that the field is strongly structured at the beginning of any iteration of the ‘while’ loop in Algorithm 5.

The following lemma shows that while backtracking on a search walk, the robot reconnects all switch components that were disconnected during procedure 2. Moreover, this backtracking stops when the robot is at the marker.

Lemma 4.6**.**

Suppose that at the beginning of an iteration of the “while” loop in algorithm 5 the field is strongly structured. Then there are no lost components in the field and the robot is at the marker after the execution of procedures 2 and 3.

Proof.

Since, by assumption, the robot is at the marker at the beginning of the iteration of the ‘while’ loop, the robot is at the marker when procedure 2 starts. Thus, in line 2 of this procedure, the robot goes to a free component $\mathcal{C}$. A free component exists due to the condition of the loop. The fact that such a component $\mathcal{C}$ is at distance $4$ from the marker follows from the assumption that the field is structured. Let $\mathcal{W}$ be the search walk traversed in a component $\mathcal{C}$ during the execution of procedure 2. By Observation 4.1, the robot arrives at the last cell of $\mathcal{W}$ as a result of the switch-traversal in line 2 of procedure 2. By Lemma 4.2(ii), each component obtained from $\mathcal{C}$ is either a $\mathcal{W}$-component, a switch-component or a shift-component. By Lemma 4.1(i), the shift-component is unique. The shift-component equals the $\mathcal{W}$-component if shifting did not occur during the execution of procedure 2, i.e., when line 2 of this procedure has been executed. We now consider the case when the shifting did occur. We have two possibilities, depending on whether the cell $c^{\prime}$ from Lemma 4.1(ii) is full or empty upon completion of shifting, i.e., at the beginning of the execution of procedure 3. By Lemma 4.1(ii), if $c^{\prime}$ is full, then it belongs to the shift component and to $\mathcal{W}$. Thus, the shift-component is identical to the $\mathcal{W}$-component. By Lemma 4.1(ii), if $c^{\prime}$ is empty, then $c^{\prime}$ is adjacent to a cell $c^{\prime\prime}$ of the shift component. Since $c$ is a special cell, there is a full cell $f$ to the left or to the right of the robot. Since $c^{\prime}$ is to the left or to the right of the robot and $c^{\prime}$ is empty, we have that $f\neq c^{\prime}$. Moreover, by Lemma 4.1(ii), $c$ is not the first cell of the last segment in $\mathcal{W}$. Thus, the condition in the ‘if’ statement in line 3 is false and hence the robot starts the return switch-traversal in line 3 in procedure 3 at the cell $c$. In this switch-traversal, the robot moves the brick from $f$ to $c^{\prime}$ thus reconnecting the shift component (whose full cell $c^{\prime\prime}$ is adjacent to $c^{\prime}$) with the $\mathcal{W}$-component. At this point, the shift component and the $\mathcal{W}$-component are equal and therefore the initial field $\mathcal{C}$ is transformed into a field with the $\mathcal{W}$-component and possibly many switch-components.

By Lemma 4.5, the robot backtracks on $\mathcal{W}$ by executing procedure 3. In other words, the robot traverses $\varphi(\mathcal{W})$. Since the robot traverses the entire search walk $\varphi(\mathcal{W})$, by the definition of return switch-traversal, each switch-component is reconnected with the $\mathcal{W}$-component. It remains to argue that during the return switch-traversal no lost component is created. Such a component could be created, if there existed a full cell $c^{\prime}$ adjacent to a cell $c$ of $\varphi(\mathcal{W})$ such that the robot performs a switch at $c$. This switch would remove the brick from $c^{\prime}$ thus creating a lost component. We now show that this is impossible. The cell $c^{\prime}$ has been made full during the switch-traversal in line 2 of procedure 2. Thus, this happened during shifting in line 2. Since during shifting, after moving each brick, the robot makes one step forward along $\varphi(\mathcal{W})$, $c$ does not belong to the first segment of $\varphi(\mathcal{W})$. By the definition of a search walk, $c$ belongs to the second segment $S$ of $\varphi(\mathcal{W})$, and $c$ is the second cell in $S$. By Lemma 4.3, the robot correctly executed the ‘if’ instruction in line 3 of procedure 3. If $S$ is of length $2$, then the robot arrives at $c$ in line 3 and makes a turn in line 3, and consequently the switch does not occur at $c$. If $S$ is of length larger than $2$, then the robot makes two moves forward along $S$ in line 3: the first of these moves brings the robot to $c$ and thus again no switch occurs when the robot is at $c$. Hence we have proved that no lost component is created while backtracking on $\mathcal{W}$.

We finally prove that the robot is at the marker at the end of procedure 3. By Lemma 4.5, the robot traverses $\varphi(W)$ in line 3 of this procedure. Thus, it becomes located at its end, which is the beginning of $\mathcal{W}$, and hence it can correctly check that it is at distance $4$ from the marker, by the definition of switch-traversal. More precisely, this is guaranteed by condition (S1’) that terminates $\varphi(\mathcal{W})$. Then the robot gets to the marker executing line 3 of procedure 3. ∎

4.3 Analysis of the rough disc construction

The following lemma shows that procedure 1 does not create lost components and makes sufficient room around the rough disc. Moreover, the cost of each call of the procedure is $O(s)$.

Lemma 4.7**.**

Suppose that the robot is at the marker and that there are no lost components. An execution of procedure 1 takes time $O(s)$ and results in a strongly structured field.

Proof.

We first prove that the field is structured after executing the procedure. The robot can correctly go to the nearest cell of the rough disc $D$ in line 1. Indeed, in a call to procedure 1 in line 5 of algorithm 5 this is because $|D|=1$ and $D$ is at distance $2$ from the robot. In each call made in procedure 4 this is because the robot is at the marker and, by Lemma 4.7(iii), the rough disc and the marker form two separate components. While traversing the border of the rough disc in line 1, the robot iterates over each cell $c$ of the gap in all executions of the ‘for’ loop in line 1. Since the distance between the current location $c^{\prime}\in D$ and $c$ is at most $7$, the robot can correctly execute instructions in line 1. In line 1, the robot finds the first empty cell in the direction $d$ away from $D$. Then, in line 1, the robot drops the brick at this cell and returns to $c^{\prime}$. We argue that the latter is feasible. This is done by first finding the closest empty cell $e$ in the direction opposite to $d$. This cell is at distance at most $7$ from the rough disc, due to the condition used in line 1. Thus, the robot can remember the relative position of $e$ with respect to $c^{\prime}$ because the distance between them is bounded. The latter is due to the selected direction $d$. Indeed, the fact that direction $d$ is away from $D$ implies that the prefix of the walk in line 1 consisting of cells at distance at most $7$ from $c^{\prime}$ is of bounded length.

The above proves that each cell at distance $7$ from the rough disc, except the marker, is empty upon completion of the traversal in line 1. Since the ‘for’ loop in line 1 does not select cells at distance larger than $7$ from the rough disc, the rough disc has a gap of width $7$, i.e., the field satisfies condition (F2). Moreover, this implies that no lost component is created during the traversal in line 1 because each brick dropped in line 1 is placed next to a full cell (see line 1).

Checking if there exists a free component $\mathcal{C}$ in line 1 can be done by traversing the border of the rough disc because, by assumption, there are no lost components. By the same argument, the robot can relocate the marker in line 1 of procedure 1. This also ensures that the field satisfies condition (F1). Thus, the field is structured, i.e., it satisfies condition (T1).

By assumption, there are no lost components, and each brick dropped in line 1 is placed next to a full cell. Thus, no lost component is created during procedure 1, which implies that the field satisfies condition (T2). According to line 1 of procedure 1, upon its completion the robot is at the marker, which ensures condition (T3). Thus, the field is strongly structured as required.

Now we analyze the time needed to perform an execution of procedure 1. For each cell $c$ selected in the ‘for’ loop in line 1, all the following steps take time $O(1)$, possibly except for the walk performed in line 1 and the return from it in line 1. The cells traversed in line 1 are called a sweep-walk. Thus, to estimate the execution time of procedure 1, we estimate the total length of all such walks that occur during the execution.

The call in line 5 in algorithm 5 takes time $O(s)$ because, for the initial rough disc of size $1$, $O(1)$ cells need to be moved to ensure property (F2) of the field, and for each such cell, the sweep-walk is of length $O(s)$.

We now consider one execution of procedure 1 called in procedure 4. In order to analyze the time of executing this call, we divide sweep-walks depending on their length. Let $W_{2}$ be all sweep-walks of length at most $2$ and let $W_{*}$ be all the remaining sweep-walks. A sweep-walk $X$ is traversed by the robot because condition (F2) is violated, i.e., there is a full cell $c$ at distance less than $7$ from the rough disc. We consider two cases.

In the first case, some brick has been dropped at $c$ in the iteration of the ‘while’ loop of algorithm 5 in which the considered call to procedure 1 occurs. The event of dropping the brick occurred after the previous call to procedure 1 because this previous call, as we have proved above, left the field structured. Thus, this occurred during an execution of procedure 2 or procedure 3. The cell $c$ does not become full as a result of a switch because, by Lemma 4.6, all switch-components are reconnected with the component in which the agent is performing a return switch-traversal in procedure 3. Thus, $c$ becomes full during shifting. Let $S$ be the last segment traversed by the robot during the execution of procedure 2. Note that the brick at $c$ has been moved from a cell $c^{\prime}$ of $S$ during shifting. The cell $c$ is at distance $2$ from $c^{\prime}$. If the walk $X$ is perpendicular to $S$, then it has 2 cells because the neighbor of $c$ in $S$ is empty by the definition of shifting. If the walk $X$ is parallel to $S$, then $c$ is the single cell, among those filled during shifting, that results in a sweep-walk, due to the direction away from $D$ in procedure 1. Thus, in this first case, we have $O(s)$ sweep-walks in $W_{2}$ and at most one sweep-walk in $W_{*}$.

In the second case, the cell $c$ has been full in the iteration of the ‘while’ loop of algorithm 5 in which the considered call to procedure 1 occurs. Thus, this cell results in a sweep-walk because the robot extended the rough disc. However, for each such extension, there are $O(1)$ such cells $c$. Hence, in the second case we have $O(1)$ sweep-walks in $W_{2}$ and $O(1)$ sweep-walks in $W_{*}$.

Note that the length of a sweep-walk in $W_{*}$ is $O(\sqrt{z}+s)=O(s)$ because the span of the final rough disc is $O(\sqrt{z})$. Thus, in each iteration of the ‘while’ loop of algorithm 5, the total length of all sweep-walks is $O(s)$. ∎

Whenever procedure 4 is called in our algorithm, the robot is at the marker. The following lemma says that it can correctly execute the procedure.

Lemma 4.8**.**

If the robot is at the marker, carries a brick, and there are no lost components, then the robot can correctly execute procedure 4 in time $O(s)$.

Proof.

In order to execute the instruction in line 4 of procedure 4, it is enough for the robot to remember whether the current rough disc is a disc. Adding a brick to the rough disc requires performing one traversal along its border to find the correct location for the brick. This takes time $O(s)$ because the size of the border of a rough disc is $O(\sqrt{z})$ which is $O(s)$. By Lemma 4.7, sweeping in line 4 can be correctly executed because the robot is at the marker when it is called and, by assumption, there are no lost components. Moreover, the time needed to execute procedure 1 is $O(s)$. ∎

We are now able to prove our main result, i.e., Theorem 3.1.

Proof of Theorem 3.1.

We argue by induction on the number of iterations of the ‘while’ loop in algorithm 5 that at the beginning of the $i$-th iteration, for $i\geq 1$, the field is strongly structured. The claim holds for $i=1$ because, by Lemma 4.7, the call to procedure 1 in line 5 results in a field that is structured. Assuming that the assertion holds for some $i\geq 1$, consider the $(i+1)$-th iteration. By Lemma 4.6, after executing procedures 2 and 3 in the $(i+1)$-th iteration, there are no lost components, and the robot is at the marker. We argue that the robot is carrying a brick. If procedure 2 did not perform shifting then (see line 2) the robot is carrying a brick at the end of its execution due to Lemma 4.2(i). If shifting has been performed, then the robot is carrying a brick at the end of shifting, which is the end of the execution of procedure 2 (see line 2), due to Lemma 4.1(iii). Note that if the robot performing the return switch-traversal in procedure 3 is carrying a brick prior to a switch, then it is carrying a brick upon completion of the switch. Thus, by an inductive argument we can state that the fact that the robot is carrying a brick at the beginning of the return switch-traversal implies that the robot is carrying a brick at the end of it. Thus in particular, the robot is carrying a brick when procedure 4 is called in line 5 of algorithm 5. This implies that the assumptions of Lemma 4.8 are satisfied. By this lemma, the execution of procedure 4 extends the rough disc by one brick. The call to procedure 1 in line 4 of procedure 4 results in a field that is strongly structured, in view of Lemma 4.7. This completes the inductive argument for the $(i+1)$-th iteration. Thus we showed that, at the beginning of each iteration of the ‘while’ loop in algorithm 5 the field is strongly structured.

The above implies that there will be $z-2$ iterations of the ‘while’ loop in algorithm 5 and, upon the exit from the loop, there are only two components: the rough disc of size $z-1$ and the marker. By Proposition 2.1, adding the brick from the marker in line 5 to the rough disc results in a nest.

By the definition of a search walk, the length of any search walk is $O(s)$. The time needed to execute the two procedures that traverse the search walk and backtrack on it is linear in the length of the walk. Using Lemmas 4.7 and 4.8, the overall time of algorithm 5 is $O(sz)$. By Proposition 2.2, this time is worst-case optimal. ∎

5 Conclusion

We designed a finite deterministic automaton that builds the most compact structure starting from any connected field of bricks, and does it in optimal time. An interesting problem yielded by our research is to characterize the classes of target structures that can be built by a single automaton, starting from any connected field of bricks in the grid. Another problem is that of how the building task parallelizes, i.e., how much time many automata use to build some structure.