A cloud-supported coverage control scheme is proposed for multi-agent, persistent surveillance missions. This approach decouples assignment from motion planning operations in a modular framework. Coverage assignments and surveillance parameters are managed on the cloud and transmitted to mobile agents via unplanned and asynchronous exchanges. These updates promote load-balancing, while also allowing effective pairing with typical path planners. Namely, when paired with a planner satisfying mild assumptions, the scheme ensures that (i) coverage regions remain connected and collectively cover the environment, (ii) regions may go uncovered only over bounded intervals, (iii) collisions (sensing overlaps) are avoided, and (iv) for time-invariant event likelihoods, a Pareto optimal configuration is produced in finite time. The scheme is illustrated in simulated missions.

## Introduction

### Cloud-Supported Multi-Agent Surveillance.

Autonomous sensors are used in many modern surveillance missions, including search and rescue [1], environmental monitoring [2], and military reconnaissance [3]. Such missions often require agents to periodically exchange data with a central *cloud* (repository) and, when operating in nonideal environments or under hardware limitations, these potentially sporadic exchanges may be the only means of sharing real-time information across agents. For example, autonomous underwater vehicles are virtually isolated due to difficulties in underwater data transfer and rely on periodic surfacing to communicate with a tower [4]. Other applications that may have this constraint include data mules that periodically visit ground robots [5] and supervisory missions that require unmanned vehicles to send data to a remotely located operator [6]. Such scenarios require robust and flexible frameworks for real-time autonomous coordination.

Single-agent surveillance strategies range from simple a priori tour construction [7] to more complex methods involving Markov chains [8], optimization [9], or Fourier analysis [10]. However, it is not straightforward to generalize single-agent approaches for multi-agent missions: Naive approaches where each agent follows an independent policy often result in poor performance and introduce collision risks, while other generalizations may require joint optimizations that are intractable for even modestly sized problems [11]. Distributed control can sometimes alleviate scaling issues; however, such setups typically rely on ideal peer-to-peer data transfer making them ill-posed in many cloud-based setups.

In contrast, *decomposition-based* approaches to multi-agent surveillance, which decouple the assignment and routing problem by dividing the agent workspace, are popular in practice as they offer a straightforward, modular framework to reasonably accomplish surveillance goals, despite sacrificing optimality. However, in cloud-based architectures that rely solely on agent–cloud exchanges for real-time data transfer, implementation of such an approach is not straightforward using existing approaches to dynamic workspace decomposition. Indeed, in this case, updated mission information is only relayed to one agent at a time, rendering traditional partitioning schemes, which rely on complete or pairwise coverage updates, impossible, and existing strategies that utilize single-agent updates, e.g., see Ref. [12], may introduce undesirable configurations or collision-risks (Fig. 1).

This work extends existing literature by introducing a cloud-supported, decomposition-based framework for multi-agent persistent surveillance that promotes effective coverage without introducing collision (redundant sensing) risks and without requiring ideal or preplanned data exchanges. As such, the proposed framework allows agents to effectively respond to changes in the environment (spatial event likelihood) without having to be collected and redeployed due to the inability to transmit data to all the agents simultaneously. That is, when mission goals (captured by the event likelihood) change after agents are already in the field, the cloud incrementally relays the updated information through sporadic exchanges with individual agents, driving them to a new coverage configuration without introducing undesirable intermediate states. This framework also allows the cloud to act as a data fusion center if necessary, dynamically combining local sensory information collected by individual agents.

### Related Literature.

Multi-agent coverage control problems have generated extensive research. Typical strategies involve optimization [13], auctions [14], metaheuristics [15], potential fields [16], Markov decision processes [17], among others [18]. Of particular relevance is multi-agent *persistent surveillance* (*monitoring*), in which a sensor team is tasked with continual surveillance of some region, requiring subregions to be visited multiple (or infinitely many) times to minimize a cost, e.g., the time between visits or the likelihood of detecting events [11]. Persistent surveillance is a generalization of *patrolling*, where agents follow closed tours to protect or supervise an environment. Most current solutions to patrolling problems utilize operations research, nonlearning multi-agent systems, and multi-agent learning [19]; however, formulations are often one-dimensional and solutions usually reduce to “back and forth” motions that do not readily extend to general scenarios, e.g., see Ref. [20].

The framework herein employs a type of workspace decomposition in constructing solutions to the multi-agent problem. In the context of general robotic applications, the term *workspace decomposition* refers to any number of strategies that are employed in order to represent a complex workspace or solution space in a simpler, often lower-dimensional form. For robotic motion planning involving obstacles, this often involves the representation of the free configuration space in a graphical or modular form that captures essential connectivity properties, e.g., typical roadmap and cellular decomposition planning methods take this approach [21,22]. In multi-agent applications, workspace decomposition methods can also be used to reduce the complexity of a problem through the assignment of subtasks to individual agents, i.e., for task assignment [23]. This is the approach taken herein to reduce the multi-agent problem into a set of single-agent problems. Since the assignment problem is often difficult to solve (it has been shown to be NP-hard, i.e., nondeterministic polynomial-time hard, in some domains [23]), multi-agent planning solutions based on this type of assignment usually lead to suboptimal solutions. Despite this drawback, assignment-based approaches remain popular in practice due to their simplicity and scalability [11]. Outside of workspace decomposition, other strategies for reducing multi-agent planning problems into a set of single-agent problems include naive approaches, where each agent independently determines its own actions by locally solving a complete problem over the full workspace, and, provided sufficiently reliable sensing and data-transfer capabilities, distributed approaches, in which agents each solve a subproblem based on information shared over a communication network [24].

For planar persistent surveillance, decomposition-based approaches typically consist of two primary components: partitioning and single-agent routing. The most common approaches to optimal partitioning in convex environments are based on Voronoi partitions [25], and effective schemes exist for constructing centroidal Voronoi, equitable, or other types of optimal partitions under communication, sensing, and workload constraints [26–28]. Nonconvex workspaces are typically addressed by representing the environment as a graph, on which a number of graph partitioning schemes can be used [29]. In robotics, discrete partitioning is often considered under communication constraints, e.g., pairwise gossip [30] or asynchronous *one-to-base station communication* [12]. Our proposed scheme most closely mirrors [12], in which agents communicate sporadically with a base station; however, our approach employs additional logic to ensure that the resultant coverage regions retain properties that are consistent with effective, decomposition-based surveillance.

Single-agent path planners for persistent surveillance typically operate on graphs [31,32], and classical problems, e.g., the traveling salesperson problem [33], often play a key role. Stochasticity can be introduced using probabilistic tools, e.g., Markov chains [8]. Schemes for nondiscrete spaces (open subsets of Euclidean space) are less common. Here, strategies include a priori construction of motion routines [34], adaptation of static coverage strategies [35], the use of random fields [36], and spectral decomposition [10]. The modular framework herein incorporates any single-agent planner satisfying mild assumptions (see Sec. 5).

Remarkably, few papers explicitly consider the implications of combining dynamic partitioning with continuous routing for multi-agent persistent surveillance. Existing research is mostly preliminary, considering ideal data transfer and simplistic methods. Araujo et al. [37] employed a sweeping algorithm for partitioning and guided vehicle motion via lawn-mower patterns, while Nigam and Kroo [38] used rectangular partitions and a reactive routing policy which, in ideal cases, reduces to spiral search patterns. Maza and Ollero [39] used slightly more sophisticated partitioning in tandem with lawn-mower trajectories. In Ref. [40], partitions are based on the statistical expectation of target presence, but ideal communication is assumed. Others, e.g., see Ref. [41], employed decomposition-based structures, but focused on task-assignment without detailed treatment of the combined assignment/routing protocol.

Our work uses a *cloud-supported* computational framework. Cloud-based robotic infrastructures (*cloud robotics*) have generated growing research interest, as they can provide many benefits to complex systems, such as the storage and analysis of “big data,” the availability of parallel grid computing, the potential for collective learning, and the utilization of human computation [42]. In multi-agent systems, cloud-supported schemes have been used for a variety of tasks, including collective optimization [43], rendezvous [44], and coordinated task-assignment [12]. Our use of the cloud-based architecture is primarily motivated by supervisory systems involving unmanned vehicles. Here, cloud-based architectures arise naturally, since mobile agents are required to transmit sensor data to a remotely located human operator for analysis (thus requiring a central repository), and harsh operational environments often prohibit reliance on peer-to-peer communication. However, the proposed framework is suitable for use in any similar setup and can also run in parallel with other cloud-supported operations (e.g., data analysis, learning, etc.) within complex missions.

### Contributions.

