Elsevier

Theoretical Computer Science

Volume 939, 4 January 2023, Pages 261-291
Theoretical Computer Science

Gathering a Euclidean closed chain of robots in linear time and improved algorithms for chain-formation

https://doi.org/10.1016/j.tcs.2022.10.031Get rights and content

Highlights

  • A closed chain of disoriented robots with limited visibility and lights (

    Image 1
    ) can be gathered in linear time.

  • The first linear time gathering algorithm for disoriented robots with limited visibility in the Euclidean plane.

  • Any constant-factor approximation of the Chain-Formation problem can be achieved in linear time (LUMI robots).

Abstract

We consider formation problems for chains of disoriented, mobile robots with limited visibility operating in asynchronous rounds (Async). More precisely, we study the Chain-Formation and the Gathering problem. Chain-Formation considers a chain of robots between two stationary outer robots: Each inner robot has two identifiable neighbors, and the goal is to arrange the robots on the line segment connecting the outer robots. The Gathering problem considers a closed chain (without outer robots) and demands all robots to gather on a single, not predefined point. The robots move in the Euclidean plane and are luminous, i.e., equipped with a light visible to the neighboring robots. At each point in time, the light can have one out of a constant number of colors.

We introduce a family of algorithms inspired by the Hopper algorithm [1]. For the Chain-Formation problem, we modify the Hopper algorithm so that we can guarantee a (1+ε)-approximation to the optimal chain length (instead of a 2-approximation). Our main result is an asymptotically optimal algorithm for Gathering of a closed chain of disoriented, luminous robots with limited visibility in the Euclidean plane. All algorithms have a worst-case optimal runtime of O(n).

Introduction

The study of small mobile entities – denoted as robots – is of interest in various research fields, including robotics, control theory, artificial intelligence, data science, and distributed computing. In this work, we study specific problems for such kinds of robot systems from the perspective of distributed computing, focusing on the runtime efficiency of the presented algorithms.

Many robot coordination problems aim to arrange n point-shaped robots in the Euclidean plane in a specific formation. In this work, we investigate special types of robot formation tasks, so-called chain formation problems where the robots take the role of communication relays. Such communication relays are used to establish a communication infrastructure in hazardous areas [3], [4], [5], [6]. Either the relays connect two distinguished endpoints (an open chain), or the relays are interconnected such that the chain connections form a cycle (a closed chain). In open chains, the distinguished endpoints are denoted as outer robots while all other robots are inner robots. The practical nature of such chain systems inspired several researchers to design efficient algorithms for formation problems of robot chains [1], [7], [8], [9], [10], [11], [12], [13]. Examples of such problems are the Chain-Formation and the Gathering problem. In the Chain-Formation problem, an open chain is considered, and all inner robots are required to arrange themselves on a straight line between the two outer robots that do not move. Gathering demands a closed chain of n robots to gather at the same, not predefined position. In general, the capabilities of robots needed to solve such formation problems are of particular interest. Both Chain-Formation and Gathering can be solved (or at least converging algorithms exist) under very weak robot capabilities: Disoriented robots (no agreement on local coordinate systems), limited visibility (each robot can only perceive other robots up to a constant distance) and obliviousness (robots do not have any persistent memory). In addition to the individual robot capabilities, the time model also plays a role. Most commonly, the LCM model is considered. It assumes that robots operate in discrete cycles (rounds) consisting of three steps: Look, Compute, and Move. These cycles are controlled by a scheduler and can either be fully synchronized (Fsync), semi-synchronized (Ssync), or completely asynchronous (Async). Time is measured in epochs, where an epoch is the smallest number of rounds such that each robot can complete its LCM cycle at least once. Under the Fsync scheduler, an epoch is equal to a round. The scheduler affects, for instance, the solvability of the Gathering problem: While Gathering of disoriented, oblivious robots can be solved under the Fsync scheduler, this is impossible for the Ssync and Async schedulers [14]. Whenever oblivious robots that move in LCM cycles are considered, this is also known as the OBLOT model.

