Asynchronous Scattering

TL;DR

This paper demonstrates that asynchronous scattering of mobile robots is achievable under certain sensing capabilities, providing a constructive probabilistic approach and identifying key limitations when sensors are absent.

Contribution

It introduces a constructive, probabilistic protocol for asynchronous scattering with vision and multiplicity detection, and establishes impossibility results without these features.

Findings

Asynchronous scattering is solvable with vision and multiplicity detection.

Scattering remains unsolvable without either vision or multiplicity detection in certain cases.

A new proof technique for probabilistic robot protocols is presented.

Abstract

In this paper, we consider the problem of scattering a swarm of mobile oblivious robots in a continuous space. We consider the fully asynchronous setting where robots may base their computation on past observations, or may be observed by other robots while moving. It turns out that asynchronous scattering is solvable in the most general case when both vision (the ability to see others robots positions) and weak local multiplicity detection are available. In the case of a bidimensional Euclidean space, ASYNC scattering is also solvable with blind robots if moves are rigid. Our approach is constructive and modular, as we present a proof technique for probabilistic robot protocols that is of independent interest and can be reused for other purposes. On the negative side, we show that when robots are both blind and have no multiplicity detection, the problem is unsolvable, and when only one of those is available, the problem remains unsolvable on the line.

Tables

Table 1. Table 1: Summary of possibility and impossibility results

Vision	Weak Local	1D rigid	2D rigid	1D flexible	2D flexible
	Multiplicity
Yes	Yes	OK (Th.3)	OK (Th. 2)	OK (Th. 3)	OK (Th. 4)
No	Yes	KO (Th. 8)	OK (Th. 2)	KO (Th. 8)	?
Yes	No	KO (Th. 9)	?	KO (Th. 9)	?
No	No	KO (Th. 10)	KO (Th. 10)	KO (Th. 10)	KO (Th. 10)

Equations

$$\text{mathds}P(\exists i\in \text{mathds}N,E_{\sigma }^C(i)\in F)=\dots$$

$$=\text{mathds}P\left(\bigcup _{i\in \text{mathds}N}\text{from C, following σ, F is reached exactly at the i-th transition}\right)$$

$$=\sum _{i\in \text{mathds}N}\text{mathds}P\left(\text{from C, following σ, F is reached exactly at the i-th transition}\right)\ge p$$

$$\exists N\in \text{mathds}N,\sum _{i=0}^N\text{mathds}P\left(\text{from C, following σ, F is reached exactly at the i-th transition}\right)\ge \frac{p}{2}$$

$$\Rightarrow \exists N\in \text{mathds}N,\text{mathds}P\left(\text{from C, following σ, F is reached before N-th transition}\right)\ge \frac{p}{2}$$

$$\text{mathds}P(\text{from C, following σ, we never reach F})$$

