Well-separated Pair Decomposition Research Articles

A Python Package for Well-Separated Pair Decomposition

A Python Package for Well-Separated Pair Decomposition

A Simple and Efficient Method for Accelerating Construction of the Gap-Greedy Spanner

Let [Formula: see text] be the complete Euclidean graph on a set of points embedded in the plane. Given a constant [Formula: see text], a spanning subgraph [Formula: see text] of [Formula: see text] is said to be a [Formula: see text]-spanner, or simply a spanner, if for any pair of nodes [Formula: see text], [Formula: see text] in [Formula: see text] there exists a [Formula: see text]-path in [Formula: see text], i.e., a path between [Formula: see text] and [Formula: see text] whose length is at most [Formula: see text] times their distance in [Formula: see text]. Gap-greedy spanner, proposed by Arya and Smid, is a light weight and bounded degree spanner in which a pair of points [Formula: see text] is guaranteed to have a [Formula: see text]-path, if there exists at least one edge with some special criteria in the spanner. Existing algorithms for computing the gap-greedy spanner determine the existence of such an edge for each pair of points by examining the edges of the spanner, which takes [Formula: see text] time, however in this paper, we have presented a method by which this task can be done in [Formula: see text] time. Using the proposed method and well-separated pair decomposition, we have proposed a linear-space algorithm that can compute the gap-greedy spanner in [Formula: see text] time. How to use the well-separated pair decomposition to compute this spanner was proposed by Bakhshesh and Farshi, however using an example, we have shown that one of the algorithms they have proposed for this purpose is incorrect. We have performed various experiments to measure the duration and amount of memory used by the algorithms for computing this spanner. The results of these experiments showed that the proposed method, without a significant effect on the amount of memory consumed compared to previous algorithms, leads to a significant acceleration in the construction time of this spanner.

Well-Separated Pair Decompositions for High-Dimensional Datasets

Well-separated pair decomposition (WSPD) is a well known geometric decomposition used for encoding distances, introduced in a seminal paper by Paul B. Callahan and S. Rao Kosaraju in 1995. WSPD compresses O(n2) pairwise distances of n given points from Rd in O(n) space for a fixed dimension d. However, the main problem with this remarkable decomposition is the “hidden” dependence on the dimension d, which in practice does not allow for the computation of a WSPD for any dimension d>2 or d>3 at best. In this work, I will show how to compute a WSPD for points in Rd and for any dimension d. Instead of computing a WSPD directly in Rd, I propose to learn nonlinear mapping and transform the data to a lower-dimensional space Rd′, d′=2 or d′=3, since only in such low-dimensional spaces can a WSPD be efficiently computed. Furthermore, I estimate the quality of the computed WSPD in the original Rd space. My experiments show that for different synthetic and real-world datasets my approach allows that a WSPD of size O(n) can still be computed for points in Rd for dimensions d much larger than two or three in practice.

Local routing in WSPD-based spanners

The well-separated pair decomposition (WSPD) of the complete Euclidean graph defined on points in $R^2$, introduced by Callahan and Kosaraju [JACM, 42 (1): 67-90, 1995], is a technique for partitioning the edges of the complete graph based on length into a linear number of sets. Among the many different applications of WSPDs, Callahan and Kosaraju proved that the sparse subgraph that results by selecting an arbitrary edge from each set (called WSPD-spanner) is a $1 + 8/(s − 4)$-spanner, where $s > 4$ is the separation ratio used for partitioning the edges.Although competitive local-routing strategies exist for various spanners such as Yao-graphs, $\Theta$-graphs, and variants of Delaunay graphs, few local-routing strategies are known for any WSPD-spanner. Our main contribution is a local-routing algorithm with a near-optimal competitive routing ratio of $1 + O(1/s)$ on a WSPD-spanner.Specifically, using Callahan and Kosaraju’s fair split-tree, we show how to build a WSPD-spanner with spanning ratio $1 + 4/s + 4/(s − 2)$ which is a slight improvement over $1 + 8/(s − 4)$. We then present a 2-local and a 1-local routing algorithm on this spanner with competitive routing ratios of $1 + 6/(s − 2) + 4/s$ and $1 + 8/(s − 2) + 4/s + 8/s^2$, respectively. Moreover, we prove that there exists a point set for which our WSPD-spanner has a spanning ratio of at least $1 + 8/s$, thereby proving the near-optimality of its spanning ratio and the near-optimality of the routing ratio of both our routing algorithms.