In addition to the question on the solvability of formation problems, the runtime of formation algorithms is of particular interest. Central research questions are: How fast can specific formation problems be solved? How do robot capabilities and the synchronicity of the robot cycles affect the runtime? For disoriented robots with limited visibility, an algorithm for the Chain-Formation problem exists that converges to the optimal configuration in O(n2log(n/ε)) rounds [15]. The parameter ε determines how close the configuration is to the optimum. Under the same robot capabilities (without an open or closed chain), it is known that Gathering can be solved in O(n2) rounds under the Fsync scheduler [16]. For the algorithm, a lower bound of Ω(n2) rounds holds. The lower bound for this algorithm even holds for the closed chain model, motivating our study of a linear time algorithm for a closed chain in this work. In summary, it can be said that both problems can be solved (or algorithms at least converge to an optimal solution) with quadratic runtime under the assumption of disoriented and oblivious robots with limited visibility.

By loosening the assumption of oblivious robots and allowing the robots to make use of locally visible lights (the LUMI model [17]), faster runtimes can be achieved. The LUMI model equips each robot with a light and a set of colors. Only one color can be active in every round. Neighboring robots can perceive the light. Moreover, the light is persistent: It is still active in the next round (unless intentionally switched off). In a setting comparable to the LUMI model, the Hopper algorithm for the Chain-Formation problem has been introduced [1]. The Hopper algorithm uses so-called run-sequences that allow a locally sequential movement of the robots. These run-sequences can be easily implemented in the LUMI model. The Hopper algorithm achieves a 2-approximation of the optimal configuration in O(n) rounds under the Fsync scheduler and is the main inspiration for our work. Also, for the Gathering problem of disoriented robots with limited visibility located on the two-dimensional grid, the LUMI model could be used to design linear time algorithms: One algorithm for closed chains [7], and another algorithm for arbitrarily connected swarms [18]. Both algorithms consider the Fsync scheduler.

We restrict the discussion of related work to results about the Chain-Formation and the Gathering problem with a particular focus on results that study the runtime of the algorithms. For a comprehensive overview of robot models, different formation problems, algorithms, and analyses, we refer the reader to the recent survey [19].

The Chain-Formation problem has been initially introduced by [9] for robots located on a line (one-dimensional configurations). For the Go-To-The-Middle algorithm that moves inner robots to the midpoint between their neighbors, it has been shown that it needs O(n2log(n/ε)) rounds to converge to the optimal configuration under the Fsync scheduler. Assuming Ssync, a runtime of O(n5log(n/ε)) epochs has been proven [9]. Recently, the Ssync bound has been improved to O(n2log(n/ε)) epochs [20]. The result has been transferred to two-dimensional configurations [15] with the same upper runtime bound in Fsync [15] and Ssync [20]. A close lower bound of Ω(n2log(1/ε)) for the algorithm was proven in [8]. By considering locally visible states (comparable to the LUMI model) it was possible to design the Hopper algorithm – a linear time algorithm that achieves a 2-approximation of the optimal configuration (also under the Fsync scheduler) [1]. In addition, the Hopper algorithm assumes that the two endpoints of the chain can be distinguished (both execute different algorithms). The Hopper algorithm has greatly inspired the work in this paper.

Note that recently a variant of the Chain-Formation problem – Max-Chain-Formation – has been introduced [13]. In contrast to Chain-Formation, the outer robots can move, and the goal is to arrange the robots on a straight line of length n1 (given a viewing range of 1). Assuming one-dimensional configurations, the Max-Go-To-The-Middle algorithm has the same upper and lower runtime bounds as Go-To-The-Middle for Chain-Formation. However, in some situations, the algorithm does not converge to the optimal configuration. Starting in two-dimensional configurations, an arbitrarily high runtime might occur [13].

Concerning the Gathering problem, there is the Go-To-The-Center algorithm [21] that solves Gathering of disoriented robots with limited visibility in the OBLOT model within Θ(n2) rounds assuming the Fsync scheduler [16]. The same runtime can be achieved for robots located on a two-dimensional grid [22]. It is conjectured that both algorithms are asymptotically optimal; thus, Ω(n2) is also a lower bound for any algorithm that solves Gathering in this model. Faster runtimes could only be achieved by assuming agreement on one or two axes of the local coordinate systems or considering the LUMI model. In [23], an universally optimal algorithm with runtime Θ(DE) for robots in the Euclidean plane assuming one-axis agreement in the OBLOT model is introduced. DE denotes the initial configuration's Euclidean diameter (the largest distance between any pair of robots). Beyond the one-axis agreement, their algorithm crucially depends on the distinction between the viewing range of a robot and its connectivity range: Robots only consider other robots within their connectivity range as their neighbors but can see farther, up to their viewing range, beyond. Notably, this algorithm also works under the Async scheduler.

