Swarm Search of Expanding Regions in Grids: Upper Bounds

Abstract

In this chapter we examine the dynamic generalization of the Cooperative Cleaners problem presented in Altshuler et al., Swarm intelligent systems (2006), [10] and in the previous chapters of this book, involving a swarm of collaborative drones that are required to search a dynamically expanding region on the $\mathbf{Z}^{2}$ grid (whose “pixels” that were visited by the drones can become “un-searched” after a certain period of time). The goal of the swarm’s members is to “clean” the spreading contamination in as little time as possible. In this work we present a collaborative swarm search algorithm, as well as several upper bounds on the completion time it takes a swarm of k drones, of various velocities.

This chapter is based on work previously published in parts in [4, 10, 13].

Appendix – Definitions

This Appendix contains terms which were defined in previous chapters, as well as several algorithms and proofs, reiterated for the purpose of self-containment.

1.1 The SWEEP Cleaning Protocol

The SWEEP protocol is implemented by each agent $a_{i}$, located at time t at $\tau _{i}(t) = (x,y)$. We define below several terms we use while discussing the SWEEP protocol. We stress the fact that this is indeed a myopic protocol, relying on neighborhood information, a senile protocol (the memory needed is constant $+$ one counter whose size is upper bounded by $O(\log k)$, where k is the number of agents) and relies on implicit local communication only.

Definition 5

Let $\partial F$ denote the boundary of F. A tile is on the boundary if and only if at least one of its $8 Neighbors$ is not in F, meaning:

$$\begin{aligned} \partial F = \{v \ | \ v \in F \ \wedge \ 8 Neighbors (v) \ \cap \ (G \ \setminus \ F) \ \ne \ \emptyset \} \end{aligned}$$

Definition 6

Let $\tilde{\tau _{i}}(t)$ denote the previous location of agent i with respect to $\tau _{i}(t)$, such that $\tilde{\tau _{i}}(t) \ne \tau _{i}(t)$, defined as:

$$ \tilde{\tau _{i}}(t) \triangleq \tau _{i}(x) s.t. x = \max \{j \in \mathbb {N} \ | \ j < t and \tau _{i}(j) \ne \tau _{i}(t)\}$$

Definition 7

The term ‘rightmost’ means:

Starting from $\tilde{\tau _{i}}(t)$ (namely, the previous boundary tile that agent $a_{i}$ had been in) scan the four neighbors of $\tau _{i}(t)$ in a clockwise order until a boundary tile (excluding $\tilde{\tau _{i}}(t)$) is found. Sometimes, $\tilde{\tau _{i}}(t)$ might not be a boundary tile (this may occasionally happen after a contamination spread, for dirty regions of specific geometric features. In those cases, an agent may find itself in an internal point — a dirty tile which is not located on the boundary. From this tile the agent must move to the adjacent boundary tile, and resume its traversal along the region’s boundary). In this case, if $\tau _{i}(t)$ is a boundary point, then starting from $\tilde{\tau _{i}}(t)$ scan the four neighbors of $\tau _{i}(t)$ in a clockwise order until the second boundary tile is found. In case $t=0$ select the tile as instructed in Fig. 15.

The reference to contamination spread used in Definition 7 is given with consideration to the use of this term in the next chapters.

The additional information needed for the protocol and its sub-routines is contained in $\mathcal {M}_{i}$ and Neighborhood(x, y).

Fig. 15

When $t = 0$ the first movement of an agent located in (x, y) should be decided according to initial contamination status of the neighbors of (x, y), as appears in these charts — the agent’s initial location is marked with a filled circle while the destination is marked with an empty one. All configurations which do not appear in these charts can be obtained by using rotations. This definition is needed in order to initialize the traversal behavior of the agents in the correct direction

A schematic flowchart of the protocol, describing its major components and procedures is presented in Fig. 16. The complete pseudo-code of the protocol and its sub-routines appears in Figs. 17 and 18. Upon initialization of the system, the System Initialization procedure is called (defined in Fig. 17). This procedure sets various initial values of the agents, and call the protocol’s main procedure — SWEEP (defined in Fig. 18). This procedure in turn, uses various sub-routines and functions, all defined in Fig. 17.

Fig. 16

