Stéphane Devismes

Anissa Lamani

Franck Petit

Pascal Raymond

Sébastien Tixeuil

Optimal Grid Exploration by Asynchronous Oblivious Robots

Keywords: Exploration, Grid, Oblivious Robots, CORDA model

We propose optimal (w.r.t. the number of robots) solutions for the deterministic terminating exploration (exploration for short) of a grid-shaped network by a team of k asynchronous oblivious robots in the asynchronous non-atomic model, so-called CORDA.

In more details, we first consider the ATOM model. We show that it is impossible to explore a grid of at least three nodes with less than three robots. Next, we show that it is impossible to explore a (2, 2)-Grid with less than 4 robots, and a (3, 3)-Grid with less than 5 robots, respectively. The two first results hold for both deterministic and probabilistic settings, while the latter holds only in the deterministic case. ATOM being strictly stronger than CORDA, all these impossibility results also hold in CORDA.

Then, we propose deterministic algorithms in CORDA to exhibit the optimal number of robots allowing to explore of a given grid. Our results show that except in two particular cases, 3 robots are necessary and sufficient to deterministically explore a grid of at least three nodes. The optimal number of robots for the two remaining cases is: 4 for the (2, 2)-Grid and 5 for the (3, 3)-Grid, respectively.

Introduction

We consider autonomous robots [START_REF] Potop-Butucaru | Distributed computing with mobile robots: an introductory survey[END_REF][START_REF] Suzuki | Distributed anonymous mobile robots: Formation of geometric patterns[END_REF] that are endowed with motion actuators and visibility sensors, but that are otherwise unable to communicate. Those robots must collaborate to solve a collective task, here the deterministic terminating grid exploration (exploration for short), despite being limited with respect to input from the environment, asymmetry, memory, etc.

So far, two universes have been studied: the continuous two-dimensional Euclidean space and the discrete universe. In the former, robot entities freely move on a plane using visual sensors with perfect accuracy that permit to locate all other robots with infinite precision (see e.g., [START_REF] Das | On the computational power of oblivious robots: forming a series of geometric patterns[END_REF][START_REF] Dieudonné | Circle formation of weak mobile robots[END_REF][START_REF] Flocchini | Arbitrary pattern formation by asynchronous, anonymous, oblivious robots[END_REF][START_REF] Souissi | Using eventually consistent compasses to gather memory-less mobile robots with limited visibility[END_REF][START_REF] Suzuki | Distributed anonymous mobile robots: Formation of geometric patterns[END_REF]). In the latter, the space is partitioned into a finite number of locations, conventionally represented by a graph, where the nodes represent the possible locations that a robot can take and the edges the possibility for a robot to move from one location to another (e.g., [START_REF] Baldoni | On the solvability of anonymous partial grids exploration by mobile robots[END_REF][START_REF] Blin | Exclusive perpetual ring exploration without chirality[END_REF][START_REF] Franc ¸ois Bonnet | Asynchronous exclusive perpetual grid exploration without sense of direction[END_REF][START_REF] Devismes | Optimal exploration of small rings[END_REF][START_REF] Devismes | Optimal probabilistic ring exploration by asynchronous oblivious robots[END_REF][START_REF] Flocchini | Computing without communicating: Ring exploration by asynchronous oblivious robots[END_REF][START_REF] Flocchini | Remembering without memory: Tree exploration by asynchronous oblivious robots[END_REF][START_REF] Izumi | Mobile robots gathering algorithm with local weak multiplicity in rings[END_REF][START_REF] Kamei | Asynchronous mobile robot gathering from symmetric configurations without global multiplicity detection[END_REF][START_REF] Klasing | Gathering asynchronous oblivious mobile robots in a ring[END_REF][START_REF] Lamani | Optimal deterministic ring exploration with oblivious asynchronous robots[END_REF]).

In this paper, we pursue research in the discrete universe and focus on the exploration problem when the network is an anonymous unoriented grid, using a team of autonomous mobile robots. Exploration requires that robots explore the grid and stop when the task is complete. In other words, every node of the grid must be visited by at least one robot and the protocol eventually terminates, i.e., every robot eventually stays idle forever.