Faster Force-Directed Graph Drawing with the Well-Separated Pair Decomposition

The force-directed paradigm is one of the few generic approaches to drawing graphs. Since force-directed algorithms can be extended easily, they are used frequently. Most of these algorithms are, however, quite slow on large graphs, as they compute a quadratic number of forces in each iteration. We give a new algorithm that takes only O ( m + n log n ) time per iteration when laying out a graph with n vertices and m edges. Our algorithm approximates the true forces using the so-called well-separated pair decomposition. We perform experiments on a large number of graphs and show that we can strongly reduce the runtime, even on graphs with less than a hundred vertices, without a significant influence on the quality of the drawings (in terms of the number of crossings and deviation in edge lengths).

Distribution-Sensitive Construction of the Greedy Spanner

The greedy spanner is the highest quality geometric spanner (in e.g. edge count and weight, both in theory and practice) known to be computable in polynomial time. Unfortunately, all known algorithms for computing it on n points take varOmega (n^2) time, limiting its applicability on large data sets. We propose a novel algorithm design which uses the observation that for many point sets, the greedy spanner has many ‘short’ edges that can be determined locally and usually quickly. To find the usually few remaining ‘long’ edges, we use a combination of already determined local information and the well-separated pair decomposition. We give experimental results showing large to massive performance increases over the state-of-the-art on nearly all tests and real-life data sets. On the theoretical side we prove a near-linear expected time bound on uniform point sets and a near-quadratic worst-case bound. Our bound for point sets drawn uniformly and independently at random in a square follows from a local characterization of t-spanners we give on such point sets. We give a geometric property that holds with high probability, which in turn implies that if an edge set on these points has t-paths between pairs of points ‘close’ to each other, then it has t-paths between all pairs of points. This characterization gives an O(n log ^2 n log ^2 log n) expected time bound on our greedy spanner algorithm, making it the first subquadratic time algorithm for this problem on any interesting class of points. We also use this characterization to give an O((n + |E|) log ^2 n log log n) expected time algorithm on uniformly distributed points that determines whether E is a t-spanner, making it the first subquadratic time algorithm for this problem that does not make assumptions on E.

Global Illumination Using Well-Separated Pair Decomposition

Instant radiosity methods rely on using a large number of virtual point lights VPLs to approximate global illumination. Efficiency considerations require grouping the VPLs into a small number of clusters that are treated as individual lights with respect to each point to be shaded. Two examples of clustering algorithms are Lightcutsi¾ź[WFA*05] and LightSlicei¾ź[OP11]. In this work, we use the notion of geometric separatedness of point sets as a basis for a data structure for pre-computing and compactly storing a set of candidate VPL clusterings. Our data structure is created prior to rendering, is view-independent and relies only on geometric and radiometric information. For any point to be shaded, we show that a suitable clustering of the VPLs can be efficiently extracted from this data structure. We develop the above framework into an accurate and efficient clustering algorithm based on well-separated pair decompositions which outperforms earlier work in speed and/or quality for diffuse scenes.

Conic nearest neighbor queries and approximate Voronoi diagrams

Given a cone C and a set S of n points in Rd, we want to preprocess S into a data structure so that we can find fast an approximate nearest neighbor to a query point q with respect to the points of S contained in the translation of C with apex at q.We develop an approximate conic Voronoi diagram of O˜(n/εd) size that supports conic nearest neighbor queries in O(log⁡(n/ε)) time. Our preprocessing uses only the well-separated pair decomposition and a compressed quadtree. Previous results were restricted to simplicial cones and achieved polylogarithmic or higher query times.By increasing space to O˜(n/ε2d) our data structure further supports queries for any cone direction and angle.

The emergence of sparse spanners and well-separated pair decomposition under anarchy

A spanner graph on a set of points in R d provides shortest paths between any pair of points with lengths at most a constant factor of their Euclidean distance. A spanner with a sparse set of edges is thus a good candidate for network backbones, as desired in many practical scenarios such as the transportation network and peer-to-peer network overlays. In this paper we investigate new models and aim to interpret why good spanners ‘emerge’ in reality, when they are clearly built in pieces by agents with their own interests and the construction is not coordinated. We show that the following algorithm of constructing an edge pq , if and only if there is no existing edge p ′ q ′ with p ′ and q ′ at distances no more than (4(1+1/e)) -1 ·| pq | from p , q respectively, generates a (1+e)-spanner with a linear number of edges. The algorithm also implies a simple algorithm for constructing linear-size well-separated pair decompositions that may be of interest on their own. This new spanner construction algorithm has applications in the construction of nice network topologies for peer-to-peer systems, when peers join and leave the network and have only limited information about the rest of the network.