This work develops a cloud-supported, decomposition-based, multi-agent coverage control framework for persistent surveillance, which relies only on sporadic, unscheduled exchanges between agents and a central cloud for data transfer. In particular, we develop a sophisticated partitioning and coordination scheme that can be effectively paired with single-agent trajectory planners. This naturally leads to the complete, modular framework in which high-level coverage is coordinated on the cloud and agent trajectories are generated independently via on-board planners. We encompass realistic constraints including restrictive communication, dynamic environments, and nonparametric event likelihoods.

Specifically, our dynamic partitioning scheme only requires agents to sporadically upload and download data from the cloud. The cloud runs updates to govern region assignments, while also manipulating high-level surveillance parameters. We prove that this update structure has many desirable properties: Coverage regions collectively form a connected *m*-covering and evolve at a time-scale that allows for appropriate agent reaction, no subregion remains uncovered indefinitely, local likelihood functions have disjoint support, among others. For certain cases, we show that the set of coverage regions and associated generators converges to a Pareto optimal pair in finite time. We show that the combination of our partitioning scheme with a generic trajectory planner ensures collision (sensing overlap) avoidance, provided the planner obeys natural restrictions. Finally, we illustrate our framework through numerical examples.

Our partitioning scheme is primarily motivated by Patel et al. [12]; however, the algorithms herein are explicitly designed to operate within a multi-agent surveillance framework and introduce additional logic parameters to evoke a set of desirable geometric and temporal properties. Our proposed scheme has the following advantages: First, our framework considers a modified cost function that uses subgraph distances to maintain connectivity of intermediate coverage regions, ensuring that agents can visit their entire assigned region without entering another agent's territory. Second, timing parameters are manipulated to provide inherent collision (redundant sensing) avoidance when the scheme is paired with low-level motion planners (Fig. 2). Third, our algorithms explicitly manipulate local likelihood functions maintained by the agents to guarantee that each has support within an allowable region, promoting seamless and modular pairing with any trajectory planner that uses the support of the event likelihood to govern agent routes, e.g., see Ref. [10]. The framework has these features while simultaneously maintaining similar convergence properties as the algorithms in Ref. [12].

For clarity and readability in what follows, we have presented all the theorem proofs in the Appendix.

## Mission Overview and Solution Approach

A team of *m* mobile agents,^{2} each equipped with an on-board sensor, is tasked with persistently monitoring a nontrivial, planar region of interest. The primary goal of the mission is to collect sensor data about some dynamic event or characteristic, e.g., an intruder. Collected data are periodically uploaded to the cloud. Agents must move within the environment to obtain complete sensory information. Ideally, agent motion should be coordinated so that:

- (1)
The sensing workload is balanced across agents.

- (2)
No subregion goes unobserved indefinitely.

- (3)
Agents never collide (have sensor overlap).

- (4)
The search is biased toward regions of greater interest.

To achieve these goals, we propose a decomposition-based approach in which each agent's motion is restricted to lie within a dynamically assigned *coverage region*. The partitioning component (operating on the cloud) defines these coverage regions and provides high-level restrictions on agent motion through the manipulation of surveillance parameters, while the trajectory planning component (operating on-board each agent) incrementally constructs agent motion paths. We assume only asynchronous, cloud–agent data transfer, i.e., agents sporadically exchange data with the cloud, where interexchange times are not specified a priori, but are subject to an upper bound.

Broadly, our framework operates as follows (Fig. 2): Initial coverage variables are communicated to the agents prior to deployment, i.e., relevant initial information is known to each agent at the mission onset. Once in the field, agents communicate sporadically with the cloud. During each agent–cloud exchange, the cloud calculates a new coverage region solely for the communicating agent, along with a set of timing and surveillance parameters that serve to govern the agent's high-level motion behavior, and transmits the update. The update algorithm also alters relevant global variables maintained on the cloud. Once the update completes, the data-link is terminated and the agent follows the trajectory found via its on-board planner. Note that this structure is a type of *event-triggered* control, since high-level updates only occur in the event of an agent–cloud exchange.

## Problem Setup

The cloud, as well as each agent, has its own local processor. “Global” information is stored on the cloud, while each agent only stores information pertinent to itself.

Convention 1. *Subscripts i, j, or ℓ denote an entity or set element relevant to agent i, j, or ℓ, respectively. The superscript A denotes an entity that is stored by the agent's local processor.*

A storage summary is shown in Table 1. We expand on these and define other relevant mathematical constructs here.

Variable | Description |
---|---|

Stored on the cloud | |

G(Q) | Graphical representation of the environment |

P | m-covering of Q (P ∈ Cov(_{m}Q)) |

c | Set of generators (c ∈ Q)^{m} |

$ID$ | Set of identifiers $(ID\u2208{1,\u2026,m}|Q|)$ |

T | Set of timers $(T\u2208\mathbb{R}\u22650m)$ |

ω | Set of most recent exchange times $(\omega \u2208\mathbb{R}\u22650m)$ |

Φ | Global likelihood $(\Phi :Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}>0)$ |

Stored by agent i | |

G(Q) | Graphical representation of the environment |

$PiA$ | Coverage region $(PiA\u2286Q)$ |

$ciA$ | Coverage region generator $(ciA\u2208Q)$ |

$PiA,pd$ | Set of “recently added” vertices $(PiA,pd\u2286PiA)$ |

$\tau iA$ | Local timing parameter $(\tau iA\u2208\mathbb{R})$ |

$\omega iA$ | Most recent exchange time $(\omega iA\u2208\mathbb{R}\u22650)$ |

$\Phi iA$ | Local likelihood $(\Phi iA:Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}\u22650)$ |

Variable | Description |
---|---|

Stored on the cloud | |

G(Q) | Graphical representation of the environment |

P | m-covering of Q (P ∈ Cov(_{m}Q)) |

c | Set of generators (c ∈ Q)^{m} |

$ID$ | Set of identifiers $(ID\u2208{1,\u2026,m}|Q|)$ |

T | Set of timers $(T\u2208\mathbb{R}\u22650m)$ |

ω | Set of most recent exchange times $(\omega \u2208\mathbb{R}\u22650m)$ |

Φ | Global likelihood $(\Phi :Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}>0)$ |

Stored by agent i | |

G(Q) | Graphical representation of the environment |

$PiA$ | Coverage region $(PiA\u2286Q)$ |

$ciA$ | Coverage region generator $(ciA\u2208Q)$ |

$PiA,pd$ | Set of “recently added” vertices $(PiA,pd\u2286PiA)$ |

$\tau iA$ | Local timing parameter $(\tau iA\u2208\mathbb{R})$ |

$\omega iA$ | Most recent exchange time $(\omega iA\u2208\mathbb{R}\u22650)$ |

$\Phi iA$ | Local likelihood $(\Phi iA:Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}\u22650)$ |

### Agent Dynamics.

Each agent (sensor) *i* is a point mass that moves with maximum possible speed *s _{i}* > 0. Define $s:={si}i=1m$. Note that this setup allows heterogeneity with respect to speed, i.e., agents can travel at different speeds.

### Communication Protocol.

Each agent periodically exchanges data with the cloud. Assume the following:

- (1)
Each agent can identify itself to the cloud and transmit/receive data.

- (2)
There is a lower bound $\Delta \xaf>0$ on the time between any two successive exchanges involving the cloud.

- (3)
There is an upper bound $\Delta \xaf>0$ on the time between any

*single agent's*successive exchanges with the cloud.

Assume that agent–cloud exchanges occur instantaneously, and note that condition 2 implies no two exchanges (involving any agents) occur simultaneously.^{3} Since computation time is typically small in comparison to interexchange times and exchanges occur sporadically, these assumptions are without significant loss of generality.

### Environment.

Consider a bounded surveillance environment as a finite grid of disjoint, nonempty, simply connected subregions. We represent the grid as a weighted graph $G(Q):=(Q,E)$, where *Q* is the set of vertices (each representative of a unique grid element), and *E* is the edge set comprised of undirected, weighted edges {*k*_{1}, *k*_{2}} spanning vertices representing *adjacent ^{4}* grid elements. Let the weight associated to {

*k*

_{1},

*k*

_{2}} be some finite upper bound on the minimum travel distance between any point in the grid element associated

*k*

_{1}to any point in the grid element associated to

*k*

_{2}along a path that does not leave the union of the two elements. Locations of environmental obstacles and prohibited areas are known and are not included in the graphical representation

*G*(

*Q*).

Consider $Q\u2032\u2286Q$. A vertex *k*_{1} ∈ *Q* is *adjacent* to $Q\u2032$ if $k1\u2209Q\u2032$ and there exists {*k*_{1}, *k*_{2}} ∈ *E* with $k2\u2208Q\u2032$. Define $G(Q\u2032):=(Q\u2032,E\u2032)$ as the subgraph of *G*(*Q*) induced by the vertex set $Q\u2032$. A *path* on $G(Q\u2032)$ between $k1,kn\u2208Q\u2032$ is a sequence (*k*_{1}, *k*_{2},…, *k _{n}*), where $k1,k2,\u2026,kn\u2208Q\u2032$ and ${kr,kr+1}\u2208E\u2032$ for