The robots we consider are unable to communicate, however they can sense their environment and take decisions according to their local view. We assume anonymous and uniform robots (i.e., they execute the istically exploring a grid requires no primality condition while deterministically exploring a ring expects the number k of robots to be co-prime with n, the number of nodes.

Roadmap. Section 2 presents the system model and the problem to be solved. Lower bounds are shown in Section 3. The deterministic general solution using three robots is given in Section 4, the special case with five robots is studied in Section 5. Section 6 gives some concluding remarks.

Preliminaries

Distributed Systems. We consider systems of autonomous mobile entities called agents or robots evolving in a simple unoriented connected graph G = (V, E), where V is a finite set of nodes and E a finite set of edges. In G, nodes represent locations that can be sensed by robots and edges represent the possibility for a robot to move from one location to another. We assume that G is an (i, j)-Grid (or a Grid, for short) where i, j are two positive integers, i.e., G satisfies the following two conditions: 1. |V | = i × j, and 2. there exists an order on the nodes of V , v 1 , . . . , v i•j , such that:

• ∀x ∈ [1..i × j], (x mod i) = 0 ⇒ {v x , v x+1 } ∈ E, and

• ∀y ∈ [1..i × (j -1)], {v y , v y+i } ∈ E.
We denote by n = i × j the number of nodes in G. We denote by δ(v) the degree of node v in G. Nodes of the grid are anonymous (we may use indices, but for notation purposes only). Moreover, given two neighboring nodes u and v, there is no explicit or implicit labeling allowing the robots to determine whether u is either on the left, on the right, above, or below v. Remark that an (i, j)-Grid and a (j, i)-Grid are isomorphic. Hence, as the nodes are anonymous, we cannot distinguish an (i, j)-Grid from a (j, i)-Grid. So, without loss of generality, we always consider (i, j)-Grids, where i ≤ j. Note also that any (1, j)-Grid is isomorphic to a chain. In any (i, j)-Grid, if i = 1, then either the grid consists of one single node, or two nodes are of degree 1 and all other nodes are of degree 2; otherwise, when i > 1, four nodes are of degree 2 and all other nodes are of degree either 3 or 4. In any grid, the nodes of smallest degree are called corners. In any (1, j)-Grid with j > 1, the unique chain linking the two corners is called the borderline. In any (i, j)-Grid such that i > 1, there exist four chains v 1 , . . . , v m of length at least 2 such that δ(v 1 ) = δ(v m ) = 2, and ∀x, 1 < x < m, δ(v x ) = 3, these chains are also called the borderlines.

Robots. Operating on G are k ≤ n robots. The robots do not communicate in an explicit way; however they see the position of the other robots and can acquire knowledge based on this information. We assume that the robots cannot remember any previous observation nor computation performed in any previous step. Such robots are said to be oblivious (or memoryless).

Each robot operates according to its (local) program. We call protocol a collection of k programs, each one operating on one single robot. Here we assume that robots are uniform and anonymous, i.e., they all have the same program using no local parameter (such as an identity) that could permit to differentiate them. The program of a robot consists in executing Look-Compute-Move cycles infinitely many times. That is, the robot first observes its environment (Look phase). Based on its observation, a robot then decides to move or stay idle (Compute phase). When a robot decides to move, it moves from its current node to a neighboring node during the Move phase.

Computational Model. We consider two models: the semi-asynchronous and atomic model, ATOM [START_REF] Efrima | Distributed algorithms for partitioning a swarm of autonomous mobile robots[END_REF][START_REF] Suzuki | Distributed anonymous mobile robots: Formation of geometric patterns[END_REF] and the asynchronous non-atomic model, CORDA [START_REF] Flocchini | Computing without communicating: Ring exploration by asynchronous oblivious robots[END_REF][START_REF] Prencipe | Instantaneous actions vs. full asynchronicity : Controlling and coordinating a set of autonomous mobile robots[END_REF]. In both models, time is represented by an infinite sequence of instants 0, 1, 2, . . . No robot has access to this global time. Moreover, every robot executes cycles infinitely many times. Each robot performs its own cycles in sequence. However, the time between two cycles of the same robot and the interleavings between cycles of different robots are decided by an adversary. As a matter of facts, we are interested in algorithms that correctly operate despite the choices of the adversary. In particular, our algorithms should also work even if the adversary forces the execution to be fully sequential or fully synchronous.

In ATOM, each Look-Compute-Move cycle execution is assumed to be atomic: every robot that is activated (by the adversary) at instant t instantaneously executes a full cycle between t and t + 1.

In CORDA, Look-Compute-Move cycles are performed asynchronously by each robot: the time between Look, Compute, and Move operations is finite yet unbounded, and is decided by the adversary. The only constraint is that both Move and Look are instantaneous.

Remark that in both models, any robot performing a Look operation sees all other robots on nodes and not on edges. However, in the CORDA, a robot R may perform a Look operation at some time t, perceiving robots at some nodes, then Compute a target neighbor at some time t ′ > t, and Move to this neighbor at some later time t ′′ > t ′ in which some robots are at different nodes from those previously perceived by R because in the meantime they moved. Hence, robots may move based on significantly outdated perceptions.

Of course, ATOM is stronger than CORDA. So, to be as general as possible, in this paper, our impossibility results are written assuming ATOM, while our algorithms assume CORDA.

Multiplicity. We assume that during the Look phase, every robot can perceive whether several robots are located on the same node or not. This ability is called Multiplicity Detection. We shall indicate by d i (t) the multiplicity of robots present in node u i at instant t. We consider two kinds of multiplicity detection: the strong and weak multiplicity detections.

Under the weak multiplicity detection, for every node u i , d i is a function N → {•, ⊥, ⊤} defined as follows: d i (t) is equal to either •, ⊥, or ⊤ according to u i contains none, one or several robots at time instant t. If d i (t) = •, then we say that u i is free at instant t, otherwise u i is said occupied at instant t. If d i (t) = ⊤, then we say that u i contains a tower at instant t.

Under the strong multiplicity detection, for every node u i , d i is a function N → N where d i (t) = j indicates that there are j robots in node u i at instant t. If d i (t) = 0, then we say that u i is free at instant t, otherwise u i is said occupied at instant t. If d i (t) > 1, then we say that u i contains a tower (of d i (t) robots) at instant t.

As previously, to be as general as possible, our impossibility results are written assuming the strong multiplicity detection, while our algorithms assume the weak multiplicity detection.

Configurations and Views. To define the notion of configuration, we need to use an arbitrary order ≺ on nodes. The system being anonymous, robots do not know this order. (Actually, this order is used in the reasoning only.) Let v 1 , . . . , v n be the list of the nodes in G ordered by ≺. The configuration at time t is d 1 (t), . . . , d n (t). We denote by initial configurations the configurations from which the system can start at time 0. Every configuration where all robots stay idle forever is said to be terminal.

∀v i ∈ V , we have d i = d ′ j where v j = f (v i ).
The view of robot R at time t is a labelled graph isomorphic to G, where every node u i is labelled by d i (t), except the node where R is currently located, this latter node u j is labelled by d j (t), * . (Indeed, any robot knows the multiplicity of the node where it is located.) Hence, from its view, a robot can compute the view of all other robots, and decide whether some other robots have the same view as its own. Every decision to move is based on the view obtained during the last Look action. However, it may happen that some edges incident to a node v currently occupied by the deciding robot look identical in its view, i.e., v lies on a symmetric axis of the configuration. In this case, if the robot decides to take one of these edges, it may take any of them. As in related work (e.g., [START_REF] Flocchini | Computing without communicating: Ring exploration by asynchronous oblivious robots[END_REF][START_REF] Flocchini | Remembering without memory: Tree exploration by asynchronous oblivious robots[END_REF][START_REF] Lamani | Optimal deterministic ring exploration with oblivious asynchronous robots[END_REF]), we assume the worst-case decision in such cases, i.e. the actual edge among the identically looking ones is chosen by the adversary.

Execution. We model the executions of our protocol in G by the list of configurations through which the system goes. So, an execution is a maximal list of configurations γ 0 , . . . , γ i such that ∀j > 0, we have:

1. γ j-1 = γ j .
2. γ j is obtained from γ j-1 after some robots move from their locations in γ j-1 to a neighboring node.

3. For every robot R that moves between γ j-1 and γ j , there exists 0 ≤ j ′ ≤ j, such that R takes its decision to move according to its program and its view in γ j ′ .

An execution γ 0 , . . . , γ i is said to be sequential if and only if ∀j > 0, exactly one robot moves between γ j-1 and γ j .

Exploration. We consider the exploration problem, where k robots, initially placed at different nodes, collectively explore an (i, j)-grid before stopping moving forever. By "collectively" explore we mean that every node is eventually visited by at least one robot. More formally, a protocol P deterministically (resp. probabilistically) solves the exploration problem if and only if every execution e of P starting from a towerless configuration satisfies: (1) e terminates in finite time (resp. in finite expected time), and (2) every node is visited by at least one robot during e.

Observe that the exploration problem is not defined for k > n and is straightforward for k = n. (In this latter case the exploration is already accomplished in the initial towerless configuration.)

Bounds

In this section, we first show that, except for trivial cases where k = n, when robots are oblivious, the model is atomic, and the multiplicity is strong, at least three robots are necessary to solve the (probabilistic or deterministic) exploration of any grid (Theorem 1). Moreover, in a (2, 2)-Grid, four robots are necessary (Theorem 2). Finally, at least five robots are necessary to solve the deterministic exploration of a (3, 3)-Grid (Theorem 4). In the two next sections, we show that all these bounds are also sufficient to solve the deterministic exploration in the asynchronous and non-atomic CORDA model.

Given that robots are oblivious and there are more nodes than robots, any terminal configuration should be distinguishable from any possible initial (towerless) configuration. So, we have:

Remark 1 Any terminal configuration of any (probabilistic or deterministic) exploration protocol for a grid of n nodes using k < n oblivious robots contains at least one tower.

Theorem 1 There exists no (probabilistic or deterministic) exploration protocol in ATOM using k ≤ 2 oblivious robots for any (i, j)-Grid made of at least 3 nodes.

Proof. By Remark 1, there is no protocol allowing one robot to explore any (i, j)-Grid made of at least 2 nodes. Indeed, any configuration is towerless in this case. Assume by contradiction, that there exists a protocol P in ATOM to explore with 2 oblivious robots an (i, j)-Grid made of at least 3 nodes. Consider a sequential execution e of P that terminates. (By definition, if P is deterministic, all its executions terminates; (c) while if P is probabilistic, at least one of its sequential execution must terminate.) Then, e starts from a towerless configuration (by definition) and eventually reaches a terminal configuration containing a tower (by Remark 1). As e is sequential, the two last configurations of e consist of a towerless configuration followed by a configuration containing one tower. These two configurations form a possible sequential execution that terminates while only two nodes are visited, thus a contradiction. 2

Any (2, 2)-Grid is isomorphic to a 4-size ring. It is shown in [START_REF] Devismes | Optimal probabilistic ring exploration by asynchronous oblivious robots[END_REF] that no (probabilistic or deterministic) exploration using less than four oblivious robots is possible for any ring of size at least four in ATOM. So:

Theorem 2 ([6]

) There exists no (probabilistic or deterministic) exploration protocol using k ≤ 3 oblivious robots in ATOM for a (2, 2)-Grid.

Lemma 1 Considering any deterministic exploration protocol P in ATOM using k oblivious robots for a (3, 3)-Grid, there exist sequential executions of P, e = γ 0 , . . . , γ w , in which:

• For every x, y with 0 ≤ x < y, γ x and γ y are distinguishable.

• Only the first configuration γ 0 is towerless.

Proof. Consider any exploration protocol P in ATOM using k oblivious robots for a (3, 3)-Grid. Consider any sequential execution e of P. By definition of the exploration, e is finite and starts from a towerless configuration. Moreover, the terminal configuration of e contains a tower, by Remark 1.

Take the last towerless configuration of e and all remaining configurations that follow in e (all of them contain a tower) and form e ′ . e ′ is a possible sequential execution of P where only the first configuration is towerless.

Let e ′ = α 0 , . . . , α m . Let two configurations α x = d x 1 , . . . , d x n and α y = d y 1 , . . . , d y n of e ′ , that are indistinguishable with 0 ≤ x < y. Then, by definition, there exists an automorphism f on G satisfying the additional condition: Let v 0 , . . . , v r be the nodes of V , for all s ∈ [0..r], we have

d x s = d y ℓ where v ℓ = f (v s ). Then, α 0 , . . . , α x , β y+1 , β m is a possible sequential execution of P such that ∀z ≥ y + 1, we have β z = d z g(1) , . . . , d z g(n) where g is a bijection such that ∀s ∈ [1..n], f (v s ) = v g(s) and α z = d z 1 , . . . , d z n .
Moreover, in α 0 , . . . , α x , β y+1 , β m , the number of configurations indistinguishable from α x decreases by one. Repeating the same construction, we eventually obtain a possible sequential execution e ′′ = ρ 0 , . . . , ρ w of P starting from a towerless configuration only followed by configurations containing at least one tower such that for every x, y with 0 ≤ x < y, ρ x and ρ y are distinguishable.

2

Lemma 2 Considering any deterministic exploration protocol P in ATOM model using k oblivious robots for a (3, 3)-Grid, if there exists an execution of P e = γ 0 . . . γ x . . . where γ x contains a tower of k robots, then there exists an execution e ′ starting with the prefix e = γ 0 . . . γ x such that at most one new node can be visited after γ x .

Proof.

Assume the existence of an execution of P e = γ 0 . . . γ x . . . where γ x contains a tower of k robots. Then, γ x is not γ 0 and is indistinguishable from configuration (a), (b), or (c) of Figure 1. In Figure 1, symbols inside the circles represent the multiplicity of the node and numbers next the circle are node's labels to help explanations only. Without loss of generality, assume that γ x is either configuration (a), (b), or (c).

To visit a new node, one of the robots should eventually decide to move. Moreover, in γ x , all robots have the same view. So, the adversary can choose any of them to move.

(1) Consider configuration (a). Then, all possible destinations for the robots are symmetric. So, the adversary can activate the robots in a way we retrieve configuration γ x-1 . Then, it can activate robots in a way that the system return to γ x , and so on. Hence, in this case, there exists a possible execution of P that is infinite, a contradiction. So, from (a), P cannot try to visit a new node.

(2) Consider configuration (b).

If robots synchronously move to node 5, node 5 may be unvisited. So, it is possible to visit a new node, but then we retrieve Case (1). So, we can conclude that in this case from (b) only one new node can be visited.

If robots synchronously move to node 1 (resp. 7), then this node may be unvisited. So, it is possible to visit a new node. But, in node 1, all possible destinations for the robots are symmetric. So, the adversary can activate the robots in a way that we retrieve the previous configuration, if we want to visit another node. So, as for Case (1), we can conclude that no new node can be visited, that is from (b) only one new node can be visited.

(3) Using a reasoning similar to case (1), we can conclude that from (c), P cannot try to visit a new node.

2 Lemma 3 Assume that there exists a deterministic exploration protocol P in ATOM model using 3 oblivious robots for a (3, 3)-Grid. Consider any suffix γ w , . . . , γ z of any sequential execution of P where:

• For every x, y with 0 ≤ x < y, γ x and γ y are distinguishable.

• γ w contains a tower of 2 robots.

Then, at most 4 new nodes can be visited from γ w before a robot of the tower moves.

Proof. Proving this lemma is particularly tedious and error-prone because many cases must be taken into account (positions of robots, symmetry classes, etc.). The proof was thus completed as automatically as possible, by using model-checking techniques. The method is briefly sketched here, a detailed presentation, together with the source code and the necessary tools can be found on the web 1 . First, an operational model of the problem is built: this model is a reactive program that manages an abstract view of the grid and robots, according to a flow of (random) move commands. This model is restricted to the configurations relevant for the property: an immobile two-robots tower and a mobile single robot. The reactive program (i.e., the model) computes the consequences of the moves induced by the input commands; in particular, it takes trace of the visited nodes, and the encountered indistinguishable configuration classes. As soon as such a class has been reached twice, a flag stuck is raised. And, all along the execution, a validity flag is computed that way: stuck ⇒ number of new visited nodes is ≤ 4. A model-checker tool is then used to check the following invariant: whatever be a sequence of input move commands, valid remains true. In other terms, the invariance of valid is sufficient to establish that, starting from any configuration with a tower and a single moving robot, at most 4 new nodes can be visited before the configuration becomes indistinguishable from some already encountered configuration. Concretely, the model is written in the Lustre language [START_REF] Halbwachs | The synchronous dataflow programming language lustre[END_REF][START_REF] Raymond | Synchronous program verification with lustre/lesar[END_REF], and is itself partially generated by a "meta" program written in oCaml (which computes, in particular, the classes). The source is made of approximately 150 lines of oCaml, and 100 lines of Lustre. The invariance checking is performed by the model-checker from the lustre distribution. 2

Theorem 3 There exists no deterministic exploration protocol in ATOM using k ≤ 3 oblivious robots for a (3, 3)-Grid.

Proof. According to Theorem 1, we only need to consider the case of 3 robots.

Assume that there exists an exploration protocol P in ATOM for a (3, 3)-Grid using 3 robots. By Lemma 1, there exists a sequential execution e = γ 0 , . . . , γ w that starts from a towerless configuration, only followed by configurations containing at least one towers, and such that for every x, y with 0 ≤ x < y, γ x and γ y are distinguishable.

In γ 0 , 3 nodes are visited. The execution being sequential, no new node is visited in the first step where a tower of two robots is created. So, in γ 1 , 3 nodes are visited and there exists a tower of two robots R 1 and R 2 .

• Assume that R 1 and R 2 never moved after γ 1 . Then, by Lemma 3, at most 4 new nodes are visited until the termination of e. So, at the termination of e, at most 7 distinct nodes have been visited, a contradiction.

• Assume that R 1 or R 2 eventually moved. Let γ ℓ the first configuration from which R 1 or R 2 moves. From the previous case, at most 7 distinct nodes have been visited before γ ℓ . The execution being sequential, only one robot of the tower moves during the step from γ ℓ to γ i+1 and as in e only the first configuration is towerless, that robot moves to an occupied node. Now, the view of R 1 and R 2 are identical in γ ℓ . So, there exists an execution e ′ starting from the prefix γ 0 , . . . , γ ℓ where both R 1 and R 2 move from γ ℓ to the same occupied node. As no new node is visited during the step, still at most 7 nodes are visited once the system is in the new configuration and this configuration contains a tower of 3 robots. By Lemma 2, at most one new node is visited from this latter configuration. So, at the termination of e ′ , at most 8 distinct nodes have been visited, a contradiction.

2

Theorem 4 There exists no deterministic exploration protocol in ATOM using k ≤ 4 oblivious robots for a (3, 3)-Grid.

Proof. According to Theorem 3, we only need to consider the case of 4 robots. Assume, by the way of contradiction, that there exists an exploration protocol P for a (3, 3)-Grid with 4 robots in ATOM.

Figure 2 depicts three possible configurations for a (3, 3)-Grid with 4 robots. In Figure 2, symbols inside the circles represent the multiplicity of the node and numbers next the circle are node's labels to help explanations only. Note that both Configuration (a) and (b) can be initial configuration.

From now on, consider any synchronous execution of P (synchronous executions are possible in the asynchronous model) starting from configuration (a). By "synchronous" we mean that robots execute each operation of each cycle at the same time. Numbers near the circles are node's labels that are used to ease the explanations only.

Configuration (a) is not a terminal configuration by Remark 1. So at least one robot move in the next Move operation. Moreover, the views of all robots are identical in (a). So, every robot moves in the next Move operation. Two cases are possible:

• Every robot moves to Node 5 and the system reaches Configuration (c). In this case, none of the corners has been visited, so Configuration (c) is not terminal and at least one robot moves in during the next Move operation. Moreover, the views of all robots are identical, so every robot moves in the next Move operation. Each robot cannot differentiate its four possible possible destinations. So, the adversary can choose destinations so that the system reaches configuration (a) again.

• Every robot moves to a corner node and as its view is symmetric, the destination corner is chosen be the adversary. In this case, the adversary can choose destinations so that the system reaches configuration (b). Configuration (b) being not terminal, at least one robot moves in during the next Move operation. Moreover, the views of all robots are identical, so every robot moves in the next Move operation. Each robot cannot differentiate its two possible possible destinations. So, the adversary can choose to destinations so that the system reaches configuration (a) again.

From the two previous case, we can deduce that there exist executions of P that never terminates, so P is not an exploration protocol, a contradiction. 2 4 Deterministic solution using three robots

In this section, we focus on solutions for the exploration problem that use three robots only, in CORDA, and assuming weak multiplicity detection. Recall that there exists no deterministic solution for the exploration using three robots in a (2, 2)or (3, 3)-grid assuming that model (Section 3). Moreover, exploring a (3, 1)grid using three robots is straightforward. So, we consider all remaining cases. We split our study in two cases. A general deterministic solution for any (i, j)-grid such that j > 3 is given in Subsection 4.1. The particular case of the (2, 3)-grid is solved in Subsection 4.2.

General Solution

Overview. Our deterministic algorithm works according to the following three main phases:

Set-Up phase: The aim of this phase is to create a single line of robots starting at a corner and along one of the longest borderlines of the grid -refer to Figure 3. Let us refer to this configuration as the Figure 3: Set-Up configuration. The phase can be initiated from any arbitrary towerless configuration that is not a Set-Up configuration. Note that no tower is created during this phase.

Set-Up Configuration (0,3) (0,4) (0,5) (0,6) (1,6) (1,5) (1,4) (1,3) (1,2) (1,1) (1,0) (2,0) (2,1) (2,2) (2,3) (2,4) (2,5) (2,2) (3,6) (3,5) (3,4) (3,3) (3,2) (3,1) (3,0) (4,6) (4,5) (4,4) (4,3) (4,2) (4,1) (4,0) (0,0) (0,1) (0,2)
Orientation phase: This phase follows the Set-Up phase. Starting from a Set-Up configuration, this phase aims at giving an orientation to the grid. To achieve that, one tower is created allowing the robots to establish a common coordinate system -refer to Figure 4. The resulting configuration is called an Oriented configuration.

Exploration phase: This phase starts from an Oriented configuration in which exactly one node is occupied by one single robot, called Explorer. Based on the coordinate system defined during the Orientation phase, the explorer visits all the nodes, except three already visited ones -refer to Figure 6, page 17.

We now describe the three above phases in more details.

Set-Up Phase. Starting from any towerless configuration, the Set-Up phase ends in a Set-Up configuration, where there is a single line of robots starting at a corner and along a longest borderline of the grid.

In this phase, we distinguish three main configurations:

Leader: In such a configuration, there is exactly one robot located at a corner of the grid.

Choice: In such a configuration, at least two robots are located at a corner of the grid. We choose one of them to remain at a corner. The other ones have to leave their corner.

Undefined: In such a configuration, there is no robot at any corner of the grid. The idea is then to elect one robot that will move to join a corner of the grid.

In the following, we present the behavior of the three robots, respectively referred to as R1, R2, and R3,2 in each of the main configurations. These configurations are declined into several subconfigurations.

1. The configuration is of type Leader: In such a configuration, there is exactly one robot that is at a corner of the grid. Let R1 be this robot. We consider the following subcases:

A) The configuration is of type Strict-Leader: In such a configuration, there is no other robot on any borderline having the corner where R1 is located as extremity. In this case, the robots that are the closest to R1 are the ones allowed to move. Their destination is their adjacent free node on a shortest path towards the closest free node that is on a longest borderline having the corner where R1 is located as extremity. (If there is several shortest paths, the adversary makes the choice.)

