Failure-Resilient Coverage Maximization with Multiple Robots
IImproved Resilient Coverage Maximizationwith Multiple Robots
Ishat E Rabban
Department of Computer ScienceUniversity of Maryland
College Park, MD, [email protected]
Pratap Tokekar
Department of Computer ScienceUniversity of Maryland
College Park, MD, [email protected]
Abstract —The task of maximizing coverage using multiplerobots has several applications such as surveillance, exploration,and environmental monitoring. A major challenge of deployingsuch multi-robot systems in a practical scenario is to ensureresilience against robot failures. A recent work [1] introduced theResilient Coverage Maximization (
RCM ) problem where the goalis to maximize a submodular coverage utility when the robots aresubject to adversarial attacks and/or failures. The
RCM problemis known to be NP-hard. The state-of-the-art solution of the
RCM problem [1] employs a greedy approximation strategy withtheoretical performance guarantees. In this paper, we proposetwo approximation algorithms for the
RCM problem, both ofwhich empirically outperform the existing solution in terms ofaccuracy and/or execution time. To demonstrate the effectivenessof our proposed solution, we empirically compare our proposedalgorithms with the existing solution and a brute force optimumalgorithm.
Index Terms —Coverage Maximization, Multi-Robot Systems,Resilience
I. I
NTRODUCTION
Tasks such as surveillance [3], tracking [2], and motionplanning [7] can be formulated as an optimization problemthat aims to maximize the coverage of a set of target ob-jects. These coverage maximization tasks can be benefitedby the use of multiple robots as opposed to a single robot.Indeed, the advancements in robotic mobility, sensing, andcommunication technology have led to the use of multiplecollaborating robots to support such tasks [4]–[6]. But a majorchallenge for practical deployment of such multi-robot systemsis to make the robots resilient to failures. For example, therobots may undergo adversarial attacks [10], or the field-of-view of some robots may get occluded due to environmentalhazards [11], or the sensors may stop working due to technicalmalfunction [12]. In this paper, our goal is to devise coveragemaximization algorithms that are resilient to such failures.The standard coverage maximization problem has been wellstudied in literature [15]–[17]. But an adversarial variant ofthe coverage maximization problem that ensures robustnessagainst robot failures has gained attention among the researchcommunity only recently [8], [13], [14]. In a recent work,Zhou et al. [1] introduced a new variant of the coveragemaximization problem that takes into account the resilienceof the multi-robot system. In their proposed problem setup,a team of robots aim to cover a set of targets (Figure 1).
Fig. 1. Two robots (drone signs) are tracking targets (black dots). The left(right) robot has 3 (4) available trajectories (dotted arrow). Coverage regionof one trajectory of each robot is shown in gray. The highlighted trajectoryof the left (right) robot covers 3 (2) targets.
For each robot, there is a set of candidate trajectories, oneof which the robot will follow. The list of targets covered byeach robot trajectory is provided. It is assumed that at most α robots may fail. But it is unknown which robots are going tofail. The objective of the problem is to select one trajectoryfor each robot such that the target coverage is maximized incase of a worst case failure of α robots. We call this problem Resilient Coverage Maximization ( RCM ) problem. The
RCM problem is known to be NP-hard [9].Inspired by a recent work of Tzoumas et al. [13] thatexplores generalized resilient optimization subject to matroidconstraints, Zhou et al. [1] proposed an approximation algo-rithm for the
RCM problem that involves two phases. In thefirst phase, the algorithm determines the worst case subset of α robots that could fail, and selects their trajectories. In thenext phase, assuming that the robots selected in the first phasewill actually fail, the rest of the robot trajectories are selectedgreedily such that, for each greedy selection, the marginal gainin target coverage is maximized. We call this algorithm the ( ) algorithm. The execution time of the algorithm is O( P ), where P is the sum of the numberof trajectories of all the robots.In this paper, we propose two algorithms for the RCM problem that perform better than the algorithm in termsof accuracy and/or execution time. Here, by accuracy of asolution, we mean how much target coverage the solutionachieves with respect to an optimum solution. Our proposedalgorithms are called
Ordered Greedy ( OrG ) algorithm and
Local Search ( LS ) algorithm. a r X i v : . [ c s . R O ] J u l he OrG algorithm produces an ordering of the robotsaccording to some sorting criteria, and greedily selects thetrajectories for each robot one after another according to theabove sorted order such that, for each robot, incrementaltarget coverage is maximized. The execution time of the
OrG algorithm is O( P ). Experimental results show that the accuracyof the OrG algorithm is slightly better than the algorithm,and it runs much faster than the algorithm.In the LS algorithm, we start with an initial solution ofthe RCM problem. Then, at each iteration, we estimate theaccuracy of the neighbors of the current solution and selecta neighbor solution with higher estimated accuracy. The al-gorithm terminates when we find a local optima. Empiricalstudies show that the accuracy of the LS algorithm is signifi-cantly better than the algorithm, while the two algorithmsare close to each other in terms of execution time.In case of both algorithms, we consider several designchoices and compare the accuracy of the variants of thealgorithms that arise from different design choices. In caseof the OrG algorithm, the design choice is the sorting criteriaused to sort the robots. In case of the LS algorithm, designchoices include the initial solution and the attack model.In summary, we make the following contributions: • We propose two algorithms for the
RCM problem,namely, the
OrG algorithm and the LS algorithm, whichperform better than the state-of-the-art algorithm interms of accuracy and/or execution time. • We conduct extensive experiments with synthetic datasetsto evaluate the accuracy and execution time of ourproposed algorithms with respect to the algorithmand a brute force optimum algorithm.The organization of the rest of the paper is as follows.In Section II, we provide the formal definition of the
RCM problem. Next, in Section III and Section IV, we describe the
OrG and LS algorithms respectively. The experimental resultsare presented in Section V. Finally, in Section VI, we makesome concluding remarks.II. P ROBLEM F ORMULATION
In this section, we describe the framework of the resilientcoverage maximization problem (Section II-A), present theformal definition of the problem (Section II-B), and providesome supplementary definitions (Section II-C).
A. Framework
We adopt the framework introduced by Zhou et al. [1]in their work on resilient multi-target tracking. According tothe proposed framework, we consider a set of targets, X ,which are being tracked/covered by a set of mobile robots, R . The targets can be mobile or stationary, distinguishableor indistinguishable, and can have known or unknown motionmodel. It is assumed that the robots have perfect localizationand can communicate with each other at all times. Usingsensors, communication, and filtering techniques, the robotsare able to calculate the estimated position of the targets. Time is divided into rounds of finite duration. We considereach round independently. At the beginning of a round, eachrobot generates a set of candidate trajectories, one of whichwill be followed in the current round. The set of trajectories ofa robot r is denoted be T r . The set of all robots’ trajectories isdenoted by T R , i.e., T R := ∪ r ∈R T r . Let P be the number ofall trajectories, i.e., P = |T R | . Here the notation |A| denotesthe cardinality of set A . Target Coverage function:
The coverage of a trajectory τ is defined as the set of targets that τ covers, which we denoteby C( τ ) . The target coverage function , F , takes as input a setof trajectories T and returns the number of distinct targets cov-ered by the trajectories in T , i.e., F( T ) := | ∪ τ ∈T C( τ ) | . Thetarget coverage function F is monotone and submodular [16].Other examples of monotone and submodular target coveragefunctions are mutual information and entropy [18]. Attack Model:
We assume that at most α robots/sensorscan fail at a time. We consider the worst case/optimum attackmodel as defined below. Given a set of trajectories T , the targetcoverage function F, and an integer α denoting the maximumattack size, an optimal attack on T of size α is defined asfollows. A ∗ α ( T ) := argmin A⊆T F( T \A ) s.t. |A| ≤ α In other words, an optimal attack on T of size α is a subsetof T of size at most α such that removal of the subset from T results in maximum decrease of the target coverage. In theabove definition, the notation A\B denotes the set of elementsin A that are not in B . B. Problem Definition
Given a set of targets, a set of robots R , the trajectoriesfor the robots T R , the attack size α , and a target coveragefunction F, the Resilient Coverage Problem problem aims toselect a set of trajectories according to the following objectivefunction. argmax
S⊆T R F( S\ A ∗ α ( S )) s.t. |S ∩ T r | = 1 , ∀ r ∈ R (1)In other words, the solution subset contains one trajectoryper robot (enforced by the constraints), such that in case of anoptimal attack of size α , the target coverage of the remainingrobots is maximized. C. Supplementary Definitions A Feasible Solution is a subset of T R that satisfies theconstraints in (1). A feasible solution corresponds to a validassignment of trajectories to robots, i.e., one trajectory perrobot. The feasible solution that maximizes the objectivefunction (1) is called the Optimum Solution . We denote theoptimum solution by S ∗ . The Residual Coverage of a feasiblesolution S is the number of targets covered by S after theoptimal attack set is removed from S . The residual coverageof S is denoted by R( S ) . According to the above definition, R( S ) = F( S\ A ∗ α ( S )) , where α is the attack size.II. O RDERED G REEDY A LGORITHM
In this section, we present a class of greedy algorithms thatrequire O ( P ) evaluations of the target coverage function F.The algorithm is named Ordered Greedy Algorithm ( OrG ) andis presented below (Algorithm 1). In this algorithm, first wesort the robots according to some sorting criteria (Line 1).Then we consider the robots in the sorted order (Line 3). Foreach robot, we greedily select the trajectory that maximizesthe incremental coverage of the targets (Line 4-5).
Algorithm 1
Ordered Greedy Algorithm
Input: R , T R , α , F Output:
Set of trajectories, S < r , r , . . . , r |R| > ← sort( T R , F) S ← ∅ for i ← |R| do τ ∗ ← argmax τ ∈T ri F( S ∪ τ ) S ← S ∪ τ ∗ end for return S To perform the sorting of the robots, for each robot r ,we calculate a numerical value V( r ) , according to somesorting criteria, and then sort the robots in increasing and/ordecreasing order of the assigned numerical value. We use thefollowing sorting criteria to evaluate the accuracy and perfor-mance of the ordered greedy algorithms. Each criteria resultsin two different variants of the ordered greedy algorithms: onefor increasing order, and one for decreasing order. • Sum of Target Coverage : The numerical value of robot r is the sum of the number of targets covered by allthe trajectories of r , i.e., V( r ) = (cid:80) τ ∈T r | C( τ ) | . Theresultant ordered greedy algorithms are named OrG-S-I and
OrG-S-D (for increasing and decreasing order ofsorting, respectively). • Size of Union of Target Coverage : The numerical valueof robot r is the number of distinct targets covered byall the trajectories of r , i.e., V( r ) = | ∪ τ ∈T r C( τ ) | . Theresultant algorithms are named OrG-U-I and
OrG-U-D . • Maximum Individual Target Coverage : The numericalvalue of robot r is the cardinality of the trajectoryof r that covers the maximum number of targets, i.e., V( r ) = max τ ∈T r | C( τ ) | . The resultant algorithms arenamed OrG-M-I and
OrG-M-D .We also consider another variant where the ordering ofthe robots is random (
OrG-R ). Note that, each of the abovealgorithms requires O ( P ) evaluations of F. Here, P is thesum of number of trajectories of all robots. To calculate thenumerical values of the robots, we need P evaluations of F.Also, in Line 4 of Algorithm 1, the call to F is executed P times in total. Thus, the total number of evaluations of F forthe ordered greedy algorithm is O ( P ) .IV. L OCAL S EARCH A LGORITHM
In this section, we describe a class of algorithms based onlocal search technique. In a traditional local search algorithm, we start with an initial solution. At each iteration, we makesmall local changes to the current solution to form a setof candidate neighboring solutions. Then we evaluate theobjective function on the neighboring solutions to find ifany improvement over the current solution is possible. If abetter solution is found, the search moves to that direction.Otherwise, the algorithm terminates.A tricky aspect of adopting a local search based approach tothe resilient coverage maximization problem is that evaluatingthe objective function for a given solution is not straight-forward. In this problem, the objective value of a solution S is F( S\ A ∗ α ( S )) . Thus, given a candidate solution S , inorder to evaluate the objective function for S , we are requiredto construct an optimal attack on S . But constructing anoptimal attack on S is a combinatorially hard problem, whichrequires exponential computation time with respect to the sizeof S . Consequently, in this algorithm, we use computationallyfeasible greedy attack models, instead of an optimal attackmodel, to drive the local search. We denote the greedy attackfunction by A, which is further discussed later in this section. Algorithm 2
Local Search Algorithm
Input: R , T R , α , F Output:
Set of trajectories, S S ←
INIT( T R , F) z ← F( S\ A α ( S )) while TRUE do f ← FALSE for all neighbor ˙ S of S do A ← A α ( ˙ S ) ˙ z ← F( ˙
S\A ) if ˙ z > z then f, S , z ← TRUE , ˙ S , ˙ z break end if end for if f = FALSE then break end if end while return S Now we describe the Local Search algorithm (Algorithm2) in details. We start with an initial solution S (Line 1) andthe corresponding objective value z (Line 2). At each iterationof the local search (Line 3-16), we consider all neighbors ofthe current solution S (Line 5). Any feasible solution whichdiffers with S by exactly one trajectory is defined to be a neighbor of S . For each neighbor ˙ S of S , we construct agreedy attack on ˙ S , denoted by A (Line 6), and calculatethe corresponding objective value ˙ z (Line 7). If the candidatesolution is better than the current solution (Line 8), we restartthe iteration with updated solution and objective value (Line9-10). If no neighbor leads to a solution better than the currentsolution, the local search terminates (Line 4, 13-14), and theurrent solution is returned (Line 17) as the solution of theresilient coverage maximization problem.Several variants of the local search algorithm arise whenwe use different attack models (Line 2, 6) and different initialsolutions (Line 1). We consider the following two greedyattack models. In both models, the attacker makes α greedychoices, one after another, obeying the constraint that at mostone trajectory can be selected per robot. • Attack Model 1 (A1) : At each iteration, the attacker selectsthe trajectory which maximizes the increase in targetcoverage. • Attack Model 2 (A2) : Let U be the set of targets whichare covered by exactly one of the remaining trajectories.At each iteration, the attacker selects the trajectory whichcovers the maximum number of targets in U .We consider two initial solutions as follows. • Initial Solution 1 (I1) : The output of the Oblivious Greedyalgorithm (to be described in Section V-A). • Initial Solution 2 (I2) : The output of the
OrG-U-I algo-rithm (described in Section III).Two attack models and two initial solutions yield fourvariants of the LS algorithm. We append the attack type andinitial solution type to name the variants. For example, LS-A1-I2 is the variant of the local search algorithm that uses attackmodel 1 and initial solution 2.Note that, in the local search algorithm, the number ofevaluations of F is dominated by the number of calls to theattack function in Line 6. In case of both of the above attackmodels, constructing a greedy attack requires O ( αR ) calls toF, where R is the number of robots. Also, there are O ( P ) neighbors of the current solution S . Consequently, in caseof both attack models, the local search algorithm requires O ( IαRP ) evaluations of F, where I is the number of timesthe local search iterates. But, by using some hash-based datastructures, we reduce the execution time of the local searchalgorithm by a factor of T , where T is the number of targets.We describe the acceleration technique in Appendix A.V. E XPERIMENTS
In this section, we empirically evaluate our proposed algo-rithms and present the experimental results. First, we discussthe experimental setup (Section V-A). Next, we compare theaccuracy (Section V-B) and execution time (Section V-C) ofour proposed algorithms with the algorithm. Finally, weevaluate the performance of our proposed algorithms in caseof a non-optimal attack model (Section V-D).
A. Experimental Setup
Evaluation Metric : We use two metrics to empiricallyevaluate our proposed algorithms: accuracy and executiontime. The accuracy of a feasible solution S is the ratio of theresidual coverages of S and S ∗ , where S ∗ is the optimumsolution. Thus, the accuracy of a feasible solution S is ameasure of the quality of S with respect to the optimumsolution S ∗ . If, in an experiment, the optimum solution is known, we directly report the accuracy of the solutions foundby the algorithms which are being compared. On the otherhand, if the optimum solution is unknown, we compute theresidual coverages of the solutions found by the algorithms andreport the relative accuracy with respect to the algorithm.Note that, a higher residual coverage corresponds to higheraccuracy, and vice versa, since the ratio of residual coveragesof two feasible solutions equals the ratio of their accuracy. Compared Algorithms : We empirically compare the per-formance of our proposed algorithms (
OrG and LS ) with the algorithm. We additionally consider two straightforwardalgorithms as follows: • Brute Force algorithm : The Brute Force ( BF ) algorithmdetermines the optimum solution of the RCM problem.In this algorithm, we consider all feasible solutions,construct an optimal attack on each feasible solution, andreport the feasible solution with maximum residual cov-erage. Thus, the BF algorithm has exponential executiontime with respect to the number of robots. • Oblivious Greedy algorithm : In the Oblivious Greedy(
ObG ) algorithm, we select, for each robot, thetrajectory that covers maximum number of targets.Formally, the solution found by this algorithm is (cid:83) r ∈R argmax τ ∈T r F( { τ } ) . The ObG algorithm makes P calls to the target coverage function F. Dataset : In our experiments, we use a synthetic datasetgenerated as follows. First, we select the locations of thetargets and robots within a ×
2D grid withuniform probability. For each robot, we consider 4 trajectories:forward, backward, left, and right as shown in Figure 2.We assume that the regions covered by the 4 trajectoriesare rectangular (shown in gray). The targets falling inside arectangle are assigned to the corresponding trajectory.
Fig. 2. Generation of Dataset.
Parameter Set : We use different sets of parameter valuesfor different experiments. For example, in the experimentswhere we compute a brute force solution, we use only 6robots to keep the total execution time in check. But for otherexperiments we use higher number of robots. The values ofthe parameters used in each experiment is mentioned in thecorresponding subsection. Each experiment is conducted 100times and the average is reported. We assume that the numberof robot failures is equal to the attack size, α . Platform : The algorithms are implemented using C++ pro-gramming language. The experiments are conducted on a core-i7 2GHz PC with 8GB RAM, running Microsoft Windows 10. R e s i dua l C o v e r age w r t P G Attack Size(a) Oblivious Greedy Algorithm (R = 15, T = 150) R e s i dua l C o v e r age w r t P G Attack Size(b) Ordered Greedy Algorithm (R = 15, T = 150) R e s i dua l C o v e r age w r t P G Attack Size(c) Local Search Algorithm (R = 15, T = 150)
Fig. 3. Comparison of accuracy of (a)
ObG algorithm, (b)
OrG algorithm, and (c) LS algorithm with algorithm. B. Comparison of Accuracy
Relative Accuracy with respect to
Algorithm : Inthis experiment, we construct a dataset with 15 robots and 150targets. We vary the attack size in increments of 3 and reportthe average relative accuracy (in percentage) of our proposedalgorithms with respect to the algorithm (Figure 3). Theaverage standard deviation is shown in the legends.The experimental results (Figure 3(a)) show that the ac-curacy of the
ObG algorithm is consistently lower than the algorithm. In case of the
OrG algorithm, the
OrG-I variants (i.e., variants of
OrG algorithm sorted in increasing order) have better accuracy in comparison with their
OrG-D counterparts (Figure 3(b)). The accuracy of the and
OrG-R algorithms lie in between the
OrG-I and
OrG-D variants.We argue that the increasing sorting order leads to aneven distribution of the targets to trajectories. Consequently,the reduction of target coverage after an optimal attack issmaller in case of the
OrG-I variants as opposed to the
OrG-D ones. We empirically verify the correctness of theabove claim by conducting an experiment where we comparethe standard deviations of the incremental coverages at eachgreedy iteration of
OrG-U-I and
OrG-U-D . We find thatthe standard deviation of the
OrG-D variant is on average higher than the
OrG-I variant, which provides empiricalevidence in support of our claim.In case of the LS algorithm, experimental results (Fig-ure 3(c)) show that attack model 2 ( A2 ) leads to better accuracythan attack model 1 ( A1 ). Also, initial condition 2 ( I2 ) giveshigher accuracy in comparison to initial condition 1 ( I1 ). Thus, LS-A2-I2 has the highest accuracy among the LS variants.Also, the accuracy of LS-A2-I2 is significantly better than the algorithm across all attack sizes.
Comparison with Brute Force Algorithm : In this experi-ment, we determine the accuracy of our proposed algorithms.Note that, the accuracy of a feasible solution S is the ratioof the residual coverages of S and S ∗ , the optimum solution.We compute the optimum solution using the BF algorithm,which has exponential running time. Consequently, in thisexperiment, we consider small instances of the RCM problemwith 6 robots and 60 targets, and use attack sizes 2, 3, and 4. A cc u r a cy ( % ) Attack SizeAccuracy wrt Brute Force Algorithm (R = 6, T = 60)
Fig. 4. Comparison of accuracy of proposed algorithms with BF algorithm. For brevity of presentation, from now on, instead of report-ing the accuracy of all the variants of our proposed algorithms,we only report the results for the
OrG variant
OrG-U-I and LS variant LS-A2-I2 along with the oblivious greedy algorithm
ObG and algorithm. The experimental results (Figure 4)show that the local search algorithm has the highest accuracy,followed by the ordered greedy algorithm, algorithm, andthe oblivious greedy algorithm, which is in accordance withthe experimental results presented in the previous section. Notethat, the accuracy of BF algorithm is 1 or 100%. C. Comparison of Execution Time
In this experiment, we vary the number of robots/targetsfrom 100 to 5000, and use an attack size of 10. The experimen-tal results (Figure 5) show that the oblivious greedy algorithmhas the lowest execution time, followed by the ordered greedyalgorithm. The local search algorithm and the algorithmare slower than the former two algorithms, and the local searchalgorithm outperforms the algorithm as the number ofrobots/targets goes past 1000. The experimental results are inaccordance with the time complexity analysis of the comparedalgorithms presented in the previous sections. Note that, othervariants of the
OrG and LS algorithm have similar executiontime as the counterpart compared above. .2514166425610244096100 200 500 1000 2000 5000 T i m e ( m illi s e c ) Number of Robots and/or TargetsExecution Time (R = T, attack size = 10)2PGLS-A2-I2OrG-U-IObG
Fig. 5. Comparison of execution time of the proposed algorithms with 2PGalgorithm.
D. Evaluation of Accuracy for Large Problem Instances
In this section, we evaluate the accuracy of our proposedalgorithms for large instances of the
RCM problem. In caseof large problem instances, it is not feasible to computethe residual coverage, because constructing an optimal attackrequires exponential time with respect to the number of robots.Consequently, we resort to a non-optimal greedy attack modelto compute an estimation of the residual coverage. We useattack model 2 ( A2 ), outlined in Section IV, which is a greedyapproximate attack model computable in polynomial time. R e s i dua l C o v e r age w r t P G Attack SizeAccuracy for Non-optimal Attack (R = 100, T = 1000)
Fig. 6. Comparison of accuracy with Non-optimal Attack Model.
In this experiment, we use 100 robots and 1000 targets,vary the attack size in increments of 20, and report the relativeaccuracy with respect to the algorithm. The experimentalresults (Figure 6) show that the accuracy of the proposedalgorithms using non-optimal attack model A2 is equivalentto the accuracy found in previous sections using an optimalattack model. The local search algorithm still has the bestaccuracy among the compared algorithms.VI. C ONCLUSION
In this work, we have proposed two algorithms for thecoverage maximization problem with multiple robots in an ad-versarial setting. Our proposed algorithms have outperformed the state-of-the-art algorithm in terms of accuracy and/orexecution time. We have demonstrated the effectiveness of ourproposed solutions by conducting empirical studies.In future, we intend to perform real world testing of ourproposed algorithms in the context of practical applications ofsurveillance and patrolling. One may also consider reformulat-ing the problem with a computationally feasible non-optimalattack model, and reevaluate the performance of the existingand proposed algorithms.VII. A
CKNOWLEDGEMENT
This work is supported by the National Science Foundationunder Grant No. 1943368. We are grateful to Dr. Lifeng Zhou,and other members of RAAS lab at UMD for their feedbackon this paper. R
EFERENCES[1] L. Zhou, V. Tzoumas, G. J. Pappas, and P. Tokekar, “Resilient activetarget tracking with multiple robots,” IEEE Robotics and AutomationLetters, vol. 4, pp. 129–136, 2018.[2] P. Tokekar, E. Branson, J. Vander Hook, and V. Isler, “Trackingaquatic invaders: Autonomous robots for monitoring invasive fish,” IEEERobotics & Automation Magazine, vol. 20, no. 3, pp. 33–41, 2013.[3] B. Grocholsky, J. Keller, V. Kumar, and G. Pappas, “Cooperative air andground surveillance,” IEEE Robotics & Automation Magazine, vol. 13,no. 3, pp. 16–25, 2006.[4] V. Kumar and N. Michael, “Opportunities and challenges with au-tonomous micro aerial vehicles,” The International Journal of RoboticsResearch, vol. 31, no. 11, pp. 1279–1291, 2012.[5] N. Atanasov, J. Le Ny, K. Daniilidis, and G. J. Pappas, “Informationacquisition with sensing robots,” in IEEE International Conference onRobotics and Automation, 2014, pp. 6447–6454.[6] C. Robin and S. Lacroix, “Multi-robot target detection and tracking:taxonomy and survey,” Autonomous Robots, vol. 40, pp. 729–760, 2016.[7] J. R. Spletzer and C. J. Taylor, “Dynamic sensor planning and controlfor optimally tracking targets,” The International Journal of RoboticsResearch, vol. 22, no. 1, pp. 7–20, 2003.[8] A. Pierson, Z. Wang, and M. Schwager, “Intercepting rogue robots: Analgorithm for capturing multiple evaders with multiple pursuers,” IEEERobotics and Automation Letters, vol. 2, no. 2, pp. 530–537, 2017.[9] P. Tokekar, V. Isler, and A. Franchi, “Multi-target visual tracking withaerial robots,” in IEEE/RSJ International Conference on IntelligentRobots and Systems, 2014, pp. 3067–3072.[10] E. Sless, N. Agmon, and S. Kraus, “Multi-robot adversarial patrolling:Facing coordinated attacks,” in International Conference on AutonomousAgents and Multi-agent Systems, 2014, pp. 1093–1100.[11] H. H. Gonzlez-Banos, C.-Y. Lee, and J.-C. Latombe, “Real-time com-binatorial tracking of a target moving unpredictably among obstacles,”in Robotics and Automation, 2002. Proceedings. ICRA02. IEEE Inter-national Conference on, vol. 2. IEEE, 2002, pp. 1683–1690.[12] S. I. Roumeliotis, G. S. Sukhatme, and G. A. Bekey, “Sensor faultdetection and identification in a mobile robot,” in Intelligent Robots andSystems, 1998. Proceedings., 1998 IEEE/RSJ International Conferenceon, vol. 3. IEEE, 1998, pp. 1383–1388.[13] V. Tzoumas, A. Jadbabaie, and G. J. Pappas, “Resilient Non-SubmodularMaximization over Matroid Constraints,” arXiv: 1804.01013, 2018.[14] B. Schlotfeldt, V. Tzoumas, D. Thakur, and G. J. Pappas, “Resilient ac-tive information gathering with mobile robots,” IEEE/RSJ InternationalConference on Intelligent Robots and Systems, 2018.[15] D. S. Hochbaum and A. Pathria, “Analysis of the greedy approach inproblems of maximum k-coverage,” Naval Research Logistics, vol. 45,no. 6, pp. 615–627, 1998.[16] M. Conforti and G. Cornujols, “Submodular set functions, matroids andthe greedy algorithm,” Discrete Applied Mathematics, vol. 7, no. 3, pp.251–274, 1984.[17] R. Iyer, S. Jegelka, and J. Bilmes, “Fast semidifferential-based sub-modular function optimization,” in International Conference on MachineLearning, 2013, pp. 855–863.[18] A. Krause, and D. Golovin, “Submodular function maximization,” 2014. R e s i dua l C o v e r age w r t P G Attack Size(a) Oblivious Greedy Algorithm (R = 15, T = 150) R e s i dua l C o v e r age w r t P G Attack Size(b) Ordered Greedy Algorithm (R = 15, T = 150) R e s i dua l C o v e r age w r t P G Attack Size(c) Local Search Algorithm (R = 15, T = 150)
Fig. 7. Comparison of accuracy of (a)
ObG algorithm, (b)
OrG algorithm, and (c) LS algorithm with algorithm for random dataset. A PPENDIX AA CCELERATION OF THE L OCAL S EARCH A LGORITHM
In this section, we present a technique to make the localsearch algorithm (described in Section IV) execute faster. Themain idea is to use a hash-based data structure so that we canreduce the time required to construct an attack.First we compute the running time of a straightforwardimplementation of the attack function A. We use R and T to denote the number of robots and targets respectively. Toconstruct the attack, we make α greedy choices. At eachgreedy iteration, we make R calls to the target coveragefunction F. F can be computed in O( T ) time by maintaining aboolean array of size T that stores the coverage status of allthe targets. Thus a straightforward implementation of A takesO( αRT ) time.Now we present how we can accelerate the process ofconstructing an attack. We present the methodology for bothattack models A and A separately below. Here, S denotesthe feasible solution that is passed as input parameter to theattack function A, and L τ denotes the set of targets coveredby the trajectory τ . • Attack model 1 ( A ): In case of A , at each greedyiteration, the attacker selects the trajectory that maximizesthe increase in target coverage. In our implementation of A , we maintain a boolean array of size T , which stores,for each target t , if t is covered by at least one of thetrajectories greedily selected thus far. Using the array, wedetermine the incremental coverage of a trajectory τ inO( | L τ | ) time. • Attack model 2 ( A ): In case of A , at each greedyiteration, the attacker selects the trajectory that covers themaximum number of targets in U , where U is the set oftargets which are covered by exactly one of the remainingtrajectories. In our implementation of A , for each target t , we store the set of trajectories in S which cover t .Let’s denote the collection of all such sets by X . Weimplement U and the sets in X using hash-tables, whichpermit find, insertion, and delete operations in constanttime. In the implementation of A , when we greedily selecta trajectory τ , we remove τ from all sets in X whichinclude τ . If the size of any set in X reduces to one, weupdate U accordingly. Using the hash-based implemen-tation of U and X , we determine the number of targetsthat are covered by exactly one trajectory after removalof a trajectory τ in O( | L τ | ) time.In case of both attack models, using the above mentioneddata structures, we can make each greedy choice in timeO( Rt ∗ ) , where t ∗ denotes the maximum number of targetscovered by one trajectory. This makes the overall computationtime of the attack function O( αRt ∗ ). Thus, using the abovedescribed acceleration technique, we achieve a performancespeedup of a factor of Tt ∗ over the straightforward algorithm,which is O( T ) if we assume that t ∗ is a constant.A PPENDIX BE XPERIMENTAL R ESULTS FOR R ANDOM D ATASET
In this section, we present the experimental results for asynthetic dataset that is generated in a different way than theone mentioned in Section V. We call the new dataset random dataset. To generate a random dataset, we consider 4 trajec-tories for each robot. For each trajectory τ , we generate aninteger n uniformly within the range [5, 15], which indicatesthe number of targets covered by τ . Then, from the set oftargets, we select n targets with uniform probability and assignthem to the trajectory τ .Let’s call the dataset used in the experiments in Section V geometric dataset. The random dataset is fundamentally dif-ferent from the geometric dataset, because it does not haveany underlying geometric structure. Consequently, experimen-tations using the random dataset demonstrate slightly differentoutcomes in comparison with geometric dataset.Now we present the results of empirical evaluation of ourproposed algorithms with random dataset. We conduct thesame set of experiments as in Section V using the same valuesof the parameters. In Figure 7, we compare the accuracyof our proposed algorithms with the algorithm. Theexperimental results differ from the geometric dataset in twoways. We observe that the accuracy of all OrG and LS variantsecreases with increase in attack size. Also, the averagestandard deviation of the relative accuracy is significantlylower in case of random dataset in comparison with geometricdataset. A cc u r a cy ( % ) Attack SizeAccuracy wrt Brute Force Algorithm (R = 6, T = 60)
Fig. 8. Comparison of accuracy of proposed algorithms with BF algorithmfor random dataset. R e s i dua l C o v e r age w r t P G Attack SizeAccuracy for Non-optimal Attack (R = 100, T = 1000)
Fig. 9. Comparison of accuracy with Non-optimal Attack Model for randomdataset.
Figure 8 shows the accuracy of our proposed algorithms incomparison with the brute force algorithm. We observe thatthe accuracy of the algorithms being compared is significantlyhigher in case of random dataset than the geometric dataset.But the order of the accuracy of the compared algorithmsis preserved across the datasets. Figure 9 shows that the ex-perimental results with non-optimal attack model for randomdataset is similar to the results found using geometric dataset.A
PPENDIX CS ENSITIVITY A NALYSIS
In the above experiments, we have assumed that the numberof robot failures equals the attack size, α . But in reality, thetwo quantities will differ in most cases. For example, in apractical deployment of 10 robots which assumes a maximumattack size of 2 (i.e., α = 2 ), there may be no robot failure.Hence, we present experimental results where the number ofrobot failures differs from the attack size. R e s i dua l C o v e r age w r t P G Failure CountSensitivity Analysis (R = 15, T = 150)
Fig. 10. Sensitivity analysis for geometric dataset. R e s i dua l C o v e r age w r t P G Failure CountSensitivity Analysis (R = 15, T = 150)
Fig. 11. Sensitivity analysis for random dataset.
In this experiment, we consider a scenario with 15 robots,150 targets, and attack size, α = 6 . We vary the numberof robot failures (worst case failure) in increments of 2 andreport the relative accuracy of our proposed algorithms withrespect to the algorithm for both geometric (Figure 10)and random (Figure 11) datasets.The experimental results show that, for both datasets, theaccuracy of the proposed algorithms ( OrG-U-I and
LS-A2-I2 )drops sharply if the number of robot failure exceeds α . If thenumber of robot failures is within the attack size (i.e., less thanor equal to α ), the proposed algorithms give better accuracythan the2PG