Multi-Robot Routing for Persistent Monitoring with Latency Constraints

TL;DR

This paper addresses multi-robot persistent monitoring with latency constraints, proposing approximation and heuristic algorithms, and demonstrating their effectiveness through simulations and benchmarks.

Contribution

It introduces a $O(\log ho)$ approximation algorithm and a heuristic for multi-robot routing under latency constraints, with empirical evaluation.

Findings

Heuristic often outperforms the approximation algorithm in simulations.

Algorithms effectively handle large problem instances.

Comparison with existing solvers shows competitive performance.

Abstract

In this paper we study a multi-robot path planning problem for persistent monitoring of an environment. We represent the areas to be monitored as the vertices of a weighted graph. For each vertex, there is a constraint on the maximum time spent by the robots between visits to that vertex, called the latency, and the objective is to find the minimum number of robots that can satisfy these latency constraints. The decision version of this problem is known to be PSPACE-complete. We present a $O(\log \rho)$ approximation algorithm for the problem where $\rho$ is the ratio of the maximum and the minimum latency constraints. We also present an orienteering based heuristic to solve the problem and show through simulations that in most of the cases the heuristic algorithm gives better solutions than the approximation algorithm. We evaluate our algorithms on large problem instances in a patrolling scenario and in a persistent scene reconstruction application. We also compare the algorithms with an existing solver on benchmark instances.

Equations