B) The configuration is of type Half-Leader: In such a configuration, among R2 and R3, only one robot, say R2, is on a borderline having the corner where R1 is located as extremity. Two subcases are possible:

• The configuration is of type Half-Leader1: R2 is on a longest borderline. In this case, the third robot R3 is the one allowed to move. Its destination is an adjacent free node towards a closest free node on the borderline that contains both R1 and R2. (If there is several shortest paths, the adversary makes the choice.)

• The configuration is of type Half-Leader2: R2 is not on the longest borderline. In this case, R2 is the one allowed to move, its destination is the adjacent free node outside the borderline, if any. In the case where there is no such a free node, R2 moves to a free node on its own borderline (In case of symmetry, the adversary makes the choice.)

C) The configuration is of type All-Leader: All the robots are on a borderline having the corner where R1 is located as extremity. In this case, R2 and R3 are not necessary on the same borderline. Thus, we have two subcases:

• The configuration is of type Fully-Leader: In such a configuration, all the robots are on the same borderline, D1. The two following subcases are then possible:

(i)
The configuration is of type Fully-Leader1: In this case, D1 is a longest borderline.

If the robots form a line, then the Set-Up configuration is reached and the phase is done.

Otherwise, let R2 be the closest robot from R1. If R1 and R2 are not neighbors, then R2 is the only allowed to move and its destination is the adjacent free node towards R1. In the other case, R3 is the only robot allowed to move and its destination is the adjacent free node towards R2.