$$=\text{mathds}P(\bigcap _{i\in \text{mathds}N}\forall j\in [[n_i,n_{i+1}[[,E_{\sigma }^C(j)\notin F)$$

$$=\text{mathds}P(\bigcap _{i\in \text{mathds}N}\forall j\in [[n_i,n_{i+1}[[,E_{{\sigma }_i}^{C_{n_i}}(j)\notin F)$$

$$\le \prod _{i\in \text{mathds}N}1-\frac{p}{2}$$

$$=0$$

Full text

It turns out that asynchronous scattering is solvable in the most general case when both vision (the ability to see others robots positions) and weak local multiplicity detection are available. In the case of a bidimensional Euclidean space, ASYNC scattering is also solvable with blind robots if moves are rigid. Our approach is constructive and modular, as we present a proof technique for probabilistic robot protocols that is of independent interest and can be reused for other purposes.

On the negative side, we show that when robots are both blind and have no multiplicity detection, the problem is unsolvable, and when only one of those is available, the problem remains unsolvable on the line.

1 Introduction

We consider mobile oblivious robots that evolve in a bidimensional Euclidean space [8, 4]. Those robots are modeled as dimensionless points and repeatedly execute cycles that consist of Look-Compute-Move phases: they first obtain a snapshot of their environment using visual sensors (Look), then compute their next tentative location (Compute), and finally move toward their computed destination (Move). After a Look-Compute-Move cycle is complete, the local memory of a robot $r$ is erased before $r$ starts a new cycle (the robot is said oblivious). In the semi-synchronous model (SSYNC in the current terminology [8, 4]), a non-empty subset of robots is chosen by the scheduler (considered as an adversary) to simultaneously and atomically execute a Look-Compute-Move cycle. An even more restricted model is the fully synchronous model (FSYNC [8, 4]), where the subset of scheduled robots is the full set of robots. While SSYNC and FSYNC model make it easier to write and prove robot protocols, they do not represent well the asynchronous behavior of actual robotic entities. For that purpose, the asynchronous model (ASYNC [5, 4]) has been introduced: in that model, each phase of the Look-Compute-Move cycle of a robot may occur at any time. In particular, the following events may occur: When a robot executes a Look phase, the other robots are not necessarily still; also, a robot follows a straight path to reach its destination, but not necessarily at a constant speed (though it cannot move back).

The visual sensors of a robot $r$ output information about the $r$’s environment in an ego-centered coordinate system (which we denote in the sequel as frame). It is generally assumed that robots’ coordinate systems do not share a common direction (same ”North-South axis”), a common orientation (same ”North”), a common chirality (same handedness), or even a common unit distance. In this ego-centered coordinate system, the output of the visual sensors consists in (possibly partial) information about the positions of the other robots (the current robot always being at the origin of the coordinate system). A first criterium to classify vision sensors is its range [5]: how far can it see other robots positions? In this paper we consider two kinds of robots: perceptive robots can see every location occupied by at least one robot, while blind robots cannot see any other location than the origin of the coordinate system. A second criterium for vision sensors is its ability to detect multiple robots placed at the exact same location [7]: strong multiplicity detection returns the exact number of robots placed on a given location, weak multiplicity detection returns true if a location hosts at least two robots, and false if it contains exactly one robot, while no multiplicity detection returns no information about a position other than whether it contains at least one robot. Multiplicity detection is local if it can only be used on the observing robot’s location, and is global if it can be used on every occupied location within the range of the vision sensor (and this range is greater than [math]).

During the move phase, the move of the robot is either rigid or flexible [6]. If robot moves are considered rigid, a robot always reaches its computed destination (possibly after some unbounded time in the ASYNC model). If robot moves are flexible, then the scheduler can interrupt a robot $r$ before it reaches its destination. Then $r$ starts a new Look-Compute-Move cycle. In the classical model [8], the scheduler may not stop $r$ before it moves at least some distance $\delta>0$ (unknown to $r$) unless $r$ target destination is closer than $\delta$ (in that case, $r$ reaches its destination). In this paper, we instead consider a more extreme case where robot moves can be infinitesimal: each robot $r$ can be interrupted after it moves some distance $\epsilon>0$, for any such $\epsilon$.

The problem we consider is that of scattering: from any initial situation where robots may occupy the same locations, any execution of a scattering protocol ends up in a situation where all robots occupy distinct positions. Termination (that is, reaching a fixed global state where all robots remain still) is not required, as long as robots remain at distinct locations. A deterministic scattering protocol for oblivious mobile robots is feasible if and only if there does not exists clone robots [8]: two robots are clones if they start at the same position, are given the same coordinate system, and are always activated simultaneously by the scheduler. Two deterministic clone robots never separate. By contrast, a robot with no clone can simply move ”North” by one distance unit when activated by the scheduler to separate from another robot initially located at the same position. As clone robots cannot be avoided in general, most subsequent work studied probabilistic protocols. The first probabilistic scattering for the SSYNC model is due to Dieudonné and Petit [3]: anytime a robot is activated, it tosses a coin, if the coin is [math], the robot stays in place, otherwise it moves arbitrarily within its Voronoï cell. Then, Clément et al. [2] proposed an expected constant time scattering protocol for the SSYNC model: assuming knowledge of $n$, the number of robots, anytime a robot is activated, it chooses a destination randomly among $n^{2}$ ones, still within its Voronoï cell. Recently, Bramas and Tixeuil [1] considered the random bit complexity of mobile robot scattering in the SSYNC model: anytime a robot is activated, it chooses randomly among $f$ destinations ($f$ depends on the observed configuration, so no knowledge of $n$ is assumed) within its Voronoï cell. Bramas and Tixeuil [1] show that their solution is the best possible in SSYNC (both in terms of coin tossing and round complexity) when $n$ is not known. Overall, it turns out that the scattering problem for oblivious mobile robots was only investigated in the SSYNC model. The reason is that for all aforementioned protocols, the core proof argument relies on the fact that once two robots separate, they never occupy the same position ever again, hence the number of robots on a given multiplicity point always decreases. In the ASYNC model, this property is no longer guaranteed using previous approaches. For example, consider the protocol of Dieudonné and Petit [3], and two stacks of $2$ and $3$ robots, respectively. First the stack of two robots is activated: one robot chooses to move to destination $d$ and the other chooses to stay, but the moving robot, called $r_{1}$, is put on hold. Then the stack of $3$ robots is activated, $2$ of those $3$ robots, say $r_{2}$ and $r_{3}$ decide to move, and the other one decides to stay. Now $r_{2}$ is activated again, but its observation of other positions is updated (and so is its Voronoï cell). So, it may turn out that $r_{2}$ chooses $d$ as its destination. Now, both $r_{1}$ and $r_{2}$ move to $d$, creating a new multiplicity point. So, solving the problem in ASYNC requires a fresh approach, at least with respect to the proof techniques.

We investigate the possibility of asynchronous scattering in various settings. In particular, we consider both perceptive and blind robots, both weak local multiplicity detection and no multiplicity detection, and both rigid and flexible moves. It turns out that ASYNC scattering is solvable in the most general case when both vision and weak local multiplicity detection are available. In the case of a bidimensional Euclidean space, ASYNC scattering is also solvable with blind robots if moves are rigid. Our approach is constructive and modular, as we present a proof technique for probabilistic robot protocols that is of independent interest and can be reused for other purposes. On the negative side, we show that when robots are both blind and have no multiplicity detection, the problem is unsolvable, and when only one of those is available, the problem remains unsolvable on the line. Unlike previous approaches [3, 2, 1], we consider the fully realistic ASYNC model, and unlike Clement et al. [2], we do not consider that robots are aware of $n$. Our positive result do not assume that robots share the same chirality, while impossibility results remain valid if robots share a common chirality.

The remaining of the paper is structured as follows. Section 2 details the mathematical framework we work with. Section 3 features a general result, which we believe is of independent interest, that is later used to prove our results about scattering in Section 4 and 5. Section 6 presents preliminary complexity results, while Section 7 takes a computability perspective. Finally, Section 8 provides some concluding remarks.

2 Framework

2.1 Notations

$\mathds{R}$ denotes the set of real numbers, $\mathds{Q}$ the set of rational numbers, and $\mathds{N}$ the set of natural numbers. The set of natural numbers except 0 is denoted by $\mathds{N}^{\star}$. Let f be a function, we can also denote it as $f(\bullet)$. $\|\bullet\|:\mathds{R}^{2}\hookrightarrow\mathds{R}$ denotes the standard euclidean norm over $\mathds{R}^{2}$, and $\langle\bullet,\bullet\rangle$ denotes the standard scalar product over $\mathds{R}^{2}\times\mathds{R}^{2}$. Let $E$ be a set, then $E^{*}$ denotes the set of all finite sequences of elements of $E$, $E^{\mathds{N}}$ denotes the set of all sequences over $E$, and the set of infinite sequences $E^{\infty}=E^{\mathds{N}}\cup E^{*}$. Let $e\in E_{1}\times E_{2}$ let $p$ and $q$ be the two elements such that $e=(p,q)$, then $e(1)=p$ and $e(2)=q$, we generalize this notation to the case where $e$ is composed of more than two elements.

2.2 Execution Model

We consider the oblivious Look-Compute-Move model (a.k.a. the $\mathcal{OBLOTS}$ model) in an asynchronous setting.

The current state of a robot is modelled as a 6-tuple $(l,d,r,s,a,c)\in\mathscr{S}$ such that:

$l\in\mathds{R}^{2}$ is the current location of the robot, 2. 2.

$d\in\mathds{R}^{2}$ is the destination of the robot, 3. 3.

$r\in\{0;1\}$ is $1$ if the robot is activated and [math] otherwise, 4. 4.

$s\in\mathds{R},s>0$ is the scale of the referential of the robot (the size of the unit distance), 5. 5.

$a\in[0;\pi[$ is the angle of the referential of the robot (where is the north), 6. 6.

$c\in\{0;1\}$ is $1$ if the robot is right-handed and [math] otherwise.

We define the set of configurations $\mathscr{C}$ as the set of combinations of the local states of the robots where at most one robot is activated in each configuration: $\mathscr{C}=\{(s_{1},\ldots,s_{n})\in\mathscr{S}^{n}|\exists i\in\llbracket 1;n\rrbracket(s_{i}(3)=1\Rightarrow\forall j\in\llbracket 1;n\rrbracket,j\neq i\Rightarrow s_{j}(3)=0)\}$. We say that the $k$-th robot is activated if and only if $C(k)(3)=1$, otherwise it’s inactivated. Having a single robot activated at any time does not weaken the ASYNC model as it still allows to simulate simultaneous executions, yet it permits to simplify notations in the sequel.

Let $\mathds{APART}$ be the set of configurations such that there is no location occupied by two or more robots, and every robot is immobile (its destination and its location are equal): $\mathds{APART}=\{(s_{1},\ldots,s_{n})\in\mathscr{C}$ — $\forall i,j\in\llbracket 0;1\rrbracket^{2},s_{i}(1)=s_{i}(2)\wedge s_{i}(1)\neq s_{j}(1)\}$.

Let $\mathscr{A}$ be the algorithm all robots execute. We consider two settings for visual sensors:

• •

If vision is assumed $\mathscr{A}$ receives as inputs the set of points where there is at least one robot. Said differently given a point in $\mathds{R}^{2}$ robots know if there is at least one robot there but not how many. If vision is not assumed the robot is said to be blind

• •

If local weak multiplicity is assumed, $\mathscr{A}$ receives as input a bit indicating if there is another robot on the same position as the robot running $\mathscr{A}$.

An execution is an element of $\mathscr{C}^{\infty}=C_{1}\rightarrow C_{2}\rightarrow C_{3}\ldots$ such that every transition $C_{i}\rightarrow C_{i+1}$ is valid. Now, $C\rightarrow D$ is a valid transition for $\mathscr{A}$ if and only if there exists a unique $k\in\mathds{N}$ such that $C(k)\neq D(k)$ (i.e. only one robot did something) and all of the following properties are satisfied:

• •

At least one of the following conditions is true:

• –

choice of frame $C(k)=(p,p,0,r,\theta,b)$ and $D(k)=(p,p,1,r^{\prime},\theta^{\prime},b^{\prime})$: the scheduler assigns a frame to robot $k$,

• –

computation $C(k)=(p,p,1,r,\theta,b)$ and $D(k)=(p,q,0,r,\theta,b)$: the robot $k$ computes its destination $q$ using $\mathscr{A}$,

• –

ready to move $C(k)=(p,q,0,r,\theta,b)$ where $p\neq q$ and $D(k)=(p,q,1,r,\theta,b)$: robot $k$ is about to move,

• –

move $C(k)=(p,q,1,r,\theta)$ where $p\neq q$ and $D(k)=(q^{\prime},q,0,r,\theta)$ where $q^{\prime}\in]p;q]$: robot $k$ moves towards its destination,

• –

move and interrupt $C(k)=(p,q,1,r,\theta)$ where $p\neq q$ and $D(k)=(q^{\prime},q^{\prime},0,r,\theta)$ where $q^{\prime}\in]p;q]$: robot $k$ moves towards its destination, but may be interrupted prematurely by the scheduler.

• •

If more than one condition is true, then computation, move, and move and interrupt transitions have priority over the other two.

Notice that transitions are of two types, the ones that inactivate robot $k$ (computation, move, move and interrupt), and the ones that activate it (choice of frame, ready to move). Due to the higher priority of the former set of transitions, the property that at most one robot is activated in any configuration is preserved throughout the execution. Starting from configuration $C_{i}$, if $\mathscr{A}$ is deterministic, then there is at most one reachable configuration. If $\mathscr{A}$ is a probabilistic algorithm, then there can be more than one reachable configurations. An execution $E$ is fair if all robots perform the computation transition infinitely many times. Given an algorithm $\mathscr{A}$, we denote by $\mathscr{E}_{\mathscr{A}}$ the set of executions conforming to $\mathscr{A}$.

Let us now define schedulers. Intuitively the scheduler chooses when robots are activated, by how much they move when the movement is not rigid, etc. Let $\mathscr{A}$ be an algorithm, let $\sigma:\mathscr{C}^{*}\hookrightarrow\mathscr{C}$ be a function. If $\forall C_{1},\ldots,C_{k},C_{k}\rightarrow\sigma(C_{1},\ldots,C_{k})$ is a valid transition for $\mathscr{A}$, then $\sigma$ is said to be a scheduler for $\mathscr{A}$. This ensures that all executions conform to $\mathscr{A}$.

Given an initial configuration $C$, we define execution $E_{\sigma}^{C}$ as the execution starting from $C$ according to scheduler $\sigma$, and $E_{\sigma}$ is the set of all possible executions. If $\mathscr{A}$ is deterministic, then $E_{\sigma}^{C}(0)=C$, and $\forall i\in\mathds{N}^{\star},\quad E_{\sigma}^{C}(i)=\sigma(E_{\sigma}^{C}(0),\ldots,E_{\sigma}^{C}(i-1))$. If $\mathscr{A}$ is probabilistic, then $E_{\sigma}^{C}(i)$ is a random variable defined the same way as in the deterministic case, and $\sigma$ is a probabilistic function, that is to say it returns its output according to a certain distribution law given by the algorithm $\mathscr{A}$ for the transitions of the kind computation.

In the deterministic setting, $\sigma$ is a fair scheduler if $\sigma$ is a scheduler and $E_{\sigma}$ is fair. In the probabilistic setting, $\sigma$ is fair if $\mathds{P}(E_{\sigma}\text{ is fair})=1$. Given Algorithm $\mathscr{A}$, the set of all possible schedulers conforming to $\mathscr{A}$ is noted $\Sigma_{\mathscr{A}}$. If the algorithm is implied, we simply write $\Sigma$. If a scheduler never chooses a move and interrupt transition, the movements are called rigid.

The fine grained approach we used for transitions permits to simulate an arbitrary number of robots running simultaneously (even when other are moving). Two concurrent robots $A$ and $B$ could first sequentially execute choice of frame and computation, and at a later time execute (again sequentially) ready to move and move. A robot $A$ can be seen while moving by robot $B$ interleaving move by $A$, computation by $B$, and ready to move by $A$. However, our modeling with at most one robot activated in any configuration permits to simplify proof notations.

3 Theorem of Choice

Definition 1** (Safe Zone).**

Let $\mathscr{A}$ be an algorithm, let $F\subset\mathscr{C}$, $F$ is called a safe zone for $\mathscr{A}$ if valid transistions only lead to configurations of $F$. Formally: $\quad\forall(\sigma,C)\in\Sigma_{\mathscr{A}}\times F,\forall i\in\mathds{N},E^{C}_{\sigma}(i)\in F\Rightarrow E^{C}_{\sigma}(i+1)\in F$.

Lemma 1**.**

Let $F\subset\mathscr{C}$ and $\mathscr{A}$ be an algorithm. If there exists a positive probability $p$ such that, starting from any configuration and for any scheduler, every execution reaches a configuration in $F$, then configurations in $F$ are reached with probability $1$. Formally: $\exists p\in]0;1],\forall(C,\sigma)\in\mathscr{C}\times\Sigma_{\mathscr{A}},\mathds{P}(\exists i\in\mathds{N},E^{C}_{\sigma}(i)\in F)\geq p\Rightarrow\forall(C,\sigma)\in\mathscr{C}\times\Sigma_{\mathscr{A}},\mathds{P}(\exists i\in\mathds{N},E^{C}_{\sigma}(i)\in F)=1$.

Proof.

Let $p$ be a positive real number. For all $(C,\sigma)\in\mathscr{C}\times\Sigma$, we have that:

[TABLE]

This implies that for all $(C,\sigma)\in\mathscr{C}\times\Sigma$:

[TABLE]

For each configuration $C$ and scheduler $\sigma$, we can thus define $N(C,\sigma)$ as the smallest integer $N$ such that: \mathds{P}(\text{from C$, following$\sigma$,$F$is reached before the$N-th transition})\geq\frac{p}{2}.

We now prove the lemma. Let $C$ be a configuration and $\sigma$ a scheduler. With execution $E^{C}_{\sigma}$ and $i\in\mathds{N}$, we define $shift(\sigma,E^{C}_{\sigma},i)$ as $\sigma(E^{C}_{\sigma}(0),\ldots,E^{C}_{\sigma}(i),\bullet)$. To simplify notations, $C_{i}$ denotes $E^{C}_{\sigma}(i)$ in the sequel.

Let $E^{C}_{\sigma}$ be a random execution starting from $C$. We define $(n_{i})_{i\in\mathds{N}}$ and $(\sigma_{i})_{i\in\mathds{N}}$ as $n_{0}=0$, $\sigma_{0}=\sigma$, and $\forall i\in\mathds{N}^{\star},n_{i+1}=n_{i}+N(C_{n_{i}},\sigma_{i})$, and $\sigma_{i+1}=shift(\sigma,E^{C}_{\sigma},n_{i+1})$. Now, from $C\in\mathscr{C}$, following $\sigma$, we run $n_{1}$ transitions so that $F$ is reached with probability $\frac{p}{2}$. If we did reach $F$ we stop. Otherwise, from $C_{n_{i}}$, following $\sigma$, we run $n_{2}$ transitions so that $F$ is reached with probability $\frac{p}{2}$. If we did reach $F$, we stop. Otherwise we repeat the process. Overall the probability that $F$ is never reached is:

[TABLE]

∎

The following theorem is a direct corollary of Lemma 1 using the closure property of a safe zone.

Theorem 1** (Choice).**

Let $\mathscr{A}$ be an algorithm, let $F\subset\mathscr{C}$ be a safe zone for $\mathscr{A}$, if $\exists p\in]0;1],\forall(C,\sigma)\in\mathscr{C}\times\Sigma_{\mathscr{A}},\mathds{P}(\exists i\in\mathds{N},E^{C}_{\sigma}(i)\in F)\geq p$, then $\forall(C,\sigma)\in\mathscr{C}\times\Sigma_{\mathscr{A}},\mathds{P}(\exists N\in\mathds{N},\forall i\in\mathds{N},i\geq N\Rightarrow E^{C}_{\sigma}(i)\in F)=1$

So, if $F$ be a safe zone, if there is a positive probability $p$, such that for any scheduler $\sigma$ and any reachable configuration $C$, any execution from $C$ that follows $\sigma$ reaches a configuration in $F$ with probability $p$, then $F$ is reached with probability 1. A reachable configuration is a configuration with a positive probability of occurring in the execution. Note that the converse is also true: If $F$ is reached with probability $1$, then starting from any reachable configuration and following any scheduler, $F$ is reached with probability $1>0$.

While Theorem 1 is very general, we mostly use it for the purpose of scattering robots: our safe zone $F$ is a set of configurations where robots remain separated whatever the subsequent execution, and we want that starting from any initial configuration $C$ (possibly with already moving robots) and following any scheduler $\sigma$, algorithm $\mathscr{A}$ reaches $F$ with probability $1$. Then, using Theorem 1, it becomes sufficient to exhibit a pattern of random bits used by $\mathscr{A}$ so that the robots reach $F$ with probability $p>0$, and prove that $p$ is independent of $C$ and $\sigma$.

4 Blind Rigid ASYNC Scattering in $\mathds{R}^{2}$

In this section, we consider the rigid setting when all robots are blind but are endowed with weak local multiplicity detection.

4.1 Algorithm

The pseudo-code for our algorithm is presented as Algorithm 1. Lines $5$ and $8$ use the rbit() function that returns a $1$ or a [math] with equal probability. The while loop is used to select a random natural number such that value $n$ is obtained with probability $2^{-n}$. The keyword move to takes as input an element of $\mathds{R}^{2}$ and updates the destination of the robot. Finally, $u(n)$ is a computable sequence of points in $\mathds{Q}^{2}$ such that there exists a circle containing all $u(n)$, and $\forall i,j\quad u(i)\neq u(j)$ (such a sequence does exist).

4.2 Proof of correctness

Lemma 2**.**

$\mathds{APART}$* is a safe zone for Algorithm 1.*

Proof.

Starting from a configuration in $\mathds{APART}$, a robot does nothing when there is no other robot at its position (Line 2). ∎

Lemma 3**.**

With $F=\mathds{APART}$, and $\mathscr{A}=$Algorithm 1, the conditions of Lemma 1 are satisfied.

Proof.

Let $\sigma,C\in\Sigma,\mathscr{C}$. Step by step, we construct a sequence of positions that reach $\mathds{APART}$ with probability $p>0$, independently of $\sigma$ and $C$. We denote by $(p_{1},\ldots,p_{n})_{t}$ the positions occupied by the robots at step $t$, and $(q_{1},\ldots,q_{n})_{t}$ the positions the robots want to go to at step $t$. Initially, we define:

• •

$(p_{1},\ldots,p_{n})_{0}=(C(1)(1),\ldots,C(n)(1))$

• •

$(q_{1},\ldots,q_{n})_{0}=(C(1)(2),\ldots,C(n)(2))$

Suppose at step $t$, the current configuration is $D$, when the scheduler selects a computation transition from $D$ to $D^{\prime}$ for a robot $k$ on a multiplicity point, the robot chooses its destination for step $t+1$, and we define:

• •

$(p_{1},\ldots,p_{n})_{t+1}=(D(1)(1),\ldots,D(n)(1)),\left(=(D^{\prime}(1)(1),\ldots,D^{\prime}(n)(1))\right)$

• •

$(q_{1},\ldots,q_{n})_{t+1}=(D^{\prime}(1)(2),\ldots,D^{\prime}(n)(2))$

There is a probability $\rho>0$ that $\forall i\in\llbracket 0;n\rrbracket,i\neq k\Rightarrow q\notin[p_{i},q_{i}]\wedge q_{i}\notin[p,q]$. We call this event the $(\ast)$ event. This events means that the robot chose a destination that is not on another robot’s path ($q\notin[p_{i},q_{i}]$), and that does not make the robot cross another robot’s destination ($q_{i}\notin[p,q]$). As there are at most $2n$ points that can be selected by $k$ and do not satisfy these two properties (see Figure 2), there is a probability at least $2^{-2n}$ of choosing a point that does satisfy those two conditions.

Assume that at each step $(\ast)$ happens then we claim that we do at most $n$ steps. Indeed if we do $n+1$ steps then it means that a robot computed twice whilst not alone (from now on we only consider the computation the robot did ”whilst not alone”), let us say it is the $k$-th robot who is the first robot to compute twice. If the robot computes twice then it means that at the time of its second computation it is not alone on its position, the h-th robot is also there. Let us call q the current position of the two robots (notice that q was also the result of the first computation of k), p the position where k was when it did its first computation, p’ the position where h was when k did its first computation. Let $q^{\prime}$ be the destination of h when k does its second computation. There are two possibilities : either the robot h had $q^{\prime}$ in mind before the first computation of k or it had it after.

• •

if $h$ had it before: then when $k$ did its first computation, it got $q\in[p^{\prime};q^{\prime}]$, which is impossible by assumption (by the condition $q\notin[p_{h},q_{h}]$),

• •

if $h$ had it after: then $h$ did a computation while at position $e$ and chose $q^{\prime}$ as a destination, with $q\in[e,q^{\prime}]$, which is impossible by assumption (by the condition $q_{k}\notin[e;q^{\prime}]$).

Since $(\ast)$ has probability at least $2^{-2n}$ of occurring, it has probability at least $2^{-2n^{2}}$ of occurring $n$ times in a row (notice that this probability is independent of $\sigma$ and $C$). Now, if it occurs $n$ times in a row, then $\mathds{APART}$ is reached. Therefore $\mathds{APART}$ has a probability at least $2^{-2n^{2}}$ of being reached from $C$, following $\sigma$. ∎

Theorem 2**.**

Algorithm 1 solves the asynchronous rigid scattering problem in $\mathds{R}^{2}$.

Proof.

The proof is a direct application of theorem of choice to the result of Lemma 3 ∎

One remaining interesting question is a necessary and sufficient condition about $\{u(i)\}_{i\in\mathds{N}}$ such that Algorithm 1 solves the ASYNC blind rigid scattering problem (see Figure 3). One may think that the following property is true: ”Algorithm 1 solves ASYNC blind rigid scattering if and only if $\{u(i)\}_{i\in\mathds{N}}$ spans $\mathds{R}^{2}$”. While it is necessary (Algorithm 1 does not solve scattering when all $u(i)$ are on the same line), it is not sufficient. Indeed, if $\forall n,n=0[2]\Rightarrow u(0)=(1,0)\wedge n=1[2]\Rightarrow u(1)=(0,1)$, Algorithm 1 does not solve scattering (see Figure 4), yet $\{u(i)\}_{i\in\mathds{N}}$ is a base of $\mathds{R}^{2}$. Instead, we propose the following conjecture:

Conjecture 1**.**

The $u(i)$ permit Algorithm 1 to solve ASYNC blind rigid scattering if and only if there exists no finite set $C\subset\mathds{R}^{2}$ of points such that from any points of $C$ there is a way for the scheduler to choose a frame that makes every $u(i)$ coincide with points of $C$.

5 Flexible Scattering in ASYNC

In this section, we consider the more difficult case of flexible (a.k.a. non rigid) moves, where the scheduler may stop the robot before it reaches its destination (but not before the robot moves by some distance $\delta>0$). The previous blind solution (Algorithm 1) may no longer be valid as the condition for not ending up in the same location now requires that robot trajectories do not cross. So, the constant probability (from any configuration) of not reaching another robot’s location is not guaranteed, and so neither is scattering. As a result, we devise new algorithms for this setting that are not blind, first in the unidimensional case (Section 5.1), and then in the bidimensional case (Section 5.2).

5.1 Flexible ASYNC scattering in $\mathds{R}$

The pseudocode for our solution is presented as Algorithm 2. The term ”unit distance” found in Line 6 refers to the one given by the scheduler. Figure 5 presents the two possible locations a robot located in $A$ may chose as a target destination when occupied locations are only $A$, $B$, and $C$.

Lemma 4**.**

$\mathds{APART}$* is a safe zone for algorithm 2.*

Proof.

Starting from a configuration in $\mathds{APART}$, a robot does nothing when there is no other robot at its position (Line 2). ∎

Theorem 3**.**

Algorithm 2 solves the ASYNC flexible scattering problem in $\mathds{R}$.

Proof.

Our strategy is to increase by at least one the number of isolated (and hence immobile) robots at each step of the proof. We first fix a left-right orientation (unknown to the robots), and number the robots from $1$ to $n$. Let $\sigma$ be a scheduler and $C$ a configuration. For the first step, we devise a strategy to put one robot to the right of every other robot (and it remains so forever): if a robot located at the rightmost position (called ”rightmost robot”) is requested to make a choice, then if no other rightmost robot already goes to the right, go to the right; otherwise, go to the left. We refer to this event as ($\ast$). We now assume that event ($\ast$) always happens when it can, i.e. our strategy occurs.

This strategy occurs with probability at least $2^{-2n}$. Indeed, if a rightmost robot decides to go left once, it is never considered again as it cannot become a rightmost robot again. In more details, Algorithm 2 requires that for a robot $A$ to cross a robot $B$ to the right, $B$ should go to the left. With our strategy, at least one rightmost robot goes right or stays still. It follows that the number of times we need to repeat the strategy is at most $2n$, as at most $n$ rightmost robots may be requested to go to the left (and if a rightmost robot goes to the left it must be that a rightmost robot has chosen to go to the right). Then, we need each robot on the rightmost position stack to make the right choice between left and right, each one has a probability $\frac{1}{2}$ of making this right choice. So, the strategy is followed with probability at least $2^{-2n}$. 2. 2.

There is a time after which no robot wants to go further to the right of or at the same position as the rightmost robot, and the rightmost robot does not want to move to the left. Said differently there is a time after which the rightmost robot remains the rightmost robot forever (we call this property $P$). This is entailed by two facts: (i), ($\ast$) can occur at most $2n$ times (see above) and if ($\ast$) occurs finitely many times, then property $P$ is satisfied. It is easy to be convinced of this claim if one notices that a non-rightmost robot cannot become a rightmost robot via a computation (unless the rightmost robots all move left). Next, because we follow the strategy, the rightmost robots cannot go left (except maybe at the beginning).

We now give the technical proof : Assuming the robots follow our strategy, there is a time after which no one wants to go further to the right of or at the same position as the rightmost robot and the rightmost robot does not want to move to the left, as a result the rightmost robot will remain the rightmost robot forever (we call this property P).

We will prove it by induction on the number of robots who may become the rightmost robot at least once.

Firstly it is easy to be convinced there is a time $t_{right}$ after which the position of the rightmost robot can only increase.

Secondly if at a time $t>t_{right}$ a robot is still (its position and its destination is the same) and is not one of the rightmost robots, it can never become one of the rightmost robot. We call this property S.

Let us now prove property P : by contradiction, let us assume that ”who the rightmost robot” is changes an infinite amount of time, let us place ourselves after ($\ast$) does not happen anymore. Since we assume ($\ast$) happens whenever it can happen then it means that there is no situation, after some time $t>t_{right}$, where one of the rightmost robot is asked to compute.

We say that a robot is in the race for rightmost status if there is a scheduler such that following this scheduler and our strategy there is a non-zero probability that this robot becomes, at least for some time, the rightmost robot. In other words a robot is in the race for rightmost status if there is a way for this robot to become one of the rightmost robots at some point.

We place ourselves at time t, we number from 1 to r the robots in the race for rightmost status. There is a time t’ where the rightmost robot is crossed by the robot k (by assumption). There is a time t” at which k stops (either because the scheduler interrupted him or because k reached its destination) at this point k’s position and k’s destination are the same. If k never moves again it is removed from the race. If k moves once again then it means there is a time $t_{3}$ where another robot q which goes on top of it and k performs a computation. If at time $t_{3}$ k is not the rightmost robot then it is removed from the race (by property S). But k is not the rightmost robot at time $t_{3}$ because $t_{3}>t$, and by definition of t the rightmost robot cannot compute after t. Therefore k is removed from the race. By induction this proves claim P (P is equivalent to having only one robot in the race for rightmost status). 3. 3.

After long enough the rightmost robot does not want to move : by the last point there is a time at which there the rightmost robot does not move or moves to the right by fairness of the scheduler it will eventually reach its destination or be interrupted and never be reached by another robot (by the previous point)

The set of configurations $F_{1}$ were a single rightmost robot does not want to move, and every other robot does not want to cross it is safe (by points 2 and 3 above). Moreover from any starting configuration $C$ and for any scheduler $\sigma$, there is a probability at least $2^{-2n}$ to reach this set. By theorem of choice, $F_{1}$ is thus reached with probability $1$.

For the next step of the strategy, we assume that there exists some integer $k\geq 1$ such that the following property holds: ”the set of configuration $F_{k}$ where the $k$ rightmost robots are lonely and do not want to move, and every other robot does not want to cross the leftmost of those $k$ rightmost robots is safe”. If a configuration is in $F_{k}$, We call $R_{k}$ the set of robots minus the $k$ single rightmost robots. Then, we use a strategy similar to the base case of the induction: if you are a rightmost robot of $R_{k}$ and you are required to make a choice, if no other robots at your current location is already going to the right, then go to the right, otherwise, go to the left. By a similar set of arguments as for the base case, after long enough, a configuration in $F_{k+1}$ is reached, and this configuration is safe.

Step by step, we conclude that we eventually reach a configuration in $F_{n}$, and this configuration is safe. Obviously, $F_{n}$ satisfies $\mathds{APART}$. ∎

5.2 Flexible ASYNC Scattering in $\mathds{R}^{2}$

The pseudo-code for algorithm scattering is given as Algorithm 3. The smallest enclosing polygon (line 10) is also known as the convex hull. Cardinal directions (Line 7) are given by the scheduler, while the vector $\overrightarrow{e_{x}}$ (Line 14) denotes the first axis of the frame given by the scheduler to the robot.

When we write ”move alongside $\theta$”, where $\theta$ is an angle, we mean that the robot should move in the direction given by the vector $\overrightarrow{v}$, of size one and where $angle(\overrightarrow{e_{x}},\overrightarrow{v})=\theta$. An illustration of the algorithm is given in Figure 6.

Lemma 5**.**

$\mathds{APART}$* is a safe zone for Algorithm 3.*

Proof.

Starting from a configuration in $\mathds{APART}$, a robot does nothing when there is no other robot at its position (Line 2). ∎

Theorem 4**.**

Algorithm 3 solves the flexible ASYNC scattering problem in $\mathds{R}^{2}$.

Proof.

The proof for the $\mathds{R}^{2}$ case follows the same pattern as the one for $\mathds{R}$. However, it is now more ambiguous to talk about ”farthest” robots. We use the smallest enclosing polygon to define the set of farthest robots, but instead of two directions (left and right) in the case of $\mathds{R}$, we now have multiple angles to distinguish between farthest robots. In more details,let us denote by $\overrightarrow{e_{x}}$ the first coordinate vector of $\mathds{R}^{2}$, let $C$ be a finite set of points in $\mathds{R}^{2}$, let $\theta$ be a number in $[0;\pi[$, $c\in C$ is one of the $\theta$-furthest points if $\langle c,e^{i\theta}\rangle=\underset{c^{\prime}\in C}{\mathrm{max}}\langle c^{\prime},e^{i\theta}\rangle$ where $e^{i\theta}$ is the vector of length 1 and such that $\langle\overrightarrow{e_{x}},e^{i\theta}\rangle=\theta$ (see figure 7)

We number robots from 1 to $n$. Let $\sigma$ be a scheduler and $C$ a configuration.

For the first step, we choose an angle $\theta$ arbitrarily, and we devise a strategy to put a robot the farthest along $\theta$ (called $\theta$-farthest). The strategy to follow is: if a robot $r$ is one of the $\theta$-furthest robots and is required to make a choice, if no other robot on the same location is already going $\theta$-further, $r$ pick a direction that makes it go $\theta$-further, otherwise $r$ picks a direction that does the opposite (that is, makes $r$ go $\theta$-closer). This event is called ($\ast$). Note that it is always possible to comply with the instructions because among the 4 directions robot $r$ can go to, at least one is making $r$ go $\theta$-further.

• •

this strategy happens with a probability at least $\frac{1}{4}^{-2n}$. Indeed, if at some point $r$ decides to go $\theta$-closer, $r$ never applies the strategy again because $r$ cannot become a $\theta$-farthest robot again (by construction of the algorithm and the strategy). Therefore the event ($\ast$) happens at most $2n$ times, since there are 4 equally likely destinations and that at least one goes $\theta$-farther, we get $\frac{1}{4}^{-2n}$.

• •

After long enough, no robot wants to go $\theta$-further or equally $\theta$-far as the $\theta$-furthest robots (there can eventually be multiple $\theta$ farthest robots) : the proof is similar to the uni-dimensional case. Assuming the robots follow our strategy there is a time after which the set of $\theta$-farthest robots never change anymore. We call this property P.

Firstly is it easy to be convinced that there is a time $t_{\theta}$ after which the value of the projection of the position of the $\theta$-farthest robots over the vector $e^{i\theta}$ only increases.

Secondly if at a time $t>t_{\theta}$ a robot is still (its position and its destination is the same) and is not one of the $\theta$-farthest robots, it can never become one of the $\theta$-farthest robots. This is because, in the algorithm, the robot can move a distance which is strictly inferior to the distance to the closest enclosing polygon. We call this property S.

Let us now prove property P : by contradiction, let us assume that the set of $\theta$-farthest robots changes an infinite amount of time, let us place ourselves after ($\ast$) does not happen anymore. Since we assume ($\ast$) happens whenever it can happen then it means that there is no situation, after some time t ¿ $t_{\theta}$, where one of the $\theta$-farthest robot is asked to compute. We say that a robot is in the race for $\theta$-farthest status if there is a scheduler such that following this scheduler and our strategy there is a non-zero probability that this robot becomes, at least for some time, the $\theta$-farthest robot.

We place ourselves at time t, we number from 1 to r the robots in the race for $\theta$-farthest status. Since the set of $\theta$-farthest robot always change by assumption, there is a time t’ where robot k becomes a $\theta$-farthest robot (and it was not just before that). There is a time t” at which k stops (either because the scheduler interrupted him or because k reached its destination) at this point k’s position and k’s destination are the same. If k never moves again there are two possibilities

• –

there is a point after which it is not a part of the set $\theta$-farthest robots and it is removed from the race (since it will never move)

• –

or it will always be a part of the set of $\theta$-farthest robots.

If k moves once again then it means there is a time $t_{3}$ where another robot q which goes on top of it and k performs a computation. If at time $t_{3}$ k is not the $\theta$-farthest robot then it is removed from the race (by property S). But k cannot be $\theta$-farthest robot at time $t_{3}$ because $t_{3}>t$ (and no robot $\theta$-farthest robot can compute after time t). Therefore robot k is removed from the race. By induction this proves claim P because each time we either discard a robot from ever being in the set of $\theta$-farthest robots or we put a robot in this set forever, at some point the set of $\theta$-farthest robot will never change anymore (which is property P).

• •

After long enough, the $\theta$-furthest robots do not want to move anymore. Once the situation described in the previous bullet case is reached, we just wait for the $\theta$ furthest robots to reach their destination (or be stopped by the scheduler, for what matters).

After events listed in the above point have happened, the set of $\theta$-farthest robots remains the same forever.

Next steps of the strategy :

A polygon (or shell) is said stable if all robots on the border of the polygon are standing still and no one inside this polygon wants to go outside or on the border of the polygon. We successively apply the strategy we used for a specific $\theta$ to all $\theta^{\prime}\in[0;\pi[$. For a given $\theta$ it can be we are already at a point where the set of $\theta$-farthest robots will always stay the same and we have nothing to do. The cases where we do have something to do occur at most n times. Once the strategy has been applied for all $\theta^{\prime}\in[0;\pi[$ the outer shell (or convex hull) of the robots is stable. Just like in the uni-dimensional case we then apply the same strategy to the robots strictly inside the stable shell. We simply change in the reasoning ”$\theta$-furthest” by ”$\theta$-furthest among the robots that are not part of a stable shell”.

At the end, by application of the theorem of choice we reach $\mathds{APART}$.

∎

Observe that Algorithm 3 very easily extends to higher dimension.

6 Complexity

The notion of complexity can be studied in two variants: the expected number of coin tosses until scattering, and the expected number of rounds until scattering. A round is a smallest fragment of an execution during which all robots execute each at least one Look-Compute-Move cycle.

Theorem 5**.**

Algorithm 1 achieves scattering of $n$ robots in expected $O(2^{2n^{2}})$ rounds.

Proof.

Let $E$ be the expected number of rounds it takes to scatter the robots. There is a $2^{-2n^{2}}$ probability that $\mathds{APART}$ is reached in one round (see the proof of Lemma 3). Therefore, $E\leq 1+(1-2^{-2n^{2}})*E\Rightarrow E\leq\mathcal{O}(2^{2n^{2}})$ ∎

Theorem 6**.**

Algorithm 1 uses expected $\mathcal{O}(2n*2^{n^{2}})$ coin tosses.

Proof.

The proof is similar to the last theorem. ∎

By tweaking the algorithm 3, we can get a better bound of $E\leq(\frac{4\pi^{2}}{6})^{n}*n^{2n}$. For this change, the probability of picking the $i$-th direction to $\sim\frac{6}{\pi^{2}i^{2}}$ instead of $2^{-i}$.

We know that in the SSYNC setting, scattering can be achieved in $\Theta(n\log n)$ coin throws on average. In the ASYNC setting, assuming a robot throws a coin anytime it chooses a new destination, it turns out that $\Omega(n^{2})$ coin tosses are needed for flexible scattering in $\mathds{R}$.

Theorem 7**.**

Assuming robots are not blind and have weak local multiplicity detection, any algorithm that solves flexible ASYNC scattering in $\mathds{R}$ and makes a robot throw at least one coin anytime it chooses a new destination requires $\Omega(n^{2})$ coin tosses.

Proof.

At step $1$, suppose every robot is at the same position (at the origin of the coordinate system). At step $2$, every robot computes. There is thus a point $p$ (denoted by a red cross on Figure 8) on the left or on the right such that at least $n/2$ robots wish to cross $p$. Out of these $n/2$ robots, we disseminate $n/4$ along the path to $p$ by prematurely stopping them. The $n/4$ other robots are put on hold. At step $3$, we choose one of the $n/4$ robots that were put on hold at step $2$, and call it $q$. We now make $q$ move toward $p$ in an multi-stop fashion: anytime $q$ crosses one of the disseminated $n/4$ robots, say $q^{\star}$, $q$’s movement is suspended, and $q^{\star}$ computes a new destination (since $q^{\star}$ and $q$ occupy the same location at this moment). When $q$ reaches $p$, the scheduler stops it.

Each of the $n/4$ has made a computation transition (and hence a coin toss). The scheduler now moves and interrupts each of those in such a way that they remain between the origin and $p$. The process is then repeated with every remaining $n/4-1$ robots that were put on hold. As a result, each of the $n/4$ disseminated robots computes $n/4$ times, yielding a $\Omega(n^{2})$ number of coin tosses. ∎

Our assumption that a robot tosses a coin anytime it chooses a new destination is justified by the following observation: in our schedule, the scheduler only selects for computation robots that are on a multiplicity point; now if a robot on a multiplicity point does not perform a coin toss, its behavior may be identical to that of other robots on the same multiplicity point, delaying scattering.

7 Necessary and Sufficient conditions for ASYNC scattering

In this section, we consider necessary and sufficient conditions for the solvability of ASYNC scattering depending on system hypotheses: rigidity of moves, dimensionality of the locations space, vision, and availability of weak local multiplicity detection. The summary of our results is presented in Table 1.

Theorem 8**.**

Rigid ASYNC scattering in $\mathds{R}$ is impossible if the robots are blind, even with weak local multiplicity detection.

Proof.

Consider three robots $A$, $B$, and $C$ that are still and $A$ is on the left of $B$, while $C$ shares $B$’s position. Let $d\in\mathds{R}$ be a positive distance. Then, for any $p\in]0,1[$, the scheduler can force a robot that computes a new destination to compute a distance at least $d$ with probability $p$ (indeed, the scheduler can change the scale of the coordinate system at every Look-Compute-Move cycle). We now construct a schedule such that there is a positive probability that the robots never reach $\mathds{APART}$. We define routine(i) as ”Assume there are exactly two robots $p$ and $q$ sharing the same location and at least one of them, $p$, is still, while the third robot is called $h$. We also assume that $q$ is not going toward $h$. If at least one of the assumptions is false, the routine aborts, otherwise, the scheduler does the following:

• •

If $q$ is still, the scheduler makes $p$ compute and ensures it chooses a destination that is farther than $dist(p,h)$ with probability $1-\frac{1}{2}^{(i+1)}$. If $p$ chooses to go towards $h$, the scheduler makes it move to the exact location of $h$, from which we execute routine(i+1). Otherwise, the scheduler simply executes routine(i+1).

• •

If $q$ is not still, the scheduler makes $p$ compute and ensures it chooses a destination that is farther than $max(dist(h,p),dist(dest(q),p)$ with probability $1-\frac{1}{2}^{(i+1)}$. If $p$ goes towards $h$, the scheduler makes it move to the exact location of $h$ and executes routine(i+1). If $p$ goes farther than $q$, the scheduler makes $q$ go to its destination, then makes $p$ move to the location of $q$, and finally execute routine(i+1). If $q$ goes further than $p$, the scheduler makes $p$ go to its destination, then makes $q$ move to the location of $p$ and execute routine(i+1).”

Now, with the initial configuration we considered, let the scheduler execute routine(0). As we request the scheduler to ensure a certain moving distance with a certain probability, for any integer $i$, the routine(i) never aborts, and the robots never reach $\mathds{APART}$. The probability that this execution occurs is $\prod_{i=1}^{+\infty}(1-\frac{1}{2}^{(i+1)})\geq 1/2$. ∎

Theorem 9**.**

Rigid ASYNC scattering in $\mathds{R}$ is impossible if robots have no multiplicity detection, even with full vision.

Proof.

Let us first consider a network of three robots $A$, $B$, and $C$ such that $A$ is on the left, and $B$ and $C$ occupy the same location on the right. All robots are still. Now, when $B$ is activated, there must be a positive probability that $B$ computes a new position. Suppose $B$ only selects one direction: opposite to $A$. Then, the same holds for $C$, as the algorithm is uniform for all robots. The scheduler then uses the following schedule: (i) activate $B$ until $B$ decides to move to the right by some distance $d_{B}>0$, then (ii) activate $C$ until $C$ decides to move to the right by some distance $d_{C}>0$, then (iii.a) if $d_{B}<d_{C}$, move $B$ until it reaches its destination, move $C$ until it reaches $B$, activate $B$ until it decides to go right again by some distance $d^{\prime}_{B}>0$, then repeat the process until $d^{\prime}_{B}>d_{C}-d_{B}$, or (iii.b) if $d_{B}>d_{C}$, move $C$ until it reaches its destination, move $B$ until it reaches $C$, activate $C$ until it decides to go right again by some distance $d^{\prime}_{C}>0$, then repeat the process until $d^{\prime}_{C}>d_{B}-d_{C}$. This schedule yields an execution such that robots $B$ and $C$ occupy the same position infinitely often, hence scattering is never achieved. This implies that robots $B$ and $C$ must run an algorithm such that there exists a positive probability to move to the left (that is, toward $A$).

Now, consider a network of two robots $A$ and $B$ initially separated and still (hence satisfying $\mathds{APART}$), where $A$ is on the right. Since $B$ has exactly the same vision as in the previous situation (it has no multiplicity detection), there is a positive probability that $B$ goes to the left (toward $A$). By symmetry, there is also a positive probability that $A$ goes to the right (that is, toward $B$). Now, the distance can be oblivious of the distance between $A$ and $B$ (that is, an absolute value based on the unit distance given by the scheduler) or a function of the distance between $A$ and $B$ (since the scale is given by the scheduler, the perceived distance can be always one unit, so this equates to a fraction of the distance). In the case of absolute value, the scheduler simply chooses the distance between $A$ and $B$, so that they occupy the same position again, invalidating $\mathds{APART}$ safety. In the case of a fraction, say $1/3$ (see Figure 9, the same number is chosen by both $A$ and $B$ with probability $p>0$ since they have the same view. Then $A$ computes a right target with probability $p$ but does not move, then $B$ computes and move four times in a row, hence, with probability $p^{5}$, $A$ and $B$ occupy the same position again, hence $\mathds{APART}$ is not safe. If the fraction is $1/k$, for some integer $k$, the overall probability of a meeting of $A$ and $B$ becomes dependent of $k$, but remains positive.

∎

One may wonder if it is possible to scatter robots that are blind and have no weak local multiplicity detection (even in $\mathds{R}^{2}$). The following theorem show that it is not the case.

Theorem 10**.**

Rigid ASYNC scattering in $\mathds{R}^{2}$ is impossible if robots are blind and have no weak local multiplicity detection.

Proof.

Since the robots do not have weak local multiplicity detection and are blind, there exists probability $p>0$ that the robots move, otherwise they would never separate if placed on the same location. Let $d\in\mathds{R}^{2}$ be a position, since the robots are blind by adjusting the scale and orientation of their referential the scheduler can take the robot to position $d$ with probability $p>0$. Let us suppose we have $n>1$ robots in $\mathds{R}^{2}$ that execute a scattering algorithm. Let us also suppose those robots are in a configuration that satisfies $\mathds{APART}$. We now show that it is possible that two robots meet with positive probability. Let $d$ be the position of robot number $1$, the scheduler activates robot number $2$ such that robot $2$ has a probability $p$ of choosing $d$ as a destination. If robot $2$ chooses $d$ then we have reached a configuration not in $\mathds{APART}$ with probability $p$. If robot $2$ does not choose $d$, the scheduler makes robot $2$ move to its destination and once arrived, activates it again so that it chooses $d$ with probability $p$. By doing this repeatedly, we eventually reach a conifguration not in $\mathds{APART}$.

Admittedly, a fairness issue may arise, if robot $1$ is not activated fairly. However, the arguments remains the same if robot $1$ is activated and moves every $k$ (for some integer $k>0$) activations of robot $2$, as the probability $p$ is independent of the position of robot $1$. ∎

The first unresolved case in this table is whether it is possible to scatter blind robots in $\mathds{R}^{2}$ with flexible moves. We conjecture the answer is yes and that Algorithm 1 is a solution. However, the proof argument is expected to be more involved than the one we provided. The second unresolved case is whether it is possible to scatter robots without weak local multiplicity detection in $\mathds{R}^{2}$ (be it rigid or flexible moves). We also conjecture the answer to this question is yes, but different algorithmic techniques from the ones we provided are expected to be necessary.

8 Concluding Remarks

We presented the first solutions to the oblivious mobile robots asynchronous scattering problem. Contrary to previous work, we do not assume that the configuration observed by the robots is always up to date or does not features moving robots. It turns out that the problem can be solved in the most general case when robots are able to see other occupied location, and can determine whether more than one robot occupies their current location. Our positive results are constructive, and a byproduct of our approach is a new proof technique that could reveal useful for other oblivious mobile robot problems requiring randomization. Perhaps surprisingly, it remains possible to solve the problem when robots are blind (they cannot see other occupied locations) in a bidimensional Euclidean space. Releasing both assumptions (vision and weak local multiplicity detection) yields immediate impossibility, while removing one of them yields impossibility in the case of line. Some cases remain open and most likely require new proof arguments.

While our approach was mostly driven by a computability perspective, our positive result command a thorough complexity analysis of the problem. Preliminary results we obtained show that, under a reasonable assumption, a lower bound of $\Omega(n^{2})$ coin tosses is necessary to scatter $n$ robots in ASYNC. This contrasts with the weaker SSYNC model where $\Theta(n\log n)$ coin tosses are tight. We leave this path of research as a future work.