*r*∈ {1,…,

*n*− 1}. We say $Q\u2032$ is

*connected*if a path exists in $G(Q\u2032)$ between any $k1,k2\u2208Q\u2032$. Let $dQ\u2032:Q\u2032\xd7Q\u2032\u2192\mathbb{R}\u22650\u222a{\u221e}$ be the standard distance on $G(Q\u2032)$, i.e., the length of a shortest weighted path in $G(Q\u2032)$ (if none exists, $dQ\u2032$ takes value

*∞*). Note that $dQ(k1,k2)\u2264dQ\u2032(k1,k2)$ for any $k1,k2\u2208Q\u2032$. With slight abuse of notation, we also let $dQ\u2032$ denote the map $dQ\u2032:Q\u2032\xd72Q\u2032\u2192\mathbb{R}\u22650\u222a{\u221e}$, where $dQ\u2032(k,Q\u2033)$ is the length of a shortest weighted path in $G(Q\u2032)$ between

*k*and any vertex in $Q\u2033$.

### Coverage Regions.

An *m-covering* of *Q* is a family $P:={Pi\u2286Q}i=1m$ satisfying (i) $\u222ai=1mPi=Q$, and (ii) $Pi\u2260\u2205$ for all *i*. Define Cov* _{m}*(

*Q*) as the set of all the possible

*m*-coverings of

*Q*. An

*m-partition*of

*Q*is an

*m*-covering that also satisfies (iii) $Pi\u2229Pj=\u2205$ for all

*i*≠

*j*. An

*m*-covering or

*m*-partition

*P*is

*connected*if each

*P*is connected. In what follows, the cloud maintains an

_{i}*m*-covering

*P*of

*Q*, and surveillance responsibilities are assigned by pairing each agent

*i*with

*P*∈

_{i}*P*(called agent

*i*'s

*coverage region*). Each agent maintains a copy $PiA$ of

*P*. The cloud also stores a set $c:={ci\u2208Q}i=1m$ (

_{i}*c*is the

_{i}*generator*of

*P*), and each agent

_{i}*i*maintains a copy $ciA$ of

*c*.

_{i}### Identifiers, Timers, and Auxiliary Variables.

The proposed algorithms introduce logic and timing variables to ensure an effective overall framework. To each *k* ∈ *Q*, assign an *identifier*$IDk\u2208{1,\u2026,m}$. Define $ID:={IDk}k\u2208Q$, and let $PID:={PiID}i=1m$, where $PiID:={k\u2208Q|IDk=i}$. Note $PID$ is an *m*-partition of *Q*. For each agent *i*, define a timer *T _{i}* having dynamics $T\u02d9i=\u22121$ if

*T*≠ 0, and $T\u02d9i=0$ otherwise. Define $T:={Ti}i=1m$. Each agent

_{i}*i*maintains a local timing variable $\tau iA$. Even though $\tau iA$ plays a similar role to

*T*, note that $\tau iA$ is constant unless explicitly updated, while

_{i}*T*has autonomous dynamics. Next, the cloud maintains a set $\omega :={\omega i}i=1m$, where

_{i}*ω*is the time of agent

_{i}*i*'s most recent exchange with the cloud. Each agent maintains a copy $\omega iA$ of

*ω*. Finally, each agent stores a subset $PiA,pd\u2286PiA$, which collects vertices that have recently been added to $PiA$.

_{i}### Likelihood Functions.

The likelihood of a relevant event occurring within any subset of the surveillance region is maintained on the cloud in the form of a time-varying probability mass function^{5}$\Phi :Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}>0$. For simplicity, assume that, at any *t*, the instantaneous support, $supp(\Phi (\xb7,t))$, equals *Q*.

*local likelihood*$\Phi iA:Q\xd7\mathbb{R}\u22650\u2192\mathbb{R}\u22650$ as the function that, loosely, represents the agent's local belief regarding events. Specifically, define

The conditions defining $\Phi iA$ are understood as follows: At some time *t*, an element *k* ∈ *Q* only belongs to $supp(\Phi iA(\xb7,t))$ if (i) $k\u2208PiA$ and (ii) sufficient time has passed since *k* was first added to $PiA$, as determined by the parameters $\tau iA,\u2009\omega iA$, and $PiA,pd$. In general, each $\Phi iA$ will be different^{6} from Φ.

*Remark**1* (Global Data). If global knowledge of Φ is not available instantaneously to agent *i*, $\Phi iA$ can alternatively be defined by replacing Φ(*k*, *t*) in Eq. (1) by $\Phi (k,\omega iA)$. All the subsequent theorems hold under this alternative definition.

*Remark**2* (Data Storage). The cost of storing a graph as an adjacency list is $O(|Q|+|E|)$. The generator set *c*, each element of *P*, and the identifier set $ID$ are stored as integral vectors. The timer set *T* and the likelihood *Φ* are stored as time-varying real vectors, while the set *ω* is stored as a (static) real vector. Thus, the cost of storage on the cloud is $O(m|Q|+|E|)$. Similarly, each agent's local storage cost is $O(|Q|+|E|)$.

## Dynamic Coverage Update Scheme

Adopt the following convention for the remaining analysis.

Convention 2. *Suppose that:*

- (1)
$min\u2205:=max\u2205:=0$

*.* - (2)
*Given a specific time instant, superscripts “−”or “+” refer to a value before and after the instant in question, respectively.*

### Additive Set.

We start with a definition.

Definition 1 (Additive Set).*Given*$k\u2208PiID$*, the additive set*$Piadd(k)\u2286Q$*is the largest connected subset satisfying:*

- (1)
$PiID\u2286Piadd(k)$.

- (2)
For any $h\u2208Piadd(k)\u2229Pj$, where

*j ≠ i*:- (a)
*T*= 0._{j} - (b)
$(1/si)dPiadd(k)(h,k)<(1/sj)dPj(h,cj)$.

- (a)

The following characterizes well-posedness of Definition 1.

Proposition 1 (Well-Posedness). *If*$PiID$*is connected and disjoint from*$\u222aj\u2260iPj$*, then*$Piadd(k)$*exists and is unique for any*$k\u2208PiID$.

*Proof.* With the specified conditions, $PiID$ is connected and satisfies 1 and 2 in Definition 1; $Piadd(k)$ is the unique, maximally connected superset of $PiID$ satisfying 1 and 2.

Under the conditions of Proposition 1, if $h\u2208Piadd(k)$, then $max{Tj\u2009|\u2009j\u2260i,h\u2208Pj}=0$ and there is a path from *k* to *h* in $G(Piadd(k))$ that is shorter than the optimal path spanning *c _{j}* and

*h*within

*G*(

*P*), for any

_{j}*j*≠

*i*with

*h*∈

*P*.

_{j}### Cloud-Supported Coverage Update.

If (i) each agent is solely responsible for events within its coverage region, and (ii) events occur proportionally to Φ, then $H(c,P,t)$ is understood as the expected time required for an agent to reach a randomly occurring event from its region generator at time *t*; related functions are studied in Refs. [12,26], and [30]. Algorithm 1 defines the operations performed on the cloud when agent *i* makes contact at time *t*_{0}. Here, the input Δ_{H} > 0 is a constant parameter.^{7} Recall from Sec. 3.3 that, given a vertex *k* and sets $Q\u2033\u2282Q\u2032$, the value $dQ\u2032(k,Q\u2033)$ represents the minimum time required to travel from *k* to any node in the set $Q\u2033$. Therefore, the operations in lines 1 and 2 of Algorithm 2 are implicitly max–min operations that, intuitively, define upper bounds on the time required for the agents to vacate areas that have shifted as a result of the update. Additional remarks to aid in reader understanding are given by the comments within the algorithms (italicized text preceded by a “%” character).

Consider the following initialization assumptions.

Assumption 1 (Initialization). *The following properties are satisfied when t = 0:*

- (1)
*P is a connected m-partition of Q.* - (2)
$P=PID$.

- (3)
*For all i**∈**{1,…, m}*(a) $Pi=PiA$.

(b) $ci=ciA\u2208PiA$.

(c) $PiA,pd=\u2205$.

(d) $Ti=\omega i=\omega iA=0$.

(e) $\tau iA=\u2212\Delta H$.

- (3)

Notes 1 and 3b together imply that *c _{i}* ≠

*c*for any

_{j}*j*≠

*i*. Our first result guarantees well-posedness of Algorithm 1.

