Gathering in the Plane of Location-Aware Robots in the Presence of Spies

by   Jurek Czyzowicz, et al.

A set of mobile robots (represented as points) is distributed in the Cartesian plane. The collection contains an unknown subset of byzantine robots which are indistinguishable from the reliable ones. The reliable robots need to gather, i.e., arrive to a configuration in which at the same time, all of them occupy the same point on the plane. The robots are equipped with GPS devices and at the beginning of the gathering process they communicate the Cartesian coordinates of their respective positions to the central authority. On the basis of this information, without the knowledge of which robots are faulty, the central authority designs a trajectory for every robot. The central authority aims to provide the trajectories which result in the shortest possible gathering time of the healthy robots. The efficiency of a gathering strategy is measured by its competitive ratio, i.e., the maximal ratio between the time required for gathering achieved by the given trajectories and the optimal time required for gathering in the offline case, i.e., when the faulty robots are known to the central authority in advance. The role of the byzantine robots, controlled by the adversary, is to act so that the gathering is delayed and the resulting competitive ratio is maximized. The objective of our paper is to propose efficient algorithms when the central authority is aware of an upper bound on the number of byzantine robots. We give optimal algorithms for collections of robots known to contain at most one faulty robot. When the proportion of byzantine robots is known to be less than one half or one third, we provide algorithms with small constant competitive ratios. We also propose algorithms with bounded competitive ratio in the case where the proportion of faulty robots is arbitrary.



There are no comments yet.


page 1

page 2

page 3

page 4


Message Delivery in the Plane by Robots with Different Speeds

We study a fundamental cooperative message-delivery problem on the plane...

Priority Evacuation from a Disk Using Mobile Robots

We introduce and study a new search-type problem with (n+1)-robots on a ...

Byzantine Dispersion on Graphs

This paper considers the problem of Byzantine dispersion and extends pre...

Asynchronous Network Formation in Unknown Unbounded Environments

In this paper, we study the Online Network Formation Problem (ONFP) for ...

A Competitive Algorithm for Online Multi-Robot Exploration of a Translating Plume

In this paper, we study the problem of exploring a translating plume wit...

The Pony Express Communication Problem

We introduce a new problem which we call the Pony Express problem. n rob...

Efficient Algorithms for Optimal Perimeter Guarding

We investigate the problem of optimally assigning a large number of robo...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

1.1 The background

A collection of mobile robots need to meet at some point of the geometric environment. This task, known as gathering or rendezvous, has been extensively investigated in the past. The gathering may be necessary, e.g., to coordinate a future task or to exchange previously acquired information.

In most formerly studied cases, robots have limited knowledge about the environment and they do not know the positions of the other robots. In the present paper, the robots are distributed in the two-dimensional Cartesian plane. They are equipped with GPS devices and they can wirelessly communicate their positions to the central authority. The central authority then informs each individual robot of the trajectory it is to follow in order to meet. However, the team of reliable robots has been contaminated with “spies” - a subset of byzantine robots, indistinguishable from the original ones, controlled by an omnipotent adversary. The role of the faulty robots is simple – delay the gathering of the reliable ones for as long as possible. A byzantine robot may report a wrong position, fail to report any, or fail to follow its assigned route. As the central authority does not recognize which robots are byzantine, it sends the travel instructions to all of them.

Our goal is to design a strategy resulting in gathering of all reliable robots within the smallest possible time. We attempt to minimize the competitive ratio – the ratio of the time required to achieve gathering of the reliable robots, to the time required for such gathering to occur under the assumption that the reliable robots were known in advance.

1.2 The model and the problem

A collection of mobile robots move at maximum unit speed within the two-dimensional plane. It is assumed that each robot in is equipped with a GPS device so it is aware of a pair of Cartesian coordinates representing its current location in the plane.

We consider the problem of gathering an unknown subset of robots. The robots of need to arrive at some time at a same point on the plane in order to complete some given task.We refer to this set of at least robots as the set of reliable robots and define of robots as the set of byzantine robots. We call this problem of gathering all reliable robots from a collection containing at most byzantine robots the Gather(, ) problem.

At the beginning, all robots in send a single message recording their starting positions to the central authority. In turn, the central authority computes a set of trajectories instructing each robot how to time their respective movements in order to achieve gathering. At this point the robots follow the trajectories provided.

The movement continues until all reliable robots meet for the first time. We imagine a successful gathering as a meeting of robots possessing pieces of information allowing them to solve some puzzle. As long as all pieces are disassembled, the puzzle remains unsolved, and the identification of useful or invalid information is not possible.

The byzantine robots may report incorrect initial locations, which can potentially adversely affect the robots’ trajectories. Clearly, this results in byzantine robots not being able to follow the assigned trajectories. However, as long as all reliable robots complete their trajectories, the schedule must lead to their gathering.

