Distributed Assignment with Limited Communication for MultiRobot MultiTarget Tracking ^{†}^{†}thanks: This material is based upon work supported by the National Science Foundation under Grant No. 1637915.
Abstract
We study the problem of tracking multiple moving targets using a team of mobile robots. Each robot has a set of motion primitives to choose from in order to collectively maximize the number of targets tracked or the total quality of tracking. Our focus is on scenarios where communication is limited and the robots have limited time to share information with their neighbors. As a result, we seek distributed algorithms that can find solutions in a bounded amount of time. We present two algorithms: (1) a greedy algorithm that is guaranteed to find a –approximation to the optimal (centralized) solution but requiring communication rounds in the worst case, where denotes the number of robots; and (2) a local algorithm that finds a –approximation algorithm in communication rounds. Here, and are parameters that allow the user to tradeoff the solution quality with communication time. In addition to theoretical results, we present empirical evaluation including comparisons with centralized optimal solutions.
1 Introduction
We study the problem of assigning robots with limited FieldOfView (FOV) sensors to track multiple moving targets. Multirobot multitarget tracking is a wellstudied topic in robotics parker1997cooperative (); parker2002distributed (); touzet2000robot (); kolling2007cooperative (); honig2016dynamic (). We focus on scenarios where the number of robots is large and solving the problem locally rather than centrally is desirable. The robots may have limited communication range and limited bandwidth. As such, we seek assignment algorithms that rely on local information and only require a limited amount of communication with neighboring robots.
Constraints on communication impose challenges for robot coordination as global information may not always be available to all the robots within the network. As a result, it may not be always possible to design algorithms that operate on local information while still ensuring global optimality. Recently, Gharesifard and Smith gharesifard2017distributed () studied how limited information due to the communication graph topology affects the global performance. Their analysis applies for the case when the robots are allowed only one round of communication with their neighbors. If the robots are allowed multiple rounds of communication, they can propagate the information across the network. Given sufficient rounds of communication, all robots will have access to global information, and therefore can essentially solve the centralized version of the problem. In this paper, we investigate the relationship between the number of communication rounds allowed for the robots and the performance guarantees. We focus on the problem of distributed multirobot, multitarget assignment for our investigation (Figure 1).
We assume that each robot has a number of motion primitives to choose from. A motion primitive is a local trajectory obtained by applying a sequence of actions howard2014model (). A motion primitive can track a target if the target is in the FOV of the robot. The set of targets tracked by different motion primitives may be different. The assignment of targets to robots is therefore coupled with the selection of motion primitives for each robot. Our goal is to assign motion primitives to the robots so as to track the most number of targets or maximize the quality of tracking. We term this as the distributed Simultaneous Action and Target Assignment (SATA) problem.
This problem can be viewed as the dual of the set cover problem, known as the maximum (weighted) cover suomela2013survey (). Every motion primitive covers some subset of the targets. Therefore, we would like to pick motion primitives that maximize the number (or weight) of covered targets. However, we have the additional constraint that only one motion primitive per robot can be chosen at each step. This implies that the relationship between a robot and the corresponding motion primitives turns out to be a packing problem suomela2013survey () where only one motion primitive can be “packed” per robot. The combination of the two aforementioned problems is called a Mixed Packing and Covering Problem (MPCP) young2001sequential ().
We study two versions of the problem. The first version can be formulated as a (sub)modular maximization problem subject to a partition matroid constraint nemhauser1978analysis (). A sequential greedy algorithm, where the robots take turns to greedily choose motion primitives, is known to yield a –approximation for this problem tokekar2014multi (). We evaluate the empirical performance of this algorithm by comparing it with a centralized (globally optimal) solution. The drawback of the sequential greedy algorithm is that it requires at least as many communication rounds as the number of robots. This may be too slow in practice. Consequently, we study a second version of the problem for which we present a local algorithm whose performance degrades gracefully (and provably) as a function of the number of communication rounds.
A local algorithm suomela2013survey () is a constanttime distributed algorithm that is independent of the size of a network. This enables a robot only to depend on local inputs in a fixedradius neighborhood of robots (Figure 2). The robot does not need to know information beyond its local neighborhood, thereby achieving better scalability.
Floréen et al. floreen2011local () proposed a local algorithm to solve MPCP using maxmin/minmax Linear Programming (LP) in a distributed manner. We show how to leverage this algorithm to solve SATA. This algorithm has a bounded communication complexity unlike typical distributed algorithms. Specifically, the algorithm yields a approximation to the globally optimal solution in synchronous communication rounds where and are input parameters.^{1}^{1}1An algorithm is called a approximation to a maximization problem if it guarantees a solution whose value is at least of the optimal value, where is some constant. We verify the theoretical results through empirical evaluation.
The contributions of this paper are as follows:

We present two versions of the SATA problem.

We show how to use the greedy algorithm and adapt the local algorithm for solving the two versions of the SATA problem.

We perform empirical comparisons of the proposed algorithm with baseline centralized solutions.