Theorem 1 (Well-Posedness). *Under Assumption 1, a scheme in which, during each agent–cloud exchange, the cloud executes Algorithm 1 to update relevant global and local variables is well-posed. That is, operations required by Algorithm 1 are well-posed at the time of execution.*

Algorithm 1 does not ensure that coverage regions (elements of *P*) remain disjoint. It does, however, guarantee that the *m*-covering *P*, the local coverage regions $PA:={PiA}i=1m$, and the local likelihoods ${\Phi iA}i=1m$ retain properties that are consistent with a decomposition-based scheme. Namely, the coverings *P* and *P ^{A}* maintain connectivity, and each $\Phi iA$ has support that is disjoint from that of all other local likelihoods, yet evolves to provide reasonable global coverage. Further, Algorithm 2 ensures that agents can “safely” vacate areas that are reassigned before newly assigned agents enter. We expand upon these ideas in the following Secs. 4.3 and 4.4.

### Set Properties.

The next result formalizes key set properties.

Theorem 2 (Set Properties). *Suppose Assumption 1 holds, and that, during each agent–cloud exchange, the cloud executes Algorithm 1 to update relevant global and local variables. Then, the followings hold at any time t ≥ 0:*

- (1)
$PID$

*is a connected m-partition of Q.* - (2)
*P is a connected m-covering of Q.* - (3)
*c*_{i}*∈**P*_{i}and c_{i}≠ c_{j}for any i ≠ j. - (4)
$supp(\Phi iA(\xb7,t))\u2286Pi$

*for any i.* - (5)
$\u2229i=1msupp(\Phi iA(\xb7,t))=\u2205$.

When the cloud makes additions to an agent's coverage region, newly added vertices are not immediately included in the instantaneous support of the agent's local likelihood. If agent movement is restricted to lie within this support, the delay temporarily prohibits exploration of newly added regions, allowing time for other agents to vacate. Conversely, when regions are removed from an agent's coverage region, Algorithm 1 ensures that a “safe” path, i.e., a path with no collision risk, exists and persists long enough for the agent to vacate. Let $d\xaf:=maxi(1/si)\u2211{k1,k2}\u2208EdQ(k1,k2)$, and define agent *i*'s *prohibited region*, $Prohi(t)$, as the set of vertices not belonging to the support of $\Phi iA(\xb7,t)$, i.e., $Prohi(t):={k\u2208Q\u2009|\u2009k\u2209supp(\Phi iA(\xb7,t))}$. We formalize this discussion here.

Theorem 3 (Coverage Quality). *Suppose Assumption 1 holds, and that, during each agent–cloud exchange, the cloud updates relevant global and local coverage variables via Algorithm 1. Then, for any k**∈**Q and any t ≥ 0:*

- (1)
*k belongs to at least one agent's coverage region P*_{i}. - (2)
*If*$k\u2208Prohi(t)\u2229Pi$*for some i, then there exists t*$t<t0<t+\Delta \xaf+d\xaf$_{0}satisfying*such that, for all*$t\xaf\u2208[t0,t0+\Delta H]$*, the vertex k belongs to the set*$Pi\Prohi(t\xaf)$. - (3)
*If k is removed from P*_{i}at time t, then, for all$t\xaf\u2208(t,t+1sidPi\u2212(k,PiID,\u2212)]$*we have*- (a)
$PiID,\u2212\u2286Pi$.

- (b)
*There exists a length-minimizing path on*$G(Pi\u2212)$*from k into*$PiID,\u2212$*, and all of the vertices along any such path (except the terminal vertex) belong to the set*$ProhIDk+(t\xaf)\\u222aj\u2260IDk+Pj$.

- (a)

Theorems 2 and 3 allow Algorithm 1 to operate within a decomposition-based framework to provide reasonable coverage with inherent collision avoidance. Indeed, if agents avoid prohibited regions, the theorems imply that each agent (i) can visit its entire coverage region (connectedness), (ii) allows adequate time for other agents to vacate reassigned regions, and (iii) has a safe route into the remaining coverage region if its current location is removed during an update.

*Remark**3* (Coverage Variables). If Assumption 1 holds and updates are performed with Algorithm 1, then $Pi=PiA$ and $ci=ciA$ for all *i* and all *t*. Thus, both Theorems 2 and 3 are equivalently stated by replacing *P _{i}* with $PiA$ and

*c*with $ciA$ in their respective theorem statement.

_{i}*Remark**4* (Bounds). Theorem 3 holds if $d\xaf$ is replaced by any upper bound on the time required for any arbitrary agent to travel between two arbitrary vertices within an arbitrary connected subgraph of *G*.

### Convergence Properties.

Our proposed strategy differs from Ref. [12] due to logic, i.e., timing parameters, etc., that ensures effective operation within a decomposition-based framework. Note also that $H$ differs from previous partitioning cost functions in Refs. [12,26], and [30], since it uses subgraph, rather than global graph, distances. As such, convergence properties of the algorithms herein do not follow readily from existing results. Consider the following definition.

Definition 2 (Pareto Optimality). *The pair (c, P) is Pareto optimal at time t if*

- (1)
$H(c,P,t)\u2264H(c\xaf,P,t)$

*for any*$c\xaf\u2208Qm$. - (2)
$H(c,P,t)\u2264H(c,P\xaf,t)$

*for any*$P\xaf\u2208Covm(Q)$.

When Φ is time-invariant (and Assumption 1 holds), Algorithm 1 produces finite-time convergence of coverage regions and generators to a Pareto optimal pair. The limiting coverage regions are “optimal” in that they balance the sensing load in a way that directly considers the event likelihood. Further, the operation only requires sporadic and unplanned agent–cloud exchanges. We formalize this result here.

Theorem 4 (Convergence). *Suppose Assumption 1 holds and that, during each agent–cloud exchange, the cloud updates relevant global and local coverage variables via Algorithm 1. If Φ is time-invariant, i.e.,*$\Phi (\xb7,t1)=\Phi (\xb7,t2)$*for all t _{1}, t_{2}, then the m-covering P and the generators c converge in finite time to an m-partition P* and a set c*, respectively. The pair (c*, P*) is Pareto optimal at any time following convergence.*

*Remark 5* (Weighted Voronoi Partitions). It can be shown that Pareto optimality of (*c**, *P**) in Theorem 4 implies that, following convergence, *P** is a multiplicatively weighted Voronoi partition (generated by *c**, weighted by *s*, subject to density Φ(⋅, *t*)) by standard definitions (e.g., see Ref. [12]). If the centroid set of each *P _{i}* is defined as $argminh\u2208Pi\u2211k\u2208PidPi(k,h)\Phi (k,t)$, then

*P** is also centroidal.

Our coverage scheme balances the sensing load in that it updates coverage responsibilities in a way that locally minimizes the expected time required for an appropriate agent to travel from its region generator to a randomly occurring event within the environment. In essence, this serves to avoid unreasonable configurations, e.g., configurations where one agent is assigned responsibility of all the important areas and remaining agents are only given unimportant regions. Further, the update rules consider agent speeds, so faster agents will generally be assigned larger (weighted by the likelihood) coverage regions than slower agents. Similar strategies are employed in traditional load-balancing algorithms that are based on Voronoi partitions and operate over environments with stochastic event likelihoods, e.g., see Refs. [12,26], and [30].

Theorem 4 and Remark 5 provide a rigorous characterization of the type of load-balancing provided in the static likelihood case. A few comments are in order. First, Pareto optimal pairs (and multiplicatively weighted, centroidal Voronoi partitions) are nonunique. Theorem 4 only guarantees that one possible Pareto optimal pair will be found in the static likelihood case and does not exclude the existence of a lower-cost configuration. Second, the coverage configurations produced by our algorithms may not be *equitable*, i.e., the probability of events in each coverage region may vary across agents, even in the static case. The development of a strategy that produces equitable partitions within a similar cloud-supported architecture is an open problem and an interesting area of future research.

## Decomposition-Based Surveillance

This section pairs the proposed partitioning framework with a generic, single-vehicle trajectory planner, forming the complete, multi-agent surveillance framework.

### Complete Routing Algorithm.

By Theorem 2, the support of each $\Phi iA$ (i) lies entirely within the coverage region $PiA$ and (ii) is disjoint from the support of other local likelihoods. By Theorem 3, (i) any vertex can only go uncovered over bounded intervals, and (ii) the parameter Δ_{H} is a lower bound on the time that a recently uncovered vertex must remain covered before it can become uncovered again. These results suggest that an intelligent routing scheme that carefully restricts motion according to the instantaneous support of the local likelihood functions could achieve adequate coverage while maintaining collision avoidance. This motivates the following assumption.

Assumption 2 (Agent Motion). *Each agent i has knowledge of its position at any time t, and its on-board trajectory planner operates under the following guidelines:*