Triangulating the Square and Squaring the Triangle: Quadtrees and Delaunay Triangulations are Equivalent

We show that Delaunay triangulations and compressed quadtrees are equivalent structures. More precisely, we give two algorithms: the first computes a compressed quadtree for a planar point set, given the Delaunay triangulation; the second finds the Delaunay triangulation, given a compressed quadtree. Both algorithms run in deterministic linear time on a pointer machine. Our work builds on and extends previous results by Krznaric and Levcopolous and Buchin and Mulzer. Our main tool for the second algorithm is the well-separated pair decomposition (WSPD), a structure that has been used previously to find Euclidean minimum spanning trees in higher dimensions. We show that knowing the WSPD (and a quadtree) suffices to compute a planar Euclidean minimum spanning tree (EMST) in linear time. With the EMST at hand, we can find the Delaunay triangulation in linear time. As a corollary, we obtain deterministic versions of many previous algorithms related to Delaunay triangulations, such as splitting planar Delaunay triangulations, preprocessing imprecise points for faster Delaunay computation, and transdichotomous Delaunay triangulations.

Energy-Efficient Paths in Radio Networks

We consider a radio network consisting of n stations represented as the complete graph on a set of n points in the Euclidean plane with edge weights ω(p,q)=|pq| δ +C p , for some constant δ>1 and nonnegative offset costs C p . Our goal is to find paths of minimal energy cost between any pair of points that do not use more than some given number k of hops. We present an exact algorithm for the important case when δ=2, which requires $\mathcal {O}(kn\log n)$ time per query pair (p,q). For the case of an unrestricted number of hops we describe a family of algorithms with query time $\mathcal {O}(n^{1+\alpha})$, where α>0 can be chosen arbitrarily. If we relax the exactness requirement, we can find an approximate (1+e) solution in constant time by querying a data structure which has linear size and which can be build in $\mathcal {O}(n\log n)$ time. The dependence on e is polynomial in 1/e. One tool we employ might be of independent interest: For any pair of points (p,q)∈(P×P) we can report in constant time the cluster pair (A,B) representing (p,q) in a well-separated pair decomposition of P.

Pruning spanners and constructing well-separated pair decompositions in the presence of memory hierarchies

Given a geometric graph G = ( S , E ) in R d with constant dilation t, and a positive constant ε, we show how to construct a ( 1 + ε ) -spanner of G with O ( | S | ) edges using O ( sort ( | E | ) ) memory transfers in the cache-oblivious model of computation. The main building block of our algorithm, and of independent interest in itself, is a new cache-oblivious algorithm for constructing a well-separated pair decomposition which builds such a data structure for a given point set S ⊂ R d using O ( sort ( | S | ) ) memory transfers.

Well-separated pair decomposition in linear time?

Given a point set in a fixed dimension, we note that a well-separated pair decomposition can be found in linear time if we assume that the ratio of the farthest pair distance to the closest pair distance is polynomially bounded. Many consequences follow; for example, we can construct spanners or solve the all-nearest-neighbors problem in linear time (under the same assumption), and we compute an approximate Euclidean minimum spanning tree in linear time (without any assumption).

I/O-Efficient Well-Separated Pair Decomposition and Applications

We present an external-memory algorithm to compute a well-separated pair decomposition (WSPD) of a given point set S in ℝd in O(sort(N)) I/Os, where N is the number of points in S and sort(N) denotes the I/O-complexity of sorting N items. (Throughout this paper we assume that the dimension d is fixed.) As applications of the WSPD, we show how to compute a linear-size t-spanner for S within the same I/O-bound and how to solve the K-nearest-neighbour and K-closest-pair problems in O(sort(KN)) and O(sort(N+K)) I/Os, respectively.

Deformable spanners and applications