We demonstrate the applicability of the proposed algorithm through Gazebo simulations.
A preliminary version of this paper was presented at ICRA 2018 sung2018distributed (). This expanded paper extends the preliminary version with a more thorough literature survey, additional theoretical analysis, and significantly expanded empirical analysis including a description of how to implement the greedy algorithm in practice.
The rest of the paper is organized as follows. We begin by introducing the related work in Section 2. We describe the problem setup in Section 3. Our proposed distributed algorithms are presented in Section 4. We present results from representative simulations in Section 5 before concluding with a discussion of future work in Section 6.
2 Related Work
A number of algorithms have been designed to improve multirobot coordination under limited bandwidth yan2013survey (); li2017high (); otte2013any (); otte2018dynamic (); kassir2016communication () and under communication range constraints williams2013constrained (); vander2015algorithms (); kantaros2015distributed (). This includes algorithms that enforce connectivity constraints kantaros2017distributed (); williams2015global (), explicitly trigger when to communicate dimarogonas2012distributed (); zhou2018active (); ge2017distributed1 () and operate when connectivity is intermittent best2018planning (); guo2018multirobot (). In this section, we focus on work that is most closely related to the SATA problem and local algorithms.
2.1 MultiRobot Target Tracking
There have been many studies on cooperative target tracking in both control and robotics communities. We highlight some of the recent related work in this section. For a more comprehensive overview of multirobot multitarget tracking, see the recent surveys khan2016cooperative (); robin2016multi ().
Charrow et al. charrow2014approximate () proposed approximate representations of the belief to design a control policy for multiple robots to track one mobile target. The proposed scheme, however, requires a centralized approach. Yu et al. yu2015cooperative () worked on an auctionbased decentralized algorithm for cooperative path planning to track a moving target. Ahmad et al. ahmad2017online () presented a unified method of localizing robots and tracking a target that is scalable with respect to the number of robots. Zhou and Roumeliotis zhou2011multirobot () developed an algorithm that finds an optimal trajectory of multiple robots for the active target tracking problem. Capitan et al. capitan2013decentralized () proposed a decentralized cooperative multirobot algorithm using auctioned partially observable Markov decision processes. The performance of decentralized data fusion under limited communication was successfully shown but theoretical bounds on communication rounds were not covered. Moreover, theoretical properties presented in the above references considered single target tracking, which may not necessarily hold in the case of tracking multiple targets in a distributed fashion.
Pimenta et al. pimenta2009simultaneous () adopted Voronoi partitioning to develop a distributed multitarget tracking algorithm. However, their objective was to cover an environment coupled with multitarget tracking. Banfi et al. banfi2018integer () addressed the fairness issue for cooperative multirobot multitarget tracking, which is achieving balanced coverage among different targets. One of the problems that we define in Section 3 (i.e., Problem 1) has a similar motivation. However, unlike the algorithm in Banfi et al. banfi2018integer (), we are able to give a global performance guarantee. Xu et al. xu2013decentralized () presented a decentralized algorithm that jointly solves the problem of assigning robots to targets and positioning robots using mixedinteger nonlinear programming. While they proved the complexity in terms of computational time and communication (i.e., the amount of data needed to be communicated), the solution quality was only evaluated empirically. Instead, we bound the solution quality as a function of the communication rounds. Furthermore, our formulation takes as input a set of discrete actions (i.e., motion primitives) that the robot must choose from, unlike the previous work.
We study a problem similar to the one termed as Cooperative Multirobot Observation of Multiple Moving Targets (CMOMMT) proposed by Parker and Emmons parker1997cooperative (). The objective in CMOMMT is to maximize the collective time of observing targets. Parker parker2002distributed () developed a distributed algorithm for CMOMMT that computes a local force vector to find a direction vector for each robot. We empirically compare this algorithm with our proposed one and report the results in Section 5. Kolling and Carpin kolling2007cooperative () studied the behavioral CMOMMT that added a new mode (i.e., help) to the conventional track and search modes of CMOMMT. The help mode asks other robots to track a target if the target escapes from the FOV of some robot. Although our work does not allow mode changes, previous works regarding CMOMMT did not provide theoretical optimality guarantees and did not explicitly consider scenarios where the communication bandwidth is limited. Refer to Section IV(C) of Reference khan2016cooperative () for a more detailed summary of CMOMMT.
In our prior work tokekar2014multi (), we addressed the problem of selecting trajectories for robots that can track the maximum number of targets using a team of robots. However, no bound on the number of communication rounds was presented, possibly resulting in alltoall communication in the worst case. Instead, in this work, we introduce a new version of the problem and also explicitly bound the amount of communication required for target assignment.
2.2 MultiRobot Task Assignment
Multirobot task assignment can be formulated as a discrete combinatorial optimization problem. The work by Gerkey and Matarić gerkey2004formal () and the more recent work by Korsah et al. korsah2013comprehensive () contain detailed survey of this problem. There exists distributed algorithms with provable guarantees for different versions of this problem choi2009consensus (); luo2015distributed (); liu2011assessing (). There also exists various multirobot deployment strategies for task assignment under communication constraints. These constraints include limited available information kanakia2016modeling (), limited communication flows le2012adaptive (), and connectivity requirement kantaros2016global (). See the survey papers zavlanos2011graph (); ge2017distributed2 () on these results. Ny et al. le2012adaptive () studied a formulation with a similar communication constraint as ours. However, their formulation assumed that the robots know which targets to track. In this paper, we tackle the challenge of simultaneously assigning robots to targets by choosing motion primitives with limited communication bandwidth which might degrade task performance when there are unreliable communication links and communication delays.
Turpin et al. turpin2014capt () proposed a distributed algorithm that assigns robots to goal locations while generating collisionfree trajectories. Morgan et al. morgan2016swarm () solved the assignment problem by using distributed auctions and generating collisionfree trajectories by using sequential convex programming. Bandyopadhyay et al. bandyopadhyay2017probabilistic () adopted the Eulerian framework for both swarm formation control and assignment. However, these works may not be suitable for target tracking applications as the targets were assumed to be static. For more survey results about SATA, see the work by Chung et al. chung2018survey (). Recently, Otte et al. otte2017multi () investigated the effect of communication quality on auctionbased multirobot task assignment. None of the above works, however, analyzed the effect of communication rounds on the solution quality, as is the focus of our work.
2.3 Local Algorithms
A local algorithm angluin1980local (); linial1992locality (); naor1995can () is a distributed algorithm that is guaranteed to achieve desired objective in a finite (typically, fixed) amount of time. The typical approach is to find approximate solutions with provable (and global) performance guarantees while ensuring a bound on the communication complexity that is independent of the number of vertices in the graph. Local algorithms have been proposed for a number of graphtheoretic problems. These include, graph matching hanckowiak2001distributed (), vertex cover aastrand2009local (); aastrand2010fast (), dominating set lenzen2010minimum (), and set cover kuhn2006price (). Suomela suomela2013survey () gives a broad survey of local algorithms. We build on this work and adapt a local algorithm for solving SATA.
3 Problem Description
Consider a scenario where multiple robots are tracking multiple mobile targets. Robots can observe targets within their FOV and predict the future states of targets. Based on predicted target states, robots decide where to move (i.e., by selecting a motion primitive) in order to keep track of targets. By discretizing time, the problem becomes one of combinatorial optimizations — choose the next position of robots based on the predicted position of the targets. Thus, we solve the SATA problem at each time step.
We define sets, and , to denote the collection of robot and target labels respectively: for robot labels and for target labels. Let and denote the set of robot states and predicted target states, respectively. In this paper, states are given by the positions of the robots and the targets in 2 or 3dimensional space. However, the algorithms presented in this paper can be used for more complex states (e.g., 6 degreeoffreedom pose). Here, denotes the state of the robots at time . denotes the state of the targets at the next time step (i.e., at time ) predicted at time . We assume that the targets can be uniquely detected and multiple robots know if they are observing the same target. Therefore, no data association is required. Each robot independently obtains the predicted states, , by fusing its own noisy sensor measurements using, for example, a Kalman filter.
We define the labels of available motion primitives for the th robot as These labels correspond to a set of motion primitive states of the th robot at time given by: . Note that the term motion primitives in this paper represents the future state of a robot at the next time step (i.e., at time ) computed at time . We compute a set of the motion primitives a priori by discretizing the continuous control input space. This can be done by various methods such as uniform random sampling or biased sampling based on predicted target states. However, once a set of the motion primitives is obtained, the rest of the proposed algorithms (in Section 4) remain the same.
We define to be the set of targets that can be observed by the th motion primitive of th robot at time . Specifically, the th target is said to be observable by the th motion primitive of a robot , iff . It should be noted that only targets that were observed by robot at time are candidates to be considered for time because unobserved targets at time cannot be predicted by the robot . Note also that since is a set function, we can model complex FOV and sensing range constraints that are not necessarily restricted to 2D.
We make the following assumptions.^{2}^{2}2After these assumptions, we omit the time index (i.e., ) for notational convenience.
Assumption 1.
(Communication Range). If two robots have a motion primitive that can observe the same target, then these robots can communicate with each other. This implies if there exists a target such that and , then th and th robots can communicate with each other.
Assumption 2.
(Synchronous Communication). All the robots have synchronous clocks leading to synchronous rounds of communication.
From Assumption 1, neighboring robots can share their local information with each other when they observe the same targets. For example, robots can use techniques such as covariance intersection niehsen2002information () to merge their individual predictions of the target’s state into a joint prediction . This can be achieved in one round of communication when each robot simply broadcasts its own estimate of all the targets within its FOV. Note that a robot does not need to know the prediction for all the targets but only the ones that are within the FOV of one of its motion primitives. In this sense, a communication graph can be created from a sensing graph at each time, where and denote edges among robots and edges between targets and motion primitives, respectively.
As shown in Figure 1, each robot is able to compute feasible motion primitives of its own and detect multiple unique targets within the FOV. Then, the objective of the proposed problem is to choose one of the motion primitives for each robot, yielding either the best quality of tracking or the maximum number of targets tracked by the robots, depending on the application. One possible quality of tracking can be measured by the summation of all distances between selected primitives and the observed targets.
Let be the binary variable which represents the th robot selecting the th motion primitive. That is, if a motion primitive is selected by a robot and otherwise.^{3}^{3}3If all for a robot , then it can choose any motion primitives since the objective value will remain the same. Since each robot can choose only one motion primitive, we have:
(1) 
Our objective is to find . We propose two following problems.
Problem 1 (Bottleneck).
The objective is to select primitives such that we maximize the minimum tracking quality:
(2) 
subject to the constraints in Equation (1). Here, denotes weights on sensing edges between th motion primitive of th robot and th target.
Here, can represent the tracking quality given by, for example, the inverse of the distance between th motion primitive of th robot and th target. Alternatively, can be binary (1 when the th motion primitive of robot sees target and otherwise) making the objective function equal to maximizing the minimum number of targets tracked.
We term this as the Bottleneck version of SATA. In the Bottleneck version, multiple robots may be assigned to the same target. We also define a Winner TakesAll variant of SATA where only one robot is assigned to a target.
We define additional binary decision variable, . represents the th robot assigned to track the th target. We have, if th robot is assigned to th target and otherwise.
Since we restrict only one robot to be assigned to the target (unlike Bottleneck), we have:
(3) 
Problem 2 (WinnerTakesAll).
Both versions of the SATA problem are NPHard vazirani2001approximation (). The WinnerTakesAll version can be optimally solved using a Quadratic Mixed Integer Linear Programming (QMILP) in the centralized setting.^{4}^{4}4Note that Problem 2 can also be converted into a simpler Mixed Integer Linear Programming (MILP) by linearizing the product of the binary variables in Equation (4), which is not covered in this paper. Our main contributions are to show how to solve both problems in a distributed manner: an LPrelaxation of the Bottleneck variant using a local algorithm; and the WinnerTakesAll variant using a greedy algorithm. The following theorems summarize the main contributions of our work.
Theorem 3.1.
Let be the maximum number of motion primitives per robot and be the maximum number of motion primitives that can see a target. There exists a local algorithm that finds an approximation in synchronous communication rounds for the LPrelaxation of the Bottleneck version of SATA problem, where and are parameters.
The proof follows directly from the existence of the local algorithm described in the next section. We show how the local algorithm for MPCP can be modified to solve SATA by means of a linear relaxation.
Theorem 3.2.
There exists a –approximation greedy algorithm for the WinnerTakesAll version of the SATA problem for any in polynomial time.
This directly follows from the fact that the problem is a modular maximization problem subject to a partition matroid constraint nemhauser1978analysis (). The algorithms are described in the next section.
4 Distributed Algorithms
We begin by describing the local algorithm that solves the Bottleneck version of SATA.
4.1 Local Algorithm
In this section, we show how to solve the Bottleneck version of the SATA problem using a local algorithm. We adapt the local algorithm for solving maxmin LPs given by Floréen et al. floreen2011local () to solve the SATA problem in a distributed manner.
Consider the tripartite, weighted, and undirected graph, shown in Figure 3. Each edge is either with weight 1 or with weight . The maximum degree among robot nodes is denoted by and among target nodes is . Each motion primitive is associated with a variable . The upper two layers of in Figure 3 are related with a packing problem (Equation (4)). The lower two layers are related with the covering problem.
Lemma 1.
The Bottleneck version (Equation (2)) can be rewritten as a linear relaxation of ILP:
(5) 
The proof is given in Appendix A.
Floréen et al. floreen2011local () presented a local algorithm to solve MPCP in Equation (5) in a distributed fashion. They presented both positive and negative results for MPCP. We show how to adopt this algorithm for solving the Bottleneck version of SATA.
An overview of our algorithm is given in Figure 4. We describe the main steps in the following.
4.1.1 Local Algorithm from Reference floreen2011local ()
The local algorithm in Reference floreen2011local () requires . However, they also present a simple local technique to split nodes in the original graph with into multiple nodes making . Then, a layered maxmin LP is constructed with layers, as shown in Figure 5. is a userdefined parameter that allows to tradeoff computational time with optimality. If the number of layers is set to , then it means that a robot can communicate with another robot that is no more than communication edges (i.e., hops) away. The layered graph breaks the symmetry that inherently exists in the original graph. This layered mechanism is specifically designed for solving MPCP and is covered in depth in Section 4 of Reference floreen2011local (). We omit the details in this paper due to limited space and redirect the readers to Section 4 of Reference floreen2011local () for the construction of the layered graph.
They proposed a recursive algorithm to compute a solution of the layered maxmin LP. The solution for the original maxmin LP can be obtained by mapping from the solution of the layered one. The obtained solution corresponds to values of . They proved that the resulting algorithm gives a constantfactor approximation ratio.
Theorem 4.1.
There exists local approximation algorithms for maxmin and minmax LPs with the approximation ratio for any , , and , where denotes the number of layers.
Proof.
Please refer to Corollary 4.7 from Reference floreen2011local () for a proof. ∎
Note that each node in the layered graph carries out its local computation (details of the local computation for solving SATA are included in Reference floreen2011local ()). Each node also receives and sends information from and to neighbors at each synchronous communication round. Constructing the layered graph is done in a local fashion without requiring any single robot to know the entire graph.
4.1.2 Realization of Local Algorithm for SATA
To apply the local algorithm of Section 4.1.1 to a distributed SATA problem, each node and edge in a layered graph must be realized at each time step (i.e., generating a graph shown in Figure 5 which becomes the input to the local algorithm floreen2011local ()). In our case, the only computational units are the robots. Nodes that correspond to motion primitives, , can be realized by the corresponding robot . Moreover, nodes corresponding to the targets must also be realized by robots. A target is realized by a robot satisfying . If there are multiple robots whose motion primitives can sense the target (by Assumption 1), they can arbitrarily decide which amongst them realizes the target nodes in a constant number of communication rounds.
After applying the local algorithm of Section 4.1.1 to robots, each robot obtains on corresponding at each time. However, due to the LP relaxation, will not necessarily be binary, as in Equation (1). For each robot we set the highest equal to one and all others as zero. We shortly show that the resulting solution after rounding is still close to optimal in practice. Furthermore, increasing the parameter finds solutions that are close to binary.
The following pseudocode explains the overall scheme of each robot for a distributed SATA. We solve the SATA problem at each time step.
4.1.3 Advantages of the Local Algorithm
It is possible that there are some robots that are isolated from the others. That is, the communication graph or the layered graph may be disconnected. However, each component of the graph can run the local algorithm independently without affecting the solution quality. Furthermore, if a robot is disconnected from the rest, then it can take a greedy approach as described in Reference tokekar2014multi () before they reach any other robots to communicate.
The algorithm also allows for the number of robots and targets to change over time. Since each robot determines its neighbors at each time step, any new robots or targets will be identified and become part of the timevarying local layered graphs. The robots can also be anonymous (as long as they can break the symmetry to determine which robot, amongst a set, will realize the target node, when multiple robots can observe the same target).
The number of layers, , directly affects the solution quality and can be set by the user. Increasing results in better solutions at the expense of more communication. is equivalent to the greedy approach where no robots communicate with each other.
0.5000  0.5000  0.5000  

