Dynamic Locality Sensitive Orderings in Doubling Metrics

TL;DR

This work delivers the first dynamic data-structure for maintaining a locality-sensitive ordering (LSO) with a constant-size-like primitive in doubling metrics by introducing a suite of tree-based tools. Central to the construction are pairwise index trees (PITs) and a dynamic pairwise tree cover that, when composed with a stabilized dynamic net-tree cover, yield stable DFS leaf orderings necessary for an LSO. The authors prove that dynamic updates decompose into a small number of stable operations on GT-like trees, enabling $O(\log n)$ per-update time for the dynamic LSO and $O(1)$ predecessor/successor queries per ordering. This dynamic LSO then underpins several algorithmic applications, including dynamic $k$-fault-tolerant spanners with optimal sparsity, and dynamic solutions for dynamic closest-pair, bichromatic closest-pair, and approximate nearest neighbor problems in doubling metrics. The framework thus recovers and extends the power of LSO for dynamic geometric problems in broader metric spaces, with potential for wide applicability in dynamic geometric data structures.

Abstract

In their pioneering work, Chan, Har-Peled, and Jones (SICOMP 2020) introduced locality-sensitive ordering (LSO), and constructed an LSO with a constant number of orderings for point sets in the $d$-dimensional Euclidean space. Furthermore, their LSO could be made dynamic effortlessly under point insertions and deletions, taking $O(\log{n})$ time per update by exploiting Euclidean geometry. Their LSO provides a powerful primitive to solve a host of geometric problems in both dynamic and static settings. Filtser and Le (STOC 2022) constructed the first LSO with a constant number of orderings in the more general setting of doubling metrics. However, their algorithm is inherently static since it relies on several sophisticated constructions in intermediate steps, none of which is known to have a dynamic version. Making their LSO dynamic would recover the full generality of LSO and provide a general tool to dynamize a vast number of static constructions in doubling metrics. In this work, we give a dynamic algorithm that has $O(\log{n})$ time per update to construct an LSO in doubling metrics under point insertions and deletions. We introduce a toolkit of several new data structures: a pairwise tree cover, a net tree cover, and a leaf tracker. A key technical is stabilizing the dynamic net tree of Cole and Gottlieb (STOC 2006), a central dynamic data structure in doubling metrics. Specifically, we show that every update to the dynamic net tree can be decomposed into a few simple updates to trees in the net tree cover. As stability is the key to any dynamic algorithm, our technique could be useful for other problems in doubling metrics. We obtain several algorithmic applications from our dynamic LSO. The most notably is the first dynamic algorithm for maintaining an $k$-fault tolerant spanner in doubling metrics with optimal sparsity in optimal $O(\log{n})$ time per update.

Figures (17)

• Figure 1: Data structures highlighted in light blue are static while those highlighted in light yellow are dynamic. Data structures with rectangular shapes are stable; others are unstable.
• Figure 2: A node $x$ in a PIT changes parent from $u$ to $v$ leads to changes in DFS leaf orderings of $v$ and its ancestors, and of $u$ and its ancestors. Rectangular nodes are active nodes, which either leaves corresponding to non-deleted points or internal nodes with at least one active descendant leaf.
• Figure 3: Illustrating a net tree $T$ (left), a PIT $T'$ derived from $T$ (right). We create $(x, y, i)$ by pairing up $(x, i-1)$ and $(y, i-1)$ in $T$, and this nodes is $O(\varepsilon)$-close to the pair $(x_0, y_0)$. The dashed arrows show corresponding single-label pairwise nodes, and the dot arrows show corresponding double-label pairwise nodes.
• Figure 4: Examples of red-blue graphs created from Step 1. The left figure is the net tree $T$, and the right figure includes $G_{i-1}$ and $G_i$. $G_i$ consists of solid edges and nodes; $G_{i-1}$ consists of dashed edges, and its vertex set includes dashed and solid nodes. The only blue edge in $G_i$ is $(x, y)$, while $G_{i-1}$ contains $(r, z)$ and $(r, t)$ as blue edges.
• Figure 5: Illustration for step 2 - creating pairwise nodes. Depending on matched edges in $G_i$ and pairwise nodes at level $i-1$, we have different structures of PITs, as shown in figures (a) and (b). Blue lines are matched edges, and bold blue nodes are pairwise nodes created from these edges. The filled nodes are pairwise nodes of unmatched points, and specifically, $(x, y, i)$ is the pairwise node of unmatched point $(z, i-1)$.

Theorems & Definitions (116)

• Definition 1: $(\tau, \varepsilon)$-LSO
• Definition 2: Dynamic LSO Data Structure
• Theorem 1
• Definition 3: Pairwise index tree (PIT)
• Definition 4: Pairwise tree cover
• Definition 5: Dynamic pairwise tree cover data structure
• Theorem 2
• Theorem 3
• Theorem 4
• Theorem 5