- (1)
*Generated trajectories obey agent motion constraints.* - (2)
*Trajectories are constructed incrementally and can be altered in real-time.* - (3)
*The agent is never directed to enter regions associated with*$Prohi(t)$.

*Each agent precisely traverses generated trajectories*.

Note that condition 3 of Assumption 2 implies that the agent is never directed to leave regions associated with $PiA$. Algorithm 3 presents the local protocol for agent *i*. Here, the on-board trajectory planner is used to continually update agent trajectories as the mission progresses (line 1). As such, the low-level characteristics of each individual agent's motion (i.e., the relation between the underlying likelihood function, the coverage configuration, and the resultant trajectory) depend on the particular planner employed.

### Collision Avoidance.

Although Assumption 2 locally prevents agents from entering prohibited regions, dynamic coverage updates can still place an agent within its prohibited region if the vertex corresponding to its location is abruptly removed during an update. If this happens, Algorithm 3 constructs a route from the agent's location back into a region where there is no collision risk. With mild assumptions, this construction: (i) is well-defined and (ii) does not present a transient collision risk. We formalize this result here.

Theorem 5 (Collision Avoidance). *Suppose Assumptions 1 and 2 hold, and that each agent's initial position lies within its initial coverage region P _{i}. If each agent's motion is locally governed according to Algorithm 3, where the update in line 4 is calculated by the cloud via Algorithm 1, then no two agents will ever collide.*

*Remark**6* (Agent Dynamics). We assume point mass dynamics for simplicity. However, all the theorems herein also apply under alternative models, e.g., nonholonomic dynamics, provided that the surveillance environment is discretized so that: (i) travel between adjacent grid elements is possible without leaving their union, (ii) agents can traverse the aforementioned paths at maximum speed, and (iii) edge weights accurately upper bound travel between adjacent regions. Typically, these conditions can be met by choosing discretization cells that are sufficiently large. For example, under a Dubins vehicle model, choosing square cells whose edge lengths are at least twice the minimum turning radius of any of the vehicles is sufficient. If these conditions are not met, Theorems 1, 2, 3, and 4 still apply, though Theorem 5 is no longer guaranteed since more sophisticated logic would be needed to ensure that agent trajectories remain within the allowable regions. The development of an algorithmic extension that would guarantee collision avoidance for general nonholonomic vehicles is not straightforward and is left as a topic of future research.

In practice, however, we note that even if Theorem 5 is not satisfied in a strict sense, implementation of the algorithms herein within a decomposition-based scheme will usually still provide a significantly reduced collision or redundant sensing risk, provided that vehicles remain close to the allowable regions specified by the updates.

## Numerical Examples

This section presents numerical examples to illustrate the proposed framework's utility. In all the examples, updates are performed on the cloud via Algorithm 1 during each agent–cloud exchange, and each agent's local processor runs the motion protocol in Algorithm 3. For incremental trajectory construction (Algorithm 3—line 1), all the examples use a modified *spectral multiscale coverage* (SMC) scheme [10], which creates trajectories to mimic ergodic dynamics while also locally constraining motion to lie outside of prohibited regions. Note this planner satisfies Assumption 2. Initial region generators were selected randomly (enforcing noncoincidence), and each agent was initially placed at its region generator. The initial covering *P* was created by calculating a weighted Voronoi partition, and remaining initial parameters were chosen to satisfy Assumption 1. It is assumed that relevant initial variables are uploaded to the agents' local servers prior to initial deployment, i.e., each agent has full knowledge of relevant initial information at time 0. For each simulation, randomly chosen agents sporadically exchanged data with the cloud. Agent–cloud exchange times were randomly chosen, subject to a maximum interexchange time $\Delta \xaf$.

### Time-Invariant Likelihood.

Consider a four-agent mission, executed over a 100 × 100 surveillance region that is subject to a time-invariant, Gaussian likelihood centered near the bottom left corner. The region is divided into 400, 5 × 5 subregions. Regions are considered adjacent if they share a horizontal or vertical edge. Here, each agent had a maximum speed of one unit distance per unit time, and $\Delta \xaf=10$ time units. Figure 3 shows the evolution of the coverage regions for an example simulation run. Agent trajectories are shown by the solid lines. Note that Fig. 3 only shows each agent *i*'s *active* coverage region, i.e., $Pi\Prohi(t)$. The family of active coverage regions does not generally form an *m*-covering of *Q*; however, elements of this family are connected and never intersect as a result of inherent collision avoidance properties.

The left plot in Fig. 4 depicts the maximum amount of time that any grid square went uncovered, i.e., the grid square did not belong to any agent's active covering, during each of 50 simulation runs. Here, the maximum amount of time that any region went uncovered was 186 units, though the maximum for most trials was less than 75 units. This is well-below the loose bound $\Delta \xaf+d\xaf=770$ predicted by Theorem 3 (see Remark 4). Note that this metric does not capture the time between the agent's actual visits to the grid square, only the length of intervals on which no agent was *allowed* to visit the square. The time between visits is governed by the particular choice of trajectory planner and the parameter Δ_{H.}

The right plot in Fig. 4 shows the mean values of the cost function $H$, calculated over the same 50 simulations runs. Here, error bars represent the range of cost values at select points. The variance between runs is due to the stochastic nature of the agent–cloud exchange patterns. Note the cost is nonincreasing over time, eventually settling as the coverage regions/generators reach their limiting configuration, e.g., see Fig. 3. These configurations are each Pareto optimal and form a multiplicatively weighted Voronoi partition (Remark 5). The resultant coverage assignments provide load-balancing that takes into account the event likelihood. If the low-level trajectory planner biases trajectories according to the event likelihood, this results in desirable coverage properties. Under the modified SMC planner used here, the temporal distribution of agent locations closely resembles the spatial likelihood distribution in the limit, as shown in Fig. 5.

Further, during the simulation, no two agents ever occupied the same space due to the careful parameter manipulations employed by Algorithm 1. Figure 6 illustrates the logic governing these manipulations through a simplistic example: During the first update, the left agent acquires some of the right agent's coverage region. Rather than immediately adding these regions to its active covering, the left region waits until sufficient time has passed to guarantee that the right agent has updated and moved out of the reassigned regions. Under Algorithm 3, once the right agent communicates with the cloud, it immediately vacates the reassigned regions, after which the left agent can add the region to its active covering. This procedure guarantees that no two agents will never have overlapping active coverings and thus never collide (Theorem 5). This same logic results in inherent collision prevention over more complex scenarios.

We can also compare the coverage regions produced by Algorithm 1 to those produced by the partitioning algorithm in Ref. [12]. The two algorithms were simulated in parallel, performing updates with the same randomly chosen agent–cloud exchange orderings across the two conditions. The left and the right plots in Fig. 7 show the mean coverage cost over 50 simulation runs, calculated using $Hmin$ (defined in Ref. [12], Sec. II-C) and $H$ (Sec. 4.2), respectively (portions of the curves extending above the axes indicate an infinite value). The function $Hmin$ is defined nearly identically to $H$, but uses global graph distances, rather than subgraph distances. It is clear that the evolution produced by the algorithm in Ref. [12] converges to a final configuration slightly faster than that produced by Algorithm 1 whenever costs are quantified using $Hmin$. However, when costs are calculated using $H$, the algorithms in Ref. [12] produced intermediate configurations with infinite cost, indicating disconnected regions, while Algorithm 1 maintained connectivity. In contrast to Ref. [12], our surveillance framework allows for complete coverage without requiring the agents to leave their assigned regions, allowing it to operate more effectively within a multi-agent surveillance scheme.

### Time-Varying Likelihood.

We now illustrate how the proposed coverage framework reacts to changes in the underlying likelihood. Specifically, we study a particular type of time-varying likelihood in which the spatial distribution only changes at discrete time-points, i.e., Φ(*k*, ⋅) is piecewise constant for any *k* ∈ *Q*. This type of scenario is common in realistic missions, e.g., when the cloud's estimate of the global likelihood is only reformulated if some agent's sensor data indicate a drastic change in the underlying landscape. For this purpose, we adopt identical parameters as in the first example, with the exception of the likelihood Φ, whose spatial distribution abruptly switches at select time-points. If the switches are sufficiently spaced in comparison to the rate of convergence, then the coverage regions dynamically adjust to an optimal configuration that is reflective of the current state. For example, Fig. 8 shows the coverage region evolution after the underlying likelihood undergoes a single switch between the likelihoods in Fig. 9 at time *t* = 2000. In contrast, if the likelihood changes faster than the rate of convergence, coverage regions are constantly in a transient state. Despite this, the proposed framework still provides some degree of load-balancing. To illustrate, the left plot in Fig. 10 shows the value of $H$ during a simulation in which the underlying likelihood switches at 12 randomly chosen time-points over a 1000 unit horizon. Each switch redefined the spatial likelihood as a Gaussian distribution centered at a randomly selected location. Note that the cost monotonically decreases between the abrupt spikes caused by changes in the underlying likelihood. A convergent state is never reached; however, coverage regions quickly shift away from high-cost configurations, as seen in the right plot in Fig. 10, which shows the average percentage drop in the value of the cost $H$ as a function of the number of nontrivial updates, i.e., updates that did not execute Algorithm 1—line 3, following an abrupt switch in the likelihood. The percentage drop is calculated with respect to the cost immediately following the most recent switch. During the first nontrivial update, the cost drops on average 21.8% of the initial postswitch value, indicating a quick shift away from high-cost configurations.