The trajectories designed by the central authority are computed uniquely on the basis of the reported set of robot positions and possibly using the knowledge of the upper bound on the number of byzantine robots. Once the robots start their movements, no adaptation to our algorithm is ever possible as no extra information may be obtained. We assume that the adversary knows in advance our algorithm and it will put the byzantine robots in the positions which result in the worst possible competitive ratio.

We note that the requirement of a central authority may be removed by allowing the robots to instead broadcast their initial positions to all other robots. In this situation all robots compute the same set of trajectories using the same algorithms.

We are interested in developing algorithms solving the Gather(, ) problem which are optimal in terms of the competitive ratio for a given initial configuration of robots, at most of which are byzantine. We define the competitive ratio of an algorithm for the specific subset of the input as the ratio of the time – the time of the first gathering of all robots belonging to – divided by – the minimal time necessary to gather the robots in , i.e. We also define the overall competitive ratio of an algorithm with input as the maximal over any subset of , i.e. We further define the optimal competitive ratio for an input as the minimal for any algorithm , i.e. For ease of presentation we will often drop the subscripts and when they are implied by context.

We define an optimal algorithm solving the Gather(, ) problem as any algorithm satisfying


1.3 Our results

We provide algorithms with constant competitive ratio for all but a small bounded region in the space of possible and pairs. In doing so we demonstrate that having knowledge of the upper bound of the number of byzantine robots in the subset (represented by the parameter ) permits fine-tuning of the gathering algorithm, resulting in better competitive ratios.

In Section 2 we consider the gathering problem for collections involving only a single byzantine robot. After developing insight into the problem we give a gathering algorithm that is optimal for any number of robots, at most one of which is byzantine. For the boundary case of three robots, one of which is byzantine, we give a closed form expression for the competitive ratio.

Section 3 presents two algorithms with small constant competitive ratio when the number of byzantine robots is bounded by a small fraction of . Specifically, we give algorthms with competitive ratios of 2 and when and respectively.

Finally, in Section 4, we give two gathering algorithms solving the problem for any and any . The competitive ratio of one of these algorithms is constant, while the other is bounded by .

We summarize the results of the paper in Table 1.3 and Figure 1.3.

tableSummary of competitive ratio bounds for various algorithms. Upper-bound Reference 1 optimal Alg. 4 2 Alg. 5 Alg. 6 Alg. 7 Alg. 8 figureCompetitive ratio bounds for various regions of the space of possible and pairs.

1.4 Related work

The gathering problem was originally introduced in [34] as a version of pattern formation (see also [21]). In operations research, Alpern [2, 3] considers the gathering of two robots, referred to as the rendezvous problem (cf. [31]). Both problems are central in theoretical computer science. The rich related literature is due to the large variety of studied settings: deterministic and randomized, synchronous and asynchronous, for labeled and anonymous agents, in graphs and geometric environments, for same-speed or distinct maximal speed agents, etc. (cf. [4, 11, 15, 22, 25, 29, 32, 36]). More recently, efficient solutions were proposed for the plane [17] and for grids [16].

In many papers on gathering the agents are a priori assumed to have limited knowledge of the environment. Moreover, most papers supposed that an agent is not aware of the positions in the environment of other agents. In the deterministic settings, one of the central studied questions was feasibility of gathering or rendezvous, cf. [21, 22, 32], which most often led to some form of the symmetry breaking problem, see [29, 31]. Surprisingly, when agents were equipped with GPS devices, knowledge of the agent’s own position in the environment permitted executing very efficient rendezvous algorithms (see [14, 15]).

Fault tolerance in mobile agent algorithms has also been extensively studied in the past, but the failures were more often related to the static elements of the environment (network nodes or links), cf. [26, 30]. The faults of the mobile agents were studied for the problems of convergence [12], flocking [35], searching [19, 20] or patrolling [18]. Faults or imperfections arriving to mobile agents performing gathering were investigated in [1, 13, 23, 27, 33]. Research in [13], [27] and [33] considered the gathering problem in the presence of inaccurate or faulty robot perception components. In [1] the initial positions of the collection is known to all robots, which operate in so called look-compute-move cycle. The feasibility of the problem, as a function of faulty robots, is investigated in [1] for crash and byzantine faults. In [23], the gathering problem is studied in an unknown graph environment and the feasibility question for byzantine faults in the strong and weak sense are investigated. The results of [23] depend on the knowledge of the upper bound on the size of the graph environment (or the absence of such knowledge).

In [9] and [10] the authors studied, similar to ours, the online rendezvous problem using GPS-equipped robots on a line, where some robots may turn out to be byzantine. However the robot movements along the line are much easier to analyze than the setting studied in the present paper. Indeed, in the case of a line, the robots move inside a corridor forcing robots to meet.

1.5 Notation