(ii) The configuration is of type Fully-Leader2: In this case, D1 is not the longest borderline. Then, the robot among R2 and R3 that is the closest to R1 leaves the borderline by moving to its neighboring free node outside the borderline.

• The configuration is of type Semi-Leader: R2 and R3 are not on the same borderline. Two subcases are possible: (i) The configuration is of type Semi-Leader1: In this case, i = j. The unique robot among R2 and R3 which is located on the smallest borderline moves to the adjacent free node outside its borderline.

(ii) The configuration is of type Semi-Leader2: In this case, i = j. Let denote by Dist(R, R ′ ) the distance (that is, the length of a shortest path) in the grid between the two nodes where R and R ′ are respectively located. If Dist(R1, R2) = Dist(R1, R3) then the robot among R2 and R3 that is the closest to R1 is the only one allowed to move, its destination is the adjacent free node outside the borderline. Otherwise (Dist(R1, R2) = Dist(R1, R3)), either (a) there is a free node between R1 and R2, or (b) R1 is both neighbor of R2 and R3. In case (a), R1 is the only robot allowed to move and its destination is the adjacent free node towards one of its two borderlines (the adversary makes the choice). In case (b), R2 and R3 move and their destination is their adjacent free node on their borderline.

2. The configuration is of type Choice: At least two robots are located at a corner. We consider two cases:

A) The configuration is of type Choice1: In this configuration, there are exactly two robots that are located at a corner of the grid. Let R1 and R2 be these robots.

• In the case where R3 is on the same borderline as either R1 or R2 but not both -suppose R1 -then R2 is the one allowed to move, its destination is the adjacent free node towards the closest free node of the borderline that contains both R1 and R3.

• In the case where the three robots are on the same borderline. Then:

(i) If Dist(R1, R3) = Dist(R2, R3
), then the robot among R1 and R2 that is farthest to R3 moves to the adjacent free node on the borderline towards R3.

(ii) Otherwise (Dist(R1, R3) = Dist(R2, R3)), and R3 has either or not an adjacent free node on the borderline. In the former case, R3 moves to an adjacent free node on the borderline towards either R1 or R2 (the adversary makes the choice). In the latter case, R3 moves to its adjacent free node outside the borderline. • If R3 is not on any borderline, it moves to an adjacent free node on a shortest path towards the closest free node that is on a longest borderline that contains either R1 or R2. (In case of symmetry, the adversary makes the choice.)

B) The configuration is of type Choice2: In this configuration, all the robots are located at a corner. The robot allowed to move is the one that is located at a node that is common to the two borderlines of the other robots. Let R1 be this robot. The destination of R1 is the adjacent free node on a longest borderline. (In case of symmetry, the adversary makes the choice.)

3. The configuration is of type Undefined: In this configuration, there is no robot that is located at any corner. The cases below are then possible:

A) The configuration is of type Undefined1: In this case, i = j and there is one borderline that contains two robots R1 and R2 such that R1 is closer from a corner than R2 and R3. Let D1 be this borderline. R3 is the only one allowed to move and its destination is an adjacent free node on a shortest path towards a closest free node of D1. (If there are several shortest paths, the adversary makes the choice.)

B) The configuration is of type Undefined2: It is any configuration different from Undefined1, where there is exactly one robot that is the closest to a corner. In this case, this robot is the only one allowed to move, its destination is an adjacent free node on a shortest path to a closest corner. (If there are several possibilities, the adversary makes the choice.)

C) The configuration is of type Undefined3: There are exactly two robots that are closest to a corner. Let R1 and R2 be these two robots.

• If Dist(R1, R3) = Dist(R2, R3) then R3 is the only one allowed to move, and either Dist(R1, R3) = 1 or Dist(R1, R3) > 1. In the former case, R3 moves to an adjacent free node. (If there are two possibilities, the adversary make the choice.) In the latter case, R3 moves to an adjacent free node that is on a shortest path towards either R1 or R2 but not both. • If Dist(R1, R3) = Dist(R2, R3) then the robot among R1 and R2 that is closest to R3 is the only one allowed to move. Its destination is the adjacent free node that is on a shortest path to a closest corner. (If there are several possibilities, the adversary makes the choice.)