## Conclusion

This work develops a cloud-supported, decomposition-based, coverage control framework for multi-agent surveillance. In particular, a dynamic partitioning strategy balances the surveillance load across available agents, requiring only sporadic and unplanned agent–cloud exchanges. The partitioning update algorithm also manages high-level logic parameters to guarantee that the resulting coverage assignments have geometric and temporal properties that are amenable to combination with generic single-vehicle trajectory planners. In certain cases, the proposed algorithms produce a Pareto optimal configuration, while ensuring collision avoidance throughout.

Future work should further relax communication assumptions to reflect additional limitations, e.g., use of directional antennae for wireless transmission. Extensions to the proposed algorithms to incorporate explicit area constraints on coverage regions, as well as more general vehicle dynamics, should also be explored. Other areas of future research include the combination of peer-to-peer and cloud-based communication, performance comparisons between specific trajectory planners when used within our framework, e.g., those involving ergodic Markov chains, and further theoretical performance characterization.

## Acknowledgment

This work has been sponsored by the U.S. Army Research Office and the Regents of the University of California, through Contract No. W911NF-09-D-0001 for the Institute for Collaborative Biotechnologies.

### Appendix: Proofs

Proposition 2 (Sets). *Suppose Assumption 1 holds, and that, at the time of each exchange occurring prior to a fixed time*$t\xaf\u22650$*, required algorithmic constructions are well-posed so that the cloud can perform updates via Algorithm 1. Then, for any k**∈**Q and any time*$t\u2264t\xaf$*:*

- (1)
$k\u2208PIDk$

*.* - (2)
*k belongs to at most two elements of P.* - (3)
*if*$TIDk=0$*, then*$k\u2209P\u2113$*for any ℓ ≠ ID*_{k}. - (4)
*if k**∈**P*$Pj\u2229P\u2113ID=\u2205$_{j}, j ≠ ID_{k}, then*for*$\u2113\u2209{j,IDk}$.

*Proof.* Fix $t\xaf\u22650,\u2009k\u2208Q$. When *t* = 0, $P=PID$ is an *m*-partition of *Q*, implying the proposition. Since *k* is not removed from $PIDk$ or added to any *P _{i}* with

*i*≠ ID

*until its first*

_{k}*reassignment*, i.e., when ID

*is changed, the proposition holds for all*

_{k}*t*prior to the first reassignment. Suppose the proposition holds for all

*t*prior to the

*p*th reassignment, which occurs at time

*t*

_{0}. Suppose $IDk\u2212=j,\u2009IDk+=i\u2260j$. Algorithm 1 defines $PiID,+=Pi+=PIDk++$. Thus, $k\u2208PIDk++=Pi+$ and remains in these sets until another reassignment. Thus, statement 1 holds for all

*t*prior to the

*p*+ 1st reassignment. Now note that, by Algorithm 2, reassignment cannot occur at

*t*

_{0}unless $Tj\u2212=0$. By inductive assumption, statement 3 of the proposition holds when $t=t0\u2212$, implying $k\u2209P\u2113\u2212$ for any

*ℓ*≠

*j*. Upon reassignment, the timers

*T*,

_{j}*T*are modified such that $Tj+,Ti+>\omega j++\Delta \xaf\u2212t0$. Since (i) ID

_{i}*cannot change when*

_{k}*T*> 0, and (ii) agent

_{j}*j*exchanges data with the cloud and removes

*k*from

*P*prior to time $\omega j++\Delta \xaf$, we deduce that

_{j}*k*solely belongs to

*P*,

_{j}*P*until the

_{i}*p*+ 1st reassignment. Further, for any $t\u2265t0+$ at which

*T*= 0 and the

_{i}*p*+ 1st reassignment has not yet occurred,

*k*∈

*P*exclusively (addition to other sets in

_{i}*P*without reassignment is impossible). We deduce statements 2 and 3 for any

*t*prior to the

*p*+ 1st reassignment. Finally, considering Algorithm 2, it is straightforward to show that $Tj\u2212=0$ implies $Pj\u2212=PjID,\u2212$ (

*T*= 0 only if the most recent exchange that manipulated elements of $PjID$ involved agent

_{j}*j*, after which $Pj=PjID$). Further, (i) no agent claims vertices from $Pj+$ unless

*T*= 0, and (ii) no vertex is added to a coverage region without reassignment. As such, $Pj\u2229P\u2113ID=\u2205$ for any $\u2113\u2209{j,IDk=i}$ prior to another update in which some other agent claims vertices from

_{j}*P*. Extending this logic and noting the bound $\Delta \xaf$, we deduce the same result for any

_{j}*t*prior to the

*p*+ 1st reassignment of

*k*. Noting $\Delta \xaf$ once again, the proposition follows by induction.

*Proof of Theorem 1.* It suffices to show that Definition 1 is well-posed (Proposition 1) whenever additive sets are required. We proceed by induction. When *t* = 0, $PID=P$ is a connected *m*-partition of *Q*; thus, for any *i*, $PiID\u2229(\u222aj\u2260iPj)=\u2205$. The same holds prior to the first agent–cloud exchange, so the first call to Algorithm 1 is well-posed. Now assume that, for all *t* prior to the *p*th call to Algorithm 1, (i) $PID$ is a connected *m*-partition of *Q*, and (ii) if an exchange occurs that requires construction of $Piadd$ (assume this also applies to the impending *p*^{th} exchange), then $PiID\u2229(\u222aj\u2260iPj)=\u2205$ immediately prior to the exchange. This implies that Proposition 2 holds at any time *t* prior to the *p* + 1st exchange. Assume the *p*th exchange occurs at time *t*_{0} and involves agent *i*. Recall that $PID,+$ is an *m*-partition of *Q*. To show $PID,+$ is connected, first notice $PiID,+=Pi+$. Since either $Pi+=Piadd(ci+)$ (connected by Definition 1) or $PiID,+=PiID,\u2212$ (connected by assumption), connectivity of $PiID,+$ follows. Now consider $PjID,\u2009j\u2260i$. If $Tj\u2212\u22600$, then $PjID,+=PjID,\u2212$ is connected. Suppose $Tj\u2212=0$ and $PjID,+$ is not connected. By Proposition 2, $Pj+\u2229P\u2113ID,+=\u2205$ for any $\u2113\u2209{i,j}$. Thus, there exists $k1\u2208PjID,+$ such that (i) $k1\u2209Piadd(ci+)$, and (ii) any optimal path in $G(Pj+)$ spanning *k*_{1} and $cj+$ contains some $k2\u2208Piadd(ci+)=Pi+$. Select one such path and vertex *k*_{2}. Without loss of generality, assume {*k*_{1}, *k*_{2}} ∈ *E*. Definition 1 implies $(1/si)dPi+(k2,ci+)<min{(1/s\u2113)dP\u2113+(k2,c\u2113+)\u2009|\u2009\u2113\u2260i,k2\u2208P\u2113+}$ and thus $(1/si)dPi+\u222a{k1}(k1,ci+)<(1/sj)dPj+(k1,cj+)$. Since $Tj\u2212=0$ and $IDk1\u2212=j$, Proposition 2 implies $(1/si)dPi+\u222a{k1}(k1,ci+)<(1/sj)dPj+(k1,cj+)=min{(1/s\u2113)dP\u2113+(k1,c\u2113+)\u2009|\u2009\u2113\u2260i,k1\u2208P\u2113+}$, contradicting $k1\u2209Piadd(ci+)$. Thus, $PjID,+$ is connected. Invoking Proposition 2—statement 3, the inductive assumption holds for all *t* prior to the *p* + 1st exchange, implying well-posedness.

*Proof of Theorem 2*.

*Statement 1*: The proof of Theorem 1 implies the statement.

*Statement 2*: *P* is an *m*-covering of *Q* since $PID$ is an *m*-partition of *Q*, and $PiID\u2286Pi$ for any *i* (Proposition 2—statement 1). The covering *P* is connected, since $Pi=PiID$ (connected by statement 1) immediately following any agent–cloud exchange and is unchanged in between updates.

