Gathering on a Circle with Limited Visibility by Anonymous Oblivious Robots

One of the most popular models for distributed mobile robotics is the Look-Compute-Move (LCM) [21, 22]. In this model, a Euclidean space, usually the real plane $\mathbb{R}^{2}$, is inhabited by a “swarm” of punctiform and autonomous computational entities, the robots. Each robot, upon activation, takes a snapshot of the space (Look), uses this snapshot to compute its destination (Compute), and then reaches its destination point (Move).

The activation pattern of the robots is controlled by an external scheduler. At one end of the synchrony spectrum, there is the fully-synchronous scheduler (FSYNCH): in this case, time is divided into discrete units (the turns). At each turn, the entire swarm is activated, and all robots synchronously execute one LCM cycle. At the other end, there is the asynchronous scheduler (ASYNCH), where robot activations are independent, and LCM cycles are not synchronized. Somewhere halfway, there is the semi-synchronous scheduler (SSYNCH), which activates an arbitrary subset of robots at each turn, with the restriction of activating each robot infinitely often.

A common assumption in the context of mobile robots is the lack of persistent memory: a robot does not remember anything about past activations (obliviousness). Other assumptions are anonymity, where robots do not have visible and distinguishable identifying features, and silence, where robots do not have explicit communication primitives. This robot model is sometimes referred to as “OBLOT” [22].

Obliviousness, anonymity, and silence are practical, useful, and desirable properties: an algorithm for oblivious robots is inherently resilient to transient memory failures; one for anonymous robots is ideal in privacy-sensitive contexts; an algorithm for silent robots works even in scenarios where communication is jammed or unfeasible (e.g., hostile environments or underwater deployment).

The purpose of such an ensemble of weak robots is to reach a common goal in a coordinated way. Interestingly, it has been shown that mobile robots can solve an extensive set of problems [22], ranging from forming patterns [23, 25, 38, 40] to simulating a powerful Turing-complete movable entity [15].

Among all tasks, a particularly relevant one is Gathering [1, 5, 6, 12, 18, 35, 36]: in finite time, all robots have to reach the same point and stop there. Initial works assumed robots to see the entire space (full visibility). However, a more realistic assumption [3, 34] is that a robot be able to see only a portion of the space (limited visibility).

In this paper, we study the Gathering problem for a swarm of oblivious robots with limited visibility constrained to move within a circle: each robot can see only the points on the circle that have an angular distance strictly smaller than a certain visibility range $\vartheta$. We assume that robots have no agreement on common coordinates apart from sharing the same notion of clockwise direction on the circle.

From a practical perspective, the restriction of moving along a predetermined path arises in wide variety of scenarios: railway lines, roads, tunnels, waterways, etc. We argue that the circle is the most meaningful curve to study: a solution for it readily extends to all other closed curves.

From a theoretical perspective, confining the swarm on a circle (hence, a non-simply connected space) rules out all the strategies typically used for robots in the plane, such as moving toward the center of the visible set of robots (an example is in [2]). Moreover, robots cannot use any asymmetries in the environment to identify a gathering point: this makes the circle the most challenging setting for Gathering (and in general, for any problem where symmetry breaking helps).

Apart from [20], which examined the problem of scattering on a circle (reaching a final configuration where the robots are uniformly spaced out), no other works studied the computational power of oblivious robots when confined to curves: this is rather surprising, considering the copious existing literature on oblivious robots [21, 22]. To the best of our knowledge, the present paper is the first to investigate the Gathering problem for oblivious, silent, and anonymous robots on a circle with limited visibility.

We consider a swarm of $n$ oblivious, anonymous, and silent robots that start at distinct locations on a circle. Robots do not agree on a common system of coordinates, but they do share the same handedness (i.e., they have a common notion of clockwise direction). When a robot decides to move, it reaches its destination point (robots are rigid). Moreover, robots have no information on the swarm’s size, $n$. Each robot can see only the points on the circle that have an angular distance strictly smaller than a certain visibility range $\vartheta$. We must assume that the initial configuration is rotationally asymmetric, otherwise the scheduler may activate robots in such a way as to preserve the rotational symmetry, and Gathering cannot be achieved.

After giving all the necessary definitions and some preliminary results (Section 2), our first contribution is to show that there is no distributed algorithm that solves the Gathering problem in SSYNCH when $\vartheta\leq\pi/2$, i.e., each robot is only able to see at most half of the circle (Section 3). Surprisingly, this holds even if the initial configuration is rotationally asymmetric, the visibility graph of the swarm (i.e., the graph of intervisibility between robots) is connected, and all robots know $n$.