A schematic flow chart of the SWEEP protocol. The smooth lines represent the basic flow of the protocol while the dashed lines represent cases in which the flow is interrupted. Such interruptions occur when an agent calculates that it must not move until other agents do so (either as a result of waiting or resting dependencies — see Lines 6 and 19 of SWEEP for more details)

Fig. 17

The first part of the SWEEP cleaning protocol

Fig. 18

The SWEEP cleaning protocol. The term rightmost neighbor is defined in Appendix section “The SWEEP Cleaning Protocol”. l-d and r-d are left-down and right-down, respectively

1.2 Pivot Point

The initial location of the agents (the pivot point, denoted as $p_{0}$) is artificially set to be critical during the execution, hence it is also guaranteed to be the last point cleaned. Completion of the mission can therefore be concluded from the fact that all (working) agents are back at $p_{0}$ with no contaminated neighbors to go to, thereby reporting on completion of their individual missions. Note that this artificial preservation of the criticalness of the pivot point is not necessary for the algorithm to work. Rather, it just makes life easier for the user, as one can now know where to find the agents after the cleaning has been completed. If we do not start with all agents at the pivot and force $p_{0}$ to be critical, the location of the agents upon completion will generally not be known in advance.

1.3 Signaling

Since by assumption the agent’s sensors can detect the status of all tiles which are contained within a digital sphere of radius four placed around the current location of the agent, each agent can artificially calculate the desired destination of all the agents which are located in one of its $4{ {Neighbors}}{}$ tiles (see Fig. 19. Thus, the signaling action of each agent can be simulated by the other agents near him, and hence an explicit signaling by the agents is not actually required. However, the signaling action is kept in the description and flowchart of the protocol (in procedure 5) for the sake of simplicity and understandability.

Fig. 19

Digital sphere of diameter 7, placed around the agent

1.4 Connectivity Preservation

The connectivity of the region yet to be cleaned, F, is preserved by allowing the agents to clean only non-critical points. This guarantees both successful termination and agreement of completion (since having no dirty neighbors implies that $F=\emptyset$). Also, should several agents malfunction and halt, as long as there are still functioning agents, the mission will still be carried out, albeit slower.

Note that a tile which was originally clean, or which was cleaned by the agents, is guaranteed to remain clean. As a tile can be cleaned by the agents only when it is in $\partial F$, it is easy to see that the simple connectivity of F is maintained throughout the cleaning process (as the creation of “holes” — clean tiles which are surrounded by tiles of F — is impossible).

Note that when several agents are located in the same tile, only the last one who exits cleans it (see Line 33 in SWEEP), in order to prevent agents from being ‘thrown’ out of the dirty region (meaning, cleaning a tile in which another agent is located and thus preventing this agent from being able to continue the execution of the cleaning protocol). An alternative method for ensuring the agents are always capable of executing the cleaning protocol would have been the implementation of a “dirtiness seeking mechanism” (i.e. by applying methods such as suggested in [17]). Such a mechanism would have allowed an agent to clean its current location, even if other agents had also been present there. That solution, however, would have been far less elegant and would have added additional difficulties to the analysis process.

1.5 Agents Synchronization

Note that agents operating in the described environment must have some mean of synchronization, which is mandatory in order to prevent agents from operating in the same time — risking to cut the dirty region into several connected components, as shown in Fig. 20.

Fig. 20

When the agents do not possess a synchronization mechanism, they may, among others, damage the region’s connectivity. In this example, two agents clean their current locations, and move according to the SWEEP protocol. Since they are not synchronized, the tiles which they are located in are not treated as critical at the time of cleaning. However, the region’s connectivity is not preserved. Should one of the agents had waited for its neighbor to complete executing the protocol’s steps before resuming its actions, while deciding whether to clean its current location, it would have treated this tile as critical, and therefore avoid cleaning it. In this case, the connectivity of the region would have been maintained

To ensure such scenarios will not occur, an order between the operating agents must be implemented. Note — throughout the next paragraphs agents which are signaling a resting status (see Appendix section “Clustering Problem” for more details) are being disregarded while calculating the dependencies of the agents’ movements. The creation of the following order is implemented in Procedure 19 of SWEEP:

Definition 8

For agent i, let $P_{i} \subseteq \{up, down, left, right, right-down, left-down \}$ be a set of directions of tiles, in which there are currently agents, which agent i is delayed by (meaning, agent i will not start moving until the agents in these tiles move). Unless stated otherwise, $P_{i} = \emptyset$.

For agent i which is located in tile (x, y), if $(x-1,y)$ is a tile in F, which contains an agent, then $P_i \leftarrow P_i \cup \{left\}$. If $(x,y-1)$ is a tile in F, which contains an agent, then $P_i \leftarrow P_i \cup \{down\}$, and similarly for $(x+1,y-1)$ and right-down and for $(x-1,y-1)$ and left-down.

Definition 9

Let $dest_{i} \in \{up, down, left, right \}$ be the destination agent i might be interested in moving to, after leaving its current location.

Let each agent be equipped with a two bit flag (that may be implemented for example by two small light-bulbs). This flag states the desired destination of the agent. Alternatively, each tile can be treated as a physical tile, in which the agent can move. Thus, the agent can move towards the top side of the tile, which will be equivalent for using the flag in order to signal that it intends to move up.

Let each time step be divided into two phases. In phase 1, every agent “signals” the destination it intends to move towards, either by moving to the appropriate side of the tile, or by using the destination flag.

As we defined an artificial rule which states the superiority of left and down over right and up (and internally, of down over left), there are several specific scenarios in which this asymmetry should be reversed in order to ensure a proper operation of the agents. Following is such a “dependencies switching” rule: For agent i, which is located in (x, y), if $dest_{i} = right$ and tile $(x+1,y)$ contains an agent j, and $dest_{j} \ne left$, and there are no other agents which are delayed by agent i (i.e. tile $(x-1,y)$ does not contain an agent l where $dest_{l} = right$ and tiles $(x,y+1),(x+1,y+1),(x-1,y+1)$ do not contain any agent and tile $(x+1,y)$ does not contain an agent n where $dest_{n} = left$), then $P_i \leftarrow P_i \cup \{right\}$ and $P_j \leftarrow P_j \setminus \{left\}$. Also, if $dest_{i} = up$ and tile $(x,y+1)$ contains an agent k, and $dest_{k} \ne down$, and there are no other agents which are delayed by agent i (i.e. tile $(x,y-1)$ does not contain an agent m where $dest_{m} = up$ and tiles $(x+1,y),(x+1,y+1),(x-1,y+1)$ do not contain any agent and tile $(x,y+1)$ does not contain an agent q where $dest_{q} = down$), then $P_i \leftarrow P_i \cup \{up\}$ and $P_k \leftarrow P_k \setminus \{down\}$.

At phase 2 of each time step, the agents start to operate in turns, according to the order implied by $P_{i}$. This guarantees that the connectivity of the region is kept, since the simultaneous movement of two neighboring agents is prevented.

Notice that deadlocks are impossible — since the basic rule is that every agent is delayed by the agents in its left and down neighbor tiles. Therefore, at any given time, and for every possible group of agents, there exist an agent with the minimal x and y coordinates (which by definition, is not delayed by any other agent of this group). After this agent moves, all the agents which are delayed by it, can now move, and so on. As to the “dependencies switching rule” — let agent i located in tile (x, y) have the minimal x and y values among the agents who had not moved yet, and let $dest_{i} = up$, and let tile $(x,y+1)$ contain an agent j such that $dest_{j} \ne down$. Then although agent i is located below agent j, it will be delayed by it (i.e. $(up \in P_{i})$ and $\ne (down \in P_{j})$) as long as agent i is not delaying any other agent (as this is the requirement of the “dependencies switching rule”). In this case, we should show that there can not be a cycle of dependencies, which starts at agent j, ends at agent i, and is closed by the dependency of agent i on agent j. Such a circle can not exist since for it to end in agent i, it means that agent i is delaying another agent k. However, this is impossible since agent i is known not to delay any agent (specifically agent k). Hence, circular dependencies are prevented and no deadlock are possible.

Note that while phase 2 is in process, $F_{t}$ may change due to cleaning by the agents. As a result, the desired destinations of the agents as well as their dependencies forest, must also be dynamic. This is achieved through the repeated recalculation of these values, for every waiting agent. For example, assume agent i to be located in (x, y), and $dest_{i} = down$ without loss of generality, and let agent j located in tile $(x,y-1)$ moves out of this tile and cleans it. Then, $dest_{i}$ naturally change (as the tile (x, y) does no longer belong to $F_{t}$, and thus is not a legitimate destination for agent i), and thus, $P_{i}$ may also change. In this case, agent i should change its “destination signal” and act according to its new $dest_{i}$ and $P_{i}$. This is implemented in SWEEP by calculating the waiting agents’ destinations and dependencies lists repeatedly, until either all agents have moved or until the time step has ended (meaning that some agents had to change their status to resting, and pause until the next time step — see Appendix section “Clustering Problem” for more details). Note that every waiting agent is guaranteed either to complete its movement in the current time step, or to be forced to wait for the next time step, by switching its status to resting.

Notice that the “dependencies switching rule” is not required in order to ensure a proper completion of the mission, but rather to improve the agents’ performance, by preventing a bug demonstrated in Fig. 21.

Fig. 21

The upper charts demonstrate a performance bug which may be caused due to local dependencies. The agents are advancing according to the SWEEP protocol, but their cleaning performance is decreased. The lower charts demonstrates the cleaning operation after adding the dependencies switching mechanism

1.6 Clustering Problem

Since we are interested in preventing the agents from moving together and functioning as a single agent (due to a resulting decrease in the system’s performance), we would like to impose a “resting policy” which will ensure that the agents do not group into clusters which move together. This is done by artificially delaying agents in their current locations, should several agents placed in the same tile wish to move to the same destination. However, we would like the resting time of the agents to be minimal, for performance and analysis reasons.

The following resting policy is implemented by Line 6 of SWEEP. Using its sensors, an agent intending to move into tile v is aware of other agents which intend to move into v as well. Thus, when an agent enters a tile which already contains other agents, it knows whether these agents entered this tile at the same time step it did, or whether they had occupied this tile before the current time step had started.

Note that in phase 1 of each time step all the agents are signaling their desired destinations. Thus, an agent can identify which ones of the agents which are located in its current tile intend to move to the same destination as its. Only those agents may cause this agent to delay its actions and rest.

From the agents which intend to move to the same direction as agent i, the agent can distinguish between three groups of agents — the agents which entered this tile before the time step agent i did (group $A_{2}$), those which entered the tile in the same time step as i (group $A_{4}$), and those who entered it after agent i did (group $A_{3}$). If $A_{2} \ne \emptyset$, agent i waits, change its status to resting agent, signals this status to the other agents in its vicinity, and does not move. As this rule is kept by every other agent, agent i is guaranteed that the agents of group $A_{3}$ in their turn will wait for agent i moves before being free to do so as well.

As to the agents of $A_{4}$, the problem is solved by induction over the time steps, namely — that at any given time, two agents can not leave the same tile towards the same direction at the same time step. The base of this induction holds for small values of t as the agents are periodically released by the initialization procedure of SWEEP, while no two agents are released at the same time step. Later, as we are assured that all the agents of group $A_{4}$ arrived to v from different tiles (which are also different than the tile agent i had entered v from), then since all the agents in group $A_{4}$ know the previous locations of each other, a consensus over a local ordering of $A_{4}$ is established (note that no explicit communication is needed to form this ordering). An example for such an order is the Priority function of the SWEEP protocol. As a result, the agents are able to exit the tile they are currently located in, in an orderly fashion, according to a well defined order. Thus, the following invariant holds: “at any given time t, for any two tiles v, u, there can only be a single agent which moves from v to u at time step t”. Thus, the clustering problem is solved.

Notice that there is a single exception to this mechanism, in which the resting commands are overruled. This happens when all non-critical perimeter tiles contain at least two agents. In this scenario, following the resting commands would have created a situation in which no tile can be cleaned, as for every agent which leaves a certain tile, there are still “resting” agents located in the same tile. Therefore, once this scenario is detected by the check near completion of mission procedure of SWEEP, the agents ignore their resting commands momentarily, in order to be able to clean the non-critical perimeter tiles. The order and internal prioritization of the agents are maintained, for calculating the new resting commands in the following time step.

1.7 Mission Termination

The termination of the protocol is done in one of two cases — either an agent finds itself in the pivot point, while all of its neighbors are clean (which means that this is the last dirty tile and therefore should be cleaned), or when each dirty tile contains at least one agent (which is a generalization of the previous scenario). The second case is implemented by allowing the agents to signal to their four neighbors whether all of their dirty neighbors contain at least a single agent.