We will use to refer to a general collection of any robots (reliable and/or byzantine) and use () to represent a set of reliable (byzantine) robots only. We will represent the cardinality of a set as and will always use , and . We reserve the use of for the upper bound on the number of byzantine robots in (and, as such, it may be that ).

As we are dealing with robots in the plane we will use the term robot and point interchangeably. When it is required to refer to a particular robot / robots in a set we will use the capital letters , , and . We use the capital letter to refer to meeting points of robots.

We let the distance between any two points and be , and use to represent the directed line segment joining and . We will refer to the individual coordinates of a point using the subscripts and , e.g., .

We define as the minimum enclosing circle (MEC) of a set of points , and let be the supporting set of . It is a well known property that [8]. We further define the radius and of to be the radius and center of the MEC of respectively.

Finally, we let represent the furthest-point Voronoi diagram (FVD) of the point set , and, for a point in , we let be the cell / region in belonging to the point . See [6] for a description of the properties of the FVD.

2 One byzantine robot

In this section we develop optimal algorithms for the case that there is only a single byzantine robot within the collection .

To do this we will need to consider subsets of containing robots and we therefore introduce some convenient notation. We let , represent the subsets of robots that can be formed from and we define an ordering for the in such a way that . For the sake of brevity, we use and for the remainder of the section.

We start with the following (trivial) lemma concerning the optimal meeting time of any set of robots in the plane,

Lemma 1

The minimal time necessary to gather any set of robots is .

An immediate consequence of the above lemma is the following optimal algorithm for gathering a group of reliable robots.

1:Set ;
2:All robots in move at full speed towards ;
3:The algorithm terminates when the last robot in reaches ;
Algorithm 1 (Optimal Gather(, ))

To get an idea of how different the problem is when we consider the presence of even a single byzantine robot, let us run the above algorithm on the two inputs depicted in Figure 2.

figureInputs for example analysis of competitive ratio. In both cases the robots , , and move directly towards the center of the minimum enclosing circle of .

figureSetup for the proof of Lemma 4.

For a given input the adversary can choose at most one of the robots , , and to be byzantine. We assume that they will do so in such a way as to maximize the competitive ratio of our algorithm. Which robot would they choose?

In the case a) the choice is not so obvious, and, indeed, the competitive ratios for all three possibilities are not very different. In the case b), however, there is an obvious choice: the adversary would make byzantine since the robots and were initially very close but travelled far before meeting.

This exercise, although simple, highlights an important observation – the “closest” robots should meet first. It turns out that, when , we can formalize this statement111When there are cases when this is not true..

Lemma 2

Consider an optimal algorithm solving the Gather(, ) problem for the input . Let be the first group of robots to meet. Then , i.e. is the group of robots in with the smallest enclosing circle.


(Lemma 2) Assume we have an optimal algorithm such that – the first group to gather using – is not the group with the smallest enclosing circle, i.e. . In this case an adversary chooses . Since the minimal time at which all robots can gather is , the competitive ratio of is .

Now apply Algorithm 1 to solve this Gather(, ) problem and observe that the competitive ratio of this algorithm is equal to . This implies that is, at best, as good as Algorithm 1. However, Algorithm 1 is not an optimal algorithm solving the Gather(, ) problem. Thus, we must conclude that is not an optimal algorithm either – a contradiction. ∎

So, we now know that we have to make the smallest group of robots meet first. What choice does this leave the adversary? Well, naturally, they would choose the byzantine robots in such a way that the second-smallest group of robots should have gathered. This observation leads us to the following:

Theorem 2.1

The competitive ratio of any algorithm solving the Gather(, ) problem with input is at least .


(Theorem 2.1) Consider an algorithm solving the Gather(, ) problem with input . Let be the first group of robots to meet using , and let be the group of reliable robots. Observe that an adversary can always choose to make such that, effectively, all robots must meet before terminates. Let the time at which this happens be . Lemma 1 tells us that is the minimum time necessary to gather all robots and we thus have . The competitive ratio of is therefore at least . There are two cases to consider: and the adversary chooses such that , or, and the adversary chooses such that . ∎

At this point we can make a useful observation: an optimal gathering algorithm ends either at the moment the first group of robots meet or the moment all robots meet. Furthermore, at the moment of the first meeting, all robots are located at either one of only two positions. Thus, in an optimal algorithm, we must send these remaining two groups of robots directly towards each other. We can claim the following:

Lemma 3

An optimal algorithm solving the Gather(, ) problem can be completely described by the single point at which the first robots gather.

Corollary 1

(Lemma 3) There is an optimal algorithm solving the Gather(, ) problem following the strategy given in Algorithm 2.

1:All robots start moving at full speed towards some point ;
2:if The first robots to arrive at are all reliable; then
3:     The algorithm terminates ;
5:     Let be the midpoint of and the position of the single robot that has not yet arrived at (at the time the first group of robots gather at ) ;
6:     All robots move at full speed towards . The algorithm terminates once they meet ;
Algorithm 2 (General Gather(, ) )

