{'fraction_non_alphanumeric': 0.04709888206581641, 'fraction_numerical': 0.014918910407809793, 'mean_word_length': 4.1048929970863055, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 4, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 22, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On a Registration-Based Approach to Sensor Network Localization

We consider a registration-based approach for localizing sensor networks from range measurements. This is based on the assumption that one can find overlapping cliques spanning the network. That is, for each sensor, one can identify geometric neighbors for which all inter-sensor ranges are known. Such cliques can be efficiently localized using multidimensional scaling. However, since each clique is localized in some local coordinate system, we are required to register them in a global coordinate system. In other words, our approach is based on transforming the localization problem into a problem of registration. In this context, the main contributions are as follows. First, we describe an efficient method for partitioning the network into overlapping cliques. Second, we study the problem of registering the localized cliques, and formulate a necessary rigidity condition for uniquely recovering the global sensor coordinates. In particular, we present a method for efficiently testing rigidity, and a proposal for augmenting the partitioned network to enforce rigidity. A recently proposed semidefinite relaxation of global registration is used for registering the cliques. We present simulation results on random and structured sensor networks to demonstrate that the proposed method compares favourably with state-of-the-art methods in terms of run-time, accuracy, and scalability.


I. INTRODUCTION
Recent developments in wireless communication and micro-electro-mechanics have proliferated the deployment of wireless sensor networks (WSN) [1]. A typical WSN may consist of few tens to thousands of nodes. Each node is a low-power device equipped with transducers, power supply, memory, processor, radio transmitter, and actuators. A global positioning system (GPS) is often installed on some of the nodes. Such nodes are referred to as anchor nodes. However, only a small fraction of the nodes are equipped with GPS to minimize weight and power consumption. In this paper, we will use sensor to specifically refer to a node that does not have a GPS, while the term node will be used for both sensors and anchors. WSNs are mostly deployed in remote locations, and nodes have limited memory capacity, so wireless transmitters are used to transfer the sensor data to base stations. Due to power constraints, two nodes can communicate if and only if the inter-node distance is within some radio range, which we will denote by r [1]. We would like to note that although GPS modules are getting cheaper, deploying them in large scale would still be costly. Moreover, GPS comes with its own limitations [1]. To calculate the position of a sensor using GPS alone, at least four line-of-sights (with satellites) are required. This might not be viable in case of bad weather. Furthermore, for underwater surveys and mining applications, it is not even feasible to have line-of-sights. In fact, in applications where the position information is crucial, localization algorithms can be used to back up GPS positioning.
To meaningfully interpret the sensor data, one requires the locations of the sensors. A central problem in this regard is to estimate the sensor locations from the inter-sensor distances and the anchor locations. This problem is referred to as sensor network localization (SNL) [2], [3]. To set up the mathematical description of SNL, we introduce some notations that will be follow throughout the paper. Assume that we have a total of N sensors and K anchors. We label the sensors using S = {1, . . . , N }, the anchors using A = {N + 1, . . . , N + K}, and N = S ∪ A denotes the nodes in general. Let X s = {x i : i ∈ S} and X a = {ā k : k ∈ A} (1) denote the sensor and anchor locations. We assumex i andā k to be in R d , where d is typically 2 or 3 [1], [2]. The distance between two nodes i and j (that are within the radio range r) can be calculated using different techniques, such as the received signal strength or the time of arrival [3]. A measurement graph G is used to encode the distance information [4], [5]. Particularly, G = (V, E), where V(G) = N , and (i, j) ∈ E(G) if and only if the distance between the i-th and the j-th node is known. The problem is to compute the unknown sensor locations X s from the measured distances and the anchor locations X a . We make the standard assumption that the anchor locations are noise-free [4], [6].

A. Optimization Algorithms
The decision version of the SNL problem is known to be computationally intractable [7]. The presence of noise makes the problem even more challenging in practice. Nonetheless, several methods have been proposed that can compute approximate solutions. A survey of the literature on SNL is beyond the scope of this paper. Instead, we will focus on some of the recent optimization methods that are related to the present work. We refer the interested reader to [3] for a survey of algorithms that are not based on optimization.
The simplest optimization framework for SNL is that of strain minimization [8]. In this approach, the sensor locations x 1 , . . . , x N are obtained by minimizing the strain function In (2), the indices i, j are reserved for S, and the index k for A. Unfortunately, it is difficult to compute the global minimum of (2) since it is non-convex in the variables [2]. In this regard, several approximation algorithms based on convex programming have been proposed, which can provably compute the global minimum under certain conditions. Based on the computing paradigm, one can broadly classify these as centralized and distributed algorithms. Centralized algorithms employ a server to store the transmitted range measurements, based on which the sensor locations are computed. It was observed in [9] that the distance bounds in SNL can be posed as semidefinite constraints. Later, in the seminal paper [8], the authors showed how (2) can be approximated using a convex semidefinite program (SDP). The main advantage of posing SNL as a convex program is that we can find the global minimizer of the problem independent of the initialization. The flip side, however, is that standard SDP solvers (e.g., SeDuMi [10]) are memory and computation intensive, and hence cannot be scaled to large-sized problems. For example, the SDP-based algorithm in [8] can scale only up to a few hundred nodes [11]. To improve the scalability, a further edge-based relaxation of [8] was proposed in [11]. While the relaxation can indeed scale up to 8000 nodes, its performance is nevertheless inferior to that of the original SDP for medium-sized problems.
On the other hand, distributed algorithms divide the processing over the nodes. As a result, they exhibit better scalability compared to centralized methods. The main drawback is that they suffer from error propagation [3]. Moreover, distributed methods such as the ones in [4], [6], [12], [13] can operate only in the presence of anchors (which might not be available, e.g., in indoor WSN). The distributed algorithm in [12] that can handle million sensors without any significant communication overhead. However, the localization accuracy of this method is conditioned on a good initialization. More recently, distributed methods based on convex programming have been proposed in [4], [6], [13]. In particular, a distributed algorithm based on the alternating direction method of multipliers was proposed in [6]. However, as reported in [4], the approach is computationally demanding since each node is required to solve an SDP per iteration, and also the communication overhead is significant. A distributed algorithm that is cheaper and requires a smaller communication overhead was later proposed in [4]. One shortcoming of the latter method is that it requires the sensors to be in the convex hull of the anchors, which is difficult to guarantee in practice.
The present work was motivated by a class of centralized algorithms that use divide-and-conquer approaches to improve scalability [5], [14], [15], [16]. The general mechanism is to partition G into overlapping subgraphs, localize each subgraph using the induced distances, and finally register the subgraphs. The idea is to construct subgraphs that are denser than the original graph. Moreover, the smaller graphs can be efficiently localized. The algorithms essentially differ on how each subproblem is solved. For example, a Cuthill-McKee-type permutation is used in [15] to partition G. In [5], [16], G is partitioned using neighborhood subgraphs. To improve the localization, rigid subgraphs [17] are extracted from each neighborhood subgraph in [5]. Recently, recursive spectral clustering was used in [14]. We note that the subgraphs obtained using the graph partitioning in [14], [15] are not guaranteed to be rigid [18], [19], and hence can result in poor localization. In fact, a few poorly localized subgraphs can adversely affect the overall registration. The algorithms in [15], [16] register the subgraphs in a sequential fashion, and inevitably suffer from error propagation. Recently, a least-square method was proposed in [20] that can register the subgraphs in a globally-consistent manner. In particular, it was demonstrated in [20] that global registration can successfully operate in adversarial situations where sequential methods fail. In this regard, we note that a lateration condition was introduced in [20] that can guarantee exact recovery in the noise-free setting. However, there is no known efficient algorithm for testing lateration.

B. Contributions
We propose a divide-and-conquer algorithm building on the ideas in [14], [20], [21]. In particular, we address the following issues that emerged from this line of work: testing and ensuring that each subgraph is rigid, formulating a testable condition for recovering the sensor coordinates, and developing a scalable algorithm for registering the localized subgraphs. In this context, the contributions are as follows: (i) To bypass the rigidity issue associated with the localization of each subgraph, we propose to use cliques. Cliques are trivially rigid and can be efficiently localized using multidimensional scaling [22]. However, given that finding cliques in a large graph is challenging, we first partition G into neighborhood graphs [5], [16]. We then extract a clique from each neighborhood graph using the algorithm from [23]. Finally, we augment the vertices of a clique to expand it into a maximal clique. We experimentally demonstrate that the complete process is fast for both random and structured geometric graphs.
(ii) We study the problem of registering a system of localized cliques. In particular, we establish a rigidity condition that is necessary for recovering the original sensor coordinates. The proposed condition can be efficiently tested simply by computing the maximum flow between the vertices of an appropriate graph. We present supporting examples to conjecture that the proposed rigidity condition is also sufficient for exact recovery. Moreover, we demonstrate using numerical examples that the registration performance can be improved in the noisy setting by enforcing the rigidity condition.
We note that a registration-based approach for anchorless SNL was earlier proposed in [21] that uses cliques and cMDS. In the present work, we focus on anchored SNL (though the method can also be used for anchorless SNL). Moreover, we consider a different clique exploration process. Importantly, we investigate the rigidity problem associated with registration which was not discussed in [21].

C. Organization
The rest of the paper is organized as follows. In Section II, we propose a rigidity criteria for the registration problem, and explain how this can be tested efficiently. The proposed graph partitioning is described in Section III keeping the registration problem in mind. Classical multidimensional scaling is reviewed in Section IV, which is used to localize the cliques. The registration algorithm is described in Section V. Experimental results and comparisons are provided in Section VI. Fig. 1. A configuration of two patches, two sensors and three anchors (left) and its correspondence graph (right). Circles, diamonds, and squares are used to represent the sensors, anchors, and patches; note that C is the anchor patch. It is clear that this configuration is rigid in two dimensions (see text for precise definitions). We have marked the edges of the three disjoint paths between patch vertices A and B using different colors (right). See text for comments.

II. THE RIGIDITY PROBLEM
We first study the fundamental problem of rigidity whose resolution will be useful during the graph partitioning phase in Section III. This problem is also relevant for other divide-and-conquer approaches [5], [14], [16], [20], where a system of point sets are required to be registered. More precisely, consider the sensors X s and the anchors X a in (1), and subsets C 1 , . . . , C M ⊂ N . Following [5], [14], we will refer to each C i as a patch. Moreover, we create an additional patch C M +1 consisting solely of the anchors A. Assume that the points in each patch have been derived from the respective points in X s ∪ X a via a rigid transform. Letx where x k,i is the coordinate of the k-th point in the i-th patch, and R i = (O i , t i ) is the rigid transform associated with the i-th patch, where the orthogonal matrix O i represents rotation (or reflection) and t i is the translation component. We will refer to the (x k,i )'s as the patch coordinates. The patches and the patch coordinates together form a configuration. The registration problem is one of determining the unknown X s from the given configuration.
Problem II.1 (Registration). Find x 1 , . . . , x N and rigid transforms Q 1 , . . . , Q M such that, for 1 ≤ i ≤ M , where k ∈ C i \ A and l ∈ C i ∩ A.
In the noiseless setting, the solution (points and transforms) sought above exists trivially, namely, the ground truth x k =x k and Q i = R i . The rigidity problem is to determine whether the solution is unique (upto a global rigid transformation). That is, if x 1 , . . . , x N is a solution of Problem VIII.4, then is it necessary that for some rigid transform R, A set of points in R d is said to be non-degenerate if their affine span is R d . Clearly, the cardinality of such points must be d + 1 or more. For example, three points are non-degenerate in two-dimensions if and only if they are not collinear. We note that the transforms Q 1 , . . . , Q M in Problem VIII.4 are latent variables and do not appear in the Problem VIII.5.

Definition II.3 (Rigidity).
A configuration is said to be rigid in R d (or simply rigid) if the solution is unique in the sense of Problem VIII.5; otherwise, the configuration is said to be flexible.
To provide geometric insights to the rigidity problem, we consider simple instances of rigid and flexible configurations in Figures 1 and 2. In particular, we wish to highlight the importance of overlaps among patches in determining rigidity. In Figure 1, patches A and B share two sensors. The patches can be reflected along the line joining sensors 1 and 2, but due to the presence of anchors in A and B, reflection is ruled out. The configuration is thus rigid in the sense of Definition II.3. On the other hand, the configuration in Figure 2 is flexible since patches C and D can be reflected along the red dotted line. The above concepts and definitions were motivated by the rigidity aspects of the SNL problem [2], and more generally, the distance-geometry problem [18], [19]. Here, the problem is to determine if the available distance measurements uniquely define the sensor locations (modulo a rigid transform which leaves the distances unchanged). A fundamental result in this regard is that, if the original sensor locations are generic [19], then the uniqueness problem can be completely resolved using just the measurement graph [17], [18], [19]. Our present objective is to come up with similar results for Problem VIII.5. At this point, we wish to emphasize that rigidity theory is solely concerned with exact measurements [19], [24]. The point is that the combinatorial structure of the problem should, in principle, be able to guarantee exact recovery of the ground truth when the measurements are perfect. The design of an algorithm that can provably recover the ground truth is however a completely different topic. We will present some representative examples in Section VI, which suggest that rigidity can also help improve the algorithmic performance in the noisy setting. We will assume the following in the rest of the discussion. Assumption II.4 (Non-degeneracy). There are at least d + 1 non-degenerate points in each patch.
Under the above assumption, we provide a necessary condition for rigidity. Before doing so, we note that a lateration criteria was earlier proposed in [20] that can guarantee rigidity. However, it is not known if there exists an efficient test for lateration. Moreover, a path configuration can be rigid without being laterated, that is, lateration is not necessary for rigidity. This fact is demonstrated with an example in Figure 3. This motivated us to look for a criteria that is both necessary and sufficient for rigidity. We propose a necessary condition for rigidity that can be tested efficiently. We present some examples where the condition is also sufficient, and conjecture that this is true in general.
Before stating the result, we set up a special bipartite graph that captures the overlap-pattern among patches. Recall that a graph is said to be bipartite if the vertex set V can be divided into disjoint subsets V 1 and V 2 such that there are no edges between the vertices of a given V i .
Definition II.5 (Correspondence graph). We define the bipartite correspondence graph to be The correspondence graph for the configuration in Figure 1 is shown on the right. Finally, we introduce a special notion of connectivity. Recall that a path is an ordered sequence of vertices The path is said to be between vertices α and β (or the path connects α and β) if v 1 = α and v n = β. Two paths in a graph are said to be vertex-disjoint over a set Θ if they do not share a common vertex from Θ. A set of paths are said to be Θ-disjoint if any two paths are vertex-disjoint over Θ.
Definition II.6 (Quasi connected). The correspondence graph Γ is said to be quasi k-connected if any two vertices in V 2 (Γ) have k or more V 1 (Γ)-disjoint paths between them. Moreover, there exist two vertices in V 2 (Γ) that are connected by exactly k paths that are V 1 (Γ)-disjoint.
For latter reference, we record the following characterization of quasi k-connectivity. The equivalence can be derived by adapting the proof of Menger's theorem [25, Theorem 3.3.1].
Proposition II.7. The following are equivalent. (a) The correspondence graph Γ is quasi k-connected. (b) E(Γ) can be divided into two disjoint subsets E 1 and E 2 such that the edges from E 1 and that from E 2 are (i) incident on at least k common vertices from V 1 (Γ), and (ii) not incident on any common vertex from V 2 (Γ).
In Figure 2, notice that there are 3 paths between any pair of vertices in V 2 (Γ), but at most two paths are V 1 (Γ)-disjoint. In this case, the configuration is not rigid. In fact, we have the following result (cf. supplementary material for the proof).
Theorem II.8 (Necessary condition). Under Assumption VIII.1, if a configuration is rigid in R d , then its correspondence graph must be quasi (d+1)-connected.
Moreover, we see from the example in Figure 2 that, if Γ fails to be quasi (d + 1)-connected, then the configuration is not rigid. We are yet to find a counter-example where the configuration is flexible yet Γ is quasi (d + 1)-connected. Based on empirical evidences, we make the following conjecture.
Conjecture II.9. Suppose Assumption VIII.1 holds, and that any k ≥ d + 1 points in X s ∪ X a are non-degenerate. Then a configuration is rigid in R d if and only if its correspondence graph is quasi (d+1)-connected.
The second assumption appears somewhat stringent at first sight. The relevance of this assumption is somewhat clear from the example in Figure 1. Namely, if sensors 1, 2 and anchor 5 are concurrent, then one can reflect patch B about the line joining these points. We note that the use of some form of non-degeneracy assumption is standard in rigidity theory [19].
Based on Definitions II.5 and II.6, it is not difficult to establish a relation between quasi connectivity and the maximum flow between the vertices of V 2 (Γ) [26]. In this context, recall that a vertex is said to have capacity κ if the incoming and outgoing flows for the vertex are at most κ [26].  [20]. The configuration is not laterated, but the correspondence graph (right) is quasi 3-connected. The edges of the three disjoint paths between patch vertices A and B are marked in solid.
Proposition II.10 (Connectivity using flow). Assume that each vertex in V 1 (Γ) is assigned unit capacity while computing the flow. Then the maximum flow between the vertices of The key point is that one can efficiently check if, under the assumption that the vertices in V 1 (Γ) have unit capacity, the maximum flow between the vertices of V 2 (Γ) is at least k. This can be done using the Ford-Fulkerson algorithm [26]. Note that we do not need to check the maximum flow for all pairs of vertices in V 2 (Γ). We can simply fix a vertex and check the maximum flow between this vertex and the remaining vertices.

III. PARTITIONING
We now describe a heuristic for partitioning G into overlapping patches such that the corresponding Γ is quasi (d + 1)-connected. In this relation, we note that divide-and-conquer approaches have been proposed in [14], [5], [15], [16], where G is partitioned into overlapping patches. The difficulty with the approaches in [14], [15] is that the patches and the resulting patch configuration are not guaranteed to be rigid.
We propose to bypass the former rigidity issue by using cliques, that is, complete subgraphs of the measurement graph. In other words, each patch is a clique in our approach. This is precisely why we choose to denote the patches as C i in Section II. Cliques are trivially rigid [18], [19], and can be localized using multidimensional scaling [22]. In particular, for each i ∈ V(G), we extract a maximal clique containing i. The system of cliques forms a clique-cover. We recall that a clique is said to be maximal if it is not contained in a strictly larger clique. By targeting maximal cliques, we wish to minimize the number of cliques that are required to be registered in the final phase.
Let G i denote the neighborhood graph of some i ∈ V(G). Namely, G i is the subgraph of G induced by i and its one-hop neighbors. For each vertex i, we want to find a maximal clique C ⊂ V(G) containing i. In this regard, we note that it suffices to restrict the search to G i . Proposition III.1. Let C be a maximal clique. Then i ∈ C if and only if C ⊂ V(G i ).
Proof. Let C be a maximal clique containing i. Then, for any j ∈ C, we have (i, j) ∈ E(G). Hence, j ∈ V(G i ).
In the other direction, suppose that C ⊂ V(G i ), but i does not belong to C. Then, by appending vertex i to C, we obtain a clique that strictly contains C, which contradicts the maximality of C.
Unfortunately, finding cliques is generally intractable [23]. Based on Proposition III.1, we first extract a clique from a given subgraph G i using the algorithm in [23]. In this work, the combinatorial problem of finding maximal cliques is relaxed into a continuous optimization problem. The stationary points of the latter are computed using projected gradient descent. The key result of the paper is that one can provably locate a clique by running the gradient-descent for sufficient number of iterations and rounding the output [23, Theorem 7, Corollary 3]. The authors empirically noticed that the clique retuned by the algorithm is often maximal. Since the subgraphs G i are typically small for practical values of r, we found the algorithm in [23] to be quite efficient for our purpose.
The clique located within a given G i using the above clique-finding algorithm may not contain vertex i. In this case, we can in fact obtain a larger clique simply by appending vertex i to the found clique. Generally, since the subgraphs are small, one can efficiently test for maximality, and keep appending nodes until the maximal clique is found. In practice, we noticed that the cliques returned by the algorithm in [23] are often maximal or near-maximal. As a result, the combined process of appending vertices and testing for maximality is quite fast. We note that an extracted clique can belong to two or more subgraphs. We discard the redundant cliques during the clique-finding process. At the end, suppose that we have located, say, m maximal cliques, C 1 , . . . , C m , that cover the vertices of G. We next test the rigidity of the patch configuration. To do so, we append to the existing cliques an additional clique C m+1 containing the anchors, and test if Γ is quasi (d + 1)-connected. If so, we set M = m, and proceed to the localization phase in Section IV.
If Γ fails the test, we proceed as follows. Following Proposition II.10, we know that there exist s, t ∈ V 2 (Γ) for which the maximum s-t flow is k ≤ d, where recall that the vertices in V 1 (Γ) are assigned unit capacity. In fact, the Ford-Fulkerson algorithm returns the value k and the corresponding minimum cut C = (S, T ), where s ∈ S and t ∈ T [26]. Let I S and I T be the indices of the cliques in S and T , that is, I S = S ∩ V 2 (Γ) and I T = T ∩ V 2 (Γ).
Proof. From the max-flow-min-cut theorem [26], |A ∩ B| ≤ k. If |A ∩ B| is less than k, then there would be a vertex in V 1 (Γ) with more than one edge in the cut set [26]. However, since each vertex in V 1 (Γ) has unit capacity, this is not possible.
We wish to increase the maximum flow by extracting a clique and appending it to the existing configuration. In particular, the appended clique must contain some i ∈ A \ B and j ∈ B \ A. Our task is to find a maximal clique containing i and j. Define G ij be the common subgraph of G i and G j , that is, G ij is the subgraph of G induced by the vertices V(G i ) ∩ V(G j ). Similar to Proposition III.1, we note the following. Proposition III.3. Let C 0 be a maximal clique. Then i, j ∈ C 0 if and only if C 0 ⊂ V(G ij ).
After appending C 0 to the existing cliques, we obtain a new configuration. Accordingly, we update V 2 (Γ) and E(Γ), and increase m by 1. In particular, we reorder the indices of the cliques so that C m+1 continues to be the anchor clique. For the updated Γ, we recompute I S or I T , and note that m belongs to either of these. As a result, we conclude the following. Moreover, if the maximum flow is uniquely achieved for the vertices identified by the Ford-Fulkerson algorithm, then appending C 0 actually increases the maximum flow. We continue this process, in which we alternately augment the configuration and test rigidity, until we attain the maximum flow of d + 1. It is possible that the process is prematurely terminated if we are unable to find a clique of size at least d + 1. This typically happens in adversarial settings where r is small, making G extremely sparse. At the end of the process, assume that we have M + 1 cliques, C 1 . . . , C M +1 , where C M +1 is the anchor clique. For the simulations in Section VI, we found that M is typically about 30% of the total number of nodes.

IV. LOCALIZATION
Having partitioned the measurement graph into a system of overlapping cliques, we now localize them in parallel. Since all the inter-node distances are available in a clique, we can efficiently localize a clique using multidimensional scaling [22]. However, there are two types of cliques, namely, cliques without anchors and those with anchors. For the former, we can directly use classical multidimensional scaling (cMDS). In particular, suppose that the clique has n sensors, and the distances are {d ij : 1 ≤ i, j ≤ n}. Consider the n × n matrices D and B given by where u is the all-ones vector of length n, and I n is the n × n identity matrix. Since B is symmetric, it has real eigenvalues and a full set of orthonormal eigenvectors. Let λ 1 ≥ · · · ≥ λ n be the sorted eigenvalues, and q 1 , . . . , q n be the corresponding eigenvectors.
Theorem IV.1 (Multidimensional Scaling, [22]). Suppose that the available distances are exact, that is, d ij = x i − x j for some x 1 , . . . , x n . Then B 0 and rank(B) ≤ d. The sensor locations can be taken to be If the distances are noisy, B can have negative eigenvalues and its rank can be greater than d. In this case, it is customary to use the positive eigenvalues and the corresponding eigenvectors in (5). The resulting inter-sensor distances are an approximation to the available distances, where the approximation error is determined by the rank of B, and the number and magnitude of the negative eigenvalues [22]. Perturbation analysis of cMDS is a well-researched topic and the method is known to be stable under deformations [27].
If a clique has one or more anchors, we have to take into consideration the stipulated anchor locations. More precisely, we have a constrained problem, where we need to reconstruct the sensor locations keeping the anchor variables fixed. In such scenarios, we can use cMDS followed by an alignment. Assume that, of the n nodes, the first k are anchors and the remaining are sensors. We first localize the n nodes using cMDS, regardless of the anchor locations. Then we align the reconstructed anchors with the original anchors via a rigid transformation. In particular, if there is just one anchor, and if the reconstructed and original locations are x andā, then we translate the reconstructed nodes byā − x. If there are more than one anchor, then we perform an optimal alignment using least-square fitting: where x i andā i are the reconstructed and the original anchor locations. As is well-known, the minimum of (6) has a simple closed-form solution [28]. In particular, the optimal transform is given by . We apply the transform x → O x + t on the reconstructed sensors, and place the anchors in their stipulated locations. Finally, we refine the localization by minimizing the stress function using a gradient-based method [8]. The refinement is particularly effective when the distances are noisy.

V. REGISTRATION
As a final step, we need to register the localized cliques in a global coordinate system. While the least-square formulation of the registration problem has a closed-form solution for two cliques [28], the problem is generally intractable when there are three or more cliques [20]. Recently, it was demonstrated in [20] that the least-square optimization can be approximated using a semidefinite program (SDP). Later, a scalable ADMM-based solver for this SDP was proposed in [21]. For completeness, we review the SDP relaxation and the ADMM solver.
In the absence of noise, the relation between the local and global coordinates are given by (12) and (13). Since these are not expected to hold exactly in the presence of noise, the authors in [14] proposed to minimize the least-square objective where are the registration errors for sensors and anchors. The scale λ > 0 is used to combine the gross errors. The variables are the sensor coordinates x k and the rigid transformations (O i , t i ). The dummy variable O M +1 is introduced to make the objective homogenous [14]. In terms of the matrix variables we can express (7) as where Here, ⊗ is the Kronecker product, δ L i is the all-zero vector of length L with unity at the i-th position, The minimum of (8) over Z is attained when Z = OBJ −1 . On substituting Z in (8), we get the following problem: min  It was observed in [20] that the objective and the constraints in (9) are convex, except for the rank condition. By dropping the rank constraint, the authors arrived at the following SDP relaxation: The global minimum of (10) can be computed for small or even medium-sized problems using an interiorpoint solver [10]. However, such solvers are both memory and computation intensive. In particular, the cost of approximating the global minimum of (10) within a given accuracy is O((M d) 4.5 ) [20]. Since M is of the order O(|N |) in our case, the size of the SDP variables can be few hundreds or thousands. Interiorpoint solvers run out of memory for such large problems. To achieve scalability, an iterative solver based on ADMM was proposed in [21]. The ADMM updates are summarized in Algorithm 1, where S + is the set of symmetric positive semidefinite matrices of size L = (M +1)d, Ω is the set of symmetric matrices of size L whose d × d diagonal blocks are identity, and Π S (A) denotes the projection of A onto a convex set S. Notice that the only non-trivial computation is determining Π S+ (A). This is obtained by computing the eigendecomposition of A and setting the negative eigenvalues to zero. The projection Π Ω (A) amounts to setting the d × d diagonal blocks of A to I d , while keeping the non-diagonal blocks unchanged. We initialize H using the spectral algorithm in [20]. The Lagrange multiplier Λ is initially set to be the zero matrix. We use a condition from [29] to terminate the iterations.
We can establish the convergence of Algorithm 1 using the analysis in [29]. In particular, we have the following result.
That is, (G k ) approaches the feasible set in (10).
In fact, since updates 3 and 4 in Algorithm 1 are convex projections, we can establish the Theorem V.1 using elementary results from convex analysis. This and other technical results will be reported separately [30].
Having approximated the optimal G using Algorithm 1, we compute O = [O 1 · · · O M +1 ] using the rounding in [20]. The first N columns of Z = OBJ −1 are taken to be the estimated sensor locations. As a final step, we refine the locations using stress minimization [8] and denote the result as x 1 , . . . , x N .

VI. NUMERICAL EXPERIMENTS
In this section, we conduct numerical simulations to demonstrate the performance of the proposed method. In particular, we illustrate the impact of rigidity on the performance of the registration algorithm, and study the timing of different phases of the proposed method and the scaling of the localization error with the noise level. We then compare with some of the state-of-the-art algorithms [6], [8], [11], [4] in terms of accuracy, run-time, and scalability. The comparisons are performed on planar networks, namely, the random geometric graph (RGG) [8], [11], [14], and the structured PACM logo [5]. The diameter  (maximum distance between any two points) of the logo is 16.92. We consider the following noise model that was used in [8], [11], [14]: where ij and ik are i.i.d. Gaussians with mean zero and standard deviation η. As mentioned earlier, we enforce symmetry by replacing d ij and d ji with their average [31]. For a quantitative comparison of the localization accuracies, we use the average normalized error (ANE) [5] given by wherex c is the centroid of the original sensor locations. Of course, we assume that the reconstruction has been optimally aligned with the ground truth before computing the ANE [28]. We also present visual comparison of the localizations obtained using different methods. For all experiments, we have used λ = 1 in (7) and ρ = 0.01 for the augmented Lagrangian.

A. Performance Analysis
To assess the performance of our method, we present simulation results on RGGs over the unit square [8], [11], [14], [5]. To generate a RGG, we uniformly sample N points on the unit square [−0.5, 0.5] 2 and fix them to be the sensors. We additionally pick K points at random from the square (distinct from the sensors) and fix them to be the anchors. We assume that the distance between two sensors, or between a sensor and an anchor, is known if it is at most r. Experiment 1: To understand the importance of rigidity, a network consisting of 500 sensors and 10 anchors is considered where r is taken to be 0.17. We generate several instances of random graphs with the above parameters until we have an instance where the corresponding Γ fails to be quasi 3-connected. We run our algorithm at noise levels η = 0 and 0.1 on these instances and record the localization results. We then augment the existing clique system to ensure that Γ is quasi 3-connected. This is done using the heuristics proposed in Section III. We again run our algorithm at noise levels η = 0 and 0.1 and record the results. A particular instance is reported in Figure 4. We notice that the proposed algorithm performs poorly if Γ is not quasi 3-connected. In particular, notice that the registration mechanism fails in specific regions of the network. This can be attributed to the "fold-over" phenomena associated with patches that are loosely connected to the rest of the patch system [16]. However, when Γ is forced to be quasi 3-connected, we notice that the registration output improves significantly for both the noiseless and noisy cases. In fact, we achieve almost machine-level precision for the noiseless case. Experiment 2: In Table I, we report the run-times of the three phases of the algorithm for networks of different sizes (we round K to 10% of N in each case). The experiments were performed using MATLAB 8.2 on a 4-core workstation with 3.4 GHz processor and 32 GB memory. Notice that the timing of the localization and the partitioning phase increases almost linearly with the number of sensors. Interestingly, the timing does not vary much with the noise level for a fixed N . However, the timing of the final registration phase appears to depend heavily on the noise level. An explanation for this is that we use the solution of the spectral relaxation of (10) as an initialization for the ADMM solver [20]. If the spectral relaxation turns out to be a good approximation of the optimal solution, then the ADMM solver converges in few iterations. Else, a large number of ADMM iterations are required. Experiment 3: As a final analysis, we study the scaling of ANE with the noise level, when r = 0.12, 0.15, and 0.18.
A fixed network consisting of 500 sensors and 50 anchors was used. For a particular η and r, we averaged the ANEs obtained over 10 realizations of the random graph and the measured distances. The results from a typical experiment are plotted in Figure 5. We notice that the ANE increases almost linearly with η when r = 0.12 and 0.15. However, when r = 0.12, the ANE tends to increase abruptly at large noise levels. The reason for this is that the registration process can fail when r is low and η is large (low signal-to-noise ratio scenario).

B. Comparison
We now compare the proposed method with the following optimization-based methods: Edge-based Maximum Likelihood (E-ML) relaxation [6], SNL using SDP (SNLSDP) [8], Edge-based SDP (ESDP) relaxation [11], SNL using Disk Relaxation (SNLDR) [4]. E-ML uses distributed optimization to minimize a surrogate of the ML estimator for the distance measurements in SNL. SNLDR uses distributed optimization for a novel convex relaxation of the SNL problem. On the other hand, SNLSDP is a centralized algorithm which is based on an SDP-based relaxation of the SNL problem. ESDP is a further relaxation of SNLSDP that can handle large networks. Experiment 4: The proposed method is compared with E-ML, SNLSDP, ESDP and SNLDR on random geometric graphs. The results are reported in Table II. For a fair comparison with SNLDR, we additionally placed an anchor at each of the four corners of the unit square to ensure that the sensors are in the convex hull of the anchors [4]. The localization obtained using our method is comparable with that obtained from SNLSDP for small networks (N ≤ 500). The performance of SNLSDP starts degrading when N > 500, and it cannot handle large networks (N > 1000). On the other hand, the proposed method is able to maintain its performance across networks of all sizes. Notice that, though ESDP can scale up to networks of size 8000, its performance falls off abruptly when N > 4000. The proposed method is generally faster than ESDP and SNLSDP.   that the reconstruction from the proposed method is visibly superior to the competing methods in either case, which is also reflected by the ANE. The accuracy is competitive with SNLSDP, but consistently better than the other methods. In particular, notice the poor localizations obtained using SNLDR when η = 0.5. Additional comparisons with [4], [8], [11], and [12] are provided in the supplementary material. The MATLAB code of our algorithm is publicly available [32].

VII. CONCLUSION
We demonstrated that by transforming the localization problem into a registration problem, one can achieve scalability without compromising the localization accuracy. In particular, the convex relaxation of the registration problem appears to be better behaved in terms of scalability and approximation quality compared to the convex relaxations of the localization problem. For example, the proposed algorithm can localize a network of 8000 nodes in 15 minutes with almost machine-precision accuracy of 1e-12. In contrast, the convex relaxation in [8] cannot be scaled beyond 1000 nodes. An exception in this regard is ESDP, which can be scaled to networks with thousands of nodes. However, its localization accuracy starts falling off with the increase in network size. A key contribution of the paper is that we formulated and analysed the rigidity problem associated with multi-patch registration. An open question that emerged from this analysis is whether quasi-connectivity is sufficient for the patch configuration to be rigid. Another relevant question that remains unaddressed is the impact of rigidity on the performance of the registration algorithm, both in terms of tightness and stability. These will be investigated in future work.

VIII. SUPPLEMENTARY
A. Proof of Theorem II.8 In this section, we prove Theorem II.8. First, we recall a basic assumption that was made in this regard.
Assumption VIII.1 (Non-degeneracy). There are at least d + 1 non-degenerate points in each patch.
We now restate Theorem II.8.
Theorem VIII.2 (Necessary condition). Under Assumption VIII.1, if a configuration is rigid in R d , then its correspondence graph must be quasi (d+1)-connected.
To prove Theorem VIII.2, we will need the following proposition: Proposition VIII.3. The following are equivalent. (a) The correspondence graph Γ is quasi k-connected. (b) E(Γ) can be divided into two disjoint subsets E 1 and E 2 such that the edges from E 1 and that from E 2 are (i) incident on at least k common vertices from V 1 (Γ), and (ii) not incident on any common vertex from V 2 (Γ).
For completeness, we recall Problems II.1 and II.2 from the main manuscript.
Problem VIII.4 (Registration). Find x 1 , . . . , x N and rigid transforms Q 1 , . . . , Q M such that, for 1 ≤ i ≤ M , where k ∈ C i \ A and l ∈ C i ∩ A.
Problem VIII.5 (Uniqueness). Determine whether Problem VIII.4 have a unique solution up to a rigid transform. That is, if x 1 , . . . , x N is a solution of Problem VIII.4, then is it necessary that for some rigid transform R, where k ∈ S and l ∈ A?
Moreover, we assume that the points in each patch have been derived from the respective points in X s ∪ X a via a rigid transform. Let andā We consider a different registration problem where the patch coordinates are replaced by the original coordinates.
Problem VIII.6 (Registration). Find x 1 , . . . , x N and rigid transforms T 1 , . . . , T M such that, for 1 ≤ i ≤ M , where k ∈ C i \ A and l ∈ C i ∩ A.
A trivial solution is x k =x k and T i = (I d , 0). As with Problem VIII.5, we can ask whether this is the only solution. It turns out that the questions are related.
Proposition VIII.7 (Equivalence). Problem VIII.4 has an unique solution if and only if Problem VIII.6 has an unique solution.
Proof. Combining (12), (13) and (14), we can write Comparing (15) with (11), we have Q i = T i • R i . It follows that the T i 's are unique if and only if the Q i 's are unique. Moreover, the uniqueness of the x k 's follows from the uniqueness of the transforms and relations (11) and (14).
We also make the observation concerning Problem VIII.6 that T 1 , . . . , T M satisfying (14) are unique, i.e., T i = R(I d , 0) for some rigid transform R, if and only if the corresponding x 1 , . . . , x N are related tō x 1 , . . . ,x N via a rigid transform. If T i = R(I d , 0), then it follows from (14) that x k = R(x k ). Conversely, if x k = R(x k ) for some rigid transform R, then the corresponding T i should necessarily be of the form 0). Indeed, if some T i = R(I d , 0), then we can construct a solution that is not related tō x 1 , . . . ,x N via a rigid transform, and this would lead to a contradiction.
To complete the proof of Theorem VIII.2, it remains to show that, if the solution of Problem VIII.6 is unique, then Γ must be quasi (d + 1)-connected. We will prove this by contradiction. As a first step, we note that Γ is at least quasi-1 connected.
Proposition VIII.8. If Problem VIII.6 has a unique solution, then Γ must be quasi-k connected for some k ≥ 1.
Proof. Indeed, suppose that there exist non-empty subsets S and T of V 2 (Γ) such that there is no path between any i ∈ S and j ∈ T . Define Clearly, A ∩ B must be empty. Else, we can find a path between some i ∈ S and j ∈ T , which would violate our assumption. However, on setting T i = (I d , 0) for i ∈ S, and T j = (−I d , 0) for j ∈ T , we obtain a solution to Problem VIII.6 which is different from the trivial solution. Hence, our assumption about the existence of S and T must be wrong.
In fact, we can make the stronger claim that Γ is quasi k-connected, where k ≥ d + 1. To establish the claim, we show that the rigidity assumption is violated if k ≤ d.
First, we introduce few notations about paths. Suppose that there are one or more paths between two vertices of V 2 (Γ). We denote the j-th vertex on the i-th path using σ j i . In particular, σ 1 i and σ pi i are the initial and final vertices, where p i is the number of vertices on the path. Since Γ is bipartite, p i must be odd, and The first vertex represents a node, while the latter two represent patches. Moreover, the node belongs to both the patches. Therefore, for 1 ≤ i ≤ k and 1 ≤ j ≤ (p i − 1)/2, To arrive at a contradiction, we show that if k ≤ d, then there exists at least some T i = (O i , t i ), 1 ≤ i ≤ M, different 1 from (I d , 0) for which the system of equations in (14) hold. To do so, we divide V 2 (Γ) into two disjoint sets. Note that, from Proposition VIII.3, we can identify disjoint subsets E 1 , E 2 ⊂ E(Γ) such that the edges from E 1 and that from E 2 are not incident on any common vertex of V 2 (Γ). In particular, define S ⊂ V 2 (Γ) to be the vertices on which the edges of E 1 are incident. Similarly, let T ⊂ V 2 (Γ) be the vertices on which the edges of E 2 are incident. Then, S and T are non-empty and disjoint. Without loss of generality, we assume that the vertex corresponding to the anchor patch belongs to S. Since Γ is quasi k-connected, we can find a distinct vertex t ∈ T which is connected with the anchor patch vertex by paths σ 1 , . . . , σ k that are V 1 (Γ)-disjoint. Note that, since the anchor patch is fixed, O M +1 = I d and t M +1 = 0. Therefore, we set and show that if k ≤ d, then we can find (O, t) = (I d , 0) such that (14) holds. Note that Proposition VIII.3 also tells us that the edges from E 1 and that from E 2 are incident on exactly k common vertices from V 1 (Γ); we denoted these vertices using Ω. It is also be reasoned that each path contains exactly one vertex from Ω. Assume that σ 2qi i ∈ Ω be the vertex on the path σ i . Therefore, If k = 1, then O = −I d and t = 2x σ 2q i i satisfy (17), and hence the equations in (14). On the other hand, if 2 ≤ k ≤ d, then we have k equations similar to (17), one for each path. We eliminate t by subtracting the equations corresponding to 2 ≤ i ≤ k from the equation corresponding to i = 1. This gives us 1 Without loss of generality, we omit the global rigid transform R.
We collect this into the fixed-point equation OX = X, where X = x σ 2q 2 2 −x σ 2q 1 1 · · ·x σ 2q k k −x σ 2q 1 1 ∈ R d×(k−1) . Now, if we assume that k ≤ d, then we can find O = I d such that OX = X. In particular, we can find O that acts as an identity transform on the space spanned by the columns of X, and as a non-trivial rotation on the orthogonal complement of this space. We set t using (17) for this choice of O. One can verify that the above choice of (O, t) = (I d , 0) satisfies the equations in (14). This concludes the proof of Theorem VIII.2.