Assuming disoriented robots, the algorithms that achieve a runtime of o(n2) are developed under the LUMI model and assume robots that are located on a two-dimensional grid: There exist two algorithms having an asymptotically optimal runtime of O(n); one algorithm for closed chains [7] and another one for arbitrary (connected) swarms [18]. Following the notion of [7], we consider a closed chain of robots in this work. In a closed chain, the robots form a winding, possibly self-intersecting, chain where the distance between two neighbors is upper bounded by the connectivity range, and the robots can see a constant distance along the chain in each direction, denoted as the viewing range. The main difference between a closed chain and arbitrary (connected) swarms is that in the closed chain, a robot only observes a constant number of robots in each direction along the chain, while in arbitrary swarms, all robots in the viewing range of a robot are considered. Interestingly, the lower bound of the Go-To-The-Center algorithm [16] also holds for the closed chain model.

When switching to a continuous time model, all three problems (including Max-Chain-Formation) can be solved without lights in asymptotically optimal time O(n) [10], [13], [24]. Regarding the Gathering problem, an entire class of continuous algorithms has been studied in [26] (including algorithms with a slightly larger runtime of O(nDE)).

We introduce a family of algorithms for disoriented robots with limited visibility assuming the LUMI model and the Async scheduler. All algorithms use the notion of a run-state introduced in [1]. A run-state is a state that allows a robot to move and is sequentially forwarded along the chain. The forwarding process is denoted as a run-sequence. Thus, a locally sequential movement is ensured with the help of a visible light. The results can be summarized as follows:

Chain-Formation:  We show improved algorithms for the Chain-Formation problem. Our ε-Hopper algorithm is able to achieve a (1+ε)-approximation of the optimal configuration for an arbitrary constant 0<ε1 in O(nε) epochs. Prior to this work, only a 2-approximation was known [1]. Both the Hopper and the ε-Hopper algorithm consider outer robots that can be distinguished since run-sequences start only at one outer robot while the other remains stationary. We show that this restriction can be removed by increasing the viewing range of each robot to 2. The algorithm ε-2-Hopper starts run-sequences at both outer robots and achieves a (1+ε)-approximation of the optimal configuration while having a runtime of O(nε) epochs. Besides the improved approximation factors, these are the first algorithms with provable runtime guarantees regarding Chain-Formation under the Async scheduler. Table 1 contains a comprehensive comparison of our results to previous ones about the Chain-Formation problem.

Gathering:  Our main result is a linear time algorithm to solve Gathering of a closed chain of disoriented robots with limited visibility in the Euclidean plane. In the CC-Hopper algorithm, the visible lights are used to identify locally unique robots that initiate run-sequences if the configuration is asymmetric. One of the challenges in the closed chain is handling highly symmetric configurations. While it is possible to identify locally unique robots in every connected configuration on the grid (as in [18]), this is impossible in the Euclidean plane. We identify the class of isogonal configurations based on isogonal polygons by Grünbaum [25] and show that no locally unique robots can be determined in these configurations. We believe this characterization is of independent interest because highly symmetric configurations often cause a large runtime. For instance, the Ω(n2) lower bound of the Go-To-The-Center algorithm holds for an isogonal configuration [16]. See Table 2 for comparing our results to previous results about Gathering with limited visibility.

Synchronization:  Initially, we develop all of our algorithms for the Fsync scheduler. Afterward, we introduce a two-step synchronization based on existing results to transfer our algorithms to the Ssync and Async schedulers. As the core property of a run-sequence is the locally sequential movement of robots, the synchronization idea is as follows: Each run-sequence executes only one operation per epoch ensuring that run-sequences with the same movement direction yield the same outcome as under the Fsync scheduler. For run-sequences with opposite movement directions, some operations for the Fsync algorithm require a synchronized movement of the robots. As this is impossible to guarantee under the Ssync and Async scheduler, we show how to linearize these operations over a constant number of epochs such that the same outcome can be achieved. Practically, to ensure that each run-sequence executes only one operation per epoch, we use the core idea of the α-synchronizer [27]. This synchronization procedure adds a constant number of colors to the light of each robot and allows, together with the linearized modifications of synchronized movements, to execute our algorithms under the Ssync scheduler. Afterward, we add a constant number of lights to adapt a synchronization approach designed for robots with unlimited visibility to our case (robots with limited visibility) [28]. The combination of both approaches enables an Async execution of the algorithms with a runtime of O(n) epochs.