Corollary 1 reduces the task of searching for an optimal algorithm to the conceptually simpler task of searching for some optimal meeting point . The following lemma tells us how to find this point:

Lemma 4

Consider an optimal algorithm solving the Gather(, ) problem for the input parameterized by the point . Let the group represent the first group of robots to gather at the point . Then the point lies on the perpendicular bisector of the two robots in furthest from .


(Lemma 4) Let and be the last two robots in that reach and let be the single robot in that is not contained in . We argue by contradiction and assume that the point does not lie on the perpendicular bisector of and . Without loss of generality assume that reaches before . This situation is depicted in Figure 1.

If we let the group of reliable robots be then the competitive ratio of is

Now consider the algorithm which replaces the point in with the point on the segment located some small distance in the direction of such that and are still the last two robots to arrive at (and arrives before ). The competitive ratio of this new algorithm is,

We claim that . It is obvious that . Thus we need to show that . Indeed, observe that We can thus conclude that which is in contradiction to our assumption that is an optimal algorithm. ∎

As a last step we derive an expression for the competitive ratio of an optimal Gather(, ) algorithm.

Lemma 5

An optimal algorithm following the strategy in Algorithm 2 solves the Gather(, ) problem for the input with competitive ratio where is one of the two points in furthest from and is the point in that is not in .


(Lemma 5) Lemma 2 tells us that the first group of robots to gather is the group . Thus, if is the point in that is furthest from , then, in the case that , the competitive ratio of the algorithm is .

If , then, if is the single point in that is not in , the algorithm terminates after time . Thus, the overall competitive ratio of the algorithm is as required. ∎

We are now ready to present our main result:

1:Set as the single robot in that is not in ;
2:Determine the Furthest-point Voronoi diagram of the point set ;
3:Set , and ;
4:for each edge in  do
5:     Set and as the two points such that the edge separates and ;
6:     Determine the point on that minimizes
7:     if  then
8:         Set and      return ;
Algorithm 3 (Optimal Gather(, ) point)
1:The robots perform Algorithm 2 with the point determined by Algorithm 3;
Algorithm 4 (Optimal Gather(, ) )
Theorem 2.2

Algorithm 4 is an optimal algorithm solving the Gather(, ) problem with input . The complexity of the algorithm is .


(Theorem 2.2) By Lemmas 2 and 4 we know that the optimal point must lie on the perpendicular bisector of two points in that are furthest from . In Algorithm 3 we are choosing to be on one of the edges of the FVD of . Thus, by construction, does in fact lie on the perpendicular bisector of two points in that are furthest from .

The fact that the algorithm is optimal follows from Lemma 5 and the definition of an optimal algorithm given in Eq. (1).

The complexity of the algorithm is since we need to determine the FVD of which can be found optimally in time [6]. Minimizing the quadratic equation given in Lemma 5 on a line segment can be done in constant time, and this needs to be done only once for each of the edges of the FVD. ∎

It does not seem likely that a closed form expression can be derived for the competitive ratio of Algorithm 4 for arbitrary . However, in the boundary case that and this is possible. The complete solution of the Gather(, ) is presented in the appendix and the results are reproduced below:

Theorem 2.3 ()

Algorithm 2 optimally solves the Gather(, ) problem with input of side lengths and respective angles if the point is chosen such that , , and if , otherwise

The competitive ratio of the algorithm equals if , otherwise it is .

3 Bounded number of byzantine robots

We now consider instances of the Gather(, ) problem when the value of is a small constant fraction of . We give two algorithms corresponding to the cases that , and . In both cases we show that a small constant competitive ratio is attainable.

We start with the case that . We have the following:

Theorem 3.1

Consider the Gather(, ) problem with input and for any . Then, there is a gathering algorithm solving this problem with competitive ratio at most 2. The complexity of the algorithm is .


(Theorem 3.1) We will make use of the centerpoint theorem (see [24] [Theorem 4.3]) which states that any finite set of points in admits a point (a centerpoint) such that any open half-space avoiding contains at most points of . In particular, for , this implies that we can always determine a such that any line through partitions into two sets each with at least robots. This result inspires the following algorithm,

1:The robots compute a centerpoint of the set of robots;
2:All robots move directly towards ;
3:The algorithm terminates once the final reliable robot reaches ;
Algorithm 5 (Move to centerpoint)

Consider the reliable robot that is initially furthest away from the point determined in Algorithm 5. Draw a line through perpendicular to the line segment (as done in Figure 1). Observe that, since is a centerpoint, there are at least robots on either side of . Furthermore, by assumption, is strictly less than and we are thus guaranteed to have a reliable robot on either side of . Consider any reliable robot on the opposite side of as and note that the robot is at least a distance away from the robot . The competitive ratio of Algorithm 5 is therefore at most .