Our proof uses a novel technique based on random perturbations, of which we offer an intuitive probabilistic argument, as well as a formal and more elementary proof by derandomization. We show that, for any given distributed algorithm, either there exists an asymmetric configuration of robots that can evolve into a symmetric one within one time unit (in SSYNCH), or there is an asymmetric configuration where no robot can move. In either case, Gathering is impossible.

We stress that our result has a profound meaning, since it shows that, when $\vartheta\leq\pi/2$, any distributed algorithm, including the ones that do not aim to solve Gathering, has an initial asymmetric configuration that either repeats forever or evolves into a symmetric configuration in one step. This implies a novel impossibility result for geometric Pattern Formation on circles: even when robots start from an asymmetric configuration, they cannot form a target asymmetric pattern. This is in striking contrast with the unlimited-visibility setting, where, even under the ASYNCH scheduler, any pattern can be formed from any asymmetric configuration [22].

To the best of our knowledge, this the first impossibility proof for oblivious robots that neither relies on invariants induced by symmetries (e.g., [25, 39]) nor on the disconnection of the visibility graph (e.g., [15, 41]). Due to the above, we think that our technique is of independent interest, and its core ideas could be applied to other settings, as well.

On the possibility side, we show that, if $\vartheta=\pi$ (i.e., each robot can see the entire circle except its antipodal point), there is a distributed algorithm that solves the Gathering problem in SSYNCH for swarms of any size (Section 4). The algorithm’s strategy is to attempt to elect a unique leader and form a multiplicity point, where all robots will subsequently gather. The main challenge is that, since a robot ignores whether its antipodal point is occupied by another robot or not (robots do not know $n$), there may be an ambiguity on who is the true leader. Several robots may believe to be the leader, but this also comes with the awareness of the possibility of being wrong: these “undecided” robots will make some adjustment moves, which eventually result in a configuration where one robot is absolutely certain of being the true leader. The leader will then form a multiplicity point by moving to another robot, and finally all other robots will join them.

A conference version of this paper has appeared at DISC 2020 [17].

The relevant literature can be divided into (i) works that study the Gathering problem in the plane, (ii) works where robots are confined on a circle (or a polygon with holes) but use memory, randomness, or other forms of symmetry breaking (e.g., different speeds), and (iii) works that consider oblivious robots but a discrete space (i.e., a ring graph).

In [24], Gathering is solved in ASYNCH, assuming that all robots agree on the orientation of both coordinate axes. This induces an implicit agreement on a total order among all robots, and such an order is at the base of the algorithm: each robot moves to its rightmost neighbor; if none is visible, it moves to its topmost neighbor. In [37], the Gathering problem is solved in SSYNCH, assuming an eventual agreement on the North direction.

A recent paper, [30], investigated the assembly of robots with a “defective view”. In this model, the snapshot taken by a robot captures a subset of up to $k\leq n$ robots. Two defective models are discussed: an adversarial one, where the subset is chosen by an adversary, and a distance-based one, where the snapshot includes the $k$ nearest robots. The paper presents solution algorithms for $k=n-2$ in the adversarial setting (when $n\geq 5$) and for $k=2$ and $n=4$ in the distance-based setting. Additionally, the paper demonstrates the impossibility of solving the problem when $k=1$ and $n=3$ in both adversarial and distance-based models.

All the aforementioned works heavily rely on the ability to freely move within a plane or on agreements on at least one direction.

The proposed algorithms employ a strategy wherein a robot is first elected as a leader, who then gathers the remaining robots. It is worth noting that the reliance on randomness (where robots can flip random coins) and persistent memory means that the techniques used in this work are not applicable to our setting.

Other works that investigated Gathering on a circle in the continuous model are [27, 32]. However, the solutions proposed in these papers strongly rely on either randomness or different robot speeds, both of which are ways to break symmetry.

Finally, there is a series of papers [7, 8, 9] that solve a weaker version of Gathering, where robots are required to reach the same point, even if they are unaware of each other and do not stop at that point. In polygons with holes, however, these algorithms require persistent memory. An exception is [16], which studies a related problem for oblivious robots in a polygonal environment, and proposes a strategy to simulate persistent memory by carefully moving within a neighborhood of a polygon’s vertex.