D) The configuration is of type Undefined4: There are three robots that are closest to a corner. Again, four cases are possible:

• The configuration is of type Undefined4-1: There is exactly one robot that is on a borderline. In this case, this robot is the only one allowed to move. Its destination is an adjacent free node that is on a shortest path to a closest corner. (In case of two shortest paths, the adversary breaks the symmetry in the first step.) • The configuration is of type Undefined4-2: In such a configuration, there are exactly two robots on a borderline. Let R1 and R2 be these two robots. The robot allowed to move is R3.

Its destination is the adjacent free node towards a closest corner. (The adversary may have to break the symmetry.) (i) If there are more than one robot on the same borderline. In this case, there are exactly two robots on the same borderline, and let R1 and R2 be these robots. Then R3 is the only one allowed to move and its destination is an adjacent free node towards a closest corner. (The adversary may have to break the symmetry.) (ii) If there is at most one robot on each borderline: Exactly one borderline is perpendicular to the two others. The robot on that borderline is the only one allowed to move and its destination is the adjacent node towards a closest corner. (The adversary may have to break the symmetry.)

• The configuration is of type Undefined4-4: In this case, there is no robot on any borderline.

(i) In the case where there are two robots, R1 and R2, that are closest to the same corner, and this corner is not a closest corner to R3, then R3 is the only robot allowed to move and its destination is an adjacent free node on a shortest path towards a closest corner. (If there are several possibilities, the adversary makes the choice.) (ii) In the case where there are two robots, R1 and R2, that are closest to corners C1 and C2, respectively, where C1 = C2, and R3 is closest to both C1 and C2, then R3 is the only one allowed to move (refer to Figure 5), and it moves toward C1 or C2 according to a choice of the adversary.

(iii) In the case where all the robots are closest to different corners, there is one robot R1 whom corner is between the two other targeted corners of R2 and R3. The robot allowed to move is R1, its destination is an adjacent free node on a shortest path towards its closest corner. (If there are several shortest paths, the adversary makes the choice.)

The correctness of the Set-Up phase is established by Lemmas 4 and 8.

Lemma 4 Starting from any arbitrary towerless configuration, Set-Up phase does not create any tower.

Proof. It is clear that in the case where one robot is allowed to move, no tower is created because the robot always moves to an free adjacent node. Thus lets consider the cases in which there are at least two robots that are allowed to move:

• The configuration is of type Strict-Leader: Suppose that the robot that is at the corner is R1, and the two other ones (that are neither at a corner nor at the same borderline as R1) are R2 and R3, respectively. R2 and R3 are allowed to move at the same time only in the case they are at the same distance from R1. Since their destination is their adjacent free node on the shortest path towards the longest borderline that contains R1, we are sure that the both will move to different free nodes. Thus no tower is created in this case.

• The configuration is of type Semi-Leader2: we consider the case in which Dist(R1, R2) = Dist(R1, R3) such as there is no free node between R1 and both R2 and R3 respectively. It is clear that if the adversary activates them at the same time no tower is created since they move to their adjacent free node on the borderline they belong to, in the opposite direction of R1 (recall that they are in two different borderlines). In the case the adversary activates only one robot (R2), no tower is created as well since it moves to its adjacent free node on the borderline it belongs to (note that is this case i = j). Note that the configuration reached remains of type Semi-leader2, however, Dist(R1, R2) = Dist(R1, R3). Thus the robot that is allowed to move now is R3, which is the one that was supposed to move at the first place. Thus either we retrieve the configuration in which both robots moved (this will happen in the case R3 has an outdated view). Or the configuration reached is of type Half leader1 and all the robots have a correct view.

From the cases above we can deduce that starting from any configuration that is towerless, Set-Up phase does not create any tower and the lemma holds.

2

Lemma 8 is established using the following three technical lemmas.

Lemma 5 Starting from a configuration of type Leader, a configuration of type Set-Up is reached in a finite time.

Proof.

In a configuration of type Leader, there is only one robot that is at the corner (suppose that this robot is R1). It is easy to see that in the case i = j all the robots will be on the longest borderline that contains R1 (refer to Strict Leader, HalfLeader1 configurations). Once the robots on the same longest borderline, it is also easy to create a line of robots keeping one robot at the corner. (The robot (R2) that is the closest to R1 moves first until it becomes neighbor of R1. Once it is done, the remaining robot (R3) moves to become neighbor of R2.) Hence we are sure that a configuration of type Set-Up is reached in a finite time. In the case i = j when the robots move to the closest borderline that contains R1 either we have the same result as when i = j (all the robots will be on the same borderline) and hence we are sure to reach a configuration of type Set-Up. Or, each robot R2 and R3 is on the same borderline as R1, however both of them are on different borderlines. The sub-cases are then possible as follow:

1. Dist(R1, R2) = Dist(R1, R3). In this case, the robot that is the closest to R1 moves to its adjacent node outside its own borderline (Let this robot be R2). Note that when it moves, its new destination is the closest free node on the same borderline as both R1 and R3 (see Semi-Leader2 configuration). Thus we are sure that R2 will be on the same borderline of R1 and R3 in a finite time, thus we are sure that the Set-Up configuration is reached in a finite time.

2. Dist(R1, R2) = Dist(R1, R3). The two sub-case below are possible:

(a) There is an free node between R1 and the other robots. R1 is the one that will move, its destination is its adjacent free node on one of its two adjacent borderlines (Suppose that it moves towards R2). Note that once it has moved, all the robots are in a borderline such as there is one borderline that contains two robots (R1 and R2), let D1 be this borderline (the configuration is of type Undefined1). The robot allowed to move is R3 (Note that R3 is not part of D1), its destination is its adjacent free node on a shortest path towards the closest free node of D1. Once it moves, it becomes at the same distance as R1 from a corner. The configuration becomes of type Undefined3 such that Dist(R1, R2) = Dist(R1, R3). R1 is the only one allowed to move, its destination is its adjacent empty node towards the corner. Once it moves, it joins one corner of the grid. The configuration becomes of type Semi-Leader2 such that Dist(R1, R2) = Dist(R1, R3). R3 is the only robot allowed to move, its destination is its adjacent free node outside the borderline it belongs to. Once it moves, its new destination will be the borderline that contains two robots. Thus, we are sure that all the robots will be part of the same borderline in a finite time. It is clear that from this configuration is easy to build a configuration of type Set-Up. (Note that it is easy to break the symmetry,if any, since we have three robots.) (b) There is no free node between R1 and the other robots R2 and R3. In this case, R2 and R3 will be the ones allowed to move. Their destination is their adjacent free node on their borderline.

In the case the adversary activates them at the same time, we retrieve case 2a. If the adversary activates only one of the two robots, the configuration reached will be of type Semi-Leader2 such as Dist(R1, R2) = Dist(R1, R3), thus, The robot that is the closest to R1 is the one that is allowed to move. (Note that this robot is the one that was supposed to move at the first place.)

If it has an outdated view it will move to its adjacent free node and we retrieve case 2a. If not, it will move to its adjacent free node outside its borderline. When it does, its new destination is the closest free node on the same borderline of the two other robots. Note that when such a robot joins the new borderline, the configuration is of type Set-Up.

From the cases above, we can deduce that starting from a configuration of type Leader, a configuration of type Set-Up is reached in a finite time and the lemma holds. 2

Lemma 6 Starting from a configuration of type Choice, a configuration of type Leader in reached in a finite time.

Proof. It is clear that in the case where all the robots are on one corner of the grid, the next configuration reached is of type Choice1 since there will be a single robot that will move (refer to Configuration of type Choice2). Note that when the configuration is of type Choice1 the cases below are possible (Let the robots that are at the corner be R1 and R2 respectively and the third robot be R3):

1. R3 is on the same borderline D1 as R1 (Note that in this case R2 is not on D1). In this case, R2 is the one allowed to move. Note that once it moves, it leaves the corner and the configuration will be of type Leader (refer to Choice1, case (i)).