The complexity bound follows from the need to determine the centerpoint of the collection. The centerpoint of a set of points can be determined in time using an algorithm by Jadhav [28].

Figure 1: Setup for the proofs of Theorem 3.1 (left) and Theorem 3.2 (right).

The centerpoint theorem applies generally to any -dimensional space and we thus have the following corollary,

Corollary 2

(Theorem 3.1) Consider the Gather(, ) problem in for for any . Then, there exists a gathering algorithm with competitive ratio at most 2.

Now consider the case that . We claim the following:

Theorem 3.2

Consider the Gather(, ) problem with input and for any . Then, there is a gathering algorithm solving this problem with competitive ratio at most . The complexity of the algorithm is .


(Theorem 3.2) The proof is based on the following algorithm,

1:The robots compute a line that partitions the robots into two disjoint sets each containing at least robots;
2:The robots compute a line , perpendicular to , that also partitions the robots into two disjoint sets each containing at least robots;
3:The robots move towards the point that is the intersection of and .
4:The algorithm terminates once the final reliable robot reaches ;
Algorithm 6 (Move to intersection)

First, we note that, in Algorithm 6, the existence of the lines and is ensured as a result of the ham-sandwich theorem (see [24] [Theorem 4.7]).

Now consider the four open regions , , , and created by the intersection of and (as depicted in Figure 1). Note that, by assumption, we have and we are therefore guaranteed to have at least one reliable robot in each of the regions and , or in each of the regions and .

Consider the reliable robot that is furthest from and assume without loss of generality that is located in the region . If there is a reliable robot in then we have which implies that . If there is not a reliable robot in then there must be reliable robots and in and respectively. Let and let us adopt a coordinate system such that and . Observe that and . Thus, and .

The two lines and may be found in linear time by first choosing some line onto which we project the points in . We then set as the line perpendicular to dividing the points on in half (i.e. we need to find the median, time [7]). To find we repeat with replaced with .

4 Arbitrary number of byzantine robots

In this section we consider algorithms that solve the Gather(, ) for any and any . We give two algorithms: the first, grid-rendezvous, is adapted from [14] and gives a constant competitive ratio independent of . The second, shrinking-the-shortest-interval (SSI), gives a competitive ratio dependent on .

4.1 Grid rendezvous

We start with the grid-rendezvous algorithm which is a direct application of Algorithm 3 in [14]. The algorithm was originally designed to solve the rendezvous problem of two robots unaware of the other’s position (but sharing a common coordinate system).

The idea of the algorithm is to calculate a hierarchy of grids which partition the plane into non-overlapping cells. The robots then travel through a series of potential meeting points located at the centers of ever larger cells from successive grids in .

In detail, each exactly partitions the plane into square cells of side length such that one of the cells in , the central cell, has its center at the origin. In order for the partition to be exact each cell is defined to include its top and right edges, as well as its top-right vertex (in addition to its interior).

We can nearly apply Algorithm 3 as given in [14]. We only need to specify the finest grid division that will be used by the robots. Let be the size of this finest grid cell. We present (the slightly modified) Algorithm 3 from [14] below.

1:The robots choose a much smaller than the closest pair of robots in the set;
2:The robots compute the hierarchy of grids ;
3:repeat for and for each robot in
4:     Set equal to the cell of containing your initial position ;
5:     Move to the center of ;
6:     Wait until time has passed since the start of the current iteration;
7:until Gathering completed
Algorithm 7 (Grid-rendezvous [14])

The rendezvous time of the above algorithm is given by Corollary 9 in [14]. Using this time-bound we can state the following:

Theorem 4.1

Consider the Gather(, ) problem for the input . Assume that the robots and are the closest pair of robots in . Then the competitive ratio of Algorithm 7 is where can be made as small as one chooses. The complexity of this algorithm is222The complexity of the algorithm is entirely due to the determination of . .


(Theorem 4.1) Choose any two robots and in and assume that all distances are scaled such that . Then Corollary 9 from [14] tells us that the robots and gather in time .

Let be the subset of reliable robots and consider the two robots and which are the most distant in . Then the minimal time necessary to gather the robots in is at least . The competitive ratio of Algorithm 7 is therefore In the worst case, and the robots and were the closest pair in .

The complexity of the algorithm is as one needs to find the closest pair of points in in order to determine a satisfactory grid division . The closest pair in a set of points can be found optimally in time [5]. ∎

4.2 Shrink-shortest-interval

Consider the following algorithm, generalized from Algorithm 3 in [10]:

2:     Determine the two closest robots and in that are not at the same position;
3:     Set as the midpoint of and ;
4:     Set .
5:     All robots move a distance towards ;
6:until All robots in gather.
Algorithm 8 (Shrink-shortest-interval)

We claim the following:

Theorem 4.2