B. Experiments
In this section, we report some additional numerical results to demonstrate the performance of the proposed algorithm. Experiment 6: To study the effect of the number of anchors on the performance, we consider a random geometric graph (RGG) on [−0.5, 0.5] 2 consisting of 500 sensors. The sensing radius r is set as 0.17. We plot the ANE as a function of the number of anchors K for different noise levels η = 0.01, 0.05 and 0.1. The ANE is averaged over 100 noise realizations. The results are reported in Figure 6. We notice that the ANE falls off with increase in K, and saturates beyond a certain K.  Table V. We notice that for both clean and noisy measurements, the proposed method performs better than PLACEMENT. , we placed 4 anchors at (±0.5, ±0.5) (so that the sensors are guaranteed to be in the convex hull of the anchors). We set r = 0.28 and η = 0.1. The reconstructions are compared in Figure 7 along with the corresponding ANEs.   7. Comparison of the proposed algorithm with [8], [11], [4]. We placed 4 anchors at (±0.5, ±0.5). The parameters for the RGG are N = 200, r = 0.28 and noise level was set as η = 0.1. The ANE for each algorithm is mentioned at the top of the plot. Green circles (•) denote original sensor locations, red stars ( ) denote estimated locations, and blue diamonds (♦) denote anchor locations.

Experiment 9:
We repeat Experiment 3 with 500 sensors and 10 anchors (with 4 of them placed at (±0.5, ±0.5)). The localizations obtained using ESDP [11], SNLDR [4], SNLSDP [8] and the proposed method are shown in Figure 8. For this instance of RGG, the average node degree is 13.2 and the minimum node degree is 3. We note that for both Experiments 3 and 4, the ANE for the proposed method is the least.   [8], [11], [4]. We have used 10 anchors of which 4 of them are placed at (±0.5, ±0.5). The parameters used are N = 500 and η = 0.1, and the average node degree is 13.2.