Let $C\subset\mathbb{R}^{2}$ be a circle, and let $a$ and $b$ be points of $C$. The angular distance between $a$ and $b$ (with respect to $C$) is the measure of the angle subtended at the center of $C$ by the shorter arc with endpoints $a$ and $b$. It follows that the angular distance between two points is a real number in the interval $[0,\pi]$, where angles are expressed in radians. Two points of $C$ are antipodal of each other if their angular distance is $\pi$. The $\alpha$-neighborhood of a point $q\in C$ is the set of points of $C$ whose angular distance from $q$ is strictly smaller than $\alpha$. The $(\pi/2)$-neighborhood of $q$ is also called the open semicircle centered at $q$.

Furthermore, if $a$ and $b$ are distinct points of $C$, we define $cw(a,b)$ as the measure of the clockwise angle $\angle acb$, where $c$ is the center of $C$. Note that the order of the two arguments matters, and so for instance $cw(a,b)+cw(b,a)=2\pi$. We also define $cw(a,a)=0$ for every $a$.

Let $S$ be a finite multiset of points on a circle $C$. We say that $S$ is rotationally symmetric if there is a non-identical rotation around the center of $C$ that leaves $S$ unchanged (also preserving multiplicities). It is easy to see that the angle of rotation must be $2\pi/k$ radians for some integer $k>1$. If $S$ is not rotationally symmetric, it is said to be rotationally asymmetric.

We now present a sufficient condition for a set of points to be rotationally asymmetric. This will be used repeatedly in Section 3.

Let $S$ be a multiset of $n$ points on a circle $C$, and let $p\in S$. Let $p_{1}$, $p_{2}$, …, $p_{n}$ be the points of $S$ taken in clockwise order starting from $p=p_{1}$ (coincident elements of $S$ are ordered arbitrarily). We define the angle sequence of $p$ (with respect to $S$) as the $n$-tuple $(cw(p_{1},p_{2}),cw(p_{2},p_{3}),\dots,cw(p_{n},p_{1}))$. The case where all the elements of $S$ are coincident is an exception, and in this case the angle sequence of the $i$th point of $S$, with $1\leq i\leq n$, is defined as the $n$-tuple $(0,0,\dots,0,0,2\pi,0,0,\dots,0,0)$, where the term $2\pi$ appears in the $i$th position. Note that, with this convention, the sum of the elements of any angle sequence is always $2\pi$.

The next two propositions are fundamental results about angle sequences. Although they are easy observations, they will be used repeatedly in the rest of the paper.

With the above notation, let $q\in C$, and let $j$, with $1\leq j\leq n$, be the unique index such that $0<cw(p_{j},q)\leq cw(p_{j},p_{j+1})$, with the convention that $p_{n+1}=p_{1}$ (i.e., $q$ lies on the clockwise arc $p_{j}p_{j+1}$, and $q\neq p_{j}$). We say that the angle sequence of $p$ truncated at $q$ is the $j$-tuple $(cw(p_{1},p_{2}),cw(p_{2},p_{3}),\dots,cw(p_{j-1},p_{j}),cw(p_{j},q))$.

If $W_{1}$ and $W_{2}$ are two (truncated) angle sequences, we write $W_{1}\prec W_{2}$ if $W_{1}$ is lexicographically smaller than $W_{2}$ (if $W_{1}$ and $W_{2}$ do not have the same length, we first pad the shorter sequence at the end with enough zeros). We write $W_{1}\preceq W_{2}$ to mean $W_{1}\prec W_{2}$ or $W_{1}=W_{2}$, and so on. Also, to denote the concatenation of two (truncated) angle sequences $W_{1}$ and $W_{2}$, we write $W_{1}W_{2}$.

Our model of mobile robots is among the standard ones defined in [21, 22]. A swarm of $n>1$ robots is located on a circle $C\subset\mathbb{R}^{2}$, where each robot is a computational unit that occupies a point of $C$ (which may change over time) and operates in deterministic Look-Compute-Move cycles.

Time is discretized and subdivided into units, and at each time unit an adversarial (semi-synchronous) scheduler decides which robots are active and which are inactive. An inactive robot remains idle for that time unit, whereas an active robot takes a snapshot of its surroundings, consisting of an arc $B\subseteq C$ and a list of points of $B$ that are currently occupied by robots, it computes a destination point in $B$ as a function of the snapshot, and it instantly moves to the destination point. The only restriction to the scheduler is that no robot should remain inactive for infinitely many consecutive time units.