Algorithm 8 solves the Gather(, ) problem for the input with competitive ratio at most . The complexity of the algorithm is .

To prove this we will need the following lemma:

Lemma 6

Consider any point and set of points such that is the closest point to , and is the furthest point from . Let be the positions of the points in after moving them a distance towards the point . Then,


(Lemma 6) Let and be the center and radius of respectively and adopt a coordinate system which places at the origin and oriented such that the line segment is along the positive -axis. Then and, for any point on the border of we have where is the angle between and the -axis.

Define the point as the point obtained by moving the point a distance towards . We can write , and, . Observe that the equations for , and describe a parametric curve that is completely contained within a circle of radius . Thus, for any point , we can conclude that .

Now consider the case that is inside . In this case such that the curve defined by , and is completely contained within a circle of radius . ∎


(Theorem 4.2) Consider the Gather(, ) problem for the input , let be the subset of that contains only reliable robots, and let be the (actual) number of byzantine robots in .

Let and represent the unique positions of the robots in and after the iteration of the algorithm, and let . We also let be the midpoint and be half the distance between the closest pair of points in . Finally, set be the furthest point from .

Now, if in the iteration the midpoint lies within then by Lemma 6 we have . If we assume that their are iterations of this kind then the time needed to complete these iterations is at most However, observe that such that .

If does not lie within , then we can only say that . However, observe that Algorithm 8 always gathers the two closest robots in and we know that there is at least one pair of robots in with separation no greater than . This tells us that . Furthermore, since all reliable robots are, by definition, within , it is impossible for to simultaneously be: a) the midpoint of two reliable robots, and, b) lie outside of . This implies that this type of iteration can occur at most times (as it reduces the number of byzantine robots by one each time it occurs). Thus, the time needed to complete these iterations is at most .

Combining and gives us a bound on the total time necessary to complete the algorithm. We get . The bound on the competitive ratio follows from the fact that , and is the minimal time necessary to gather the robots in .

The complexity bound follows from the fact that we need to determine the closest pair of points times. ∎

In the case that we have no knowledge of the number of byzantine robots in our collection (i.e. ) the algorithm has a worst-case bound on the competitive ratio of . This reflects the fact that an adversary, if allowed, would always choose robots in to be byzantine. It is worth noting, however, that it was not necessary to know in the proof of Theorem 4.2 and thus the algorithm has a competitive ratio that is bounded by the actual number of byzantine robots in . That is, for a particular instance such that we have .

5 Conclusion

In this paper we analyzed the gathering problem for robots in the plane at most of which, , are byzantine. The robots were equipped with GPS and they could communicate their positions to a central authority. Several algorithms were designed with competitive ratio depending on the number of byzantine robots and the knowledge available to the robots.