*Statement 3*: It suffices to show $IDci=i$ for any *t*, *i*: this would imply *c _{i}* ≠

*c*for any

_{j}*i*≠

*j*, and

*c*∈

_{i}*P*(Proposition 2). Since $IDci=i$ for all

_{i}*i*at

*t*= 0, the same holds for any

*t*prior to the first agent–cloud exchange. Suppose $IDci=i$ for all

*i*(thus

*c*≠

_{i}*c*for any

_{j}*i*≠

*j*) prior to the

*p*th exchange. If agent

*i*is the

*p*th communicating agent, lines 2 and 9 of Algorithm 1 imply $IDci++=i$. Since $dPj\u2212(cj\u2212,cj\u2212)=0$ for any

*j*, we have $cj+\u2209Piadd(ci+)$. Thus, $IDcj++=j$, and induction proves the statement.

*Statements 4 and 5*: Statement 4 follows from Eq. (1), noting that $PiA=Pi$. Statement 5 holds by assumption when *t* = 0. Let *k* ∈ *Q*, and consider times when ID* _{k}* changes (

*k*is

*reassigned*). Since $supp(\Phi jA(\xb7,t))=Pj=PjA$ for any

*j*at

*t*= 0, statement 4 implies that, for any

*t*prior to the first reassignment,

*k*belongs exclusively to $supp(\Phi IDkA(\xb7,t))$. Suppose statement 5 holds for all

*t*prior to the

*p*th reassignment (occurring at time

*t*

_{0}), and $IDk\u2212=j,\u2009IDk+=i\u2260j$. Then, $Tj\u2212=0$ and

*k*belongs exclusively to $Pj\u2212$ when $t=t0\u2212$ (Proposition 2). By Algorithms 1 and 2, $k\u2208PiA,pd,+$ and $Ti+>\omega j++\Delta \xaf\u2212t0\u2265\tau iA,+$. Since $supp(\Phi iA(\xb7,t))$ is unchanging over an interval of length at least $Ti+\u2265\tau iA,+$, (1) implies $k\u2209supp(\Phi iA(\xb7,t))$ when $t\u2208[t0+,t0++\tau iA,+]$. Since

*k*is reassigned when

*t*=

*t*

_{0}, $k\u2208Pi+\PiID,\u2212$ and $Tj+=\omega j++\Delta \xaf\u2212t0$. Agent

*j*will communicate with the cloud at some time $t1<t0+Tj+=\omega j++\Delta \xaf<t0+Ti+$. Thus,

*T*> 0 when

_{i}*t*=

*t*

_{1}, and

*k*is removed from both

*P*and $supp(\Phi jA(\xb7,t))$. Thus, for all $t>t0+\tau i+$ and before the

_{j}*p*+ 1st reassignment,

*k*belongs exclusively to $supp(\varphi i(\xb7,t))$.

*Proof of Theorem 3.* Theorem 2 implies statement 1.

*Statement 2*: For any *i*, (i) *T _{i}* = 0 when

*t*= 0, and (ii) $(1/si)dQ\u2032(k1,k2)\u2264d\xaf$ for any connected $Q\u2032\u2286Q,\u2009k1,k2\u2208Q\u2032$. Thus, it is straightforward to show, for any

*i*,

*t*, we have the bound $Ti\u2264\Delta \xaf+\Delta H+d\xaf$. We show by induction that, for any

*i*,

*t*, the bound $\tau iA\u2212t+\omega iA\u2264Ti\u2212\Delta H$ also holds:

*T*= 0 and $\tau iA=\u2212\Delta H$ when

_{i}*t*= 0, so $\tau iA\u2212t+\omega iA=\tau iA\u2264Ti\u2212\Delta H$, and the bound holds prior to the first cloud–agent exchange involving

*any*agent, since $\tau iA\u2212t=\tau iA\u2212t+\omega iA\u2264\u2212\Delta H\u2264Ti\u2212\Delta H$ at any such time. Assume the bound holds prior to the

*p*th exchange (occurring at

*t*=

*t*

_{0}). Consider two cases: if agent

*i*is the communicating agent, then $\tau iA,+\u2212t+\omega iA=\tau i+:=Ti+\u2212\Delta H$; if not, then $\tau iA,+=\tau iA,\u2212$ and either (i) $Ti\u2212=Ti+$ implying the desired bound, or (ii) $Ti\u2212=0$ and $\tau iA,+\u2212t0+\omega iA,+=\tau iA,\u2212\u2212t+\omega iA,\u2212\u2264Ti\u2212\u2212\Delta H=\u2212\Delta H\u2264(\omega iA,++\Delta \xaf\u2212t0)\u2212\Delta H=Ti+\u2212\Delta H$. This logic extends to all

*t*prior to the

*p*+ 1st exchange and the desired bound follows by induction.

Using the aforementioned two bounds, we have $\tau iA+\omega iA\u2264t+\Delta \xaf+d\xaf$. Fix *t* and $k\u2208Prohi(t)\u2229Pi$. Then, $k\u2208PiA,+=Pi+,\u2009k\u2208PiA,pd,+$, and $t\u2212\omega iA,+<\tau iA,+$ (+ is with respect to the fixed time *t*). Further, over the interval $[t,\omega iA,++\tau iA,+]$, the vertex *k* is not reassigned, *P _{i}* is not augmented, and $\tau iA$ is unchanged. Therefore, $k\u2209Prohi(\omega iA,++\tau iA,+)$. Setting $t0:=\omega iA,++\tau iA,+$, we have $t<t0\u2264t+\Delta \xaf+d\xaf$. Since $Ti\u2265\tau iA+\Delta H$ at time $\omega iA,+$,

*k*is not reassigned during the interval $[\omega iA,+,\omega iA,++Ti+]\u2287[\omega iA,+,t0+\Delta H]\u2287[t0,t0+\Delta H]$. Thus, $k\u2208Pi\Prohi(\xb7)$ over the same time interval.

*Statement 3*: Fix

*t*and suppose $k\u2208Pi\u2212\Pi+$ (in this proof, “+ and −” are with respect to

*t*). Then, (i) ID

*changed (*

_{k}*k*was reassigned) at time

*t*

_{0}<

*t*, (ii) agent

*i*exchanges data with the cloud at time

*t*, and (iii) no exchanges involving agent

*i*occurred during the interval [

*t*

_{0},

*t*). Upon reassignment at time

*t*

_{0}, Algorithm 2 specifies that (i)

*T*is reset to value $\omega iA,\u2212+\Delta \xaf\u2212t0$, thus $PiID$ is unchanged over the interval [

_{i}*t*

_{0},

*t*), (ii)

*k*is added to $PIDkA,pd$, and (iii) $\tau IDkA\u2009and\u2009TIDk$ are given values of at least

implying that $PIDk,ProhIDk(\xb7)$ are constant over the interval $(t0,\omega \u0303]\u2287(t0,t+(1/si)dPi\u2212(k,PiID,\u2212)]\u2287(t0,t]$.

Since coverage regions are connected and nonempty (Theorem 2), and $Pi\u2212\u2229P\u2113ID=\u2205$ for any $\u2113\u2209{i,IDk+}$ on the interval (*t*_{0}, *t*] (Proposition 2), (i) there exists a path of length $dPi\u2212(k,PiID,\u2212)$ from *k* into $PiID,\u2212$ and every vertex along any such path (except the terminal vertex) lies within $Pi\u2212\Pi+$, and (ii) $Pi\u2212\Pi+\u2286ProhIDk+(\xb7)$ over the interval $(t0,\omega \u0303]\u2287[t,t+(1/si)dPi\u2212(k,PiID,\u2212)]$. Since (i) each vertex belongs to at most two coverage regions (Proposition 2), (ii) $k\u2208Pi\u2212\Pi+$, and (iii) no agent claims vertices within $ProhIDk+(\xb7)\u2229PIDk+$ when $TIDk+>0$, vertices along the path (excluding the terminal vertex) do not belong to *P _{j}* with

*j*≠ ID

*over $[t,t+(1/si)dPi\u2212(k,PiID,\u2212)]$. To complete the proof, Algorithm 2 implies $Ti+>(1/si)dPi\u2212(k,PiID,\u2212)$, and thus $PID,\u2212\u2286Pi$ over $[t,t+(1/si)dPi\u2212(k,PiID,\u2212)]$.*

_{k}Proposition 3 (Cost). Suppose Assumption 1 holds and that, during each agent–cloud exchange, the cloud updates relevant global and local coverage variables via Algorithm 1. If $\Phi (\xb7,t1)=\Phi (\xb7,t2)$ for all *t*_{1}, *t*_{2}, then $H(c,PID,\xb7)=H(c,P,\xb7)$.