0.5000  0.5000  0.5000  
0.6667  0.7591  0.7855  

0.3333  0.2409  0.2145  
0.3333  0.2409  0.2145  

0.6667  0.7591  0.7855 
The above table shows the result of applying the local algorithm to the graph in Figure 3 when all edge weights were set to . Three different values for were tested: , , and . In all cases, and have larger values of than other nodes. Thus, the robot 2 () and the robot 3 () will select the motion primitive () and the motion primitive (), respectively, after employing a rounding technique to ’s.
As the number of layers increases, the more distinct the values returned by the algorithm. Another interesting observation is that robot has the same equal value on both motion primitives of its own no matter how many number of layers are used. This is because all the targets are already observed by robots and with higher values.
4.2 Greedy Algorithm
The greedy algorithm requires a specific ordering of the robots given in advance. The first robot greedily chooses a motion primitive that can maximize the number of targets being observed. Those observed targets are removed from the consideration. Then, the second robot makes its choice; this repeats for the rest of robots. If the communication graph is disconnected and forms more than one connected component, the greedy algorithm can independently be applied to each connected component without modifying the algorithm. Note again that the greedy algorithm is for the WinnerTakesAll version of SATA.
As shown in Algorithm 2, the greedy algorithm runs in communication rounds at each time step. We define two additional functions: gives a quality of tracking for th target; and gives the sum of quality of tracking over all feasible targets using th motion primitive of th robot. If, for example, is used as a distance metric, the ensures that the quality of tracking for th target is only given by the distance of the nearest robot/primitive. That is, even if multiple primitives can track the same target , when counting the quality we only care about the closest one. The total quality will then be the sum of qualities for each target.
The objective in Line 5 in Algorithm 2 appears, at first sight, to be different than that given in Equation (4). The following lemma, however, proves that the two objectives are equivalent.
Lemma 2.
Greedy algorithm of Algorithm 2 gives a feasible solution for the WinnerTakesAll version of SA TA.
The proof is given in Appendix B. Since the objective in Line 5 in Algorithm 2 is submodular, the resulting algorithm yields a –approximation to WinnerTakes All nemhauser1978analysis ().
The greedy algorithm can perform arbitrarily worse than the optimal solution if it is applied to the Bottlene ck version of the problem. In Appendix C, we show an example where the greedy yields an arbitrarily bad solution for the Bottleneck version.
A centralizedequivalent approach is one where the robots all broadcast their local information until some robot has received information from all others. This robot can obtain a centralized solution to the problem. A centralizedequivalent approach for a complete runs in 2 communication rounds for receiving and sending data to neighbors. However, the greedy algorithm and local algorithm have and communication rounds, respectively, for a complete . Note that for most practical cases.
5 Simulations
We carried out four types of simulations to verify the efficacy of the proposed algorithms under the condition that the amount of time required for communication is limited. First, we compare the performance of the greedy and local algorithms with centralized, optimal solutions. Second, we study the effect of varying the parameters (i.e., the number of layers) for the local algorithm. Third, we describe how to implement the algorithms for sequential planning over multiple horizons and evaluate their performance over time. Last, we compare the greedy algorithm with a stateoftheart distributed tracking algorithm.
5.1 Comparisons with Centralized Solutions
We performed comparison studies to verify the performance of the proposed algorithms. We compared the greedy solution with the optimal, centralized QMILP solution as well as a random algorithm as a baseline for the WinnerTakesAll version. We compared the local algorithm’s solution with the optimal ILP solution as well as the LP with rounding for Bottleneck. For these comparisons, we assumed that there are only two primitives to choose from (making the random algorithm a powerful baseline). We later analyzed the algorithms with more primitives. We used TOMLAB QMILP () to solve the QMILP and ILP problems. The toolbox works with MATLAB and uses IBM’s CPLEX optimizer in the background. On a laptop with processor configuration of IntelÂ® Coreâ¢ i75500U CPU @ 2.40GHz x 4 and 16 GB of memory the maximum time to solve was around seconds on a case with 150 targets. Most of our cases were solved in less than seconds.
We randomly generated graphs similar to Figure 3 for the comparison. To control the topology of the randomly generated graphs, we defined to be the percentage of targets that are detected by a motion primitive. We denote the average degree of edges by . Therefore:
(6) 
We started with the upper half of the graph, connecting each robot to its two motion primitives. Then, we iterated through each of motion primitive and randomly chose a target node to create an edge. Next, we iterated through target nodes and randomly chose a motion primitive to create an edge. We also added random edges to connect disconnected components (to keep the implementation simpler). We repeated this in order to get the required graph. If we needed to increase the degree of target nodes in the graph, we created new edges to random primitives till we achieved the desired . We generated cases by varying , number of targets, and number of robots using the method described above. Here, the tracking quality was defined as the number of targets, i.e., for all cases.
The comparative simulation results for WinnerTakes All are presented in Figure 6. The plots show minimum, maximum, and average of the targets covered by the greedy algorithm and QMILP running 100 random instances for every setting of the parameters. We also show the number of targets covered when choosing motion primitives randomly as a baseline. We observe that the greedy algorithm performs comparatively to the optimal algorithm, and is always better than the baseline. In all the figures, , making random a relatively powerful baseline. The difference between the greedy algorithm and the baseline becomes smaller as increases. This could be because of the fact that the baseline saturates at the maximum objective value with fewer robots as increases. As , number of targets, and number of robots increase, the performance of the greedy algorithm also improves.
Figure 7 shows the comparison results for Bottlene ck where the objective values were computed from the term of Equation (5). As the proposed local algorithm is a linear relaxation of the ILP formulation, we compared the local solution with the optimal ILP solution. Note that both the ILP and LP with rounding are centralized methods. If the solution value is , this means that at least one target is not covered by any selected motion primitives. The specific configuration of input motion primitives and target states is such that no matter what motion primitives are chosen, at least one target will be left uncovered. This means that the bottleneck objective (i.e., the optimal value of ILP) is . If the mean value is larger than , this implies that all targets are covered by at least one motion primitive on average. The ILP and LP with rounding outperform the local algorithm in all cases. Nevertheless, we find that the local algorithm performs comparably to the centralized methods (and far better than the theoretical bound).
5.2 Effect of for the Local Algorithm
We analyzed the performance of the local algorithm for different number of layers (i.e., ), as shown in Figure 8. The LP value (without rounding) is the upper bound on the optimal solution. We observed how much the rounding sacrifices by comparing the LP with and without the rounding. In the case where was set to and for both with and without the rounding, there is no evident difference between them. This implies that should not necessarily be large as it does not contribute to the solution quality much (as also seen in Theorem 3.1). In other words, the local algorithm does not require a large number of communication hops among robots, which is a powerful feature of the local algorithm.
5.3 Multirobot Multitarget Tracking over Time
The greedy and local algorithms find the motion primitives to be applied over a single horizon. In order to track over time, the SATA problem will need to be solved repeatedly at each time step. In this section, we describe how to address this and other challenges associated with a practical implementation. We demonstrate a realistic scenario of cooperative multitarget tracking in the Gazebo simulator using ROS (Figure 9). A bounded environment consists of dynamic targets that move in a straight line and change their heading direction randomly after a certain period. The motion model is not known to the robots.
Greedy Algorithm.
We implemented the greedy algorithm to solve the WinnerTakesAll variant in a fully distributed fashion. There was no centralized algorithm and each robot was a separate ROS node that only had access to the local information. Each robot had its local estimator that estimated the state of targets within its FOV. We simulated proximitylimited communication range such that only robots that can see the same target can exchange messages with each other.
A sketch for the implementation of the greedy algorithm is as follows. Each robot has a local timer which is synchronized with the others. Each robot also knows its own ID which is also the order in which the sequential decisions are made. We partition the planning horizon into two periods. In the first selection period, the robots choose their own primitives sequentially using the greedy algorithm. In the second execution period, the robots apply their motion primitives and obtain measurements of the target.
In the selection period, a robot waits for the predecessor robots (of lower IDs) to make their selections. Every robot knows when it is its turn to select a motion primitive (since the order is fixed). Before its turn, a robot simply keeps track of the most recent vector received from a predecessor robot within communication range. During its turn, the robot chooses its motion primitive using the greedy algorithm, and updates the vector based on its choice. It then broadcasts this updated vector to the neighbors, and waits for the selection period to end. Then, each robot applies its selected motion primitive till the end of the horizon. The process repeats after each planning horizon. The selection period can be preceded by a sensor fusion period, where the robots can execute, for example, the covariance intersection algorithm niehsen2002information ().
For simulations we set the selection and execution periods times to and , respectively, where is the number of robots. Each robot made its choice after within the selection period. Each robot had a precomputed library of 21 motion primitives including staying in place. It should be noted that our algorithms do not require a motion primitive of stay in place. Each robot had a diskshaped FOV. The sensing and communication ranges were set to and , respectively. We tested both the inverse of the distance and the number of targets as tracking quality (which defines ).
We carried out simulations using ten robots tracking thirty moving targets, as shown in Figure 9. Initial positions of robots and targets were randomly chosen in a square environment. It may be possible that some targets were outside the FOV of any robots in the beginning.
Figure 10 shows the change in the number of targets over time from a randomly generated instance where the objective was to track the most number of targets. We show both the estimated number of targets and the actual number of targets. The estimated number is the value of the solution found at the end of the selection period (obtained every ). This is based on the predicted trajectory of the targets.^{5}^{5}5Although we model linear motion for the targets, more sophisticated models for the prediction of target states can also be employed. The actual number of targets was found by counting the target that is within the FOV of any robots during the execution period. Figure 11 shows the histogram of the actual and estimated number of targets for 10 trials, each lasting three minutes.
Figures 12 and 13 show the corresponding plots when the objective was to maximize the total quality of tracking (inverse distance to the targets). Here, we saw that the estimated and the actual values differed much more than the previous case. We conjectured that this was due to the fact that the uncertainty in the motion model of the robots, targets, and measurements had a larger effect on the actual quality of tracking as compared to the number of targets tracked. For instance, even if the actual state of the target deviates from the predicted state, it is still likely that the target will be in the FOV. However, the actual distance between the robot and the target may be much larger than estimated.
Local Algorithm.
We also implemented the proposed local algorithm as shown in Figure 14. Five mobile robots were deployed to track thirty targets (a subset of which were mobile) with a FOV of 3 on the xy plane. For each robot two motion primitives were used: one was to remain in the same position and the other one was randomly generated between and of the robot’s heading traveling randomly up to .
The objective of this simulation is to show the performance of the proposed algorithm for the Bottleneck version. At each time step, the local algorithm was employed to choose motion primitives that maximize the minimum number of targets being observed by any robots.
Figure 15 shows the resultant trajectories of robots and targets obtained from the simulation. Figure 16 presents the (total/average) number of targets tracked by the local algorithm for a specific instance. Although the local algorithm has a suboptimal performance guarantee, we observe that in practice, it performs comparably to the optimal path.
5.4 Comparison of the Greedy Algorithm with Other CMOMMT Algorithm
We compared the greedy algorithm with an algorithm proposed by Parker parker2002distributed () following the CMOMMT approach. This algorithm addresses the same objective as the WinnerTakesAll. Parker’s algorithm computes a local force vector for all robots (attraction by nearby targets and repulsion by other nearby robots). It does not require any central unit to determine their motion primitives and considers limited sensing and communication ranges, similar to this paper. Parker’s algorithm determines the moving direction of robots by using the local force vector and moves the robots along this direction until they meet the available maneuverability at each time step. However, no theoretic guarantee with respect to the optimal solution was provided by this algorithm.
We created an environment of square for comparison using MATLAB. The robots can move per time step while the targets can move per time step and randomly changed their direction every time steps. If the targets met the boundary of the environment, they picked a random direction that kept them within the environment. In each instance, robots and targets were randomly located initially. The sensing and communication ranges were set to and , respectively.
We empirically studied two cases: the first is to evaluate the objective value of the proposed greedy algorithm and Parker’s algorithm for the same problem instance at a given time step; and the second is to apply the two algorithms over time steps starting from the same configuration.
When both algorithms were applied to the same problem setup (Figure 17(a)), the objective values for both algorithms increased as the number of targets increased. Nevertheless, the greedy algorithm outperformed Parker’s algorithm. This can be attributed to the fact that Parker’s algorithm computes the local force vector based on a heuristic (get closer to the targets) but does not explicitly optimize the objective function of WinnerTakesAll. In Figures 17(b) and 17(c), similar results can be seen when both algorithms generate different trajectories for robots after time steps. The comparison measure used in Figure 17(c) is the average of the objective value over time, first proposed by Parker parker2002distributed (). These empirical simulations show the superior performance of the greedy algorithm over the existing method.
In summary, we find that our algorithms perform comparably with centralized, optimal algorithms and outperform the baseline algorithm. We also find that greedy algorithm has better performance than the decentralized algorithm from Parker parker2002distributed (). In theory, the performance bound for the local algorithm worsens as , the amount of communication available, decreases. However, in practice, we find that the local algorithm does not require a large number of layers to yield good performance, which reduces the computational and communication burden.
6 Conclusion
This paper gives a new approach to solve the multirobot multitarget assignment problem using greedy and local algorithms. Our work is motivated by scenarios where the robots would like to reduce their communication to solve the given assignment problem while at the same time maintaining some guarantees of tracking. We used powerful local communication framework employed by Floréen et al. floreen2011local () to leverage an algorithm that can tradeoff the optimality with communication complexity. We empirically evaluated this algorithm and compared it with the baseline greedy strategies.
Our immediate future work is to expand the scope of the problem to solve both versions of SATA over multiple horizons. In principle, we can replace each motion primitive input with a longer horizon trajectory and plan for multiple time steps (say, time steps). However, this comes at the expense of increased number of trajectories to choose from which will result in increased computational time. Furthermore, planning for a longer horizon will require prediction of targets’ states far in the future which can lead to poorer tracking performance. We are also working on implementing the resulting algorithms on actual aerial robotic systems to carry out realworld experimentation.
Acknowledgement
The authors would like to thank Dr. Jukka Suomela from Aalto University for fruitful discussion.
References
 (1) L. E. Parker and B. A. Emmons, “Cooperative multirobot observation of multiple moving targets,” in Robotics and Automation, 1997. Proceedings., 1997 IEEE International Conference on, vol. 3. IEEE, 1997, pp. 2082–2089.
 (2) L. E. Parker, “Distributed algorithms for multirobot observation of multiple moving targets,” Autonomous robots, vol. 12, no. 3, pp. 231–255, 2002.
 (3) C. F. Touzet, “Robot awareness in cooperative mobile robot learning,” Autonomous Robots, vol. 8, no. 1, pp. 87–97, 2000.
 (4) A. Kolling and S. Carpin, “Cooperative observation of multiple moving targets: an algorithm and its formalization,” The International Journal of Robotics Research, vol. 26, no. 9, pp. 935–953, 2007.
 (5) W. Hönig and N. Ayanian, “Dynamic multitarget coverage with robotic cameras,” in Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on. IEEE, 2016, pp. 1871–1878.
 (6) B. Gharesifard and S. L. Smith, “Distributed submodular maximization with limited information,” IEEE Transactions on Control of Network Systems, 2017.
 (7) T. Howard, M. Pivtoraiko, R. A. Knepper, and A. Kelly, “Modelpredictive motion planning: several key developments for autonomous mobile robots,” IEEE Robotics & Automation Magazine, vol. 21, no. 1, pp. 64–73, 2014.
 (8) J. Suomela, “Survey of local algorithms,” ACM Computing Surveys (CSUR), vol. 45, no. 2, p. 24, 2013.
 (9) N. E. Young, “Sequential and parallel algorithms for mixed packing and covering,” in Foundations of Computer Science, 2001. Proceedings. 42nd IEEE Symposium on. IEEE, 2001, pp. 538–546.
 (10) G. L. Nemhauser, L. A. Wolsey, and M. L. Fisher, “An analysis of approximations for maximizing submodular set functions—1,” Mathematical programming, vol. 14, no. 1, pp. 265–294, 1978.
 (11) P. Tokekar, V. Isler, and A. Franchi, “Multitarget visual tracking with aerial robots,” in 2014 IEEE/RSJ International Conference on Intelligent Robots and Systems. IEEE, 2014, pp. 3067–3072.
 (12) P. Floréen, M. Hassinen, J. Kaasinen, P. Kaski, T. Musto, and J. Suomela, “Local approximability of maxmin and minmax linear programs,” Theory of Computing Systems, vol. 49, no. 4, pp. 672–697, 2011.
 (13) Y. Sung, A. K. Budhiraja, R. K. Williams, and P. Tokekar, “Distributed simultaneous action and target assignment for multirobot multitarget tracking,” in 2018 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2018, pp. 1–9.
 (14) Z. Yan, N. Jouandeau, and A. A. Cherif, “A survey and analysis of multirobot coordination,” International Journal of Advanced Robotic Systems, vol. 10, no. 12, p. 399, 2013.
 (15) H. Li, G. Chen, T. Huang, and Z. Dong, “Highperformance consensus control in networked systems with limited bandwidth communication and timevarying directed topologies,” IEEE transactions on neural networks and learning systems, vol. 28, no. 5, pp. 1043–1054, 2017.
 (16) M. Otte and N. Correll, “Anycom multirobot pathplanning: Maximizing collaboration for variable bandwidth,” in Distributed Autonomous Robotic Systems. Springer, 2013, pp. 161–173.
 (17) ——, “Dynamic teams of robots as ad hoc distributed computers: reducing the complexity of multirobot motion planning via subspace selection,” Autonomous Robots, pp. 1–23, 2018.
 (18) A. Kassir, R. Fitch, and S. Sukkarieh, “Communicationefficient motion coordination and data fusion in information gathering teams,” in Intelligent Robots and Systems (IROS), 2016 IEEE/RSJ International Conference on. IEEE, 2016, pp. 5258–5265.
 (19) R. K. Williams and G. S. Sukhatme, “Constrained interaction and coordination in proximitylimited multiagent systems,” IEEE Transactions on Robotics, vol. 29, no. 4, pp. 930–944, 2013.
 (20) J. Vander Hook, P. Tokekar, and V. Isler, “Algorithms for cooperative active localization of static targets with mobile bearing sensors under communication constraints,” IEEE Transactions on Robotics, vol. 31, no. 4, pp. 864–876, 2015.
 (21) Y. Kantaros, M. Thanou, and A. Tzes, “Distributed coverage control for concave areas by a heterogeneous robot–swarm with visibility sensing constraints,” Automatica, vol. 53, pp. 195–207, 2015.
 (22) Y. Kantaros and M. M. Zavlanos, “Distributed intermittent connectivity control of mobile robot networks,” IEEE Transactions on Automatic Control, vol. 62, no. 7, pp. 3109–3121, 2017.
 (23) R. K. Williams, A. Gasparri, G. S. Sukhatme, and G. Ulivi, “Global connectivity control for spatially interacting multirobot systems with unicycle kinematics,” in Robotics and Automation (ICRA), 2015 IEEE International Conference on. IEEE, 2015, pp. 1255–1261.
 (24) D. V. Dimarogonas, E. Frazzoli, and K. H. Johansson, “Distributed eventtriggered control for multiagent systems,” IEEE Transactions on Automatic Control, vol. 57, no. 5, pp. 1291–1297, 2012.
 (25) L. Zhou and P. Tokekar, “Active target tracking with selftriggered communications in multirobot teams,” IEEE Transactions on Automation Science and Engineering, no. 99, pp. 1–12, 2018.
 (26) X. Ge and Q.L. Han, “Distributed formation control of networked multiagent systems using a dynamic eventtriggered communication mechanism,” IEEE Transactions on Industrial Electronics, vol. 64, no. 10, pp. 8118–8127, 2017.
 (27) G. Best, M. Forrai, R. R. Mettu, and R. Fitch, “Planningaware communication for decentralised multirobot coordination,” in Proceedings of the International Conference on Robotics and Automation, Brisbane, Australia, vol. 21, 2018.
 (28) M. Guo and M. M. Zavlanos, “Multirobot data gathering under buffer constraints and intermittent communication,” IEEE Transactions on Robotics, 2018.
 (29) A. Khan, B. Rinner, and A. Cavallaro, “Cooperative robots to observe moving targets: Review,” IEEE Transactions on Cybernetics, 2016.
 (30) C. Robin and S. Lacroix, “Multirobot target detection and tracking: taxonomy and survey,” Autonomous Robots, vol. 40, no. 4, pp. 729–760, 2016.
 (31) B. Charrow, V. Kumar, and N. Michael, “Approximate representations for multirobot control policies that maximize mutual information,” Autonomous Robots, vol. 37, no. 4, pp. 383–400, 2014.
 (32) H. Yu, K. Meier, M. Argyle, and R. W. Beard, “Cooperative path planning for target tracking in urban environments using unmanned air and ground vehicles,” IEEE/ASME Transactions on Mechatronics, vol. 20, no. 2, pp. 541–552, 2015.
 (33) A. Ahmad, G. Lawless, and P. Lima, “An online scalable approach to unified multirobot cooperative localization and object tracking,” IEEE Transactions on Robotics, vol. 33, no. 5, pp. 1184–1199, 2017.
 (34) K. Zhou, S. I. Roumeliotis, et al., “Multirobot active target tracking with combinations of relative observations,” IEEE Transactions on Robotics, vol. 27, no. 4, pp. 678–695, 2011.
 (35) J. Capitan, M. T. Spaan, L. Merino, and A. Ollero, “Decentralized multirobot cooperation with auctioned pomdps,” The International Journal of Robotics Research, vol. 32, no. 6, pp. 650–671, 2013.
 (36) L. C. Pimenta, M. Schwager, Q. Lindsey, V. Kumar, D. Rus, R. C. Mesquita, and G. A. Pereira, “Simultaneous coverage and tracking (scat) of moving targets with robot networks,” in Algorithmic foundation of robotics VIII. Springer, 2009, pp. 85–99.
 (37) J. Banfi, J. Guzzi, F. Amigoni, E. F. Flushing, A. Giusti, L. Gambardella, and G. A. Di Caro, “An integer linear programming model for fair multitarget tracking in cooperative multirobot systems,” Autonomous Robots, pp. 1–16, 2018.
 (38) Z. Xu, R. Fitch, J. Underwood, and S. Sukkarieh, “Decentralized coordinated tracking with mixed discrete–continuous decisions,” Journal of Field Robotics, vol. 30, no. 5, pp. 717–740, 2013.
 (39) B. P. Gerkey and M. J. Matarić, “A formal analysis and taxonomy of task allocation in multirobot systems,” The International Journal of Robotics Research, vol. 23, no. 9, pp. 939–954, 2004.
 (40) G. A. Korsah, A. Stentz, and M. B. Dias, “A comprehensive taxonomy for multirobot task allocation,” The International Journal of Robotics Research, vol. 32, no. 12, pp. 1495–1512, 2013.
 (41) H.L. Choi, L. Brunet, and J. P. How, “Consensusbased decentralized auctions for robust task allocation,” IEEE transactions on robotics, vol. 25, no. 4, pp. 912–926, 2009.
 (42) L. Luo, N. Chakraborty, and K. Sycara, “Distributed algorithms for multirobot task assignment with task deadline constraints,” IEEE Transactions on Automation Science and Engineering, vol. 12, no. 3, pp. 876–888, 2015.
 (43) L. Liu and D. A. Shell, “Assessing optimal assignment under uncertainty: An intervalbased algorithm,” The International Journal of Robotics Research, vol. 30, no. 7, pp. 936–953, 2011.
 (44) A. Kanakia, B. Touri, and N. Correll, “Modeling multirobot task allocation with limited information as global game,” Swarm Intelligence, vol. 10, no. 2, pp. 147–160, 2016.
 (45) J. Le Ny, A. Ribeiro, and G. J. Pappas, “Adaptive communicationconstrained deployment of unmanned vehicle systems,” IEEE Journal on Selected Areas in Communications, vol. 30, no. 5, pp. 923–934, 2012.
 (46) Y. Kantaros and M. M. Zavlanos, “Global planning for multirobot communication networks in complex environments.” IEEE Trans. Robotics, vol. 32, no. 5, pp. 1045–1061, 2016.
 (47) M. M. Zavlanos, M. B. Egerstedt, and G. J. Pappas, “Graphtheoretic connectivity control of mobile robot networks,” Proceedings of the IEEE, vol. 99, no. 9, pp. 1525–1540, 2011.
 (48) X. Ge, F. Yang, and Q.L. Han, “Distributed networked control systems: A brief overview,” Information Sciences, vol. 380, pp. 117–131, 2017.
 (49) M. Turpin, N. Michael, and V. Kumar, “Capt: Concurrent assignment and planning of trajectories for multiple robots,” The International Journal of Robotics Research, vol. 33, no. 1, pp. 98–112, 2014.
 (50) D. Morgan, G. P. Subramanian, S.J. Chung, and F. Y. Hadaegh, “Swarm assignment and trajectory optimization using variableswarm, distributed auction assignment and sequential convex programming,” The International Journal of Robotics Research, vol. 35, no. 10, pp. 1261–1285, 2016.
 (51) S. Bandyopadhyay, S.J. Chung, and F. Y. Hadaegh, “Probabilistic and distributed control of a largescale swarm of autonomous agents,” IEEE Transactions on Robotics, vol. 33, no. 5, pp. 1103–1123, 2017.
 (52) S.J. Chung, A. Paranjape, P. Dames, S. Shen, and V. Kumar, “A Survey on Aerial Swarm Robotics,” IEEE Transactions on Robotics, 2018.
 (53) M. Otte, M. Kuhlman, and D. Sofge, “Multirobot task allocation with auctions in harsh communication environments,” in MultiRobot and MultiAgent Systems (MRS), 2017 International Symposium on. IEEE, 2017, pp. 32–39.
 (54) D. Angluin, “Local and global properties in networks of processors,” in Proceedings of the twelfth annual ACM symposium on Theory of computing. ACM, 1980, pp. 82–93.
 (55) N. Linial, “Locality in distributed graph algorithms,” SIAM Journal on Computing, vol. 21, no. 1, pp. 193–201, 1992.
 (56) M. Naor and L. Stockmeyer, “What can be computed locally?” SIAM Journal on Computing, vol. 24, no. 6, pp. 1259–1277, 1995.
 (57) M. Hanckowiak, M. Karonski, and A. Panconesi, “On the distributed complexity of computing maximal matchings,” SIAM Journal on Discrete Mathematics, vol. 15, no. 1, pp. 41–57, 2001.
 (58) M. Åstrand, P. Floréen, V. Polishchuk, J. Rybicki, J. Suomela, and J. Uitto, “A local 2approximation algorithm for the vertex cover problem,” in International Symposium on Distributed Computing. Springer, 2009, pp. 191–205.
 (59) M. Åstrand and J. Suomela, “Fast distributed approximation algorithms for vertex cover and set cover in anonymous networks,” in Proceedings of the twentysecond annual ACM symposium on Parallelism in algorithms and architectures. ACM, 2010, pp. 294–302.
 (60) C. Lenzen and R. Wattenhofer, “Minimum dominating set approximation in graphs of bounded arboricity,” in International Symposium on Distributed Computing. Springer, 2010, pp. 510–524.
 (61) F. Kuhn, T. Moscibroda, and R. Wattenhofer, “The price of being nearsighted,” in Proceedings of the seventeenth annual ACMSIAM symposium on Discrete algorithm. Society for Industrial and Applied Mathematics, 2006, pp. 980–989.
 (62) W. Niehsen, “Information fusion based on fast covariance intersection filtering,” in Information Fusion, 2002. Proceedings of the Fifth International Conference on, vol. 2. IEEE, 2002, pp. 901–904.
 (63) V. Vazirani, Approximation algorithms. Springer Publishing Company, Incorporated, 2001.
 (64) “Tomlab: Optimization environment largescale optimization in matlab,” http://tomopt.com/docs/quickguide/quickguide006.php, accessed: 20170103.