In addition to improving the competitive ratio and/or complexity of our algorithms, several interesting open problems remain. In particular, one could consider models that allow the robots to communicate/exchange their positions at any time during the gathering process. Additionally, it would be interesting to consider robot gathering (in the presence of byzantine robots) under local (limited) communication range.


  • [1] N. Agmon and D. Peleg. Fault-tolerant gathering algorithms for autonomous mobile robots. SIAM Journal on Computing, 36(1):56–82, 2006.
  • [2] S. Alpern. The rendezvous search problem. SIAM Journal on Control and Optimization, 33(3):673–683, 1995.
  • [3] S. Alpern. Rendezvous search: A personal perspective. Operations Research, 50(5):772–795, 2002.
  • [4] S. Alpern and S. Gal. The theory of search games and rendezvous, volume 55. Springer, 2003.
  • [5] Jon Louis Bentley. Multidimensional divide-and-conquer. Commun. ACM, 23(4):214–229, April 1980.
  • [6] Mark de Berg, Otfried Cheong, Marc van Kreveld, and Mark Overmars. Computational Geometry: Algorithms and Applications. Springer-Verlag TELOS, Santa Clara, CA, USA, 3rd edition, 2008.
  • [7] Manuel Blum, Robert W. Floyd, Vaughan Pratt, Ronald L. Rivest, and Robert E. Tarjan. Time bounds for selection. Journal of Computer and System Sciences, 7(4):448 – 461, 1973.
  • [8] George Chrystal. On the problem to construct the minimum circle enclosing n given points in the plane. Proceedings of the Edinburgh Mathematical Society, 3:30–33, 1885.
  • [9] H. Chuangpishit, J. Czyzowicz, R. Killick, E. Kranakis, and D. Krizanc. Optimal rendezvous on a line by location-aware robots in the presence of spies. (submitted), 2017.
  • [10] H. Chuangpishit, J. Czyzowicz, E. Kranakis, and D. Krizanc. Rendezvous on a line of faulty, location-aware robots. In Proceedings 13th International Symposium on Algorithms and Experiments for Wireless Networks, Vienna, Austria, 2017. Springer, LNCS.
  • [11] M. Cieliebak, P. Flocchini, P. Prencipe, and N. Santoro. Solving the robots gathering problem. In Automata, Languages and Programming, 30th International Colloquium, ICALP 2003. Proceedings, pages 1181–1196, Eindhoven, The Netherlands, June 30 - July 4, 2003. Springer, LNCS.
  • [12] R. Cohen and D. Peleg. Convergence properties of the gravitational algorithm in asynchronous robot systems. SIAM J. Comput., 34(6):1516–1528, 2005.
  • [13] R. Cohen and D. Peleg. Convergence of autonomous mobile robots with inaccurate sensors and movements. SIAM Journal on Computing, 38(1):276–302, 2008.
  • [14] A. Collins, J. Czyzowicz, L. Gasieniec, A. Kosowski, and R. Martin. Synchronous rendezvous for location-aware agents. In International Symposium on Distributed Computing, pages 447–459, Rome, Italy, September 20-22, 2011. Springer, LNCS.
  • [15] A. Collins, J. Czyzowicz, L. Gasieniec, and A. Labourel. Tell me where I am so I can meet you sooner. In International Colloquium on Automata, Languages, and Programming, pages 502–514, Bordeaux, France, July 6-10, 2010. Springer, LNCS.
  • [16] A. Cord-Landwehr, M. Fischer, D. Jung, and F. Meyer auf der Heide. Asymptotically optimal gathering on a grid. In Proceedings of the 28th ACM Symposium on Parallelism in Algorithms and Architectures, SPAA 2016, pages 301–312, Asilomar State Beach/Pacific Grove, CA, USA,, July 11-13, 2016. ACM.
  • [17] P. Courtieu, L. Rieg, S. Tixeuil, and X. Urbain. Certified universal gathering in for oblivious mobile robots. In Distributed Computing - 30th International Symposium, DISC 2016, Proceedings, pages 187–200, Paris, France, September 27-29, 2016. Springer, LNCS.
  • [18] J. Czyzowicz, L. Gasieniec, A. Kosowski, E. Kranakis, D. Krizanc, and N. Taleb. When patrolmen become corrupted: Monitoring a graph using faulty mobile robots. In Algorithms and Computation - 26th International Symposium, ISAAC 2015, Proceedings, pages 343–354, Nagoya, Japan, December 9-11, 2015. Springer, LNCS.
  • [19] J. Czyzowicz, K. Georgiou, E. Kranakis, D. Krizanc, L. Narayanan, J. Opatrny, and S. M. Shende. Search on a line by byzantine robots. In 27th International Symposium on Algorithms and Computation, ISAAC 2016, pages 27:1–27:12, Sydney, Australia, December 12-14, 2016. Springer, LNCS.
  • [20] J. Czyzowicz, E. Kranakis, D. Krizanc, L. Narayanan, and J. Opatrny. Search on a line with faulty robots. In Proceedings of the 2016 ACM Symposium on Principles of Distributed Computing, PODC 2016, pages 405–414, Chicago, IL, USA, July 25-28, 2016. ACM.
  • [21] S. Das, P. Flocchini, N. Santoro, and M. Yamashita. On the computational power of oblivious robots: forming a series of geometric patterns. In Proceedings of the 29th PODC, pages 267–276, Zurich, Switzerland, July 25-28, 2010. ACM.
  • [22] G. De Marco, L. Gargano, E. Kranakis, D. Krizanc, A. Pelc, and U. Vaccaro. Asynchronous deterministic rendezvous in graphs. Theoretical Computer Science, 355(3):315–326, 2006.
  • [23] Y. Dieudonné, A. Pelc, and D. Peleg. Gathering despite mischief. ACM Transactions on Algorithms (TALG), 11(1):1, 2014.
  • [24] H. Edelsbrunner. Algorithms in combinatorial geometry, volume 10. Springer Science & Business Media, 2012.
  • [25] P. Flocchini, G. Prencipe, N. Santoro, and P. Widmayer. Gathering of asynchronous oblivious robots with limited visibility. In STACS 2001, 18th Annual Symposium on Theoretical Aspects of Computer Science, Proceedings, pages 247–258, Dresden, Germany, February 15-17, 2001. Springer, LNCS.
  • [26] J. Hromkovič, R. Klasing, B. Monien, and R. Peine. Dissemination of information in interconnection networks (broadcasting & gossiping). In Combinatorial network theory, pages 125–212. Springer, 1996.
  • [27] T. Izumi, S. Souissi, Y. Katayama, N. Inuzuka, X. Défago, K. Wada, and M. Yamashita. The gathering problem for two oblivious robots with unreliable compasses. SIAM Journal on Computing, 41(1):26–46, 2012.
  • [28] S. Jadhav and A. Mukhopadhyay. Computing a centerpoint of a finite planar set of points in linear time. Discrete & Computational Geometry, 12(3):291–312, Sep 1994.
  • [29] E. Kranakis, D. Krizanc, and S. Rajsbaum. Mobile agent rendezvous: A survey. In Structural Information and Communication Complexity, 13th International Colloquium, SIROCCO 2006, Proceedings, pages 1–9, Chester, UK,, July 2-5, 2006. Springer, LNCS.
  • [30] N. A. Lynch. Distributed algorithms. Morgan Kaufmann, 1996.
  • [31] A. Pelc. Deterministic rendezvous in networks: Survey of models and results. In Proceedings of 29th DISC, pages 1–15, Rome, Italy, September, 20-22, 2011. Springer, LNCS.
  • [32] G. Prencipe. Impossibility of gathering by a set of autonomous mobile robots. Theor. Comput. Sci., 384(2-3):222–231, 2007.
  • [33] S. Souissi, X. Défago, and M. Yamashita. Gathering asynchronous mobile robots with inaccurate compasses. In Principles of Distributed Systems (OPODIS), pages 333–349, Bordeaux, France, 12-15 December, 2006. Springer, LNCS.
  • [34] I. Suzuki and M/ Yamashita. Distributed anonymous mobile robots: Formation of geometric patterns. SIAM Journal on Computing, 28(4):1347–1363, 1999.
  • [35] Y. Yang, S. Souissi, X. Défago, and M. Takizawa. Fault-tolerant flocking for a group of autonomous mobile robots. Journal of Systems and Software, 84(1):29–36, 2011.
  • [36] X. Yu and M. Yung. Agent rendezvous: A dynamic symmetry-breaking problem. In ICALP, pages 610–621, Kyoto, Japan, 6-10 July, 1996. Springer, LNCS.