Robots may have full visibility, in which case the arc $B$ defining a snapshot coincides with the entire circle $C$, or they may have limited visibility, in which case the arc $B$ consists of the $\vartheta$-neighborhood of the current position of the robot taking the snapshot, where $\vartheta$ is a positive constant called the visibility range of the robots.

Furthermore, each robot has its own local coordinate system, meaning that each snapshot it takes of an arc $B\subseteq C$ is actually a roto-translated copy of $B$ and the positions of the robots within $B$. Such a copy of $B$ has its midpoint at the origin of the coordinate system (this corresponds to the location of the robot taking the snapshot) and its endpoints have non-negative $x$ coordinate and the same $y$ coordinate.

Robots are also capable of weak multiplicity detection, meaning that the snapshots they take contain some information on how many robots occupy each location. Specifically, a robot can tell if a point in a snapshot contains no robots, exactly one robot, or more than one robot: no information on the precise number of robots is given if this number is greater than one. A point occupied by more than one robot is also called a multiplicity point.

In order to simplify our notation, when no confusion arises, we will often identify a robot with its position on the circle. So, we may improperly refer to a robot as a point $p\in C$ or to a swarm of robots as a set $S\subset C$.

A distributed algorithm is a function that maps a snapshot to a point within the snapshot itself. A robot executes a distributed algorithm $A$ if, whenever it is activated and takes a snapshot $Q$, it moves to the destination point corresponding to $A(Q)$. In other words, at each time unit, an active robot chooses its destination point deterministically within its visibility range, based solely on the snapshot it currently has.

We stress that, as a consequence of the previous definitions, the robots in this model are oblivious (i.e., they have no memory of past observations), anonymous (i.e., a robot only identifies other robots by their positions in its local coordinate system, and not for instance by their IDs), silent (i.e., they cannot send messages to one another), deterministic (i.e., they cannot flip coins), rigid (i.e., they always reach the destination points they compute), they have chirality (i.e., they all agree on the clockwise direction on the circle), and they have no knowledge of $n$ (i.e., a robot can only see other robots within its visibility range, and it does not know whether there are further robots outside of it).

We say that a distributed algorithm $A$ solves the Gathering problem under condition $P$ if, whenever all the $n>1$ robots of a swarm located on a circle execute $A$, they eventually reach a configuration where all robots are in the same point of the circle and no robot ever moves again, provided that their initial configuration satisfies condition $P$, and regardless of the activation choices of the adversarial scheduler. Equivalently, we say that $A$ is a Gathering algorithm under condition $P$.

We remark that all the robots in the swarm must execute the same algorithm $A$ (i.e., robots are uniform), and the algorithm has to work for swarms of any size $n>1$, where $n$ is not a parameter of $A$. Also note that the robots’ positions should not simply converge to the same limit, but they must actually become coincident in a finite number of time units for Gathering to be achieved (albeit there is no bound on the number of time units this process may take).

There are several meaningful options concerning our choice of the initial condition $P$ for the Gathering problem. A typical assumption is that the $n$ robots be initially located in $n$ distinct points of the circle: while not strictly necessary, this is a common requirement for the Gathering problem (e.g., [38, 5, 18]).

Another assumption that we may make is that the visibility graph of the robots be initially connected. By “visibility graph” we mean the graph whose nodes are the $n$ robots, where there is an edge between two robots if and only if they are mutually visible, i.e., if their angular distance is less than $\vartheta$. This assumption is another common one (e.g., [3, 2, 24, 37, 13]) and, although not strictly necessary, it is justified by the intuition that different connected components of the visibility graph may never become aware of each other, and therefore may fail to gather. We will make this assumption in Section 3 to strengthen our impossibility result, and we will not need to explicitly make it in Section 4, because it will come as a consequence of other assumptions.

An important mandatory condition is that the multiset of the robots’ positions on the circle should be rotationally asymmetric, due to the following.

Since the robots are oblivious, this condition should hold true not only at the beginning, but at all times during the execution of a Gathering algorithm: the robots should never “accidentally” form a rotationally symmetric multiset, or they will be unable to gather.

In this section we prove that, if each robot can see at most an open semicircle (i.e., $\vartheta\leq\pi/2$), then no distributed algorithm solves the Gathering problem, even under some strong assumptions on the initial configuration, and even if the robots know the size of the swarm.