For a set S of points in R d , an s-spanner is a subgraph of the complete graph with node set S such that any pair of points is connected via some path in the spanner whose total length is at most s times the Euclidean distance between the points. In this paper we propose a new sparse ( 1 + ε ) -spanner with O ( n / ε d ) edges, where ε is a specified parameter. The key property of this spanner is that it can be efficiently maintained under dynamic insertion or deletion of points, as well as under continuous motion of the points in both the kinetic data structures setting and in the more realistic blackbox displacement model we introduce. Our deformable spanner succinctly encodes all proximity information in a deforming point cloud, giving us efficient kinetic algorithms for problems such as the closest pair, the near neighbors of all points, approximate nearest neighbor search (aka approximate Voronoi diagram), well-separated pair decompositions, and approximate k-centers.

Fast Construction of Nets in Low-Dimensional Metrics and Their Applications

We present a near linear time algorithm for constructing hierarchical nets in finite metric spaces with constant doubling dimension. This data-structure is then applied to obtain improved algorithms for the following problems: approximate nearest neighbor search, well-separated pair decomposition, spanner construction, compact representation scheme, doubling measure, and computation of the (approximate) Lipschitz constant of a function. In all cases, the running (preprocessing) time is near linear and the space being used is linear.

Well-Separated Pair Decomposition for the Unit-Disk Graph Metric and Its Applications

We extend the classic notion of well-separated pair decomposition [P. B. Callahan and S. R. Kosaraju, J. ACM, 42 (1975), pp. 67--90] to the unit-disk graph metric: the shortest path distance metric induced by the intersection graph of unit disks. We show that for the unit-disk graph metric of n points in the plane and for any constant $c\geq 1$, there exists a c-well-separated pair decomposition with O(n log n) pairs, and the decomposition can be computed in O(n log n) time. We also show that for the unit-ball graph metric in k dimensions where $k\geq 3$, there exists a c-well-separated pair decomposition with O(n2-2/k) pairs, and the bound is tight in the worst case. We present the application of the well-separated pair decomposition in obtaining efficient algorithms for approximating the diameter, closest pair, nearest neighbor, center, median, and stretch factor, all under the unit-disk graph metric.

Facility location and the geometric minimum-diameter spanning tree

Let P be a set of n points in the plane. The geometric minimum-diameter spanning tree (MDST) of P is a tree that spans P and minimizes the Euclidean length of the longest path. It is known that there is always a mono- or a dipolar MDST, i.e., a MDST with one or two nodes of degree greater 1, respectively. The more difficult dipolar case can so far only be solved in slightly subcubic time. This paper has two aims. First, we present a solution to a new data structure for facility location, the minimum-sum dipolar spanning tree (MSST), that mediates between the minimum-diameter dipolar spanning tree and the discrete two-center problem (2CP) in the following sense: find two centers p and q in P that minimize the sum of their distance plus the distance of any other point (client) to the closer center. This is of interest if the two centers do not only serve their customers (as in the case of the 2CP), but frequently have to exchange goods or personnel between themselves. We show that this problem can be solved in O( n 2log n) time and that it yields a factor-4/3 approximation of the MDST. Second, we give two fast approximation schemes for the MDST, i.e., factor-(1+ ε) approximation algorithms. One uses a grid and takes O ∗(E 6−1/3+n) time, where E=1/ ε and the O ∗ -notation hides terms of type O(log O(1) E). The other uses the well-separated pair decomposition and takes O( nE 3+ Enlog n) time. A combination of the two approaches runs in O ∗(E 5+n) time. Both schemes can also be applied to MSST and 2CP.

Fast Algorithms for Approximating Distances

In this paper we present efficient approximation algorithms for the distance selection problem. Our technique is based on the well-separated pair decomposition proposed in [8].

On plexus representation of dissimilarities

Correspondence analysis has found widespread application in analysing vegetation gradients. However, it is not clear how it is robust to situations where structures other than a simple gradient exist. The introduction of instrumental variables in canonical correspondence analysis does not avoid these difficulties. In this paper I propose to examine some simple methods based on the notion of the plexus (sensu McIntosh) where graphs or networks are used to display some of the structure of the data so that an informed choice of models is possible. I showthat two different classes of plexus model are available. These classes are distinguished by the use in one case of a global Euclidean model to obtain well-separated pair decomposition (WSPD) of a set of points which implicitly involves all dissimilarities, while in the other a Riemannian view is taken and emphasis is placed locally, i.e., on small dissimilarities. I showan example of each of these classes applied to vegetation data.