2. All the robots are on the same borderline D1. In this case, the robots R3 will be used to elect one of the two robots at the corner (refer to Choice1 configuration case (ii)). If Dist(R1, R3) = Dist(R2, R3) then the robot that is the farthest from R3 leaves the corner, thus, the configuration will contain a single robot that is at one corner. Hence the configuration will be of type Leader in a finite time. In the case Dist(R1, R3) = Dist(R2, R3), (a) if there is at least one empty node between R1 and R3 then R3 will be the one allowed to move on the borderline towards either R1 or R2 breaking the symmetry. Thus, we retrieve the case in which Dist(R1, R3) = Dist(R2, R3). (b) In the case where there is no empty nodes between R1 and R3, then R3 is the one allowed to move. Its destination is its adjacent node outside the borderline. Once it moves, it remains the only one allowed to move in the configuration reached. Its destination is its adjacent node on a shortest path towards the closest free node that is on a longest borderline that contains either R1 or R2 (the adversary makes the choice). Once it moves we retrieve the case in which Dist(R1, R3) = Dist(R2, R3). Thus we are sure that a configuration of type Leader is reached in a finite time.

3. R3 is not on a borderline. In this case, R3 is the one allowed to move. Its destination is its adjacent free node on a shortest path towards the closest longest borderline that contains either R1 or R2.

Thus we are sure that one of the two cases described above will be reached (refer to Choice1 configuration, case (iii)).

From the cases above we can deduce that a configuration of type Leader is reached in a finite time and the lemma holds. 2

Lemma 7 Starting from a configuration of type Undefined, a configuration of type Leader is reached in a finite time.

Proof. It is clear that in the case where the configuration is of type Undefined2, we are sure to reach a configuration of type Leader in a finite time, since there is only one robot that is the closest to one corner (this robot will move until it reaches the closest corner). It is also clear that in the case where the configuration is of type Undefined1, either a configuration of type Undefined2 is reached and hence a configuration of type Leader is eventually reached or a configuration where there are two robots that are both the closest to a corner is reached, this case is part of the cases below:

1. There are exactly two robots that are the closest to one corner (let these two robots be R1 and R2 respectively). In this case, R3 will be used to break the symmetry: In the case Dist(R1, R3) = Dist(R2, R3), R3 will be the one allowed to move, it destination is its adjacent node towards either (a) R1 or R2 if Dist(R1, R3) > 1. Or (b) its adjacent free node from which its distance to R1 will be different from its distance to R2. In both cases (a and b), we reach a configuration where Dist(R1, R3) = Dist(R2, R3). In the case Dist(R1, R3) = Dist(R2, R3), the robot that is the closest to R3 will be the one allowed to move, its destination is its adjacent free node on a shortest path towards the corner. Note that once it has moved, either it reaches the corner or it becomes the closest one. Thus we are sure that a configuration of type Leader is reached in a finite time.

2. All the robots are the closest to a corner. If the configuration is of type Undefined4-1, then there will be one robot that will be allowed to move (the one that is on a borderline), once it has moved, it becomes the closest to one corner of the grid, thus we are sure to reach a configuration of type Leader in a finite time. In the case there are two robots at a borderline, The third robot (which is not on a borderline) is the one that will move becoming the closest robot to one corner of the grid. Thus in this case too, we are sure to reach a configuration of type Leader. In the case all the robots are on a borderline then, i) if there is more than one robot on the same borderline (note that in this case the borderline contains two robots), the robot that is not part of the borderline moves towards the closest corner becoming the closest one, thus we are sure that a configuration of type Leader is reached in a finite time. In the case there is one robot at each borderline, then one robot is easily elected to move becoming the closest to one corner of the grid. Thus, in this case too we are sure to reach a configuration of type Leader in a finite time. In the case there is no robot on the borderline. If there are two robots that are the closest to the same corner such as the third robot is the only closest robot to another corner then this robot is the one allowed to move, when it does it becomes the only one that is the closest to one corner of the grid. Thus we are sure to reach a configuration of type Leader. In the case there is one robot (R3) that is the closest to both corners C1 and C2 such as R1 and R2 are also the closest to C1 C2 respectively, then R3 is the one allowed to move towards one of the closest corner. Note that once it has moved, it becomes the closest one and hence we are sure that a configuration of type Leader is reached in a finite time. In the case all the robots are the closest to different corner, we are sure that one of them is the closest one to one corner that is between the two other target corners (the closest to the other robots). This robot is the one allowed to move, its destination is its adjacent free node towards the closest corner. Note that one it moves it becomes either even closer (and hence it will be the only one that can move) or it will reach the corner. In both cases we are sure that a configuration of type Leader is reached.

From the cases above we can deduce that starting from a configuration of type Undefined, a configuration of type Leader is reached in a finite time and the lemma holds.

Exploring a (2,3)-Grid

The idea of the solution for the (2, 3)-Grid is rather simple. Consider the two longest borderlines of the grid. Since there are initially three isolated robots on the grid, there exists one of the two longest borderlines, say D, that contains either all the robots or exactly two robots. In the second case, the robot that is not part of D moves to the adjacent free node on the shortest path towards the free node of D. Thus, the three robots are eventually located on D. Next, the robot not located on any corner moves to one of its two neighboring occupied nodes (the destination is chosen by the adversary). Thus, a tower is created. Once the tower is created, the grid is oriented. Then, the single robot moves to the adjacent free node in the longest borderline that does not contain any tower. Next, it explores the nodes of this line by moving in towards the tower. When it becomes neighbor of the tower, all the nodes of the (2, 3)-Grid have been explored.

The following theorem is straightforward.

Theorem 6

The deterministic exploration of a (2, 3)-Grid can be solved in CORDA using 3 oblivious robots.

5 Deterministic solution for a (3,3)-grid using five robots In this section, we propose an algorithm that explores using five robots the (3, 3)-Grid, in CORDA and assuming weak multiplicity detection. The algorithm works in two phases, the Exploration phase and the Preparation phase. Figures 7 and8 depict the Exploration phase.

The Exploration phase starts from any of the three special configurations shown in Figure 7-Case (1), Figure 8-Case(1a), and Figure 8-Case(1b), respectively. In the former case, the unique robot that is (1) on a borderline, (2) not at a corner, and (3) not on the borderline linking the two occupied corners, moves toward the center. In Case (1a) of Figure 8, the unique robot located at a corner moves toward one of its neighbors (chosen by the adversary). Similarly, in Case (1b) in Figure 8, the robot located at the center moves toward one of its neighbors. In the three cases, one tower is created and the system reaches Case 2 of either Figure 7 or Figure 8, depending on the initial configuration. Next, the exploration is made following the moves depicted in either Figure 7 or Figure 8, respectively. The Preparation phase starts from any towerless configuration that is not one of the three initial configurations of the exploration phase. The Preparation phase aims at reaching one of these three configurations. The detailed algorithm of this phase is left as an exercise for the reader -a solution is given in the appendix.

Theorem 7

The deterministic exploration of a (3, 3)-Grid can be solved in CORDA using 5 oblivious robots.

Conclusion

We presented necessary and sufficient conditions to explore a grid-shaped network with a team of k asynchronous oblivious robots. Our results show that, perhaps surprisingly, exploring a grid is easier than exploring a ring. In the ring, deterministic (respectively, probabilistic) solutions essentially require five (resp., four) robots. In the grid, three robots are necessary (even in the probabilistic case) and sufficient (even in the deterministic case) in the general case, while particular instances of the grid do require four or five robots. Note that the general algorithm given in that paper requires exactly three robots. It is worth investigating whether exploration of a grid of n nodes can be achieved using any number k (3 > k ≥ n -1) of robots, in particular when k is even.

A Preparation phase of the algorithm working with 5 robots in the (3, 3)-Grid

The aim of the Preparation phase is to reach one of the special configurations, where the Exploration phase can start. It starts from an arbitrary towerless configuration that is not one of the three initial configurations shown in either Figure 7 or Figure 8. Let us define some terms that will be used later: let the interdistance d be the minimal distance among distances between each pair of robots. We call a d.block a sequence of consecutive robots that are at distance d. The size of an 1.block is the number of robots it contains. We refer to a configuration by a set of three values (X1, X2, X3) such as Xi represents the number of robots on the line i. Note that X1 and X3 are borderlines. Since the grid is of size (3, 3), we do not know which borderlines correspond to X1 and X3. Some ambiguities can appear and thus for the same configuration there will be many possible sequences (X1, X2, X3). The robots could be confused not knowing which action to take. To avoid this situation, we will use the following method: First we will choose one or two guide lines in the following manner: the line that contains the d.biggest d.block of robots is elected as a guide line. Note that the guide line can only contain two or three robots. In the case there are two possible guide lines that are perpendicular to each other, then i) in the case only one of this two guide lines is at the borderline of the grid, then this line is the guide line. ii) In the other case, the guide line is elected as follow: Let D1 be one possible guide line and D2, D3 be the lines that are horizontal to D1. In the same manner let D ′ 1 be the other possible guide line and D ′ 2, D ′ 3 be the lines that are horizontal to D ′ 1. Let B be the number of the biggest d.blocks on the lines Di and B ′ be the number of the biggest d.blocks on the lines D ′ i. The guide line is the one corresponding to the biggest value among B and B ′ . For Instance in Figure 13, the configuration can be (2, 1, 2) or (2, 2, 1). We can see that d = 1, and the size of the biggest 1.block is equal to 2. Note that there is an 1.block of size 2 on two borderlines that are perpendicular to each other (on D3 and D ′ 1 -refer to Figure 13). Let B be the number of 1.blocks on the lines that are horizontal to D3, clearly B = 2. In the same manner, let B ′ be the number of 1.blocks of size 2 on the lines that are horizontal to D ′ 1 (clearly B ′ = 1). We can see that B > B ′ , thus the guide lines are both D3 and D1 (The lines that are considered are the ones that are horizontal to D3 and D1). Thus the configuration is of type (2, 1, 2).

