{'fraction_non_alphanumeric': 0.03749742260449498, 'fraction_numerical': 0.01416831129046511, 'mean_word_length': 4.753177427554652, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 6, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 9, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A Resource-Aware Approach to Collaborative Loop Closure Detection with Provable Performance Guarantees

This paper presents resource-aware algorithms for distributed inter-robot loop closure detection for applications such as collaborative simultaneous localization and mapping (CSLAM) and distributed image retrieval. In real-world scenarios, this process is resource-intensive as it involves exchanging many observations and geometrically verifying a large number of potential matches. This poses severe challenges for small-size and low-cost robots with various operational and resource constraints that limit, e.g., energy consumption, communication bandwidth, and computation capacity. This paper proposes a framework in which robots first exchange compact queries to identify a set of potential loop closures. We then seek to select a subset of potential inter-robot loop closures for geometric verification that maximizes a monotone submodular performance metric without exceeding budgets on computation (number of geometric verifications) and communication (amount of exchanged data for geometric verification). We demonstrate that this problem is in general NP-hard, and present efficient approximation algorithms with provable performance guarantees. The proposed framework is extensively evaluated on real and synthetic datasets. A natural convex relaxation scheme is also presented to certify the near-optimal performance of the proposed framework in practice.


Introduction
Inter-robot loop closures tie individual trajectories and maps together, and allow spatial information to flow from one robot to the entire team. Finding these inter-robot measurements is a crucial problem in collaborative simultaneous localization and mapping (CSLAM) and multi-robot navigation in GPS-denied environments. This process requires exchanging observations, identifying potential matches, and verifying these potential matches for spatial consistency. Real-world scenarios often involve long-term missions in environments with high rate of perceptual aliasing. These challenges make inter-robot loop closure detection a resource-intensive process with a rapidly growing search space. This task is especially challenging for the prevalent small-size robotic platforms that are subject to various operational constraints which ultimately limit, e.g., energy consumption, communication bandwidth, and computation capacity. Designing resourceefficient frameworks for inter-robot loop closure detection thus is crucial and has sparked a growing interest as evident by the recent literature; see, e.g., (Cieslewski et al. 2017;Giamou et al. 2018; Van Opdenbosch and Steinbach 2019; Khosoussi et al. 2019).
Existing solutions can be categorized into centralized and decentralized approaches. Centralized approaches circumvent the onboard resource constraints by outsourcing the task of inter-robot loop closure detection to an offboard unit with sufficient resources; see, e.g., (Schmuck and Chli 2018). These solutions, however, are limited to applications where a sufficiently capable central node exists and is accessible via a reliable communication channel. Furthermore, in these solutions robots need to transmit all observations to the central node which is inefficient considering the fact that only a small fraction of these observations constitute inter-robot loop closures. To address such limitations, recent works have investigated efficient decentralized schemes in which robots exchange lightweight queries and collaboratively discover and verify inter-robot loop closures; see, e.g., (Cieslewski and Scaramuzza 2017b;Giamou et al. 2018;Cieslewski et al. 2017) and references therein.
Despite these crucial efforts, an important problem remains to be addressed: even with the most resource-efficient scheme, completing the loop closure detection task may still be infeasible given the allocated budgets on, e.g., communication bandwidth and computation capacity. In other words, while resource-efficiency is necessary, it is not sufficient. To address this issue, robots must be aware of such budget constraints, and further must be able to seamlessly adapt their behaviour to these constraints by intelligently utilizing resources available onboard to complete their tasks to the best of their ability.
In this work, we present such a resource-aware approach to the distributed inter-robot loop closure detection problem. At the core of our approach, the team seeks an exchangeand-verification plan that maximizes a performance metric (e.g., expected number of discovered loop closures) subject to budgets on communication (size of transmission) and computation (number of geometric verifications). In words, such a plan determines (i) "who must share what with whom" and (ii) "which subset of potential inter-robot loop closures should be tested for spatial consistency". Special cases of this problem have been studied in recent works in the context of measurement selection for SLAM, where robots are only subject to communication (Tian et al. 2018a) or computation (Khosoussi et al. 2019;Carlone and Karaman 2017) budgets. In general, this problem is NP-hard as it generalizes the maximum coverage problem. This work builds upon classical results in submodular maximization (Krause and Golovin 2014) and presents efficient approximation algorithms with provable performance guarantees for maximizing monotone submodular performance metrics under budgeted resources. The performance of the proposed approach is extensively validated using both real-world and simulated datasets, and the near-optimality of the proposed solution is demonstrated empirically using a post-hoc certification scheme based on convex relaxation.

Contributions
The main contributions of this work are two-fold: 1. A generic sensor-agnostic framework for collaborative loop closure detection-and-verification under budgeted communication and computation. 2. Greedy approximation algorithms with performance guarantees for near-optimal planning of data exchange and candidate verification under various communication and computation resource constraints models.
An early version of this work was presented at WAFR 2018 (Workshop on the Algorithmic Foundations of Robotics) (Tian et al. 2018b). This paper improves (Tian et al. 2018b) and our earlier work (Tian et al. 2018a) along the following axes: 1. New approximation algorithms with provable performance guarantees in new resource constraint regimes with pairwise and individual computational budgets (Section 4.1). 2. A data-driven (as opposed to hand-engineered) scheme based on logistic regression for learning edge weights (i.e., loop closure probabilities) in the exchange graph from NetVLAD vectors (Section 3.1). 3. Exploring the trade-off between the size and fidelity of metadata for a new metadata representation, namely NetVLAD which offers additional flexibility compared to the previously used bag-of-visual-words models (Section 6.2). 4. Extended experimental and numerical analysis (Section 6).

Outline
We review related works in Section 2. Section 3 presents an overview of the proposed framework and formulates the main optimization problem. Our main approximation algorithms are then presented in Sections 4 and 5 for modular and submodular objectives, respectively. The proposed framework is experimentally evaluated in Section 6. We then conclude the paper in Section 7. Finally, Appendix A provides the proofs.

General Notation
Bold lower-case and upper-case letters are generally reserved for vectors and matrices, respectively. Union of disjoint sets A i 's is denoted by A 1 A 2 · · · A n . For any subset V of vertices in a given graph, edges(V ) represents the set of all edges incident to at least a vertex in V . Finally, [n] {1, 2, . . . , n} for any n ∈ N.

Related Works
Resource-efficient CSLAM in general Paull et al. 2016), and data-efficient distributed interrobot loop closure detection (CSLAM front-end) in particular (Giamou et al. 2018;Cieslewski et al. 2017;Cieslewski and Scaramuzza 2017b;Tian et al. 2018a;Choudhary et al. 2017) have been active areas of research in recent years. This paper focuses on CSLAM front-ends; see, e.g., Paull et al. 2015Paull et al. , 2016 and the survey paper by Saeedi et al. (2016) for a discussion of modern resource-efficient CSLAM back-ends. Modern (visual) appearance-based loop-closure detection techniques commonly used in pose-graph SLAM and image retrieval consist of two steps: 1. Place recognition, during which a compact representation of images such as bag of visual words (BoW) (Sivic and Zisserman 2003), vector of locally aggregated descriptors (VLAD) (Jégou et al. 2010), or NetVLAD (Arandjelovic et al. 2016) is used to efficiently search for potential matches for a given query image. 2. Geometric verification (Philbin et al. 2007), which involves matching local image keypoints (e.g., with RANSAC iterations) to prune spatially inconsistent potential matches.
In multirobot scenarios such as CSLAM front-end, images are collected by and initially stored on different robots. Communication is thus needed to establish inter-robot loop closures. In a centralized solution, this task is outsourced to a "central server" with sufficient resources (e.g., ground station); see, e.g., (Schmuck and Chli 2018). Each robot thus needs to send every keypoint extracted from its keyframes (a "representative" subset of all frames) to the central server for loop closure detection. Such a solution has two major resource efficiency and operational drawbacks: (i) to discover new interrobot loop closures, robots need to maintain a connection to a central node that is capable of processing all data; (ii) robots must blindly communicate all of their data (i.e., keypoints) despite the fact that, in practice, only a small fraction of them correspond to loop closures. These shortcomings can be addressed by resource-efficient distributed paradigms in which robots collaboratively discover inter-robot loop closures. Cieslewski and Scaramuzza (2017a,b) and Cieslewski et al. (2017) propose effective heuristics to reduce data transmission during distributed visual place recognition (step 1). Specifically, in (Cieslewski and Scaramuzza 2017b) visual words are preassigned to robots. Each query is then split and each component is sent to the robot that is responsible for the corresponding word. In (Cieslewski and Scaramuzza 2017a;Cieslewski et al. 2017), a similar idea is proposed based on clustering NetVLAD descriptors in a training set. The learned cluster centers are then preassigned to robots and each NetVLAD query is only sent to the robot that has been assigned the closest cluster center. In these works, for each query image only the best admissible match is geometrically verified. Although the abovementioned techniques are highly relevant to distributed inter-robot loop closure detection, they are orthogonal to our work as we focus on the second stage in the pipeline (geometric verification). Nonetheless, as it will become more clear shortly in Section 3, these ideas can be used alongside ours to improve the overall efficiency of CSLAM front-end.
The work by Giamou et al. (2018) complements the abovementioned line of work by focusing on resourceefficiency during distributed geometric verification (step 2). Efficiency during this stage is particularly important as robots need to exchange full observations (i.e., image keypoints) whose size is typically between 100-200 times the size of compact queries, e.g., when NetVLAD is used. Rather than immediately exchanging the keypoints for geometric verification, in (Giamou et al. 2018) an exchange graph is formed in which nodes correspond to keyframes and edges represent potential matches discovered by querying compact representations such as BoW or NetVLAD. Robots then seek an exchange policy with minimum data exchange such that every potential match can be verified by at least one of the two associated robots. By exploiting the structure of the exchange graph, this approach can reduce the amount of data transmission for geometric verification.
Verifying all potential matches may not be always possible due to the limited nature of mission-critical resources available onboard. In (Tian et al. 2018a), we investigate the budgeted data exchange problem where robots have to find inter-robot loop closures under a communication budget. In such situations, one needs a performance metric to quantify the value of data exchanged for verifying a particular subset of potential matches. Maximizing such a performance metric under a communication budget thus guides the robots to prioritize their transmissions. This problem is in general NPhard. In (Tian et al. 2018a) we consider a class of monotone submodular performance metrics and provide provably nearoptimal approximation algorithms for maximizing such functions subject to a communication budget.
In an early version of the this work, we extend the formulation in (Tian et al. 2018a) to scenarios where, in addition to a communication budget, robots are also subject to a computational budget (Tian et al. 2018b). Computational budget puts a limit on the number of geometric verifications and, subsequently, the number of loop closures that will be added to the pose graph which allows us to control the cost of CSLAM back-end. Similar computational budgets were considered before in (Khosoussi et al. 2016b(Khosoussi et al. , 2019Carlone and Karaman 2017) for selecting informative measurements in SLAM. The present work extends (Tian et al. 2018b) and provides approximation algorithms with performance guarantees for inter-robot loop closure detection under both communication and computational budgets.
In addition to the line of work discussed above, alternative ideas have been proposed to improve the resource-intensive nature of inter-robot loop closure detection in specific settings. In particular, Choudhary et al. (2017) propose an object-based SLAM framework that circumvents the resource constraints by compressing sensory observations with high-level semantic labels. Such an approach would be effective only if the environment is filled with known objects. Similarly, Van Opdenbosch and Steinbach (2019) propose low-level feature coding and compression schemes for ORB to reduce data transmission during collaborative mapping. The proposed approach, however, depends on the specific choice of feature representation.

Proposed Framework
In this section, we provide an overview of our distributed interrobot loop closure detection framework. In CSLAM, robots can initiate a search for inter-robot loop closures during their occasional (preplanned or not) rendezvous. We assume that during a "rendezvous", robots can communicate with some of their peers in close proximity owing to the broadcast nature of wireless medium.
Definition 1. r-rendezvous. An r-rendezvous (r ≥ 2) refers to the situation where r robots are positioned such that each of them will receive the data broadcasted by any other robot in that group.
Each robot arrives at the rendezvous with a collection of observations (e.g., images or laser scans) acquired throughout its mission at different times and locations. Our goal is to discover loop closures (associations) between observations owned by different robots. A distributed approach to this problem divides the burden of the task among the robots, and thus enjoys several advantages over centralized schemes such as reduced data transmission and extra flexibility; see, e.g., (Giamou et al. 2018;Cieslewski and Scaramuzza 2017b). In these works, robots first perform distributed place recognition by exchanging a compact representation of their observations (hereafter, metadata) in the form of full-image descriptors such as BoW, VLAD, or NetVLAD vectors. Alternatively, spatial clues (i.e., estimated location with uncertainty) can be used if a common reference frame is already established. These compact queries can help robots to efficiently identify a set of potential inter-robot loop closures. It should be noted that although these queries are quite compact relative to the size of a full observation (i.e., size of all keypoints in a keyframe), robots still need to exchange many (i.e., one for each keyframe) of these vectors and search within them to find potential matches. In (Giamou et al. 2018) one of the robots (or a central node) is assumed to collect all metadata and conduct the search. Alternatively, when this is not feasible, one can turn to lossy (yet effective) alternative procedures for collaborative search such as (Cieslewski et al. 2017;Cieslewski and Scaramuzza 2017a,b) to reduce the burden of the search for potential loop closures.
After the initial phase of place recognition, the identified potential matches are tested for spatial consistency (Philbin et al. 2007) during geometric verification. This typically involves RANSAC iterations (Fischler and Bolles 1981) over keypoint correspondences in the two associated frames; see, e.g., (Mur-Artal and Tardós 2017). A potential match passes this test if the number of spatially consistent keypoint correspondences is above a threshold. These inliers then provide a relative transformation between the corresponding poses which will be used by the CSLAM back-end. Note that to collaboratively verify a potential loop closure, at least one of the associated robots must share its observation (e.g., image keypoints) with the other robot.
Although each geometric verification can be performed efficiently, with a growing problem size in long-term missions and under high perceptual ambiguity, geometric verification can still become the computational bottleneck of the entire system; see (Heinly et al. 2015;Raguram et al. 2012). In addition, the large amount of full observation exchange required for geometric verification may exceed the allocated/available communication budget (e.g., due to limited energy, bandwidth, and/or time). To address both issues, in the rest of this section we describe a general framework for focusing the available computation and communication resources on verifying the most "informative" subset of potential loop closures. An outline of the proposed approach is as follows: 1. Robots exchange compact queries (metadata) for their observations and use them to identify a set of potential inter-robot loop closures; see, e.g., (Cieslewski and Scaramuzza 2017b;Cieslewski et al. 2017;Giamou et al. 2018). 2. One robot forms the exchange graph (Definition 2 in Section 3.1), and approximately solves Problem 1 (Sections 3.1-3.4) using algorithms presented in Sections 4 and 5. This process determines which full observation (image keypoints) needs to be shared with the team and which potential loop closures are worthy of being tested for geometric verification based on the allocated communication and computation budgets. 3. According to the solution obtained in the previous step, robots exchange their observations and collaboratively verify the selected subset of potential inter-robot loop closures.

Exchange Graph
Rather than immediately exchanging observations for an identified potential match (Cieslewski and Scaramuzza 2017b;Cieslewski et al. 2017;Cieslewski and Scaramuzza 2017a), in this work we first form the exchange graph induced by the set of potential matches (see Figure 1a for a simple exchange graph with r = 3).
Definition 2. Exchange Graph (Giamou et al. 2018;Tian et al. 2018a). Consider an r-rendezvous. An exchange graph between r robots is a simple undirected r-partite graph G x = (V x , E x ) where each vertex v ∈ V x corresponds to an observation collected by one robot at a particular time.
The vertex set can be partitioned into r (self-independent) sets V x = V 1 · · · V r . Each edge {u, v} ∈ E x denotes a potential inter-robot loop closure identified by comparing the corresponding metadata (here, u ∈ V i and v ∈ V j ). G x is endowed with vertex and edge weights w : V x → R >0 and p : E x → [0, 1] that quantify the size of each observation (e.g., bytes, number of keypoints in a keyframe, etc), and the probability that an edge corresponds to a true loop closure, respectively.
Similar to (Cieslewski et al. 2017; Cieslewski and Scaramuzza 2017a), we choose NetVLAD (Arandjelovic et al. 2016) as our metadata representation. Given an input image, NetVLAD uses a neural network to extract a normalized vector as the corresponding full-image descriptor. During place recognition, we compute the Euclidean distance d(e) between NetVLAD vectors extracted from two keyframes stored on two robots. This distance is then mapped to an estimated probability p(e) based on a logistic regression model. Specifically, we assume a posterior probability of the form, where β 0 and β 1 are learned offline on a training dataset. Note that, alternatively, one can also use other features (based on, e.g., components of the NetVLAD vectors) in addition to the Euclidean distance in the logistic regression model. Nevertheless, this does not yield significant performance improvement in our experiments (Section 6). If the resulting probability p(e) is higher than a threshold p x ∈ [0, 1], the corresponding pair of keyframes is considered to be a potential loop closure and is added to the exchange graph as an edge weighted by its probability. It is worth noting that based on (1), enforcing a threshold on p(e) is equivalent to enforcing a (different but unique) threshold on the original distance d(e). Choosing a threshold directly for distances, however, lacks interpretability. Furthermore, the estimated probabilities are used in this work to incentivise the robots to select more promising potential matches (see Section 3.3).
Note that the "quality" of an exchange graph (e.g., in terms of precision-recall for a fixed probability threshold) is mainly determined by the fidelity of the metadata. Intuitively, as the granularity of metadata increases, one expects that a higher percentage of resulting potential matches pass the geometric verification step. This, however, comes at the cost of higher data transmission during place recognition. In our proposed framework, the dimension of NetVLAD vectors (hereafter, D NetVLAD ), which in the pre-trained models can be tuned up to 4096, serves as a "knob" which allows us to explore the tradeoff between granularity and communication cost of query and verification steps; see Section 6.2 for quantitative results.

Resource Constraints
Under the mild assumption that the computational cost of geometric verification is uniform across edges, we model the total computational cost of verifying a subset of edges E ⊆ E x by its cardinality |E|. Therefore, imposing a computational budget in this model is equivalent to enforcing the cardinality constraint |E| ≤ k on the subset of potential matches selected for verification for some budget k. In addition, note that by limiting the number of verifications one also bounds the number of new edges added to the CSLAM pose graph, which helps to control the computational cost of CSLAM back-end.
As mentioned earlier, verifying potential matches also incurs a communication cost: before two robots can verify a potential loop closure, at least one of them must share its observation with the other robot. In graph terms, verifying E ⊆ E x requires robots to broadcast a subset of their vertices (observations) V ⊆ V x that covers E. * In other words, one can verify E ⊆ E x only if there exists a V ⊆ V x such that (i) V covers E, and (ii) broadcasting V does not exceed the allocated communication budget (Giamou et al. 2018;Tian et al. 2018a). Specifically, we consider three types of In the absence of any resource constraint, the robots can collectively verify all potential loop closures. The optimal lossless exchange policy (Giamou et al. 2018) corresponds to sharing vertices of a minimum vertex cover, in this case the 3 vertices marked in red. (c) Now if the robots are only permitted to exchange at most 2 vertices (b = 2) and verify at most 3 edges (k = 3), they must decide which subset of observations to share (marked in red), and which subset of potential loop closures to verify (marked in blue). Note that these two subproblems are tightly coupled, as the selected edges must be covered by the selected vertices.
communication budgets (Table 1). First, in Total-Uniform (TU) robots are allowed to exchange at most b observations. This is justified under the assumption of uniform vertex weight (i.e. observation size) w. This assumption is relaxed in Total-Nonuniform (TN) where total data transmission must be at most b. Finally, in Individual-Uniform (IU), we assume V x is partitioned into n b blocks and robots are allowed to broadcast at most b i observations from the ith block for all i ∈ [n b ]. A natural partitioning of V x is given by V 1 · · · V r . In this case, IU permits robot i to broadcast at most b i of its observations for all i ∈ [r]. This model captures the heterogeneous nature of the team.

Performance Metrics
Given an exchange graph and the abovementioned resource budgets, robots must decide which budget-feasible subset of potential matches should be verified. This decision is driven by a so-called collective performance metric f : 2 Ex → R ≥0 .
Here, f (E) quantifies the expected utility gained by verifying the potential loop closures in E ⊆ E x . We focus on the class of monotone (non-decreasing) submodular performance metrics.
Definition 3. For a fixed finite ground set W, a set function f : 2 W → R is normalized, monotone, and submodular (NMS) if it satisfies the following properties: In what follows, we briefly review three examples of NMS functions, namely (i) the expected number of loop closures, (ii) (approximate) expected D-optimality criterion, and (iii) expected weighted tree connectivity. Note that our framework is compatible with any NMS objectives, and is not limited to the options considered below.

1) Expected Number of True Loop Closures.
Given an exchange graph G x , the expected number of loop closures (NLC) obtained after verifying any E ⊆ E x is simply given by e∈E p(e) where p : E x → [0, 1] is the probability function associated to G x . Therefore, if the team seeks to maximize the number of (true) inter-robot loop closures it discovers, it must maximize the following performance metric, Given the importance of f NLC , in Section 4 we present nearoptimal approximation algorithms specifically for (monotone) modular performance metrics such as f NLC .
2) D-optimality Criterion. The D-optimality design criterion (D-criterion), defined as the log-determinant of the Fisher information matrix (FIM), is one of the most widely adopted design criteria in the theory of optimal experimental design with well-known geometrical and information-theoretic interpretations; see (Joshi and Boyd 2009;Pukelsheim 1993). In particular, this design criterion has been used for sensor selection (Joshi and Boyd 2009;Shamaiah et al. 2010) and measurement selection in SLAM (Khosoussi et al. 2019;Carlone and Karaman 2017;Khosoussi et al. 2016b).
Let H init 0 denote the information matrix of the joint CSLAM problem before incorporating the potential loop closures. Moreover, let H e = J e Σ −1 e J e 0 be the information matrix associated to the candidate loop closure e ∈ E x in which J e and Σ e denote the measurement Jacobian matrix (evaluated at the current estimate) and the covariance of Gaussian noise, respectively. Following (Carlone and Karaman 2017), one can approximate the expected gain in the D-criterion as, (4) It has been shown that f FIM is NMS (Shamaiah et al. 2010;Carlone and Karaman 2017).
3) Tree Connectivity. The D-criterion in SLAM can be closely approximated by the weighted number of spanning trees (WST) (hereafter, tree connectivity) in the graphical representation of SLAM (Khosoussi et al. 2019(Khosoussi et al. , 2016a. Khosoussi et al. (2019) use tree connectivity as a topological surrogate for the D-criterion for selecting (potential) loop closures in planar pose-graph SLAM. Evaluating tree Cardinality Knapsack Partition Matroid connectivity is computationally cheaper than evaluating the D-criterion and, furthermore, does not require any metric knowledge of robots' trajectories.
In the following, we briefly explain how this performance metric can be evaluated for planar pose-graph CSLAM. Let t p (E) and t θ (E) denote the weighted number of spanning trees in a pose graph specified by the edge set E whose edges are weighted by the precision of the translational and rotational measurements, respectively (Khosoussi et al. 2019). Furthermore, let E init denote the set of edges in the CSLAM pose graph prior to the rendezvous. Define where expectation is taken with respect to the anisotropic random graph model introduced in Definition 2-i.e., potential loop closures are "realized" independently with probability assigned by p : then seek to maximize the following objective.
It is shown in (Khosoussi et al. 2019(Khosoussi et al. , 2016b) that f WST is NMS if the underlying pose graph is connected prior to the rendezvous.
Final Remarks Given an exchange graph, the expected number of loop closures f NLC can be evaluated efficiently with no additional overhead. Furthermore, this objective is also suitable for similar distributed matching applications such as distributed image retrieval or distributed document matching. While f NLC measures performance by the expected number of matches, f FIM and f WST incentivize verifying information-rich potential matches that have the highest impact on the CSLAM maximum likelihood estimate in terms of the determinant of the expected covariance matrix. Evaluating f FIM can be costly (cubic in the total number of CSLAM poses). Furthermore, it requires the knowledge of the information matrix which incurs additional communication cost. Alternatively, f WST provides a topological surrogate for f FIM that is cheaper to compute and requires only the knowledge of the topology of the CSLAM pose graph. Finally, it is worth noting that f FIM and f WST may be tempted to pick low-probability but high-impact candidates. To prevent this, one needs to use a more conservative (higher) threshold on the probability of the candidates included in the exchange graph (see Section 3.1).

The Optimization Problem
After introducing a number of options for the objective and constraints, we are now ready to formally define the budgeted exchange-and-verification problem for distributed loop closure detection under computation and communication constraints. As mentioned earlier, the goal is to determine (i) which observations must be broadcasted, and (ii) which subset of potential matches must be geometrically verified, in order to maximize an NMS performance metric without exceeding the resource budgets. In graph terms, our goal is to The nested formulation above reflects the inherent structure of the exchange-and-verification problem: the team must jointly decide which observations to share (outer problem), and which potential loop closures to verify among the set of verifiable potential loop closures given the shared observations (inner problem). Note that Problem 1 is NP-hard in general. Specifically, when b or b i 's are sufficiently large (i.e., unbounded communication), this problem coincides with general NMS maximization under a cardinality constraint. No polynomial-time approximation algorithm can provide a constant factor approximation for this problem better than 1 − 1/e, unless P=NP; see (Krause and Golovin 2014) for a survey. This immediately implies that 1 − 1/e is also the approximation barrier for the general case of Problem 1. In the next two sections, we present approximation algorithms with provable performance guarantees for variants of this problem. We also consider a similar setting where robots are subject to individual computational budgets in Section 4.1.

Algorithms for Modular Performance Metrics
In this section, we consider a special case of Problem 1 where f is normalized, monotone, and modular; i.e., f (∅) = 0 Problem 1 with modular objectives generalizes the well-known maximum coverage problem on graphs, and thus remains NP-hard in general. Without loss of generality, we use the modular performance metric f NLC defined in (3) as a running example in this section. In what follows, we present an efficient constant-factor approximation scheme for Problem 1 with modular objectives under the communication cost regimes listed in Table 1.
gives the optimal value of the inner maximization (over edges) in Problem 1 for a given subset of vertices V ⊆ V x . For example, for f NLC we have, Alg. Cardinality Knapsack Partition Mat.
gives the maximum expected number of true inter-robot loop closures discovered by broadcasting the observations associated to V and verifying at most k potential inter-robot loop closures. Note that g(∅) = 0 by definition. It is easy to see that the inner maximization problem in Problem 1 (with monotone modular objectives) admits a trivial solution and hence g can be efficiently evaluated for any V ⊆ V x : if V has more than k incident edges, return the sum of top k edge probabilities in edges(V ); otherwise, return the sum of all probabilities in edges(V ).
Theorem 1. For any normalized, monotone, and modular f , the corresponding g-as defined in (8)-is NMS.
Theorem 1 implies that in the case of (monotone) modular objectives, the outer (vertex selection) part in Problem 1 is a special instance of monotone submodular maximization subject to a cardinality (TU), a knapsack (TN), or a partition matroid (IU) constraint. These problems admit constantfactor approximation algorithms (Krause and Golovin 2014). The best performance guarantee in all cases is 1 − 1/e ≈ 0.63 (Table 2); i.e., in the worst case, the expected number of correct loop closures discovered by such algorithms is no less than 63% of that of an optimal solution. Among these algorithms, variants of the standard greedy algorithm are particularly well-suited for our application due to their computational efficiency. These greedy algorithms enjoy constant-factor approximation guarantees, albeit with a performance guarantee weaker than 1 − 1/e in the case of TN and IU; see the first row of Table 2 and (Krause and Golovin 2014). Hereafter, we call this family of greedy algorithms adopted to solve Problem 1 with (monotone) modular objectives MODULAR-GREEDY.
Algorithm 1 provides the pseudocode for MODULAR-GREEDY under the TU regime. At each iteration, we simply select (i.e., broadcast) the next remaining vertex v with the maximum marginal gain over expected number of true loop closures (line 5). The greedy loop is terminated when the algorithm reaches the communication budget, or when there is no remaining vertex. After broadcasting V grd , we verify the top k edges in edges(V grd ) that maximize the sum of probabilities (line 9). A naïve implementation of MODULAR-GREEDY requires O(b · |V x |) evaluations of g, where each evaluation takes O(|edges(V )| × log k) time. The number of evaluations can be significantly reduced by using the so-called lazy greedy method; see (Minoux 1978;Krause and Golovin 2014).

Algorithm 1 MODULAR-GREEDY (TU)
Input: -Exchange graph G x = (V x , E x ) -Communication budget b and computation budget k -Modular f : 2 Ex → R ≥0 and g as defined in (8)  Output: . Under TN, the same greedy algorithm, together with one of its variants that normalizes marginal gains by vertex weights, provide a performance guarantee of 1/2 · (1 − 1/e); see (Leskovec et al. 2007). Finally, in the case of IU, selecting the next feasible vertex according to the standard greedy algorithm leads to a performance guarantee of 1/2 .
Remark 1. Kulik et al. (2009) study the problem of maximum coverage with packing constraint (MCP), which includes Problem 1 with modular f under TU as a special case. Our approach differs from (Kulik et al. 2009) in two ways. Firstly, the algorithm proposed in (Kulik et al. 2009) achieves a performance guarantee of 1 − 1/e for MCP by applying partial enumeration, which is computationally expensive in practice. This additional complexity is due to a knapsack constraint on edges ("items" according to (Kulik et al. 2009)) which is unnecessary in our application. As a result, the standard greedy algorithm retains the optimal performance guarantee without any need for partial enumeration. Secondly, in addition to TU, we study other models of communication budgets (TN and IU), which leads to more general classes of constraints (i.e., knapsack and partition matroid) that MCP does not consider.
Remark 2. It is worth mentioning that in some special cases, the best performance guarantee goes beyond 1 − 1/e. For example, when f is modular, the communication cost model is TU, and there is no budget on computation (k = ∞), Problem 1 reduces to the well-studied maximum coverage problem over a graph (Hochbaum 1996). In this case, a simple procedure based on pipage rounding can improve the approximation factor to 3/4, see (Ageev and Sviridenko 1999). Furthermore, if the graph is bipartite, a specialized algorithm can improve the approximation factor to 8/9 (Caskurlu et al. 2014). Nonetheless, these approaches do not generalize to the regimes considered in our work (e.g., with a computation budget). Furthermore, they do not retain the computational efficiency and simplicity offered by the greedy algorithm.

Individual Computational Budgets
Problem 1 imposes a single computational budget on the total number of potential matches verified by the entire team. While this can help to control the number of verifications as well as the total cost of CSLAM back-end, in some scenarios one may wish to impose a specific computational budget on each robot such that robot i is only allowed to verify at most k i potential matches (similar to TU vs. IU). This allows us to control the division of labor among heterogeneous robots. Providing performance guarantees directly for this more general setting is challenging. Instead, in what follows we show how Theorem 1 and Algorithm 1 can be generalized to a similar setup under pairwise computational budgets. In this alternative regime, robots i and j together are allowed to verify at most k ij potential matches. We then describe a simple procedure for obtaining pairwise budgets {k ij } i,j∈[r],j>i from a given set of individual budgets {k i } i∈ [r] , such that robots are guaranteed to stay within their individual budgets.
For all i, j ∈ [r] and i < j, let E ij ⊆ E x denote the set of potential matches between robots i and j. Note that {E ij } partitions E into disjoint (but possibly empty) subsets. For the modified Problem 1 with pairwise computational budgets and modular objective f NLC , the inner maximization would become (9) Note that this is equivalent to imposing a partition matroid constraint over edges(V ). It is easy to see that for any given V ⊆ V x , g pair in (9) can be efficiently evaluated similar to (8): from each E ij ∩ edges(V ), simply pick the k ij edges (if available, otherwise pick all) with largest probability; and return the sum of probabilities of the selected edges.
Theorem 2. For any normalized, monotone, and modular f , the corresponding g pair -as defined in (9)-is NMS. This theorem states that, similar to g (8), g pair : 2 Vx → R ≥0 that arises from pairwise computational budgets (9) is also NMS. Therefore, in the case of pairwise computational budgets, a modified version of MODULAR-GREEDY (Algorithm 1) in which vertices are selected greedily according to g pair (instead of g) retains the same performance guarantees provided earlier for MODULAR-GREEDY. It only remains to explain how pairwise budgets {k ij } must be set such that robots do not exceed a given set of individual computational budgets {k i }. Note that in the pairwise regime, in the worst case robot i has to verify all selected edges incident to its vertices; i.e., at most j>i k ij + j<i k ji edges. Consequently, to guarantee compatibility with individual budgets, it is sufficient for {k ij } to satisfy the following condition, Although any such assignment for {k ij } is valid, we also take into account the expected number of loop closures in E ij for setting k ij by solving the following linear program (LP) and where c ij is the expected fraction of true loop closures in E ij , i.e., The objective in this LP is designed to favor allocating a greater fraction of k i to those k ij 's that contain a higher percentage of actual loop closures.

Algorithms for Submodular Performance Metrics
In this section, we study Problem 1 when f : 2 Ex → R ≥0 is an arbitrary NMS objective. To the best of our knowledge, no prior work exists on approximation algorithms for this problem except (Tian et al. 2018b). The approach we took in Section 4 for the special case of monotone modular objectives cannot be extended to this case: even evaluating the "generalized" g (8) is NP-hard in general. It is thus unclear whether any constant-factor approximation can be attained for an arbitrary NMS objective. In Sections 5.1 and 5.2, we briefly review two relaxations of Problem 1 with either unlimited communication or unlimited computation budget. In both cases, Problem 1 reduces to known measurement selection problems for which constantfactor (1 − 1/e) performance guarantee can be attained via greedy algorithms. Building on these results, in Section 5.3 we consider the most general case of Problem 1 under both communication and computation budgets. Specifically, we provide an efficient approximation algorithm under the TU regime, with a performance guarantee that depends on the ratio between the two budgets (b and k), as well as the maximum degree of the exchange graph.

Unlimited Communication Budget
Let us first relax the communication constraint in Problem 1, i.e., b = ∞ in TU and TN, and b i = ∞ for all i ∈ [n b ] in IU. In this case, any subset of at most k edges can be trivially verified, e.g., by broadcasting one of the two vertices incident to each selected edge. In terms of Problem 1, this means that the decision variable corresponding to vertex selection V ⊆ V x together with all constraints involving V can be dropped. The reduced problem is simply, which is the standard monotone submodular maximization subject to a cardinality constraint (Krause and Golovin 2014). It is well known that the standard greedy algorithm that sequentially selects the next best edge based on the marginal gain in f attains a 1 − 1/e performance guarantee ); see also (Khosoussi et al. 2016b(Khosoussi et al. , 2019Carlone and Karaman 2017) for the applications of this result in the context of measurement selection for SLAM.

Unlimited Computation Budget
Now let us relax the computational constraint in Problem 1. With a little abuse of notation, let g com : 2 Vx → R ≥0 denote the optimal value of the inner maximization in Problem 1this is similar to (8) in Section 4, albeit for an arbitrary NMS objective f as opposed to a monotone modular one. As f is monotone and k is unlimited, it is straightforward to see that the optimal value of the inner problem is attained by selecting all edges covered by V , i.e., The following theorem about g com : 2 Vx → R ≥0 follows from , Proposition 2.5) and was independently established in (Tian et al. 2018a).
Theorem 3 implies that the outer problem is an instance of monotone submodular maximization subject to a cardinality (TU), knapsack (TN), or partition matroid (IU) constraint. For TU, the standard greedy algorithm that selects vertices based on marginal gain in g and verifies all associated edges achieves a 1 − 1/e performance guarantee. The corresponding variants for TN and IU achieve a performance guarantee of 1/2 · (1 − 1/e) and 1/2, respectively; see Table 2.

The General Case
We are now ready to consider Problem 1 with both budget constraints under TU. Note that Sections 5.1 and 5.2 provide two complementary approaches. The first approach is to greedily select edges and continue as long as constraints are not violated. Let us call this algorithm EDGE-GREEDY. Note that when b is sufficiently large (e.g., when b > k), Problem 1 reduces to the special case considered in Section 5.1 for which EDGE-GREEDY achieves a 1 − 1/e performance guarantee. Algorithm 2 provides the pseudocode. Lines 3-10 show the standard greedy loop, where at each iteration we select the next remaining edge that produces the largest marginal gain in terms of f . After adding an edge, we update our selected vertices to cover the set of selected edges (line 9). An easy way to do this is to include one vertex incident to each selected edge. In case there is extra computation budget, we also include a heuristic optimization phase (lines 12-18) in which the algorithm continues to select from "communicationfree" edges, i.e., edges that are covered by the currently selected vertices. The heuristic phase does not contribute to the theoretical guarantee, but improves the performance in practice.
The second approach is to greedily select vertices, i.e., broadcast the corresponding observations and verify all edges incident to them, until violating the communication or computation budget. Let us call this algorithm VERTEX-GREEDY. When k is sufficiently large (e.g., when b < k/∆ Algorithm 2 EDGE-GREEDY (TU)

Algorithm 3 VERTEX-GREEDY (TU)
Input: -Exchange graph G x = (V x , E x ) -Communication budget b and computation budget k f : 2 Ex → R ≥0 and g com as defined in (14) Output:  E grd ← edges(V grd ) 14: end while 15: return V grd , E grd where ∆ is the maximum degree of G x ), VERTEX-GREEDY achieves a 1 − 1/e performance guarantee as noted in Section 5.2; see Algorithm 3 for pseudocode. Lines 3-14 show the greedy loop. At each iteration, we select the next feasible vertex that produces the largest gain in terms of g com (14). Once a vertex is selected, all its incident edges are included for verification (line 13). Now let SUBMODULAR-GREEDY be the algorithm according to which one runs both EDGE-GREEDY and VERTEX-GREEDY and returns the best solution among the two. Note that a naïve implementation of SUBMODULAR-GREEDY requires O(b · |V x | + k · |E x |) evaluations of the objective. In practice, the cubic complexity of evaluating the D-criterion or tree connectivity in the total of number of poses can be avoided by leveraging the sparse structure of the global pose graph. This complexity can be further reduced by reusing Cholesky factors in each round and utilizing rank-one updates; see (Khosoussi et al. 2019). As mentioned before, the number of evaluations can be reduced significantly by using the lazy greedy method (Minoux 1978;Krause and Golovin 2014).
The following theorem provides a performance guarantee for SUBMODULAR-GREEDY in terms of b, k, and the maximum degree ∆.
The above performance guarantee α(b, k, ∆) reflects the complementary nature of EDGE-GREEDY and VERTEX-GREEDY. Intuitively, EDGE-GREEDY (resp., VERTEX-GREEDY) is expected to perform well when computation (resp., communication) budget is scarce compared to communication (resp., computation) budget. To gain more intuition, let us approximate k/∆ in α(b, k, ∆) with k/∆. † With this simplification, the performance guarantee can be represented asα(κ, ∆) where κ b/k is the budgets ratio. Figure 2a showsα(κ, ∆) as a function of κ for different values of ∆.
We note that for a specific instance of the exchange graph G x , the actual performance guarantee of SUBMODULAR-GREEDY can be higher than α(b, k, ∆). This potentially stronger performance guarantee can be computed posthoc, i.e., after running SUBMODULAR-GREEDY on the given instance of G x -see Lemmas 1 and 2 in Appendix A.2. As an example, Figure 2b shows the post-hoc performance guarantee on an example exchange graph generated from the KITTI 00 dataset (Section 6). As we vary the combination of budgets (b, k), the actual performance guarantees vary from 0.18 to 0.63. In addition, Theorem 4 indicates that reducing ∆ enhances the performance guarantee α(b, k, ∆). This is demonstrated in Figure 2c. After capping ∆ at 5, the approximation factors now vary from 0.36 to 0.63. In practice, a major cause of large ∆ is high uncertainty in the initial set of potential inter-robot loop closures; e.g., in situations with high perceptual ambiguity, an observation could potentially be matched to many other observations during the initial phase of metadata exchange. This issue can be mitigated by bounding ∆ or increasing the fidelity of metadata.

Experiments
We use KITTI odometry sequence 00 (Geiger et al. 2012) and a synthetic Manhattan-like dataset (Tian et al. 2018a) for evaluating the proposed CSLAM front-end pipeline. Both datasets are divided into multiple segments to simulate individual robots' trajectories ( Figure 3). For KITTI 00, visual odometry and geometric verification are performed using a modified version of ORB-SLAM2 (Mur-Artal and Tardós 2017). Trajectories are projected to 2D in order to evaluate the tree connectivity objective f WST (6). For each image in the sequence, a NetVLAD vector is extracted as metadata using the pre-trained model provided by Arandjelovic et al. (2016). Probability for each potential loop closure is obtained using the logistic regression model described in Section 3.1. The model itself is learned offline using KITTI sequence 06 in MATLAB.
In addition to KITTI, we also make use of a synthetic Manhattan-like dataset generated using the 2D simulator of g2o (Kümmerle et al. 2011). As opposed to real-world datasets, in synthetic datasets we have access to unbiased probability estimates for the potential loop closures. This is done by simulating each potential loop closure as a random Bernoulli variable with a corresponding probability p, where p is drawn randomly from the uniform distribution U(0, 1). Apart from this, synthetic datatsets also have the advantage of being flexible in size and providing actual ground truths for trajectories and loop closures. This allows us to evaluate system performance in terms of the absolute trajectory error (ATE) (Sturm et al. 2012).
With the default configurations of ORB-SLAM2, each input image contains about 2000 keypoints, where each keypoint (consisting of keypoint coordinate, 3D landmark position, and an ORB descriptor) uses 52 bytes of data. Thus, a single keyframe translates to about 104KB of communication payload during geometric verification. We observed that the variation in the number of keypoints in keyframes is insignificant, and therefore focus on TU and IU communication budget models in our experiments (i.e., w(v) = 1 for all v ∈ V x ).

Certifying Near-Optimality via Convex Relaxation
To empirically evaluate the performance of the proposed algorithms, one would ideally need the optimal value (OPT) of Problem 1. However, computing OPT by brute force is impractical even for moderate problem sizes. We therefore compute an upper bound UPT ≥ OPT by solving the natural convex relaxation of Problem 1, and use UPT as a surrogate for OPT. Comparing with UPT provides a post-hoc certificate of near-optimality for solutions returned by the proposed algorithms. Let π [π 1 , . . . , π n ] and [ 1 , . . . , m ] be indicator variables corresponding to vertices (broadcasting an observation) and edges (verifying a potential loop closure) of the exchange graph G x , respectively. Furthermore, let A ∈ {0, 1} n×m be the undirected incidence matrix of G x . Now Problem 1 can be easily expressed in terms of π and . For example, for modular objectives (Section 4) under the TU communication model, Problem 1 is equivalent to solving the following integer linear program (ILP): where, with a minor abuse of notation, e denotes indicator variable corresponding to edge e. The first constraint in (15) enforces the communication budget, the second one enforces the computational budget, and the third one ensures that selected edges are covered by the selected vertices. Relaxing the last two integer constraints of the above ILP to 0 ≤ π ≤ 1 and 0 ≤ ≤ 1 gives the natural LP relaxation. The optimal value of the resulting LP therefore gives an upper bound UPT ≥ OPT. Similarly, Problem 1 with the D-criterion and tree connectivity objectives (Section 5) can be expressed as integer determinant maximization problems, whose natural convex relaxation gives an upper bound on OPT. For example, in the case of the D-criterion objective, Problem 1 can be expressed as: subject to constraints in (15).
Applying the same relaxation results in a convex optimization problem-an instance of the MAXDET problem subject to additional affine (budgets and covering) constraints in (15) (Vandenberghe et al. 1998). In our experiments, all LPs and ILPs are solved using the built-in solvers in MATLAB, while MAXDET problems are modeled using the YALMIP toolbox (Löfberg 2004) and solved using SDPT3 (Toh et al. 1999) in MATLAB.

Metadata Analysis
In this section, we describe the training and evaluation process for the logistic regression model proposed in Section 3.1. For training, KITTI 06 is divided into a training set and a validation set, where the training set is used to learn the parameters of the logistic regression classifier, and the validation set is used to determine the dimension of NetVLAD vectors. The entire KITTI 00 sequence is used as the test set.
The main hyperparameter studied in our experiments is D NetVLAD . A good value for D NetVLAD should strike a balance between size and quality of the learned probabilities. For this, we conduct two sets of quantitative analyses. First, we examine the expected number of loop closures in the exchange graph e∈Ex p(e) predicted by the learned model as D NetVLAD varies from 50 to 500. In this experiment, no probability threshold is imposed when forming the exchange graph, i.e., p x = 0. Consequently, E x contains every interrobot edges as a potential loop closure. For each value of D NetVLAD , the model is re-trained on the training set and re-evaluated on the validation and test sets. The results are shown in Figure 4. For reference, we also plot the ground truth number of true loop closures in both datasets (black dashed line). On the validation set, the learned models consistently exhibit good performance with a maximum prediction error of 4.76 across all values of D NetVLAD . Performance on the test set displays a more interesting variation. For small values of D NetVLAD , the model significantly overestimates the number of loop closures. This suggests that reducing D NetVLAD too much leads to degraded accuracy in the predicted probabilities. As D NetVLAD becomes larger, the predicted value stabilizes and yields an average error of 219, revealing the limit of the learned model in generalizing to new datasets. Second, Figure 5 shows the precision-recall curves corresponding to selected values of D NetVLAD on the validation and test set. Each curve is generated with a fixed D NetVLAD and varying probability threshold that classifies if a pair of images constitutes an actual loop closure. Precision is computed as the percentage of true loop closures within the set of all predicted loop closures. Recall is computed as the percentage of discovered loop closures within the set of all loop closures in the dataset. As expected, increasing D NetVLAD improves both precision and recall as the metadata is able to capture more information. Nevertheless, as D NetVLAD increases, the marginal improvement in precision and recall decreases. Based on these results, we fix D NetVLAD = 200 in all subsequent experiments. With this value, a single NetVLAD vector results in around 0.8KB of data payload, which is still very lightweight compared to the data payload of a full observation (104KB).

Results with Modular Objectives
We first evaluate our proposed framework in instances where the objective function is modular. total communication. Note that after dividing KITTI 00 into five robots, the entire dataset amounts to less than a minute of parallel localization and mapping. Practical missions with longer durations thus produce significantly larger problem instances.
The first column of Figure 6 shows the performance of the proposed MODULAR-GREEDY algorithm (Algorithm 1) under the TU communication cost model. In each figure, we use a fixed computation budget k and vary the communication budget b from 2MB to 62MB. Performance is evaluated in terms of the normalized objective, i.e., the achieved objective divided by the maximum achievable objective given infinite budgets. In the modular case, we compute the optimal solution (OPT) by solving the corresponding ILP. We also compare our results with a baseline algorithm that randomly selects b vertices and then selects k edges incident to the selected vertices. The resulting values are averaged across 10 runs to alleviate the effects of random sampling. Our results clearly confirm the near-optimal performance of MODULAR-GREEDY. In fact, the maximum unnormalized optimality gap across all experiments is 4.72, i.e., the achieved objective and the optimal objective only differ by 4.72 expected loop closures.
The second column of Figure 6 shows the performance of MODULAR-GREEDY under the IU communication cost model. Similar to the TU experiments, each figure uses a fixed computation budget k and the same range for the total communication budget b (2MB to 62MB). Each value of b is equally divided among robots to create the local communication budgets b i 's. Performance of MODULAR-GREEDY is again compared with the optimal solution (OPT) by solving the ILP, as well as the baseline random algorithm in the IU regime. In most cases, the performance of MODULAR-GREEDY is close to optimal, although the maximum optimality gap is larger (see the last figure with k = 1300) compared to the TU regime. This observation matches our theoretical analysis, as the established performance guarantee for MODULAR-GREEDY in IU (i.e., partition matroid) is weaker than in TU (i.e., cardinality constraint); see Table 2.
Furthermore, the last row (Figure 6e and 6f) reveals another interesting comparison between TU and IU. With the same computation budget k = 1300, MODULAR-GREEDY under TU reaches maximum performance at b = 30MB. Under IU, however, the algorithm reaches maximal performance much later, with a total communication of b = 54MB. This is due to the fact that inherently, IU trades off team performance with the balance of induced individual communications. Such extra considerations leads to a more restricted search space and as a result, a lower objective value given the same total communication budget b.  Figure 7 shows the fraction of total communication budget used by each of the five robots in the solutions of MODULAR-GREEDY under TU and IU. The computation budget is fixed to be k = 1300 under both regimes. As TU does not regulate individual communications, the resulting distribution of labor could be arbitrarily skewed; see Figure 7a. For example, with b = 30MB, robot 4 (purple) broadcasts 50% of all vertices selected by the team. In contrast, in IU, the amount of data transmitted by each robot is explicitly bounded (through local budgets b i 's); see Figure 7b.
In addition, we also study the induced division of labor in terms of computation under the IU communication cost model. Each robot has a fixed individual communication budget of b i = 4MB, while the total computation budget k varies from 100 to 1300. Figure 8a shows the fraction of total computation budget used by each robot after running MODULAR-GREEDY. Similar to what we observed earlier in the case of communication, without regulating individual computations the division of computation labor could be arbitrarily skewed. For example, in many instances robot 1 (blue) ends up verifying 60% of all potential loop closures selected by the team. In contrast, the approach presented in Section 4.1 explicitly ensures that each of the five robots can verify at most 20% of all selected potential matches; see Figure 8b. While this gives us more control over the induced computation workloads, as a trade-off it also limits the overall team performance as evaluated by the f NLC objective; see Figure 8c.

Results with Submodular Objectives
Figures 9a-9c show the performance of SUBMODULAR-GREEDY on the same KITTI 00 exchange graph under the TU regime. The tree connectivity performance metric (6) is used as the objective function. Similar to the modular experiments, each plot uses a fixed computation budget k, and a total communication budget varying from 2MB-62MB. The proposed algorithm is compared with the baseline random algorithm. As a surrogate for the optimal solution, we compute the upper bound (UPT) using the convex relation approach described in Section 6.1. The fractional solution returned together with UPT is further rounded to obtain an integer solution (UPT Rounded). To guarantee feasibility, b vertices are first selected greedily using the values of the relaxed indicator variables π [π 1 , . . . , π n ] ∈ [0, 1] n . Subsequently, k edges are selected greedily from all edges covered by the selected vertices using the values of the relaxed indicator variables [ 1 , . . . , m ] ∈ [0, 1] m . All objective values shown are normalized by the maximum achievable objective given infinite budgets.
In all instances, the performance of SUBMODULAR-GREEDY clearly outperforms the random baseline, and is furthermore close to UPT. These results empirically validate the theoretical performance guarantees proved in Section 5.3. The inflection point of each SUBMODULAR-GREEDY curve corresponds to the point where the algorithm switches from greedily selecting edges (EDGE-GREEDY) to greedily selecting vertices (VERTEX-GREEDY). Near inflection points, sometimes UPT Rounded achieves a higher performance than SUBMODULAR-GREEDY. This observation is consistent with what we expected from Figure 2. Note that this rounding lacks any worst-case performance guarantees. In addition, obtaining the rounded solution requires solving a potentially large MAXDET problem which may not be an option on computationally constrained platforms.

Cross-Objective Analysis
To complete our experimental analysis, we perform cross evaluations of the proposed performance metrics (f FIM , f WST , and f NLC ). In these experiments, all pose-graph SLAM instances are solved using g2o (Kümmerle et al. 2011). Figure 10a shows the evolution of absolute trajectory error (ATE) as a function of the computation budget k in simulation. As the ATE converges quickly, we use a range of small computation budgets (k = 1 to k = 50), with a fixed communication budget of b = 2.5MB in TU. In general, using the proposed metrics leads to faster decrease of ATE compared to randomly selecting potential loop closures. Moreover, note that the estimation-theoretic objectives f FIM and f WST outperform f NLC . Such results are expected, as these objectives inherently favor edges that lead to more reduction in estimation uncertainty. Lastly, Figure 10b shows the number of established loop closures as a function of k.
Once again, the proposed performance metrics outperform the random baseline noticeably.

Conclusion
Inter-robot loop closures constitute the backbone of CSLAM systems needed for multi-robot navigation in GPS-denied environments. In real-world scenarios, detecting inter-robot loop closures is a resource-intensive process with a rapidly growing search space. This task thus can be extremely challenging for robots subject to various operational and resource constraints. It is thus crucial for robots to be aware of these constraints, and to actively adapt to them by intelligently utilizing their limited mission-critical resources. We presented such a resource-aware framework for distributed inter-robot loop closure detection under budgeted communication and computation. In particular, we sought an exchange-and-verification policy that maximizes a monotone submodular performance metric under resource constraints. Such a policy determines (i) "which observations should be shared with the team", and (ii) "which subset of potential matches is worthy of geometric verification". This problem is NP-hard in general. As our main contribution, we provided efficient greedy approximation algorithms with provable performance guarantees. In particular, for monotone modular performance metrics such as the expected number of true loop closures, the proposed algorithms achieve constantfactor approximation ratios under multiple communication and computation cost models. In addition, we also proposed an approximation algorithm for general monotone submodular performance metrics with a performance guarantee that varies with the ratio of resource budgets, as well as the extent of perceptual ambiguity. The proposed framework was extensively validated on real and synthetic benchmarks, and empirical near-optimal performance was demonstrated via a natural convex relaxation scheme.
It remains an open problem whether constant-factor approximation for any monotone submodular objective is possible. We plan to study this open problem as part of our future work. Additionally, although the burden of verifying potential loop closures is distributed among the robots, our current framework still relies on a centralized scheme for evaluating the performance metric and running the approximation algorithms. In the future, we plan to leverage recent results on distributed submodular maximization to eliminate such reliance on centralized computation.

A.1. Proof of Theorem 1 and Theorem 2
In this section, we give the proofs for theorems presented in Section 4. First, we establish the following more general result which holds for any partitioning of the edge set E x . Both theorems in this section then follow as special cases. While these results are established independently (Tian et al. 2018b), we note that an even more general case with an arbitrary matroid constraint is presented in the seminal work of , Proposition 3.1).
Then g is NMS.
Proof of Theorem 5. We first show that h is NMS.
If h(B ∪ {e}) = h(B), (19) follows from the monotonicity of h. We thus focus on cases where h(B ∪ {e}) > h(B). Let E j be the partition that e belongs to, i.e., e ∈ E j . Furthermore, define A j A ∩ E j and B j B ∩ E j . Clearly, we have A j ⊆ B j . Given any subset of edges C ⊆ E x , define f k (C) as follows, f k (C) kth largest probability in C, if |C| ≥ k, 0, otherwise.
As A j ⊆ B j , it follows that f k (A j ) ≤ f k (B j ) for all k ∈ N.
By Theorem 3, g is also NMS, which concludes the proof; see (Tian et al. 2018a).
Proof of Theorem 1. This is a special case of Theorem 5 with a single block (entire E x ).
Proof of Theorem 2. This is a special case of Theorem 5 with E x = i,j∈ [r] j>i E ij , where i, j correspond to robot indices; see Section 4.1.

A.2. Proof of Theorem 4
Before proving the main theorem, we first establish approximation guarantees for the individual components of SUBMODULAR-GREEDY, namely EDGE-GREEDY (Lemma 1) and VERTEX-GREEDY (Lemma 2).
Proof of Lemma 1. As shown in Algorithm 2, we exit the standard greedy loop (line 3-10) whenever the next selected edge violates either the communication or the computation budget. In addition, the heuristic optimization at the end (line 12-18) seeks to improve the solution while remaining feasible. Therefore, the returned solution from EDGE-GREEDY is guaranteed to be feasible. Now, we establish the performance guarantee presented in the lemma. To do so, we only look at the solution after the standard greedy loop (line 3-10). Let OPT 1 denote the optimal value of Problem 1. Consider the relaxed version of Problem 1