In Section 2, we start with an introduction of our notation and the formal model. We continue in Section 3 with the key concepts of all algorithms: The idea of a run-sequence and the movement operations induced by run-sequences. The following sections deal with the concrete algorithms considering the Fsync scheduler. In Section 4, we present the algorithms ε-Hopper and ε-2-Hopper for the Chain-Formation problem. Section 5 is devoted to our main result: The CC-Hopper algorithm that solves Gathering of closed chains of robots in linear time. Section 6 explains the two-step synchronization procedure that transfers our algorithms first to the Ssync and afterward to the Async scheduler.

Section snippets

Model & notation

Time model:  Robots operate in discrete LCM (Look, Compute, Move) cycles. Each robot takes a snapshot of its neighborhood in Look, computes a target point in Compute, and moves to this point in Move. We assume a rigid movement, i.e., robots always reach their target points during Move. A scheduler controls the timing of the executions of the LCM cycles: The cycles can be fully synchronous, and all robots participate in every cycle (Fsync), or only a subset of all robots participates (Ssync).

Key concepts

All algorithms in this paper use similar movement operations based on the idea of a run-sequence (a sequential movement implemented with a light, see below). Starting a run-sequence requires determining a locally unique robot. Locally unique means that the robot has a certain property (based on geometric aspects of its neighborhood such as a minimal angle αi(t)) that makes it distinguishable from its neighbors. In the Chain-Formation problem, outer robots are locally unique due to their

ε-Hopper & ε-2-Hopper

This section is dedicated to the ε-Hopper and the ε-2-Hopper algorithms for the Chain-Formation problem. Section 4.1 deals with the ε-Hopper algorithm: it uses the same assumptions as the original Hopper algorithm, i.e., robots have a viewing range of 1 and new run-sequences are only generated at r0 while rn1 does nothing at all. The ε-2-Hopper algorithm is presented in Section 4.2. In contrast to ε-Hopper, both r0 and rn1 participate such that run-sequences are generated at both ends of the

Closed-Chain Hopper

Next, we present the Closed-Chain-Hopper algorithm for the Gathering problem. Each robot has a viewing range of 4, i.e., it can always see the positions of the next 4 neighbors in each direction along the chain. Our approach consists of two algorithms – one for asymmetric configurations and one for highly symmetric (isogonal) configurations. The impossibility of finding robots that start run-sequences in highly symmetric configurations raises the need for the additional algorithm.

Modifications for the Ssync and Async schedulers

As a final result, we show a two-step synchronization procedure to transfer all algorithms to the Ssync and Async schedulers. There are two main problems to tackle when switching the scheduler. First, consider the Ssync scheduler and observe the following problems that might occur when executing the algorithms of Sections 4 and 5 (designed for Fsync). Consider an isolated run-sequence that is passed along the chain. In Fsync, the robot ri with the run-state performs a movement operation,

Concluding remarks & future work

This work has introduced improved results for the Chain-Formation and the Gathering problem. Still, no non-trivial lower bounds for oblivious robots are known for both problems. We conjecture that the linear runtime of the algorithms in this paper is only possible due to the visible lights, and thus, quadratic lower bounds hold for the oblivious case. However, proving general lower bounds seems challenging and is left for future research. Moreover, we have analyzed an upper runtime bound of 5129

Declaration of Competing Interest

The authors declare the following financial interests/personal relationships which may be considered as potential competing interests: Jonas Harbig reports financial support was provided by German Research Foundation under the project number ME 872/14-1.

References (28)

  • C. Dixon et al.

    Maintaining optimal communication chains in robotic sensor networks using mobility control

    Mob. Netw. Appl.

    (2009)
  • Y. Gao et al.

    Autonomous wi-fi relay placement with mobile robots

    IEEE/ASME Trans. Mechatron.

    (2017)
  • S. Abshoff et al.

    Gathering a closed chain of robots on a grid

  • P. Kling et al.

    Convergence of local communication chain strategies via linear transformations: or how to trade locality for speed

  • Cited by (0)

    This work was partially supported by the German Research Foundation (DFG) under the project number ME 872/14-1. A preliminary version of this work appeared in the conference proceedings of Algosensors'21 [2].

    View full text