Our technique is essentially probabilistic, and it starts by defining a set of perturbations of a regular configuration. Then, by analyzing the behavior of a generic distributed algorithm on all perturbations of a swarm that satisfy some initial conditions, we will show that the algorithm either (i) allows the construction of a rotationally asymmetric configuration that can evolve into a rotationally symmetric one (under a semi-synchronous scheduler) or (ii) leaves the configuration unchanged forever. In both cases, the algorithm does not solve the Gathering problem on some configurations.

We are interested in special types of perturbations of regular swarm configurations, depending on $\vartheta$. In Proposition 3.1, we show that the desired requirements of such perturbations can actually be satisfied by arbitrarily large swarms of robots. Proposition 3.3 demonstrates that these perturbations have good structural properties, such as preserving the visibility graph of swarm configurations (Corollary 3.5).

Leveraging the preceding statements, we provide strong constraints on how robots must behave under a Gathering algorithm. Essentially, we argue that at every step, all robots must move to locations already occupied by robots (Lemma 3.7). Furthermore, if a Gathering algorithm prescribes that in a given configuration, a robot $r_{i}$ moves to another robot $r_{j}$, perturbing $r_{i}$ will never cause it to move to the same robot $r_{j}$ (Lemma 3.9).

With these lemmas in place, it is relatively easy to conclude that there is always a perturbation of the regular configuration that causes any given algorithm to fail to make all robots gather. We formally prove this in Theorem 3.13, making use of the technical result of Lemma 3.11.

For the rest of this section, we will denote by $C$ the unit circle centered at the origin. A finite set $S\subset C$ is regular if $(1,0)\in S$ and all points of $S$ have the same angle sequence. Hence, for every positive integer $n$, there is a unique regular set of size $n$: for $n\geq 3$, this is the set of vertices of the regular $n$-gon centered at the origin and having a vertex in $(1,0)$.

Let $S$ be the regular set of size $n$, and let $p_{1}$, $p_{2}$, …, $p_{n}$ be the points of $S$ taken in clockwise order, starting from $p_{1}=(1,0)$. Let $\varepsilon\in\mathbb{R}$ with $0<\varepsilon<2\pi/n$, and let $\gamma=(\gamma_{1},\gamma_{2},\dots,\gamma_{n})\in[0,1]^{n}\subset\mathbb{R}^{n}$. The $\varepsilon$-perturbation of $S$ with coefficients $\gamma$ is the set $S^{\prime}\subset C$ of size $n$ such that, for all $1\leq i\leq n$, there is a (unique) point $p^{\prime}_{i}\in S^{\prime}$ with $cw(p_{i},p^{\prime}_{i})=\gamma_{i}\cdot\varepsilon$, called the perturbed copy of $p_{i}$. So, any $\varepsilon$-perturbation of $S$ is obtained by rotating each point of $S$ clockwise around the origin by an angle in $[0,\varepsilon]$.

Furthermore, for $1\leq i\leq n$, we say that two coefficient $n$-tuples $\gamma=(\gamma_{1},\gamma_{2},\dots,\gamma_{n})$ and $\gamma^{\prime}=(\gamma^{\prime}_{1},\gamma^{\prime}_{2},\dots,\gamma^{\prime}_{n})$ are $i$-related if and only if they differ at most by their $i$th terms, i.e., for all $j\neq i$, we have $\gamma_{j}=\gamma^{\prime}_{j}$. Note that the $i$-relation is an equivalence relation on $[0,1]^{n}$. With the previous paragraph’s notation, we say that the set of all $\varepsilon$-perturbations of $S$ whose coefficients are in a same equivalence class of the $i$-relation is a bundle of $\varepsilon$-perturbations of $p_{i}$. Intuitively, a bundle of $\varepsilon$-perturbations of $p_{i}$ is obtained by first fixing a perturbation of all points of $S$ except $p_{i}$, and then perturbing $p_{i}$ in all possible ways.

We will prove that Gathering is impossible for any given visibility range $\vartheta\leq\pi/2$, provided that the size of the swarm $n$ is appropriate. Specifically, we say that a positive integer $n$ is compatible with $\vartheta$ if three conditions hold on the regular set $S$ of size $n$ (refer to Figure 1):

1. 1.

   For every $p\in S$, the open semicircle centered at $p$ contains exactly half of the points of $S$.

2. 2.

   No two points of $S$ have an angular distance of exactly $\vartheta$.

3. 3.

   There are two distinct points of $S$ whose angular distance is smaller than $\vartheta$.

We can show that there are arbitrarily large such integers:

For every integer $n$ compatible with $\vartheta$, we define a positive number $\varepsilon_{\vartheta,n}$, which will be used to construct perturbations of the regular set $S$ of size $n$. We set $\varepsilon_{\vartheta,n}=\delta/2$, where $\delta=\min\{|\vartheta-2\pi a/n|\mid a\in\mathbb{N},\ 0\leq a\leq n\}$.

Since $n$ is compatible with $\vartheta$, it easily follows that $\varepsilon_{\vartheta,n}>0$. Also, $\delta$ is at most half the angular distance between two consecutive points of $S$, and therefore $\varepsilon_{\vartheta,n}\leq\pi/2n$. Moreover, our choice of $\varepsilon_{\vartheta,n}$ has some other desirable properties:

Next we will describe a way of combining two configurations of robots into a new one that takes an open semicircle from each. This operation will be used to construct configurations of robots where a given distributed algorithm fails to make the robots gather.

Let $S_{1}$ and $S_{2}$ be two subsets of $C$, and let $D$ be an open semicircle. The $D$-combination of $S_{1}$ and $S_{2}$ is defined as the set $(S_{1}\cap D)\cup\rho(S_{2}\cap D)$, where $\rho$ is the rotation of $\pi$ around the origin. In other words, this operation takes $S_{1}$, discards the points that do not lie in $D$, and replaces them with the points of $S_{2}$ that lie in $D$, by mapping them to their antipodal points.

We are now ready to give our first two lemmas, which deal with swarms forming perturbations of a regular configuration, and analyze the distributed algorithms that make robots move in some ways. The first lemma states that, if an algorithm makes a robot move to a point not currently occupied by another robot, then the algorithm cannot solve the Gathering problem.

The second lemma states that, if a distributed algorithm makes a robot $r$ move on top of another robot $r^{\prime}$, and there is a perturbation of $r$ such that the same algorithm makes $r$ move on top of the same robot $r^{\prime}$, then the algorithm does not solve the Gathering problem.

Our concluding argument goes as follows. Suppose for a contradiction that there is a Gathering algorithm $A$ for some $\vartheta\leq\pi/2$. Let $n$ be an arbitrarily large integer compatible with $\vartheta$, and let $S$ be the regular set of size $n$. We will derive a contradiction by studying the behavior of $A$ on the swarms forming the $\varepsilon_{\vartheta,n}$-perturbations of $S$. Specifically, let $p_{1}$, $p_{2}$, …, $p_{n}$ be the points of $S$ taken in clockwise order, starting from $p_{1}=(1,0)$. Suppose that a swarm of $n$ robots forms a generic $\varepsilon_{\vartheta,n}$-perturbations of $S$, with robot $r_{i}$ occupying the perturbed copy of $p_{i}$, and let all robots execute algorithm $A$.

Let us first restrict ourselves to a bundle $P$ of $\varepsilon_{\vartheta,n}$-perturbations of some $p_{i}\in S$, and let us analyze the possible behaviors of the robot $r_{i}$. Recall that, by definition of bundle, the perturbations in $P$ have fixed coefficients for all the points of $S$ except $p_{i}$, and perturb $p_{i}$ in every possible way by varying the coefficient $\gamma_{i}\in[0,1]$. Observe that, by Lemma 3.7, $A$ should never make $r_{i}$ move to some unoccupied location, or $A$ would not be a Gathering algorithm. Also, if two or more perturbations in the bundle $P$ made $r_{i}$ move to the same robot, then $A$ would not be a Gathering algorithm, due to Lemma 3.9. However, by the pigeonhole principle, if $n$ perturbations in $P$ made $r_{i}$ move to some other robot, then at least two of them would make it move to the same robot. It follows that at most $n-1$ perturbations in $P$ can make $r_{i}$ move at all. So, all perturbations in $P$ except a finite number of them must make $r_{i}$ stay still.

Now, let us pick an $\varepsilon_{\vartheta,n}$-perturbation of $S$ by choosing its coefficients $\gamma\in[0,1]^{n}$ uniformly at random. Let us also define $n$ random variables $X_{i}\colon[0,1]^{n}\to\{0,1\}$, with $1\leq i\leq n$, such that $X_{i}(\gamma)=0$ if and only if algorithm $A$ makes the robot $r_{i}$ stay still when the swarm’s configuration is the $\varepsilon_{\vartheta,n}$-perturbation of $S$ defined by the coefficients $\gamma$. By the above argument, for every bundle $P$ of $\varepsilon_{\vartheta,n}$-perturbations of $p_{i}$, we have $\Pr[X_{i}(\gamma)=1\mid\gamma\in P]=0$. Thus, with the convention that $\gamma=(\gamma_{1},\gamma_{2},\dots,\gamma_{n})$, we have