The triple set (X1, X2, X3) refer then to the number of robots that are horizontal to the guide lines. The following cases are then possible:

• The configuration is of type [START_REF] Baldoni | On the solvability of anonymous partial grids exploration by mobile robots[END_REF][START_REF] Baldoni | On the solvability of anonymous partial grids exploration by mobile robots[END_REF][START_REF] Franc ¸ois Bonnet | Asynchronous exclusive perpetual grid exploration without sense of direction[END_REF]. Two sub-cases are possible: i) The configuration is similar to the one shown in Figure 9. It is clear that in this case no guide line can be determined. The robots allowed to move are the ones that are at the corner having one free node as a neighbor, their destination is their adjacent free node on the borderline they belong to. ii) The remaining cases: One line can be i elected as the guide line, this line is the one that contains an 1.block of size 3 (X3). The robot that is alone on the borderline (X1) is the one allowed to move, its destination is its adjacent free node on the shortest path towards the middle line (the one that contains X2). Note that in a case of symmetry, the adversary will break the symmetry by choosing one of the two possible neighboring nodes.

• The configuration is of type (1, 2, 2). The robot that is alone on the borderline (X1) is the one allowed to move, its destination is its adjacent free node on the shortest path towards the free node on the line that contains X2.

• The configuration is of type (1, 3, 1). Two sub-cases are possible: i) The configuration is similar to the one shown in Figure 8, Step 1. Note that for this configuration, there is a dedicated algorithm that solves the exploration problem. The algorithm is detailed in Figure 8. Note that since the system is asynchronous, the adversary in some steps of the algorithm can activates one of the two robots that are allowed to move. In this case, the robot that was supposed to move in the first place is the only one that can move, thus by moving the configuration reached when both robots were activated is reached again ii) The remaining cases: we are sure that there is one robot that is part of an 1.block of size 3 (in the middle line) that has two neighboring free nodes (Note that there is only five robots and a single 1.block of size 3), let this robot be R1. R1 is the only one allowed to move, its destination is its adjacent free node towards the closest robot that is in one of the two borderlines that are horizontal to the 1.block of size 3.

• The configuration is of type (2, 1, 2). Note that the configuration does not contain an 1.block of size 3.

Let D1 and D3 be the two borderlines corresponding to X1, X2 respectively. The sub-cases below are possible:

-Both D1 and D2 contains robots at distance 2 (d = 2). In this case, we are sure that there is one robot on the center of the grid (on the middle of the middle line, otherwise the configuration will contains an 1.block of size 3). This robot is the one allowed to move, its destination is one of adjacent free node towards the borderline (refer to Figure 10).

-The robots on D1 are at distance 1 and the robots on D2 are at distance 2. If the robot that is in the middle line (according to the guide line) is also on a borderline (see Figure 11), we are sure that there is one robot at the corner of the grid not having any neighboring robot. This robot is the one allowed to move, its destination is one of its adjacent free node. If the robot is in the center of the grid (see Figure 12), then this robot is the one allowed to move its destination is its adjacent free node towards D2.

-Both D1 and D2 contains robots at distance 1 (d = 1). Let D3 be the middle line that is horizontal to both D1 and D2. The robot allowed to move is the one that is on D3, its destination is its adjacent node towards D1 or D2 (The scheduler will make the choice in the case of symmetry).

Figure 1 :

 1 Figure 1: Three possible configurations in a (3, 3)-Grid with a tower of k robots.

Figure 2 :

 2 Figure2: Three possible configurations in a (3, 3)-Grid with 4 robots. Numbers inside the circles represent the multiplicity of the node. Numbers near the circles are node's labels that are used to ease the explanations only.

Figure 4 :

 4 Figure 4: Coordinate system built by the Orientation phase

Figure 5 : 4 •

 54 Figure 5: Sample of a configuration of type Undefined4-4

Figure 7 :

 7 Figure 7: Exploration task on grids (3, 3)

Figure 8 :

 8 Figure 8: Special Exploration of grids (3, 3)

Figure 9 :Figure 10 :

 910 Figure 9: Configuration (3, 1, 1) Figure 10: Instance of a configuration (2, 1, 2)

Figure 11 :

 11 Figure 11: Instance of a configuration (2, 1, 2) Figure 12: Instance of a configuration (2, 1, 2)

Figure 13 :

 13 Figure 13: Guide-lines, configuration of type (2, 1, 2)

  Two configurations d 1 , . . . , d n and d ′ 1 , . . . , d ′ n are indistinguishable (distinguishable otherwise) if and only if there exists an automorphism f on G satisfying the additional condition:

http://www-verimag.imag.fr/ ˜raymond/misc/robots/.

Recall that robots are anonymous, so these notations are used to ease the explanations only.

2 Lemma 8 Starting from any towerless configuration, a configuration of type Set-Up is reached in a finite time.

Proof. From Lemma 5, 6 and 7 we can deduce that starting from any arbitrary towerless configuration that does not contain a line of robots on the longest line of the grid, a configuration of type Set-Up is reached in a finite time and the lemma holds.

2

Orientation Phase. In this phase, an orientation of the grid is determined in the following manner: The starting configuration contains a line of robots on one of the longest borderline (of length greater than 3) starting at one of its corner. The robot which is at the corner is the one allowed to move, its destination is its adjacent occupied node. Once it has moved, a tower is created. Then, we can determine a coordination system where each node has unique coordinates, see Figure 4, page 10. The node with coordinates (0, 0) is the unique corner that is the closest to the tower. The X-axis is given by the vector linking the node (0, 0) to the node where the tower is located. The Y-axis is given by the vector linking the node (0, 0) to its neighboring node that does not contain the tower.

The following lemma is straightforward:

Starting from a configuration of type Set-Up, a configuration of type Oriented is reached in one step.

Figure 6: Exploration phase

Exploration Phase. This phase starts from an Oriented configuration. Note that, once this configuration is reached, nodes of coordinates (0, 0), (0, 1), and (0, 2) have been necessarily visited. Then, the goal is to visit all other nodes. To ensure that the exploration phase remains distinct from the previous phases and keep the coordinate system, we only authorize the robot that is single on a node to move. This robot is called the explorer.

To explore all remaining nodes, the explorer should order all coordinates in such a way that (a) (0, 0) and (0, 1) are before its initial position (that is (0, 2)) and all other coordinates are after; and (b) for all non-maximum coordinates (x, y), if (x ′ , y ′ ) is successor of (x, y) in the order, then the nodes of coordinates (x, y) and (x ′ , y ′ ) are neighbors. Such an order can be defined as follows:

Using the order , the explorer moves as follows: While the explorer is not located at the node having the maximum coordinates according to , the explorer moves to the neighbor whose coordinates are successors of the coordinates of its current position, as described in Figure 6.

The following lemma is straightforward:

Lemma 10 The Exploration phase terminates in finite time and once terminated all nodes have been visited.

By Lemmas 4-10, follows:

Theorem 5 The deterministic exploration of any (i, j)-Grid with j > 3 can be solved in CORDA using 3 oblivious robots and the three phases Set-Up, Orientation, and Exploration.

• The configuration is of type [START_REF] Blin | Exclusive perpetual ring exploration without chirality[END_REF][START_REF] Franc ¸ois Bonnet | Asynchronous exclusive perpetual grid exploration without sense of direction[END_REF]0). In this case the robot that in the middle line that contains three robots having an free node as a neighbor on the line that contains two robots is the one allowed to move, its destination is this adjacent free node.