$$s_i(k)=\{\begin{array}{ll}r(i)& \text{if }p(k)=i\\ s_i(k-1)-l(p(k-1),p(k))& \text{otherwise}.\end{array}$$

Full text

I Introduction

With the rapid development in field robotics, teams of robots can now perform long term monitoring tasks. Examples of such tasks include infrastructure inspection [1] to detect presence of anomalies or failures; patrolling for surveillance [2, 3] to detect threats in the environment; 3D reconstruction of scenes [4, 5] in changing environments; informative path planning [6] for observing dynamic properties of an area; and forest fire monitoring [7]. In such persistent monitoring scenarios, locations in an environment need to be visited repeatedly by a team of robots. Since the duration of the events, or the rate of change of the properties to be monitored, can be different for different locations, each location will have a different latency constraint, which specifies the maximum time allowed between consecutive visits to that location. In this paper we study the problem of finding a set of paths that continually visit a set of locations while collectively satisfying the latency constraints on each location.

We represent the locations of interest in the environment as the vertices of a graph. The edge weights give the travel time between the vertices and each vertex has a latency constraint that defines the maximum allowed time between two consecutive visits to that vertex. The problem is to find walks on the graph for the minimum number of robots that can satisfy the latency constraints.

Related Work: Persistent monitoring problems have been extensively studied in the literature [8, 9, 10, 11]. In [12], persistent coverage using multiple robots in a continuous environment is considered. The problem of determining a visit sequence for a set of locations along with the time spent at each location to gather information is considered in [13, 14]. For the problem with latency constraints, the authors in [15] use incomplete greedy heuristics to find if a single robot can satisfy the constraints on all vertices of a graph. They show that if a solution exists, then a periodic solution also exists. In this paper, we consider the multi-robot problem and our objective is to minimize the number of robots that can satisfy the latency constraints on the given graph. This problem has been considered in [16, 17], where it is called Cyclic Routing of Unmanned Aerial Vehicles. The decision version of the problem for a single robot is shown to be PSPACE-complete in [17]. The authors also show that the length of even one period of a feasible walk can be exponential in the size of the problem instance. In [16], the authors propose a solver based on Satisfiability Modulo Theories (SMT). To apply an SMT solver, they impose an upper bound on the length of the period of the solution. Since an upper bound is not known a priori, the solver will not return the optimal solution if the true optimal period exceeds the bound. The authors generate a library of test instances, but since their algorithm scales exponentially with the problem size, they solve instances up to only 7 vertices. We compare our algorithms with their solver and show that our algorithms run over $500$ times faster on average and return solutions with the same number of robots on $98\%$ of the benchmark instances provided by [16].

A related single robot problem is studied in [18] where each vertex has a weight associated with it and the objective is to minimize the maximum weighted latency (time between consecutive visits) for an infinite walk. The authors provide an approximation algorithm for this problem. The authors in [2] study the single robot problem for a security application where the length of attack on each vertex of the graph is given. To intercept all possible attacks, they design an algorithm to repeatedly patrol all vertices with the maximum revisit time to each vertex less than its length of attack.

Timed automata have been used to model general multi-robot path planning problems [19] as the clock states can capture the concurrent time dependent motion. In [20], temporal logic constraints are used to specify high level mission objectives to be achieved by a set of robots. The routing problem with latency constraints can also be modeled as a timed automaton since multiple robots may require synchronization to satisfy the latency constraints. A timed automaton based solution to the problem is presented in [21], however it is shown to perform more poorly than the SMT-based approach in [16], which we use as a comparison for our proposed algorithms.

Several vehicle routing problems are closely related to persistent monitoring with latency constraints. In the vehicle routing problem with time windows [22], customers have to be served within their time windows by several vehicles with limited capacity. The goal is to minimize the number of vehicles required. Since the problem does not require repeated visits, the length of the resulting tour is polynomially bounded, and thus the problem is in NP. In the deadline-TSP [23], the vertices have deadlines for first visits. In the period vehicle routing problem [24], the problem is to design routes for each day of a given period where each customer may require a number of visits (in a given number of allowable combinations) during this period. The main difference between these problems and the cyclic routing problem with latency constraints is that the latency constraints need to be satisfied indefinitely which makes it harder than these problems.

Contributions: We present a $O(\log\rho)$ approximation algorithm for the problem where $\rho$ is the ratio of the maximum and the minimum latency constraints (Section IV). We also provide an algorithm for the problem of minimizing the maximum weighted latency with multiple robots and show that an approximation algorithm for this problem yields a bi-criterion approximation for our problem. We present an orienteering based heuristic algorithm to solve the problem and prove its completeness (Section V). We show through simulations that the heuristic algorithm gives better solutions than the approximation algorithm. We evaluate the performance of the algorithms on large problem instances in a patrolling scenario and in an image collection application for 3D scene reconstruction. We also compare our algorithms against an existing solver on benchmark instances (Section VI).

II Background and Notation

Given a directed graph $G=(V,E)$ with edge lengths $l(e)$ for each $e\in E$, a simple walk in graph $G$ is defined as a sequence of vertices $(v_{1},v_{2},\ldots,v_{k})$ such that $(v_{i},v_{i+1})\in E$ for each $1\leq i<k$. An infinite walk is a sequence of vertices $(v_{1},v_{2},\ldots)$ such that $(v_{i},v_{i+1})\in E$ for each $i\in\mathbb{N}$. Given walks $W_{1}$ and $W_{2}$, $[W_{1},W_{2}]$ represents the concatenation of the walks. Given a finite walk $W$, an infinite periodic walk is constructed by concatenating infinite copies of W together, and is denoted by $\Delta(W)$. A cycle is a simple walk that starts and ends at the same vertex with no other vertex appearing more than once.

In general, a walk can stay for some time at a vertex before traversing the edge towards the next vertex. Therefore we define a timed walk $W$ in graph $G$ as a sequence $(o_{1},o_{2},\ldots,o_{k})$, where $o_{i}=(v_{i},t_{i})$ is an ordered pair that represents the holding time $t_{i}$ that the walk $W$ spends at vertex $v_{i}$, such that $(v_{i},v_{i+1})\in E$ for each $1\leq i<k$. The definitions of infinite walk and periodic walk can be extended to infinite timed walk and periodic timed walk. A walk with ordered pairs of the form $(v_{i},0)$ becomes a simple walk. The vertices traversed by walk $W$ are given by $V(W)$ and the length of walk $W=((v_{1},t_{1}),(v_{2},t_{2}),\ldots,(v_{k},t_{k}))$ is given by $l(W)=\sum_{i=1}^{k-1}{l(v_{i},v_{i+1})}+\sum_{i=1}^{k}{t_{k}}$. Since we are considering a multi-robot problem, synchronization between the walks is important. Given a set of walks $\mathcal{W}=\{W_{1},W_{2},\ldots,W_{k}\}$ on graph $G$, we assume that at time [math], each robot $i$ is at the first vertex $v^{i}_{1}$ of its walk $W_{i}$, and will spend the holding time $t^{i}_{1}$ at that vertex before moving to $v^{i}_{2}$.

Given a graph $G$ and length $\lambda$, the Minimum Cycle Cover Problem (MCCP) is to find minimum number of cycles that cover the whole graph such that the length of the longest cycle is at most $\lambda$. This problem is NP-hard and a $14/3$-approximation algorithm for MCCP is given in [25].

Given a graph $G=(V,E)$ with vertex weights $\psi_{i}$ for $i\in V$, and length $\lambda$, the Orienteering problem is to find a path from vertex $s$ to $t$ of length at most $\lambda$ such that the sum of the weights on the vertices in the path is maximized. This problem is also NP-hard and a $(2+\epsilon)$-approximation is given in [26].

III Problem Statement

Let $G=(V,E)$ be a directed weighted graph with edge lengths $l(e)$ for each $e\in E$. The edge lengths are metric and represent the time taken by the robot to travel between the vertices. The latency constraint for each vertex $v$ is denoted by $r(v)$ and represents the maximum time allowed between consecutive visits to $v$. The time taken by the robots to inspect a vertex can be added to the length of the incoming edges of that vertex to get an equivalent metric graph with zero inspection times and modified latency constraints [16]. Hence, we assume that the time required by the robots to inspect a vertex is zero. We formally define the problem statement after the following definition.

Definition III.1** (Latency).**

Given a set of infinite walks $\mathcal{W}=\{W_{1},W_{2},\ldots,W_{k}\}$ on a graph $G$, let $a^{v}_{i}$ represent the $i^{th}$ arrival time for the walks to vertex $v$. Similarly, let $d^{v}_{i}$ represent the $i^{th}$ departure time from vertex $v$. Then the latency $L(\mathcal{W},v)$ of vertex $v$ on walks $\mathcal{W}$ is defined as the maximum time spent away from vertex $v$ by the walks, i.e., $L(\mathcal{W},v)=\sup_{i}{(a^{v}_{i+1}-d^{v}_{i})}$.

Problem III.2** (Minimizing Robots with Latency Constraints).**

Given the latency constraints $r(v),\forall v\in V$, the optimization problem is to find a set of walks $\mathcal{W}$ with minimum cardinality such that $L(\mathcal{W},v)\leq r(v),\forall v\in V$.

The decision version of the problem is to determine whether there exists a set of $R$ walks $\mathcal{W}=\{W_{1},W_{2},\ldots,W_{R}\}$ such that $L(\mathcal{W},v)\leq r(v)$ for all $v\in V$. Note that a general solution to Problem III.2 will be a set of timed walks with possibly non-zero holding times.

In this problem definition, the graph and its edge lengths capture the robot motion in the environment. This graph can be generated from a probabilistic roadmap, or any other environment decomposition method. The latency constraints provide the maximum allowable time between visits to a vertex. For example, in dynamic scene reconstruction, each vertex corresponds to a viewpoint [4]. The latency constraints may encode the maximum staleness of information that can be tolerated for the voxels captured at that viewpoint.

III-A Multiple Robots on the Same Walk

In multi-robot problems that involve finding cycles or tours in a graph, equally placing $n$ robots on a tour reduces the cost of that tour by a factor of $n$ [27]. That is not true for Problem III.2: if a periodic walk $W$ gives latency $L(W,v)$ on vertex $v$, equally spacing more robots on one period of that walk does not necessarily reduce the latency for that vertex. Figure 1 gives an example of such a walk. The latency of vertices $a,b$ and $c$ on the walk $(a,b,a,c)$ are $2,4$ and $4$ respectively. The length of one period of the walk is $4$. If we place another robot following the first robot with a lag of $2$ units, the latency of vertex $a$ remains the same. If we place the second robot at a lag of $1$ unit, the latency will reduce to $1$ for vertex $a$ and $3$ for vertices $b$ and $c$. Hence we need more sophisticated algorithms than finding a walk for a single robot and adding more robots on that walk until the constraints are satisfied, unless that walk is a cycle.

IV Approximation Algorithm

Since Problem III.2 is PSPACE-complete, we resort to finding approximate and heuristic solutions to the problem. In this section, we present an approximation algorithm for the problem.

IV-A $O(\log\rho)$* Approximation*

We first mention a simple approach to the problem and then improve it incrementally to get the approximation algorithm. One naive solution is to find a TSP tour of the graph and equally place robots on that tour to satisfy all the latency constraints. However, a single vertex with a very small $r(v)$ can result in a solution with the number of robots proportional to $1/r(v)$. To solve this issue, we can partition the vertices of the graph such that the latencies in one partition are close to each other, and then place robots on the TSP tour of each partition. If more than one robot is required for a partition $V^{\prime}$, then another approach is to solve the MCCP for that partition. The benefit of using the MCCP over placing multiple robots on a TSP is that if all the vertices in $V^{\prime}$ had the same latency requirement, then we have a guarantee on the number of cycles required for that partition. However, a general solution to the problem might not consist of simple cycles. Lemma IV.2 relates solutions consisting of cycles to general solutions and shows that a solution consisting of cycles will have latencies no more than twice that of any general solution with same number of robots. Therefore, if we solve the MCCP on a partition with its latency constraints multiplied by two, we have a guarantee on the number of cycles. We can then use the naive idea from TSP based solutions and place multiple robots on each cycle to satisfy the latency constraints.

The approximation algorithm is given in Algorithm 1. The first four lines of the algorithm partition the vertices according to their latency constraints. For each of those partitions, the function MCCP$(V,\lambda)$ called in line 8 uses an approximation algorithm for the minimum cycle cover problem from [25]. Then, the appropriate number of robots are placed on each cycle returned by the MCCP function to satisfy the latency constraints. We will need the following definition to establish the approximation ratio of Algorithm 1. A similar relaxation technique was used in [18].

Definition IV.1**.**

Let $r_{\texttt{min}}=\min_{v}r(v)$. The latency constraints of the problem are said to be relaxed if for any vertex $v$, its latency constraint is updated from $r(v)$ to $\bar{r}(v)=r_{\texttt{min}}2^{x}$ such that $x$ is the smallest integer for which $r(v)<r_{\texttt{min}}2^{x}$.

We will also need the following lemma that follows from Lemma 2 in [27] and we omit the proof for brevity.

Lemma IV.2**.**

For any set of walks $\mathcal{W}$ on an undirected metric graph with vertices $V$, there exists a set of walks $\mathcal{W}^{\prime}$ on $V$ with $|\mathcal{W}|=|\mathcal{W}^{\prime}|$, such that each walk $W_{i}\in\mathcal{W}^{\prime}$ is a cycle of vertices $V_{j}\subseteq V$, and the sets $V_{j}$ partition $V$, and $\max_{v}L(\mathcal{W}^{\prime},v)\leq 2\max_{v}L(\mathcal{W},v)$.

The following proposition gives the approximation factor of Algorithm 1.

Proposition IV.3**.**

Given an undirected metric graph $G=(V,E)$ with latency constraints $r(v)$ for $v\in V$, Algorithm 1 constructs $R$ walks $\mathcal{W}=\{W_{1},W_{2},\ldots,W_{R}\}$ such that $L(\mathcal{W},v)\leq r(v)$ for all $v\in V$ and $R\leq 4\alpha\lceil\log(\rho)\rceil R_{\texttt{OPT}}$, where $R_{\texttt{OPT}}$ is the minimum number of robots required to satisfy the latency constraints and $\alpha$ is the approximation factor of MCCP.

Proof.

Given that $R_{\texttt{OPT}}$ robots will satisfy the latency constraints $r(v)$, they will also satisfy the relaxed constraints $\bar{r}(v)$ since $\bar{r}(v)>r(v)$. Therefore, there exists a set of at most $R_{\texttt{OPT}}$ walks $\mathcal{W}^{*}$ such that for $v\in V_{i}$, $L(\mathcal{W}^{*},v)\leq r_{\texttt{min}}2^{i}$.

Using Lemma IV.2, given the set $\mathcal{W}^{*}$, $R_{\texttt{OPT}}$ cycles can be constructed in $V_{i}$ such that the latency of each vertex in $V_{i}$ is at most $r_{\texttt{min}}2^{i+1}$. Hence, running an $\alpha$ approximation algorithm for Minimum Cycle Cover Problem (MCCP) on the subgraph with vertices $V_{i}$ and with maximum cycle length $r_{\texttt{min}}2^{i+1}$ will not return more than $\alpha R_{\texttt{OPT}}$ cycles.

Since MCCP returns cycles, equally placing $k$ robots on each cycle will reduce the latency of each vertex on that cycle by a factor of $k$. As $r(v)\geq r_{\texttt{min}}2^{i+1}/4$ for each $v\in V_{i}$, we will need to place at most $4$ robots on each cycle.

Finally, since there are at most $\lceil\log\rho\rceil$ partitions $V_{i}$, the algorithm will return $R\leq 4\alpha\lceil\log(\rho)\rceil R_{\texttt{OPT}}$ walks. ∎

Runtime: Since we run the approximation algorithm for MCCP on partitions of the graph, the runtime of Algorithm 1 is the same as that of the approximation algorithm of MCCP. That is because the runtime of MCCP is superlinear, so if $\sum|V_{i}|=|V|$, then $\sum|V_{i}|^{p}\leq|V|^{p}$ for $p\geq 1$.

Remark IV.4* (Heuristic Improvements).*

Instead of finding cycles using MCCP for each partition $V_{i}$ in line 8 of the algorithm, we can also equally place robots on the Traveling Salesman Tour of $V_{i}$ to get a feasible solution. In practice, we use both of these methods and pick the solution that gives the lower number of robots for each $V_{i}$. This modification can return better solutions to the problem but does not improve the approximation guarantee established in Proposition IV.3.

IV-B Relation to Min Max Weighted Latency

The approximation algorithm and analysis presented above helps in formulating an algorithm for the multi-robot version of a related problem. In [18], the authors study in detail the problem of minimizing the maximum weighted latency of a graph given a single robot. Here we define the multiple robot version of the problem.

Problem IV.5** (Minimizing Maximum Weighted Latency:).**

Given a graph $G=(V,E)$ with weights $\phi(v)$ for $v\in V$, and a set of walks $\mathcal{W}$, the weighted latency of $v$ is defined as $C(\mathcal{W},v)=\phi(v)L(\mathcal{W},v)$. Given the number of robots $R$, the problem of minimizing maximum weighted latency is to find a set of $R$ infinite walks $\mathcal{W}=\{W_{1},W_{2},\ldots,W_{R}\}$ such that the cost $\max_{v}C(\mathcal{W},v)$ is minimized.

Without loss of generality, $\phi(v)$ is assumed to be normalized such that $\max_{v}\phi(v)=1$. In this section we relate this problem to Problem III.2.

In [18][Algorithm 2], an approximation algorithm for the single robot version of Problem IV.5 is given. We will refer to that approximation algorithm as MinMaxLatencyOneRobot$(G_{j})$, which returns a walk in graph $G_{j}$ such that the maximum weighted latency of that walk is not more than $(8\log\rho_{j}+10)\texttt{OPT}_{1}^{j}$, where $\rho_{j}$ is the ratio of maximum to minimum vertex weights in $G_{j}$ and $\texttt{OPT}_{1}^{j}$ is the optimal maximum weighted latency for one robot in $G_{j}$. We use this approximation algorithm as a subroutine in Algorithm 2 for minimizing the maximum weighted latency with multiple robots.

Proposition IV.6**.**

Given an instance of Problem IV.5, Algorithm 2 constructs $R$ walks such that the maximum weighted latency of the graph is not more than $(\frac{8\log\rho}{R}+10)\texttt{OPT}_{1}$ if $R\leq\log\rho$ and $3\texttt{OPT}_{1}/\lfloor R/\lceil\log\rho\rceil\rfloor$ otherwise, where \rho=\max\frac{\phi(v_{i})}{\phi(v_{j})}\ and $\texttt{OPT}_{1}$ is the maximum weighted latency of the single optimal walk.

Proof.

The maximum vertex weight in the subgraph $G_{j}$ constructed at line 8 of the algorithm will be at most $1/(2^{\frac{j-1}{R}\log\rho})$, whereas the minimum vertex weight in $G_{j}$ will be at least $1/(2^{\frac{j}{R}\log\rho})$. Hence the ratio of the maximum to minimum vertex weights in $G_{j}$ will be at most $\rho_{j}=2^{\frac{\log\rho}{R}}$. Therefore, the approximation algorithm for one robot will return a walk $W_{j}$ such that the maximum weighted latency of $W_{j}$ will not be more than $(8\log\rho_{j}+10)\texttt{OPT}_{1}^{j}$. Moreover, $\texttt{OPT}_{1}^{j}\leq\texttt{OPT}_{1}$ and hence if $R<\log\rho$, the maximum weighted latency will be at most $(\frac{8\log\rho}{R}+10)\texttt{OPT}_{1}$.

The TSP tour of $V_{i}$ is an optimal solution when all the vertex weights in $V_{i}$ are equal. Since the vertex weights within $V_{i}$ differ by a factor of $2$ at most, and the approximation factor of TSP tour in metric graphs is $3/2$, the maximum weighted latency of the TSP tour will be at most $3\texttt{OPT}_{1}$. Equally placing $\lfloor R/\lceil\log\rho\rceil\rfloor$ will decrease the latency of all the vertices by a factor of $\lfloor R/\lceil\log\rho\rceil\rfloor$. ∎

Note that Algorithm 2 bounds the cost of the solution by a function of the optimal cost of a single robot. This algorithm shows that $R$ robots can asymptotically decrease the weighted latency given by a single walk by a factor of $R$, which is not straightforward for this problem as discussed in Section III-A.

Now we show that if there is an approximation algorithm for Problem IV.5, it can be used to solve Problem III.2 using the optimal number of robots but with the latency constraints relaxed by a factor $\alpha$. This is referred to as a $(\alpha,1)$-bi-criterion algorithm [28] for Problem III.2.

Proposition IV.7**.**

If there exists an $\alpha$-approximation algorithm for Problem IV.5, then there exists a $(\alpha,1)$-bi-criterion approximation algorithm for Problem III.2.

We will need the following lemma relating the two problems to prove the proposition. Given an instance of the decision version of Problem III.2 with $R$ robots, let us define an instance of Problem IV.5 by assigning $\phi(v)=\frac{r_{\texttt{min}}}{r(v)},\forall v\in V$, where $r_{\texttt{min}}=\min_{v}r(v)$.

Lemma IV.8**.**

An instance of the decision version of Problem III.2 is feasible if and only if the optimal maximum weighted latency is at most $r_{\texttt{min}}$ for the corresponding instance of Problem IV.5.

Proof.

If the optimal set of walks $\mathcal{W}$ has a cost more than $r_{\texttt{min}}$, then $L(\mathcal{W},v)>r_{\texttt{min}}/\phi(v)=r(v)$ for some vertex $v$. Hence the latency constraint for that vertex is not satisfied and the set of walks $\mathcal{W}$ is not feasible.

If the optimal set of walks $\mathcal{W}$ has a cost at most $r_{\texttt{min}}$, then $L(\mathcal{W},v)\phi(v)\leq r_{\texttt{min}}$ for all $v$. Hence, $L(\mathcal{W},v)\leq r_{\texttt{min}}/\phi(v)=r(v)$. So, the latency constraints are satisfied for all vertices and $\mathcal{W}$ is feasible. ∎

Proof of Proposition IV.7.

If a problem instance of Problem III.2 with $R$ robots is feasible, then by Lemma IV.8 the optimal set of walks has a cost at most $r_{\texttt{min}}$. The $\alpha$-approximation algorithm for the corresponding Problem IV.5 will return a set of walks $\mathcal{W}$ with a cost no more than $\alpha r_{\texttt{min}}$. Hence, $L(\mathcal{W},v)\leq\alpha r_{\texttt{min}}/\phi(v)=\alpha r(v)$, for all $v$.

Hence, we can use binary search to find the minimum number of robots for which the $\alpha$-approximation algorithm for the corresponding Problem IV.5 results in a latency at most $\alpha r(v)$ for all $v$. This will be the minimum number of robots for which the problem is feasible. ∎

V Heuristic Algorithms

The approximation algorithm for Problem III.2 presented in Section IV is guaranteed to provide a solution within a fixed factor of the optimal solution. In this section, we propose a heuristic algorithm based on the orienteering problem, which in practice provides high-quality solutions.

V-A Partitioned Solutions

In general, walks in a solution of the problem may share some of the vertices. However, sharing the vertices by multiple robots requires coordination and communication among the robots. Such strategies may also require the robots to hold at certain vertices for some time before traversing the next edge, in order to maintain synchronization. This is not possible for vehicles that must maintain forward motion, such as fixed-wing aircraft. The following example illustrates that if vertices are shared by the robots, lack of coordination or perturbation in edge weights can lead to large errors in latencies.

Example: Consider the problem instance shown in Figure 2. An optimal set of walks for this problem is given by $\{W_{1},W_{2},W_{3}\}$ where $W_{1}=((a,1),(b,1))$, $W_{2}=((b,0),(c,0))$ and $W_{3}=((c,0),(d,1),(c,1))$. Note that walk $W_{1}$ starts by staying on vertex $a$, while $W_{2}$ leaves vertex $b$ and $W_{3}$ leaves vertex $c$. Also note that any partitioned solution will need $4$ robots. Moreover, if the length of edge $\{b,c\}$ changes from $3$ to $3-\epsilon$, (e.g., if the robot’s speed increases slightly) the latencies of vertices $b$ and $c$ will keep changing with time and will go up to $5$. Hence, a small deviation in robot speed can result in a large impact on the monitoring objective.

Since the above mentioned issues will not occur if the robots do not share the vertices of the graph, and the problem is PSPACE-complete even for a single robot, we focus on finding partitioned walks in this section. The general greedy approach used in this section is to find a single walk that satisfies latency constraints on a subset of vertices $V^{\prime}\subseteq V$. Note that we do not know $V^{\prime}$ beforehand, but a feasible walk on a subset of vertices will determine $V^{\prime}$. We then repeat this process of finding feasible walks on the remaining vertices of the graph until the whole graph is covered.

V-B Greedy Algorithm

We now consider the problem of finding a single walk on the graph $G=(V,E)$ that satisfies the latency constraints on the vertices in $V^{\prime}\subseteq V$. Given a robot walking on a graph, let $p(k)$ represent the vertex occupied by the robot after traversing $k$ edges (after $k$ steps) of the walk. Also, at step $k$, let the maximum time left until a vertex $i$ has to be visited by the robot for its latency to be satisfied be represented by $s_{i}(k)$. If that vertex is not visited by the robot within that time, we say that the vertex expired. Hence, the vector $s(k)=[s_{1}(k),\ldots,s_{|V^{\prime}|}(k)]^{T}$ represents the time to expiry for each vertex. At the start of the walk, $s_{i}(0)=r(i)$, and $s_{i}(k)$ evolves according to the following equation:

[TABLE]

We will use the notation $s_{i}$ without the step $k$ if it is clear that we are talking about the current time to expiry. An incomplete greedy heuristic for the decision version of the problem with $R=1$ is presented in [15]. The heuristic is to pick the vertex with minimum value of $s_{i}(k)$ as the next vertex to be visited by the robot. This heuristic does not ensure that all the vertices on the walk will have their latency constraints satisfied since the distance to a vertex $i$ to be visited might get larger than $s_{i}(k)$. To overcome this, we propose a modification to the heuristic to apply it to our problem. Given a walk $W$ on graph $G$, the function PeriodicFeasibility$(W,G)$ determines whether the periodic walk $\Delta(W)$ is feasible on the vertices that are visited by $W$. This can be done simply in $O(|W|)$ by traversing the walk $[W,W]$ and checking if the time to expiry for any of the visited vertices becomes negative. Given this function, the simple greedy algorithm is to pick the vertex $i=\operatorname*{arg\,min}\{s_{j}\}$ subject to the constraint that PeriodicFeasibility$([W,i],G)$ returns true, where $W$ is the walk traversed so far. The algorithm terminates when all the vertices are either expired, or covered by the walk.

V-C Orienteering Based Greedy Algorithm

Algorithm 3 also finds partitioned walks by finding a feasible walk on a subset of vertices and then considering the remaining subgraph. The idea is to visit more vertices on the way to the greedily picked vertex. From the current vertex $x$, the target vertex $y$ is picked greedily as described in Section V-B. Then the time $d$ is calculated in line 12 which is the maximum time to go from $x$ to $y$ for which the periodic walk remains feasible. In line 17, Orienteering$(V-V_{\texttt{exp}},x,y,d,\psi)$ finds a path in the vertices $V-V_{\texttt{exp }}$ from $x$ to $y$ of length at most $d$ maximizing the sum of the weights $\psi$ on the vertices of the path. The set $V_{\texttt{exp }}$ represents the expired vertices whose latencies cannot be satisfied by the current walk, and they will be considered by the next robot. The vertices with less time to expiry are given more importance in the path by setting weight $\psi_{i}=1/s_{i}$ for vertex $i$. The vertices that are already in the walk will remain feasible, and so their weight is discounted by a small number $m$ to encourage the path to explore unvisited vertices.

Lemma V.1**.**

Algorithm 3 returns a feasible solution, i.e., for the set of walks $\mathcal{W}$ returned by Algorithm 3, $L(\mathcal{W},v)\leq r(v)$, for all $v\in V$.

Proof.

The vertices covered by the walk $W_{j}$ added to the solution in line 21 are removed from the set of vertices before finding the rest of the walks. Hence the latencies of the vertices $V(W_{j})$ will be satisfied by only $W_{j}$. We will show that every time $W_{j}$ is appended in line 17, it remains feasible on $V(W_{j})$.

$W_{j}$ starts from a single vertex $a$, and hence is feasible at the start. Let us denote $W_{j}^{-}$ as the walk before line 17 and $W_{j}^{+}$ as the walk after line 17. Due to line 12, if $W_{j}^{-}$ is feasible in a particular iteration, then $[W_{j}^{-},y]$ will remain feasible. Hence the only vertices than can possibly have their latency constraints violated in $W_{j}^{+}$ are in the orienteering path from $x$ to $y$. Consider any vertex $z$ in the path from $x$ to $y$ returned by the Orienteering function in line 17. If $z\in V(W_{j}^{-})$, then $L(W_{j}^{+},z)\leq r(z)$ because of line 12. If $z\notin V(W_{j}^{-})$, then $r(z)=l(W_{j}^{-})+s_{z}$ and by line 14, $r(z)\geq l(W_{j}^{-})+d+l(y,a)$. As $z$ is only visited once in $W_{j}^{+}$, $L(W_{j}^{+},z)=l(W_{j}^{+})\leq l(W_{j}^{-})+d+l(y,a)\leq r(z)$. ∎

An approximation algorithm for Orienteering can be used in line 17 of Algorithm 3. In our implementation, we used an ILP formulation to solve Orienteering. To improve the runtime in practice, we pre-process the graph before calling the Orienteering solver to consider only the vertices $z$ such that $l(x,z)+l(z,y)\leq d$. We show in the next section that although the runtime of Algorithm 3 is more than that of Algorithm 1, it can still solve instances with up to $90$ vertices in a reasonable amount of time, and it finds better solutions.

VI Simulation Results

We now present the performance of the algorithms presented in the paper. For the approximation algorithm, we used the LKH implementation [29] to find the TSP of the graphs instead of the Christofides approximation algorithm [30]. This results in the loss of approximation guarantee but gives better results in practice. The orienteering paths in Algorithm 3 were found using the ILP formulation from [31] and the ILP’s were solved using the Gurobi solver [32].

VI-A Patrolling an Environment

The graphs for the problem instances were generated randomly in a real world environment. The scenario represents a ground robot monitoring the University of Waterloo campus. Vertices around the campus buildings represent the locations to be monitored and a complete weighted graph was created by generating a probabilistic road-map to find paths between those vertices. Figure 3 shows the patrolling environment. To generate random problem instances of different sizes, $n$ random vertices were chosen from the original graph. The latency constraints were generated uniformly randomly between $\text{TSP}/k$ and $k\text{TSP}$ where $k$ was chosen randomly between $4$ and $8$ for each instance. Here TSP represents the TSP length of the graph found using LKH.

For each graph size, $10$ random instances were created. The average run times of the algorithms are presented in Figure 4. As expected, Algorithm 3 is considerably slower than the approximation and simple greedy algorithms due to multiple calls to the ILP solver. However, as shown in Figure 5, Algorithm 3 also gives the minimum number of robots for most of these instances.

VI-B Persistent 3D Scene Reconstruction

Another application of our algorithms is in capturing images for 3D reconstruction of a scene. Since existing algorithms focus on computing robot paths to map a static scene [5, 4], our algorithms could be applied to persistently monitor and thus maintain an up-to-date reconstruction of a scene that changes over time. To demonstrate this, we create problem instances using a method similar to [4]. The viewpoints were generated on a grid around the building to be monitored. For each viewpoint, five camera angles were randomly generated, and best angle was selected for each viewpoint based on a view score that was calculated assuming a square footprint for the camera. For each camera angle, equally placed rays were projected onto the building within the footprint and a score was calculated based on the distance and incidence angle of the ray. This calculation is similar to that in [4], although they used a more detailed hemisphere coverage model.

After selecting the viewing angles, the final score of a camera pose was evaluated as in [4] by greedily picking the best viewpoint first and evaluating the marginal score of other viewpoints. The resulting graph had $109$ vertices. The latencies were set such that the most informative viewpoint is visited every $8$ minutes and on average each viewpoint is visited every $50$ minutes. Algorithm 3 found a solution in $150$ seconds using two walks, as shown in Figure 7. Note that Algorithm 1 returned a solution with $3$ robots.

VI-C Comparison with Existing Algorithms in Literature

In [21, 16] the authors propose an SMT (Satisfiability Modulo Theory) based approach using Z3 solver [33] to solve the decision version of the problem. The idea is to fix an upper bound on the period of the solution and model the problem as a constraint program. The authors also provide benchmark instances for the decision version of the problem. We tested our algorithms on the benchmark instances provided and compare the results to the SMT based solver provided by [16].

Out of 300 benchmark instances, given a time limit of 10 minutes, the Z3 solver returned 182 instances as satisfiable with the given number of robots. We ran our algorithms for each instance and checked if the number of robots returned are less than or equal to the number of robots in the benchmark instance. The approximation algorithm satisfied $170$ instances whereas Algorithm 3 satisfied $178$ instances. The four satisfiable instances that Algorithm 3 was unable to satisfy had optimal solutions where the walks share the vertices, and Algorithm 3 returned one more robot than the optimal in all those instances. The drawback of the constraint program to solve the problem is the scalability. It spent an average of $3.76$ seconds on satisfiable instances whereas Algorithm 3 spent $3$ ms on those instances on average. Moreover, on one such instance where Algorithm 3 returned one more robot than the Z3 solver, Z3 solver spent 194 seconds as compared to $\sim 5$ ms for Algorithm 3. Note that these differences are for benchmark instances having up to $7$ vertices. As shown above, Algorithm 3 takes $\sim 100$ seconds for $90$ vertex instances whereas we were unable to solve instances with even $15$ vertices within an hour using the Z3 solver. Hence, the scalability of the Z3 based solver hinders its use for problem instances of practical sizes.

VII Conclusion and Future Work

In this paper we presented and analyzed an approximation and a heuristic algorithm for the problem of finding the minimum number of robots that can satisfy the latency constraints for the vertices in a graph. We demonstrated the performance of the algorithms through simulations. We also presented and analyzed an algorithm for minimizing the maximum latency given multiple robots. Finding the relation between the partitioned optimal solution and a general optimal solution is an interesting direction for future work.