Hence, the probability that $A$ will make the robot $r_{i}$ stay still when the swarm’s configuration is picked at random among all $\varepsilon_{\vartheta,n}$-perturbations of $S$ is $1$. Since this is true of all robots separately, it is also true of all robots collectively, by the inclusion-exclusion principle. In other words, with probability $1$, on a random $\varepsilon_{\vartheta,n}$-perturbation of $S$, no robot will be able to move, and therefore the robots will be unable to gather. Moreover, with probability $1$, a random $\varepsilon_{\vartheta,n}$-perturbation of $S$ is rotationally asymmetric. As a consequence, there is at least one initial configuration (actually, a great deal of configurations) where the swarm forms a rotationally asymmetric set of $n$ distinct points with a connected visibility graph, and where no robot is able to move. We conclude that $A$ cannot be a Gathering algorithm, even under such strong conditions.

The probabilistic proof we outlined above is sound for the most part, but unfortunately making it rigorous is a delicate matter. The problem is that, in order for $X_{i}$ to be a random variable, it has to be a measurable function. For this to be true, the set of coefficients corresponding to perturbations where algorithm $A$ makes the robot $r_{i}$ stay still should be a measurable subset of $[0,1]^{n}$. In turn, this requires some assumptions on the nature of $A$, whereas we only defined $A$ as a generic function mapping a snapshot to a point.

However, since the function $A$ actually implements an algorithm, which typically is a finite sequence of operations that are well-behaved in an analytic sense, most reasonable assumptions on $A$ would rule out the pathological non-measurable cases, and would therefore make $X_{i}$ a properly defined random variable, allowing the rest of the proof to go through.

Nonetheless, we choose to adopt a different approach, which is both less technical and more general in scope. Indeed, we will give a “derandomized” version of the above proof, which will not deal with probability spaces and random variables, and will not require a more restrictive re-definition of which functions are computable by mobile robots.

Next we will show how to complete the previous argument without the use of probability. Note that we do not need to prove that a random perturbation causes all robots to stay still with probability $1$: we merely have to show that there is at least one perturbation with such a property. This is significantly easier, and is achieved by the next lemma, where $X_{i}$ no longer denotes a random variable but simply a set of coefficients.

We can now prove the main result of this section.

We remark that, throughout the proofs of Lemmas 3.7, 3.9 and 3.13, only swarms of the same size $n$ appear. It follows that our impossibility result holds even if all robots know the size of the swarm.

In this section we give a Gathering algorithm for robots that can see the entire circle except their antipodal point (i.e., $\vartheta=\pi$), under the condition that the initial configuration is a rotationally asymmetric set with no multiplicity points.

First we will describe a simple Gathering algorithm for robots with full visibility, which already provides some useful ideas: elect a leader, form a unique multiplicity point, and gather there. We will then extend the same ideas to the limited-visibility case with $\vartheta=\pi$. There are some difficulties arising from the fact that not all robots will necessarily agree on the same leader, because they may have different views of the rest of the swarm. For instance, two antipodal robots will not see each other, and, if the configuration is rotationally asymmetric, they will obtain two non-isometric snapshots, which may cause them to elect two different leaders.

We will show how to cope with these difficulties. Essentially, based on what a robot $r$ knows, there are only two possibilities on who the “true” leader may be, depending on whether there is a robot antipodal to $r$ or not. If $r$ happens to be elected leader in both scenarios, then $r$ has no doubt of being the leader, and therefore behaves as in the full-visibility algorithm, creating a multiplicity point. In most cases, however, no robot will be so fortunate, but the swarm will still have to make some sort of progress toward gathering. So, the robots that see themselves as possible leaders (but could be wrong) make some preparatory moves that will ideally “strengthen their leadership” in the next turns. We will argue that, after a finite number of turns, one robot will become aware of being the leader and will create a multiplicity point, even under a semi-synchronous scheduler.

The design and analysis of our Gathering algorithm are further complicated by some undesirable special cases, where two distinct multiplicity points end up being created, or the multiplicity point is antipodal to some robot, and therefore invisible to it.