Appendix 0.A Gathering three robots

Observe that we can describe an instance of the Gather(, ) problem by the triangle whose vertices specify the initial positions of the three robots for which gathering should occur. Thus, throughout this section, we let , , and be the side lengths of , and set the angles , and . Without loss of generality we assume that .

With this description of the problem Lemmas 2, 4, 5, and Theorem 2.1 take the following simple forms:

Corollary 3

(Lemma 2 and Lemma 4) An optimal algorithm solving the Gather(, ) problem with input has the robots and meet first at some point on their perpendicular bisector.

Corollary 4

(Theorem 2.1 and Lemma 5) An optimal algorithm solving the Gather(, ) problem with input has competitive ratio


and this is at least .

At this point we could simply apply Algorithm 4 to determine the optimal point for this problem, however, in order to derive a closed form expression for the point we take a different approach. We claim the following:

See 2.3


(Theorem 2.3) First consider the case that (see Figure 0.A, top). In this case lies on the edge and we have and . Thus, by Eq. (2), we have, . We claim that the condition implies that . Indeed, observe that which we can rewrite as (where we have invoked the sine law in the last step).

figureSetup for the proof of Theorem 2.3. The shaded gray region indicates those positions of such that . Right: . Left:

Now consider the case that (see Figure 0.A, bottom) and define , and such that . We note that, over the interval , is a monotone continuous decreasing function of and is a monotone continuous increasing function of . Furthermore, when and when . We can thus conclude that the optimal competitive ratio is given when , and the optimal point is determined from the following:


Now, let us choose a coordinate system such that the midpoint of and is at the origin, and the positive -axis lies along the perpendicular bisector of and . In this coordinate system , , , and where we have introduced the parameter . Thus, we can write , and . Plugging these into Eq. (3) gives us (after some manipulation) the following quadratic equation where is the area of . Solving for we get (after some manipulation),

Finally, by applying Heron’s formula for the area of a triangle, and noting that , we get our final result:

It is interesting to note that in some cases () it was possible to achieve the lower-bound given in Theorem 2.1. This turns out to be true for the general case as well, and, in fact, it is possible to specify under which conditions this occurs:

Lemma 7

Consider an input such that . Let be the line segment defined by the two points in , and let be the convex region defined by the intersection of all circles with centers given by the points in and radii given by . Then, if intersects with , the competitive ratio of Algorithm 4 is .


(Lemma 7) Define the convex region as above and observe that since, at minimum, it contains the center of .

Now, we let in and be the two points that are also in . Observe that for any point on the segment we have . Thus, if is (one of) the furthest point(s) from , the algorithm terminates in at most time.

Now observe that for any point the distance between and any point in is at most . In particular, for the point , we have .

Thus, if it happens that: a) and intersect, and, b) we can choose in in such a way that is (one of) the furthest point(s) from , then, the competitive ratio of Algorithm 2 is

Now, observe that there must be a point in such that is furthest from it. One such point, for example, is the point of intersection of the segment and the circle of radius centered on . In order to get the optimal point we simply need to choose the that minimizes the quadratic given in Lemma 5 on the portion of contained in the region of belonging to the point . ∎