Appendix A Proof of Lemma 1
Equation (5) of a maxmin linear program is equivalent to the following maxmin problem if the scalar variable which represents the inner minimization is eliminated:
(7) 
(8) 
Appendix B Proof of Lemma 2
Considering , which is a weight between th motion primitive of th robot and th target on graph , a quality of tracking () for th target can be defined as follows:
(9) 
Therefore, the sum of quality of tracking over all targets is:
(10) 
Equation (10) is obtained by taking into account the conditional term of the first equation explicitly. The last equation follows from the property that chooses the maximum value of among all robots, which is shown in lines 1014 of Algorithm 2. Therefore, the last equation is equal to the inner term of Equation (4).
Appendix C Greedy Performs Poorly for the Bottleneck Variant
We present an example of instance that shows an arbitrary poor performance of the greedy algorithm when applied to the Bottleneck variant. Consider the following case where there are two robots () having two motion primitives () for each and two targets. The realization of the communication and sensing graphs are as in the following table. The tracking quality in this example corresponds to the number of targets being tracked.
,  ,  

Let’s apply the Bottleneck version of greedy algorithm to this case. Since the objective of the Bottleneck variant is to maximize the minimum tracking quality, the robot () chooses motion primitive () because choosing motion primitive () gives the value of while choosing motion primitive () gives the value of . For the same reason, the robot () chooses motion primitive (). This gives the total value of , whereas the optimal solution is as the first robot and second robot choose motion primitive () and motion primitive (), respectively. The similar case is reproducible with a larger number of robots, motion primitives, and targets. Thus, the simple greedy performs arbitrarily badly for the Bottleneck variant.