This section is structured as follows. We begin by describing a simple algorithm for the full-visibility case, then proceed to the scenario where $\vartheta=\pi$. In this context, we distinguish between the cognizant leader, i.e., a robot certain of its leadership, and the undecided leaders, i.e., robots that perceive themselves as leaders but are unsure due to incomplete information. Proposition 4.1 states that the true leader must belong to one of these two categories.

Next, we establish a technical result, Proposition 4.3, which supports the proof of the so-called point-addition lemma (Lemma 4.5). This crucial lemma describes a relationship between configurations that differ by only one robot; it leads to Corollary 4.7, which provides a non-trivial characterization of a cognizant leader.

These preliminary results pave the way for our Gathering algorithm, which consists of several numbered rules; any active robot applies a rule based on the configuration it observes. The rest of the section is dedicated to proving the correctness of this algorithm.

Lemma 4.9 establishes several constraints on which robots can execute certain rules and under what configurations. A notable implication of Lemma 4.9 is that only an undecided or cognizant leader may move (Corollary 4.11). Furthermore, Lemma 4.13 shows that at most two robots can move simultaneously, one of which is the true leader of the swarm.

These insights greatly simplify the analysis of potential executions of our Gathering algorithm. To begin with, it is relatively straightforward to prove that, if a multiplicity point is ever formed, the Gathering problem is eventually solved (Lemma 4.15). For all other scenarios, Lemma 4.17 shows that certain undesirable configurations do not occur as a result of executing the algorithm. Applying this knowledge, we establish that if a robot executes rule 3 or rule 4.a, the Gathering problem is eventually solved (Lemmas 4.19 and 4.21).

The rest of the analysis focuses on the remaining cases, where the only rules that are ever executed are rule 4.b and rule 4.c. Lemma 4.23 shows that under these rules, the configuration remains rotationally asymmetric without multiplicity points; Lemma 4.25 addresses the case where only the leader robot moves. Finally, Theorem 4.27 puts together all previous findings and concludes the proof of correctness.

We will describe a simple Gathering algorithm for the scenario where robots have full visibility.

Let $S$ be a rotationally asymmetric finite set of points on a circle. Recall from Proposition 2.3 that all points of $S$ have distinct angle sequences, and therefore there is a unique point $p\in S$ with the lexicographically smallest angle sequence: $p$ is called the head of $S$.

The Gathering algorithm uses the fact that all robots agree on where the head of the swarm is, and the robot located at the head is elected the leader. The algorithm makes the leader move clockwise to the next robot, while all other robots wait. As soon as there is a multiplicity point, the closest robot in the clockwise direction moves counterclockwise to the multiplicity point. The process continues until all robots have gathered.

Note that this algorithm also works in ASYNCH and with non-rigid robots (i.e., robots that can be stopped by an adversary before reaching their destination). Indeed, as the leader moves toward the next robot, its angle sequence remains the lexicographically smallest, and so it remains the leader. After a multiplicity point has been created, only one robot is allowed to move at any time, and therefore no other multiplicity points are accidentally formed.

Before delving into our main algorithm, we need definitions and lemmas that will justify some of our design choices.

Let us now consider a swarm of robots with visibility range $\vartheta=\pi$ forming a rotationally asymmetric set $S$ of $n$ distinct points. We say that the true leader of the swarm is the robot located at the head of $S$.

For each robot $r$, we define the visible configuration $V(r)$ as the set of robots that are visible to $r$, and the ghost configuration as $G(r)=V(r)\cup\{r^{\prime}\}$, with $r^{\prime}$ antipodal to $r$. Note that exactly one between $V(r)$ and $G(r)$ is isometric to the “real” configuration $S$, and therefore at least one between $V(r)$ and $G(r)$ is rotationally asymmetric.

The visible head $v(r)$ is defined as follows: if $V(r)$ is rotationally asymmetric, $v(r)$ is the head of $V(r)$; otherwise, $v(r)$ is the head of $G(r)$. The ghost head $g(r)$ is defined similarly: if $G(r)$ is rotationally asymmetric, $g(r)$ is the head of $G(r)$; otherwise, $g(r)$ is the head of $V(r)$. Note that the true leader of the swarm must be either $v(r)$ or $g(r)$.

If $v(r)\neq g(r)$, and either $r=v(r)$ or $r=g(r)$, then $r$ is said to be an undecided leader: a robot that is possibly the true leader, but does not know for sure. If $r=v(r)=g(v)$, then $r$ is a cognizant leader: a robot that is aware of being the true leader of the swarm.