*Proof.* Since Φ is time-invariant, $H(\xb7,\xb7,t1)=H(\xb7,\xb7,t2)$ for any *t*_{1}, *t*_{2}. When *t* = 0, $P=PID$, and $H(c,PID,0)=H(c,P,0)$. The same is true prior to the first agent–cloud exchange. Suppose that, prior to the *p*th exchange (occurring at *t* = *t*_{0}, involving agent *i*), we have $H(c\u2212,PID,\u2212,t0)=H(c\u2212,P\u2212,t0)$. Recall that, for any *j*, *P _{j}* and $PjID$ coincide immediately following any exchange involving agent

*j*and, if agent

*j*claims vertices from

*P*, then Algorithm 2 ensures that agent

_{i}*i*exchanges data with the cloud before additional vertices are claimed by other agents. Considering the

*p*th update, this logic, along with Proposition 2, implies that $PiID,\u2212\u2229Pj\u2212=\u2205$, for all

*j*≠

*i*. Noting that $ci+\u2208PiID,\u2212$, we deduce that any $k\u2208PiID,\u2212$ contributes equivalently to $H(c+,PID,+,t0)$ and $H(c+,P+,t0)$. If $k\u2208Piadd(ci+)\PiID,\u2212$, then for any

*j*≠

*i*such that $k\u2208Pj+$, we have $(1/si)dPi+(k,ci+)<(1/sj)dPj+(k,cj+)$ (Definition 1), implying

*k*contributes equivalently to $H(c+,PID,+,t0)$ and $H(c+,P+,t0)$. Now suppose $k\u2208Pj+\Pi+$, where $Pj+\u2229Pi+\u2260\u2205$. We show that $dPjID,+(cj+,k)=dPj+(cj+,k)$ : if a length-minimizing path in $G(Pj+)$ between $cj+$ and

*k*is also contained in $G(PjID,+)$, the result is trivial. Suppose that every such minimum-length path leaves $G(PjID,+)$. By Proposition 2, every $k\xaf\u2208Pj+$ must satisfy $IDk\xaf+\u2208{i,j}$. Thus, assume without loss of generality that

*k*is adjacent to $Pi+$. Let $k\xaf\u2208Pi+$ be a vertex that is adjacent to

*k*and lies along a minimum-length path in $G(Pj+)$ spanning $cj+$ and

*k*. Since $k\xaf\u2208Pi+\PiID,\u2212$, we have $k\xaf\u2208Piadd(ci+)$ as constructed during the update, implying $(1/si)dPi+(k\xaf,ci+)<min{(1/s\u2113)dP\u2113+(k\xaf,c\u2113+)\u2009|\u2009\u2113\u2260i,k\xaf\u2208P\u2113+}$ and thus $(1/si)dPi+\u222a{k}(k,ci+)<(1/sj)dPj+(k,cj+)$. Since $Tj\u2212=0$ and $IDk\u2212=j$, Proposition 2 implies $(1/si)dPi+\u222a{k}(k,ci+)<1sjdPj+(k,cj+)=min{(1/s\u2113)dP\u2113+(k,c\u2113+)\u2009|\u2009\u2113\u2260i,P\u2113+}$, contradicting $k\u2209Piadd(ci+)\u2282Pi+$. Thus, $dPjID,+(cj+,k)=dPj+(cj+,k)$, which, by inductive assumption, implies that

*k*contributes equally to the value of both $H(c+,PID,+,t0)$ and $H(c+,P+,t0)$. We conclude $H(c+,PID,+,t0)=H(c+,P+,t0)$. Since

*P*, $PID$, and

*c*are static between updates, the statement follows by induction.

*Proof of Theorem 4.* The cost $H(c,P,t)$ is static in between agent–cloud exchanges, as *P* and *c* are unchanged. Consider an exchange occurring at time *t*_{0} involving agent *i*. By Proposition 3, we have $H(c+,P+,t0)\u2264H(c\u2212,PID,\u2212,t0)=H(c\u2212,P\u2212,t0)$. Thus, the cost $H(c,P,t)$ is nonincreasing in time. Since Cov* _{m}*(

*Q*) is finite, there is some time

*t*

_{0}after which the value of $H$ is unchanging. Consider fixed

*t*>

*t*

_{0}at which some agent

*i*exchanges data with the cloud. Since the value of $H$ is unchanging, Algorithm 1 implies that $PID$ and

*c*are unchanged by the update. It follows that

*c*and $PID$ converge in finite time. Further, since $PiID\u2286Pi$ for any

*i*(Proposition 2), we have $PiID,\u2212=PiID,+=PiID,\u2212\u222aPiadd(ci+)=Pi+$. By persistence of exchanges imposed by $\Delta \xaf$, this implies that after some finite time,

*P*and $PID$ are concurrent.

To prove Pareto optimality of the limiting configuration, consider *t*_{0}, such that for all *t* > *t*_{0}, (*c*, *P*) is unchanging and *P* is an *m*-partition of *Q*. Timers are only reset when *P* is altered, so assume without loss of generality that *T _{i}* = 0 for all

*i*at any

*t*>

*t*

_{0}. Suppose agent

*i*exchanges data with the cloud at time

*t*>

*t*

_{0}. Algorithm 1 implies that there is no

*k*∈

*P*such that $\u2211h\u2208PidPi(h,k)\Phi (h,t)<\u2211h\u2208PidPi(h,ci)\Phi (h,t)$ (if not, the cost is lowered by moving

_{i}*c*). Similarly, for

_{i}*k*∈

*P*with

_{j}*j*≠

*i*that is adjacent to

*P*, we have $(1/si)dPi\u222a{k}(ci,k)\u2265(1/sj)dPj(cj,k)$ (if not, there exists $k\u2208Piadd(ci+)\Pi\u2212$, contradicting convergence). As such, for any

_{i}*i*, there is no $Q\u2032\u2282Q\Pi$ such that $\u2211k\u2208Q\u2032(1/si)dPi\u222aQ\u2032(ci,k)<\u2211k\u2208Q\u2032min{(1/sj)dPj(cj,k)\u2009|\u2009k\u2208Pj,j\u2260i}$, implying statement 2 of Definition 2.

*Proof of Theorem 5.* By Assumption 2, each agent's local trajectory planner never directs the agent into its prohibited region, so if no agent–cloud exchange occurs that removes the vertex corresponding to the relevant agent's location from its coverage region, then the statement is immediate. Suppose, at some time *t*_{0}, agent *i*, whose location is associated with some $k\u2208PiA,\u2212$, exchanges data with the cloud and *k* is removed, i.e., $k\u2209PiA,+$. At time $t0+$, agent *i* executes lines 5 and 6 of Algorithm 3. Theorem 3 ensures that (i) there exists a path in $G(PiA,\u2212)$ between *k* and $PiID,\u2212$, (ii) all vertices along the path belong to $ProhIDk+(t\xaf)\\u222aj\u2260IDk+Pj+$ whenever $t\xaf\u2208(t0,t0+(1/si)dPiA,\u2212(k,PiID,\u2212)]$, and (iii) $PiID,\u2212\u2286Pi:=PiA$ over the same interval. Thus, if agent *i* immediately moves along the path, it will lie exclusively within $ProhIDk+(\xb7)$ until it reaches $PiA,+$. It remains to show that the agent does not enter $Prohi(\xb7)\u2229Pi+$ while traversing the aforementioned path. Without loss of generality, consider the update at time *t*_{0} previously described. Since *k* is reassigned prior to the update, we have $Prohi(t0\u2212)\u2229Pi\u2212=\u2205$ (vertices in *P _{i}* are not claimed unless

*T*= 0, implying $t0\u2212\omega iA,\u2212>\tau iA,\u2212$). By Proposition 2, we deduce $TIDk++>0$, so no vertices in $PiA,\u2212\u2229PIDk++$ can belong to $PiA,pd,+$, and no vertex on the constructed path belongs to $Prohi(t0+)$. Since $Ti+>\tau iA,+>(1/si)dPiA,\u2212(k,PiID,\u2212),\u2009Prohi(\xb7)$ is constant over the interval $(t0,t0+(1/si)dPiA,\u2212(k,PiID,\u2212)]$.

_{i}Each agent is uniquely paired with a coverage region, so the quantity *m* represents both the number of agents and the number of regions.

Mathematically, the bound $\Delta \xaf$ also prevents *Zeno behavior*.

Travel between the elements without leaving their union is possible.

Φ(⋅, *t*) is a probability mass function for any *t*.

$\Phi iA$ is not normalized and thus may not be a time-varying probability mass function in a strict sense.

Δ* _{H}* represents, loosely, the amount of time an agent must hold a vertex before it can be reassigned. Precise characterization is in Sec. 4.3.