• The configuration is of type (3, 0, 2). In this case the robots that are in X3 (the line that contains two robots) are the one allowed to move, their destination is their adjacent free node on the shortest path towards X2.

• The configuration is of type (3, 2, 0) but is different from the special configuration (refer to Figure 14). The robots allowed to move are the two robots that are on the line corresponding to X2. Their destination is their adjacent free node on the line that contains X2. Its is clear that in the case the adversary activates only one of these two robots the configuration reached will be the Special configuration (see Figure 7, step 1), Thus the exploration task can be performed as shown in 7. In the case the adversary activates both robots at the same time, then a tower is created and the configuration reached is like the one shown in Figure 7, step 2. In this case too the exploration can be performed.

Note that once one of the two special configurations is built, one tower is created and the exploration task can be performed. refer to Figures 7 and8.

Correctness Proof.

Lemma I Starting from a configuration of type (1, 2, 2), a configuration of type (2, 3, 0) is reached in a finite time.

Proof.

In a configuration of type (1, 2, 2) the robot that is allowed to move is the one that is alone on the borderline containing X1, let R1 be this robot, its destination is its adjacent free node towards X2, Since line X2 contains two robots, when R1 joins X2, X2 will contain an 1.block of size 3 and X1 will contain no robot. Thus the configuration reached is of type (2, 3, 0) and the lemma holds.

2

Lemma II Starting from a configuration of type (1, 3, 1), either a configuration of type (2, 2, 1) or of type (2, 1, 2) is reached in a finite time.

Proof. When the configuration is of type (1, 3, 1), we are sure that there is one robot that is part of the 1.block of size 3 on X2 that has two neighboring free nodes. This robot is the one allowed to move its destination is its adjacent free node towards the closest robot on either X1 or X2. Suppose that such a robot is the one that is in the middle of the 1.block of size 3. Once the robot has moved, the configuration becomes of type (2, 1, 2) and the lemma holds. If such a robot is at the extremity of the 1.block of size 3, then by moving, the configuration reached is of type (2, 2, 1) and the lemma holds.

2 Proof. The cases below are possible:

1. Both D1 and D2 contains robots at distance 2 (d = 2). It is clear that in this case there is one robot that is in the center of the grid. This robot is the one allowed to move, its destination is one of its adjacent free node. By moving, the robot join a borderline. Note that this borderline contains an 1.block of size 3. Thus the configuration reached will be (3, 0, 2).

2. The robots on D1 are at distance 1 and the robots on D2 are at distance 2. In this case the robot that is on the borderline on D2, being at the corner of the grid and not having any neighboring robot is the one that moves towards one of its adjacent free node. Note that once the robot has moved, the configuration reached remains of type (2, 1, 2), however, both D1 and D2 contains robots at distance 1.

3. Both D1 and D2 contains robots at distance 1 (d = 1). Let D3 be the middle line that is horizontal to both D1 and D2. In this case the robot that is on D3 is the one allowed to move, its destination is its adjacent free node towards one of the two neighboring borderlines that contain an 1.block of size 2. Note that we are sure that this robot has at least one free node as a neighbor otherwise the configuration contains a single 1.block of size 3 and the configuration will not be of type (2, 1, 2).

Once the robot has moved, a new 1.block of size 3 is created at one borderline and the configuration will be of type (3, 0, 2).

From the cases above, we can deduce that starting from a configuration of type (2, 1, 2), a configuration of type (3, 0, 2) is reached in a finite time and the lemma holds.

2

Lemma IV Starting from a configuration of type (2, 3, 0), a configuration of type (3, 2, 0) is reached in a finite time.

Proof. When the configuration is of type (2, 3, 0), the robot allowed to move is the one that is on the line that contains X2 having an free node as a neighbor on the line that contains two robots. Note that once the robot has moved, a new 1.block of size 3 is created one borderline of the grid. Thus the configuration reached will be of type (3, 2, 0) and the lemma holds.

2

Lemma V Starting from a configuration of type (3, 0, 2), either a configuration of type (3, 2, 0) or of type (3, 1, 1) is reached in a finite time.

Proof. When the configuration is of type (3, 0, 2), the robots that are on the line that X3 are the one allowed to move. When they do, they move to their adjacent free node towards the line that is horizontal to the the one containing an 1.block of size 3. Note that in the case the adversary activates both robots allowed to move at the same time, then the configuration reached is of type (3, 2, 0) and the lemma holds. If it is not the case, the configuration reached is of type (3, 1, 1) and the lemma holds.

2

Lemma VI Starting from a configuration of type (3, 1, 1), either a configuration of type (3, 2, 0) or of type (2, 2, 1) is reached in a finite time.

Proof. In the case the configuration is similar to the one shown in Figure 9. The robots that are at the corner having an free node as a neighbor are the one allowed to move. Their destination is their adjacent free node. Note that in the case the adversary activates both robots at the same time, the configuration reached is iv of type (2, 2, 1) and the lemma holds. In the case the adversary activates only one robot, then the configuration reached remains of type (3, 1, 1) but it is different from the Figure 9. For the other configurations of type (3, 1, 1) (all the configurations that are different from the one shown in Figure 9). The robot that is allowed to move is the one that is single on the borderline that contains X3. Its destination is its adjacent free node on the shortest path towards the line that contains X2. Note that once it has moved, the configuration reached is of type (3, 2, 0) and the lemma holds.

2

Lemma VII Starting from a configuration of type (1, 2, 2), a configuration of type (3, 2, 0) is reached in a finite time.

Proof. From Lemma I, we are sure that starting from a configuration of type (1, 2, 2), a configuration of type (2, 3, 0) is reached in a finite time. From Lemma IV we are sure that starting from a configuration of type (2, 3, 0), a configuration of type (3, 2, 0) is reached in a finite time. Thus we can deduce that starting from a configuration of type (1, 2, 2), a configuration of type (3, 2, 0) is reached in a finite time and the lemma holds.

2

Lemma VIII Starting from a configuration of type (1, 3, 1), a configuration of type (3, 2, 0) is reached in a finite time.

Proof. From Lemma II, we are sure that starting from a configuration of type (1, 3, 1), a configuration of type (2, 2, 1) is reached in a finite time. From Lemma VII we are sure that starting from a configuration of type (1, 2, 2), a configuration of type (3, 2, 0) is reached in a finite time. Thus we can deduce that starting from a configuration of type (1, 3, 1), a configuration of type (3, 2, 0) is reached in a finite time and the lemma holds.

2

Lemma IX Starting from a configuration of type (2, 1, 2), a configuration of type (3, 2, 0) is reached in a finite time.

Proof. From Lemma III, we are sure that starting from a configuration of type (2, 1, 2), a configuration of type (3, 0, 2) is reached in a finite time. From Lemma V, we are sure that starting from a configuration of type (3, 0, 2), a configuration of type (3, 2, 0) is reached in a finite time. Thus we can deduce that starting from a configuration of type (2, 1, 2), a configuration of type (3, 2, 0) is reached in a finite time and the lemma holds.

2

Lemma X Starting from any configuration that is towerless, a configuration of type (3, 2, 0) is reached in a finite time.

Proof. From Lemmas IV-IX, we can deduce that starting from any configuration that is towerless, a configuration of type (3, 2, 0) is reached in a finite time and the lemma holds.

2

Lemma XI Starting from one of the three special configurations, all the nodes of the grid are explored and the algorithm stops.

Proof.

It is easy to see from Figure 7, that all the nodes of the grid are explored. Thus the lemma holds.

2

Lemma XII Starting from any configuration of type (3, 2, 0), the exploration can be performed.

v Proof. If the configuration is the special configuration (refer to Figure 7 (step 1)), then according to Lemma XI, the exploration task is performed and all the nodes of the ring are explored. If the configuration is as the one show in Figure 14, then the two robots that are not part of the 1.block of size 3 are the one allowed to move, their destination is their adjacent node in the center of the grid. In the case where the adversary activates only one of the two robots allowed to move, the special configuration is reached and the lemma holds. If both robots are activated then a tower is created in the center of the grid and the configuration reached will be as the one shown in Figure 7 (Step2) and in this case too the exploration is performed and the lemma holds.

2

From the lemmas above we can deduce that:

Theorem 7 The deterministic exploration of a (3, 3)-Grid can be solved in CORDA using 5 oblivious robots.

vi