Dynamic Light Spanners in Doubling Metrics
Abstract
A -spanner of a point set in a metric space is a graph with vertex set such that, for any pair of points , the distance between and in is at most times . We study the problem of maintaining a spanner for a dynamic point set – that is, when undergoes a sequence of insertions and deletions – in a metric space of constant doubling dimension. For any constant , we maintain a -spanner of whose total weight remains within a constant factor of the weight of the minimum spanning tree of . Each update (insertion or deletion) can be performed in time, where denotes the aspect ratio of . Prior to our work, no efficient dynamic algorithm for maintaining a light-weight spanner was known even for point sets in low-dimensional Euclidean space.
Keywords and phrases:
Dynamic data structures, spanners, light-weight, Euclidean metrics, doubling metricsFunding:
Sujoy Bhore: Work supported in part by ANRF ARG-MATRICS, Grant 002465.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Computational geometry ; Theory of computation Routing and network design problemsEditors:
Hee-Kap Ahn, Michael Hoffmann, and Amir NayyeriSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Let be a set of points in the metric . A graph with vertex set is a geometric graph if the weight function on the edges is the distance function . In other words, the weight of each edge is the distance between its endpoints in . Observe that if is a geometric graph, then by the triangle inequality, for every , . Given a parameter , called the stretch, we say that is a (geometric) -spanner for if for every . The natural goal is to construct, for a given stretch , a -spanner with small number of edges and a small total weight.
Lightness and sparsity are two central measures for evaluating spanners. For a spanner , the lightness is the ratio between the total weight of and the weight of a minimum spanning tree on . The sparsity of is the ratio , comparing the number of edges of to that of an MST. Since every spanner (with finite stretch) is connected and therefore contains a spanning tree, the lightness and sparsity of constitute a measure of how close a spanner (specifically and ) to the optimal weight and the optimal number of edges of a spanner with finite stretch. A long line of research has studied spanners in Euclidean spaces [5, 49, 41, 29, 32, 14, 45], doubling [35, 21, 51, 36, 33, 19, 13], planar and minor-free metric [18, 39, 25, 12], and general graphs [48, 4, 30, 28, 24, 33, 44, 16]. Of particular interest, we focus on low-dimensional Euclidean space, and more generally on doubling metrics.
Doubling metrics.
Let be a ball of radius centered at a point . A metric has doubling dimension if for every , every ball of radius can be covered by at most balls of radius : . The study of spanners in doubling metrics was initiated by Gao, Guibas, and Nguyen [35], who proved that any -point set in a metric space of doubling dimension admits a -spanner with edges. Smid [51], via an analysis of the greedy algorithm, showed that greedy -spanners have edges and achieve lightness . While it has long been known that -dimensional Euclidean point sets admit -spanners with lightness , it remained a major open problem whether an analogous result holds for metric spaces of low doubling dimension. In a major breakthrough, Gottlieb [36] proved that any metric space of doubling dimension admits a -spanner with lightness . Gottlieb devised a complicated spanner construction instead of the classic greedy spanner. Later, Filtser and Solomon [33] showed that the greedy spanner is existentially optimal, concluding that it has lightness as well. Finally, Borradaile, Le, and Wulff-Nilsen [19] showed the greedy spanner has weight , which is optimal.
Dynamic Spanners.
The problem of maintaining a sparse -spanner for a point set under insertions and deletions has also been studied over the years. Already back in 1999, Arya et al. [6] obtained polylogarithmic update time in a restricted model with random updates (a deletion removes a uniformly random point from , and an insertion results in a uniformly random point in the updated set). Later, Bose et al. [20] studied the problem in the context of -graphs, and presented an algorithm that supports insertions only and achieves polylogarithmic update time. Gao et al. [35] studied kinetic and dynamic geometric spanners for points in bounded doubling dimensions, and obtained a fully dynamic spanner with worst-case update time , where is the aspect ratio of the point set , defined as the ratio between the maximum and minimum pairwise distances in . Krauthgamer and Lee [43] obtained similar results for proximity search, where the time bounds of their dynamic updates depend also in the aspect ratio. For proximity search, later, Cole and Gottlieb [26] removed the dependency on the aspect ratio. For the Euclidean plane, Abam et al. [1] presented an algorithm with update time. For doubling metrics, Roditty [50] presented the first fully dynamic algorithm for maintaining a geometric -spanner, with update time depending only on the number of points in . The algorithm obtained in [50] supports insertions in amortized time and deletions in amortized time where hides polylogarithmic factors, and maintains spanner with edges. Gotllieb and Roditty [37] gave a dynamic spanner that supports insertions in amortized time and deletions in amortized time. Later, in [38],111Gotllieb and Roditty [38] additionally assume that they can query the distance between a deleted point and a non-deleted point, which (for example) is possible for Euclidean metrics. they gave a -spanner of constant degree that supports updates in worst-case time.
Roughly speaking, these “classic” constructions of dynamic spanners for doubling metric are based on a net tree (see Section 2). While it is straightforward to construct a sparse spanner from a net tree, this tool is too rough to obtain lightness. Indeed, in Figure 1 we illustrate the net tree of the path graph, and show that it has lightness .
A more recent approach to constructing dynamic sparse spanners is using locality-sensitive orderings (LSO) (introduced by Chan, Har-Peled, and Jones [22]). In the full version of the paper, we summarize the history of LSO, and prove that LSO-based spanners have logarithmic lightness (even for ).
While there is a substantial body of work on dynamic spanners in Euclidean metrics and, more generally, in doubling metrics, as summarized above, there is comparatively little work on dynamic light spanners. Controlling lightness is arguably a significantly harder objective, as evidenced by the extensive literature in the offline setting (see, e.g., [45, 5, 49, 18, 44, 47, 13, 33, 36, 29, 14, 23] and the references therein).
Question 1.
Can we design a dynamic algorithm that maintains a light-weight spanner for a point set under dynamic updates in doubling metrics with polylogarithmic update time?
Partial progress toward Question 1 was made by Eppstein and Khodabandeh [31], who showed that one can maintain a low-recourse light spanner for dynamic point sets in low-dimensional Euclidean space. The recourse of a dynamic spanner is the number of edges that change after each insertion or deletion. They obtained a construction with amortized recourse per insertion and amortized recourse per deletion. However, their result addresses recourse rather than efficiency: the actual time to update the spanner can be very large (no faster than just recomputing a spanner from scratch), and therefore their work does not resolve the question of achieving polylogarithmic (or even sublinear) update time.
1.1 Our Contribution
We resolve Question 1 in the affirmative. We say a set of points is -bounded if and .
Theorem 2.
Let be a metric space with doubling dimension , and let and be parameters. Let be a set of points undergoing insertions and deletions, such that at all times is -bounded. We maintain a -spanner of with lightness at most , where each insertion/deletion to can be processed in time .
For the sake of simplicity, we state our theorem as though the maximum distance must be given in advance, and the minimum distance between points in must be at least 1. Using standard techniques [43, 31] we could remove these restrictions at no loss in the running time: we obtain a data structure whose update time depends adaptively on the aspect ratio of the current point set (see the full version of the paper). Additionally, we remark that we do not need to know the doubling dimension in advance; the value only appears in the runtime analysis.
Techniques.
Our proof begin somewhat similarly to Eppstein and Khodabandeh [31]: roughly speaking, we seek to maintain a greedy spanner on top of a dynamic sparse spanner of points (crucially, this spanner is much more structured than just the greedy spanner on the complete geometric graph on ). In Section 3, we first give a new (and arguably much simpler222We avoid the bucketing technique in the algorithm of [31] and instead work with all spanner edges at once; we maintain spanner invariants that work in doubling metrics and not just Euclidean metrics (unlike the leapfrog property used in [31]); and finally, we give a simple worst-case bound on the recourse of , rather than using a potential function to bound the amortized recourse.) algorithm and analysis that such a spanner can be maintained with bounded recourse. After each insertion/deletion, we identify edges of our greedy spanner which might have to change, to satisfy the greedy spanner invariants: roughly speaking, we examine the distance between and in the graph consisting of all of edges of that are shorter than 333Our description here assumes we want to maintain a greedy spanner, but actually we maintain a slightly more robust type of spanner which we call the delayed greedy spanner: we work with distances rather than , as defined in Section 2.2. We do this to control cascading changes to ., and we insert or delete to based on whether . Our key technical contribution (in Section 4) is to show that we can efficiently maintain estimates of even as we insert or delete edges into .
1.2 Related Work
Dynamic Graph Spanners.
In general graphs, the goal is to maintain, under edge updates, for any integer , a spanner with stretch and edges. Assuming the Erdős–Girth conjecture, this trade-off is essentially optimal. The dynamic spanner problem was initiated by Ausiello et al. [7], and has since been studied extensively; see, for example, [8, 17, 27, 10, 34]. However, these works focus primarily on sparsity, and the resulting techniques do not naturally extend to maintaining light spanners. Moreover, due to inherent degree barriers in general graphs, this line of work exclusively considers edge updates. In contrast, in geometric and other structured metric spaces, vertex updates are often the more natural model, since the underlying graph need not be maintained explicitly. This distinction is crucial for light spanners, whose construction and analysis rely fundamentally on geometric structure rather than purely combinatorial sparsification.
Online Spanners.
Spanners have also been studied extensively in the closely related online model. In this setting, points from a metric space arrive one by one, and at each step, the algorithm is given the subset of points that arrived so far. The goal is to maintain a -spanner at all times. Unlike in the fully dynamic setting, the algorithm is allowed to add edges when a new point arrives, but may never remove previously added edges. In addition, the total number of points is not known in advance. A number of algorithms and lower bounds have been obtained for this model, which addressed both sparsity and lightness guarantees along with stretch, under online constraints; see, e.g., [11, 15, 2, 3, 9, 40, 46]. These results achieve near-optimal trade-offs in the online regime and highlight the fundamental differences between incremental constructions and fully dynamic settings.
2 Net trees and greedy spanners
Preliminaries.
Throughout this paper, let be a metric space with constant doubling dimension . For any vertex and radius , we let denote the set of points within distance of ; that is, . If is a (geometric) graph, we use the notation to denote shortest-path distances on . For any positive integer , we write to mean . Throughout this paper, we fix some sufficiently small positive integer and aim to construct a light -spanner; our Theorem 2 will follow after rescaling .
2.1 Net-Tree Spanners
In this subsection, we review the classic net-tree spanner [35].
Net tree.
Let be a set of points. Assume that the smallest distance between points in is , and the largest distance is ; for simplicity we assume for some integer . A -net of is a set of points such that every point is within distance of some point in , and any two net points in are at distance greater than . A -net can be constructed greedily. A net hierarchy of is a hierarchical sequence of nets such that every is a subset of , and is a -net of ; we take . Observe that (by a geometric series) every point in is within distance of some net point in . Moreover, the packing bound of doubling metrics implies that there are not too many points close together in each -net.
Observation 3 (Packing bound).
Let be a set of points that are pairwise at distance at least . For any and , there are at most points in .
Net-tree spanner.
The net-tree spanner was introduced (under the name “deformable spanner”) by Gao, Guibas, and Nguyen [35]; similar ideas were independently designed by Krauthgamer and Lee [43]. The -net-tree spanner of with respect to the net tree is the graph with vertex set and with the following edge set: for every scale , add an edge between any two vertices if , where .
Lemma 4 ([35, Theorem 3.2]).
An -net-tree spanner of is a -spanner of .
For any pair of vertices , we say the scale of is the value such that . Observe that an edge at scale in an -net-tree spanner has both endpoints in the -net of the net tree (not the -net). The packing bound implies that every vertex in the -net-tree spanner has degree at most . In fact, using a charging argument, one can show that the -net-tree spanner contains at most edges: that is, it is sparse. We frequently denote the -net-tree spanner as .
Dynamic maintenance.
Gao, Guibas, and Nguyen [35] showed that the net tree spanner can be maintained dynamically. We summarize their guarantee below.
Lemma 5 (Rephrasing of [35, Theorem 4.2]).
There is a data structure that implicitly maintains a hierarchy of nets of a point set undergoing insertions and deletions. Each insertion or deletion can be processed in time. Moreover444Note that the phrasing of [35, Theorem 4.2] does not explicitly separate the maintenance of the net hierarchy from the maintenance of the spanner (they just state the existence of a dynamic spanner); however, our phrasing of Lemma 2.1 is immediate from their proof. In our application, we will need to dynamically maintain an -net-tree spanner of and an -net-tree spanner of (for two different values ) with respect to the same net tree . This is possible using the data structure of [35]., for any constant , one can maintain an -net-tree spanner of with respect to , in time per insertion or deletion.
We will make use of Lemma 2.1, but we will have to slightly unwrap the black box – we will need some control on how the net tree changes after each insertion or deletion. Fortunately, [35] update the net tree in a simple and structured way. Inserting a point into has the following result, described in Figure 2.
Deleting a point from is described in Figure 3.
We will not discuss the details of the data structures or algorithms that [35] use to implement these two operations efficiently. We have unwrapped the [35] black box so that we can prove that every insertion/deletion of a point only changes “locally” nearby .
Lemma 6.
Let be a net tree for point set . Let be the net tree produced from by the [35] algorithm after a point is inserted into (resp. deleted from) . For any scale , every point in the symmetric difference of and satisfies .
Proof.
When is inserted into (according to the pseudocode in Figure 2), the lemma follows trivially from the [35] algorithm description: the only point that could differ between and is . We now argue that the lemma holds when is deleted from (according to the pseudocode in Figure 3). By construction, the only point that could be removed from is ; that is, the set is either or . So it remains to show that every point in satisfies . The proof is by induction on . When , every point in is contained in , so and the claim holds trivially. Now consider . Consider some point . By the algorithm description, the point satisfies
There are two cases. In the first case, suppose . Because is a -net for , we have . We conclude that as desired. In the second case, suppose ; thus , and by induction we have that .
We need one more guarantee from [35] (see full paper for details).
Claim 7.
Consider the data structure of [35] that maintains a hierarchy of nets of and an -net-tree spanner. Let . Given a scale and a query point , one can find all vertices in in time .
2.2 Invariants for Our Light Spanner: Delayed Greedy Spanner
While the net-tree spanner is sparse and can be maintained dynamically, it could have lightness (see Figure 1). We aim to find a subgraph of with lightness. Intuitively, we want to maintain a greedy -spanner of the graph : the greedy spanner (and even the approximate greedy spanner) are light [19, 33]. Recall that the greedy spanner initializes and processes edges in from smallest to largest; when we process , we add to iff . In other words, the greedy spanner satisfies: for every edge in , letting denote the set of edges in with smaller555assume all edge lengths in are distinct, by breaking ties arbitrarily lengths than , we have iff .
Delayed greedy spanner.
We maintain a light spanner, denoted that doesn’t obey the greedy spanner invariants exactly; rather, we define a more robust set of invariants. For any scale , we define the set of edges to be the set of all edges in with scale strictly less than ; that is, every edge in has length at most . For any edge of the -net-tree spanner at scale , we define ; recall that denotes the shortest-path metric in the geometric graph induced by . To construct our light spanner, we maintain a subset of edges with the following properties:
Invariant 8.
Every edge satisfies .
Invariant 9.
Every edge satisfies .
If satisfies Invariants 8 and 9, we call a delayed greedy spanner of (because there is a delay between the time an edge is added to the spanner and the time it is taken into account when making the next decision). We emphasize that the delayed greedy spanner invariants are different than the greedy spanner invariants for : in our invariants, the choice of adding to the spanner depends on (the set of edges in with scale strictly smaller than the scale of ), rather than (the set of edges in the greedy spanner that are strictly shorter than ). Nevertheless, we show that any set of edges that satisfies Invariants 8 and 9 is a -spanner (Lemma 2.2) and has constant lightness (Lemma 2.2).
Lemma 10.
Let be an -net-tree spanner for , and let . If Invariant 8 holds, then is a -approximate spanner for .
Proof.
Proof.
We use, as a black box, the fact that the greedy -spanner in a metric space of doubling dimension has lightness [19]. We consider the shortest-path metric induced by the edges of ; because has doubling dimension , the stretch bound of Lemma 2.2 together with the definition of doubling dimension implies that the doubling dimension of is (see [33, Observation 7]). Consider building the greedy -spanner of : that is, we initialize , then iterate over the edges of from smallest to largest666by triangle inequality, it suffices to examine only the edges of when building the greedy spanner, rather than all pairs of vertices in , and add an edge into the spanner iff . The greedy spanner has lightness . We now charge every edge of to an edge of . If an edge is added to , then charge to itself. Otherwise, suppose is not added to . This means that there is a path between and in (at the instant that is considered) with length at most . Because is a geometric graph, ; i.e., has length at most . Let be the scale of , meaning that . The path contains some scale- edge in the greedy spanner : otherwise, if contained only scale- edges with , we would have , contradicting Invariant 9. Charge to the scale- edge .
We now claim that every edge in is charged at most times. Indeed, whenever a scale- edge is charged by a scale- edge , we have ; this is because, by definition of charging, lies on a path and with length at most . The packing bound (Observation 2.1) implies that there are only scale- edges that could charge . Because we only charge scale- edges in to scale- edges in , we conclude that is at most times heavier than , which is times heavier than the minimum spanning tree on .
3 Light Spanner with Worst-Case Recourse Bounds
We now describe how to maintain our light spanner , satisfying Invariants 8 and 9. The current section focuses on describing a spanner with a small recourse bound, and proving that our updates maintain Invariants 8 and 9. In Section 4, we explain how to perform these updates quickly. We maintain a data structure DS. It stores:
-
a set of points
-
a net-tree on the points
-
an -net-tree spanner of with respect to
All these variables are initialized as . The data structure supports two operations – insertion and deletion of a point . We say that a procedure correctly implements insertion of point if the procedure assigns and updates , , and to satisfy the descriptions above. Similarly, a procedure correctly implement deletion of a point if it assigns and updates , , and .
3.1 Insertion
To insert a point , we first update the net-tree according to [35] (as summarized in our Lemma 2.1) and then recompute the spanner edges nearby to satisfy the invariants. The pseudocode is given below. Our key insight is that when we recompute spanner edges at level , we only need to recompute edges with endpoints in .
Lemma 12.
The procedure correctly implements the insertion of a point .
Proof.
Let , , , and denote , , , and (respectively) before the insertion process. For brevity, we write , , , and instead of , , , and . By Lemma 2.1, the variables , and are correctly maintained. Moreover, we have that , because (by description of the algorithm) and (by assumption) .
It remains to show that that every edge in satisfies Invariants 8 and 9. Suppose that edge is at scale (that is, ). Note that the distance depends only on the edges in with scale strictly less than ; thus, it suffices to show that satisfies the two invariants at the moment after the for-loop processes scale . If , then satisfies the two invariants by description of the algorithm. Now suppose that some endpoint, without loss of generality , is not in . In this case, is in if and only if is in . There are two cases:
-
Suppose that is not in . Thus is not in . To satisfy Invariant 8, we must show . In fact, we show that either or ; see Figure 4. This suffices, as satisfies Invariant 8: we conclude that as desired. Consider a shortest path in between and . The description of the algorithm implies that the only edges that that change between and are in the ball . Because we assumed , triangle inequality implies that endpoints of any edge in are far from : specifically, , and so . If has length then we are done; otherwise, does not include any edges in , and so is also a path in as desired.
Figure 4: A light spanner . For a given scale , the spanners and differ only within the ball . A scale- pair outside of . A short path between and in does not wander inside , so is also in . -
Suppose is in . Thus is in . To satisfy Invariant 9, we must show that . We claim that either , or . This suffices to prove the claim, because satisfies Invariant 9 and so ; thus, in either case, . Let be a shortest path between and in . If then we are done. Otherwise, if , then must contain some edge of that is not in . But the description of the algorithm implies that any such edge has endpoints in . By triangle inequality and our assumption that , we have , and so has length at least as desired.
We remark that the Insert procedure has bounded recourse: at most edges change in the spanner . This is because, for every scale , there are at most scale- edges in the -net-tree spanner in , by definition of net-tree spanner and packing bound (Observation 2.1).
3.2 Deletion
The procedure for deleting a point is similar to insertion. The procedure first updates the net tree according to [35], then deletes all edges in that were incident to , and finally recompute the spanner edges nearby using the procedure. The pseudocode and analysis are fairly similar to insertion procedure (albeit slightly more complicated). We defer all details to the full version of the paper.
Lemma 13.
The procedure correctly implements the deletion of a point .
We pause to remark that in our proof of Lemma 3.1 (and also Lemma 3.2), we have actually proved the following claim, which will be helpful later.
Lemma 14.
Consider the data structure DS before and after running or . Let (resp. ) denote (resp. ) before the insertion/deletion is performed. Let be a scale- edge in , with some endpoint outside of . Then is an edge in , and either (1) , or (2) both and are larger than .
4 Implementing Updates Quickly
In this section, we show how to modify the data structure so that the and procedures can be executed quickly. By prior work on the net-tree spanner (Lemma 2.1), the net-tree and the -net-tree spanner can be maintained in time. The procedure iterates over each of the scales. For each scale , it examines the many scale- edges in ; by Claim 2.1 these edges can be found in time. Each examined edge is added or removed from depending on . This means that the bottleneck for a fast update time is the computation of :
Lemma 15.
The procedure and run in time, plus the time needed for many computations of .
Unfortunately, we don’t know how to design a data structure that maintains these distances. To get around this, we first observe that it suffices to maintain an approximation for .
Definition 16.
We say a value is an -approximation for a value if . For any function on pairs of points (we will take and ), we say that is a coarse -approximation for if:
In other words, a coarse -approximation for lets us either detect when is very large or provides an -approximation for . Throughout this section, we set . As we show in Lemma 4, even if we used coarse -approximations instead of the real distances in the procedure, our spanner still satisfies Invariants 8 and 9 after the DS.Insert and DS.Delete procedures.
Augmenting the data structure with distance estimates.
We now show that we can modify our data structure to efficiently maintain coarse -approximations of for every edge in the -net-tree . In fact, we maintain something stronger: we need to store several auxiliary values in order to maintain the coarse approximations. Let be a sufficiently large constant, and let . Our data structure DS maintains (in addition to the points , the net-tree , the -net-tree spanner , and the light spanner ) the following objects:
-
An -net tree spanner for
-
For every scale and every edge in at scale , a value which is a coarse -approximation for .
-
For every scale and every edge in at scale , a value which is a -approximation for .
Observe that this data structure does indeed maintain a coarse -approximation for every edge in : this is because , and so the estimates are coarse -approximations for . The reason we maintain estimates for every edge in and not just every edge in is to control the distortion, which will accumulate by a factor at each scale.
We highlight two differences between the estimates and , for a scale- edge . First, the value seeks to estimate , which is the distance between and in the subgraph which consists of all edges in with scale strictly smaller than . On the other hand, estimates distances in the graph ; note that the shortest path between and in may include edges in at scale and , in addition to edges in . The second key difference is that is only required to be a -approximation of when , whereas is always a -approximation of . Why do we need these two types of estimates? Ultimately, our algorithm for Insert and Delete will only use the estimates , to determine whether or not the edge should be added. But in order to compute for some pair at scale , we will need to estimate for pairs at scale .
The fast insert/delete procedures.
Below, we give pseudocode for a modified procedure called , which uses the estimates instead of the true distances . We define the procedures and to be identical to and , except that they use instead of , and they also maintain a -net-tree spanner in addition to the -net-tree spanner .
In Section 4.1, we describe the procedure DS.UpdateDistEstimates and prove that it correctly maintains estimates for and . For now, we just state lemmas which summarize the guarantees of DS.UpdateDistEstimates (Lemmas 4 and 4). Assuming the lemmas hold, we prove the correctness of the fast insert/delete procedures (Lemma 4).
Lemma 17.
runs in time .
Lemma 18.
Consider the execution of or . Let be a scale, and consider the data structure DS at the instant after the execution of the call during the insertion/deletion process. Assume that every edge of with scale strictly smaller than satisfies Invariants 8 and 9. Then:
-
for every scale- edge in the -net-tree spanner , the value is a coarse -approximation for .
-
for every scale- edge in the -net-tree spanner , the value is a -approximation .
Lemma 19.
The procedure (resp. ) correctly implements insertion (resp. deletion) of . It runs in time .
Proof.
The runtime bound follows from Lemmas 4 and 4. The proof of correctness is almost identical to that of Lemmas 3.1 and 3.2 except in one place: we need to argue that every scale- edge in with both endpoints in satisfies Invariants 8 and 9.
For every such edge , the algorithm checks if and includes in iff the inequality holds. At the instant the algorithm makes the check, we may assume (by induction) that every edge in with scale strictly smaller than satisfies Invariants 8 and 9. Thus, by Lemma 4, the value of is a coarse -approximation for . As , in particular we conclude that is a coarse -approximation for . There are two cases.
Case 1: .
In this case, is not in . We claim that , so that satisfies Invariant 8. Indeed, we have ; otherwise, the definition of coarse -approximation means that , which contradicts our assumption that . Thus, the definition of coarse -approximation implies and so as desired.
Case 2: .
In this case, is added to . We claim that , so that satisfies Invariant 9. For contradiction, suppose that . The definition of coarse -approximation implies . Combining these two inequalities, we conclude that contradicting the Case 2 assumption. Theorem 2 follows from Lemmas 4, 2.2, and 2.2 (after rescaling ).
4.1 The procedure UpdateDistEstimates
We defer the details of UpdateDistEstimates to the full version of our paper.
5 Conclusion and Open Questions
We have designed the first dynamic light spanner for point sets in Euclidean and doubling metrics, with update time . Our work leaves open two interesting open questions. First, is it possible to maintain a dynamic light spanner with recourse or time bounds independent of the aspect ratio and instead depends only on the number of points ? Second, can we obtain a runtime bound where the exponent of (or ) is independent of ? Ideally, we would like to handle updates in time , which would match the best runtime for dynamic sparse spanners.
References
- [1] Mohammad Ali Abam, Mark de Berg, and Joachim Gudmundsson. A simple and efficient kinetic spanner. In Proceedings of the twenty-fourth annual symposium on Computational geometry, pages 306–310, 2008. doi:10.1145/1377676.1377729.
- [2] Noga Alon, Baruch Awerbuch, Yossi Azar, Niv Buchbinder, and Joseph Naor. A general approach to online network optimization problems. ACM Trans. Algorithms, 2(4):640–660, 2006. doi:10.1145/1198513.1198522.
- [3] Noga Alon and Yossi Azar. On-line steiner trees in the euclidean plane. In David Avis, editor, Proceedings of the Eighth Annual Symposium on Computational Geometry, Berlin, Germany, June 10-12, 1992, pages 337–343. ACM, 1992. doi:10.1145/142675.142744.
- [4] Ingo Althöfer, Gautam Das, David Dobkin, Deborah Joseph, and José Soares. On sparse spanners of weighted graphs. Discrete & Computational Geometry, 9(1):81–100, 1993. doi:10.1007/BF02189308.
- [5] Sunil Arya, Gautam Das, David M Mount, Jeffrey S Salowe, and Michiel Smid. Euclidean spanners: short, thin, and lanky. In Proceedings of the twenty-seventh annual ACM symposium on Theory of computing, pages 489–498, 1995. doi:10.1145/225058.225191.
- [6] Sunil Arya, David M Mount, and Michiel Smid. Dynamic algorithms for geometric spanners of small diameter: Randomized solutions. Computational Geometry, 13(2):91–107, 1999. doi:10.1016/S0925-7721(99)00014-0.
- [7] Giorgio Ausiello, Paolo G Franciosa, and Giuseppe F Italiano. Small stretch spanners on dynamic graphs. In Gerth Stølting Brodal and Stefano Leonardi, editors, 13th Annual European Symposium (ESA 2005), volume 3669 of Lecture Notes in Computer Science, pages 532–543. Springer, Springer, 2005. doi:10.1007/11561071_48.
- [8] Surender Baswana, Sumeet Khurana, and Soumojit Sarkar. Fully dynamic randomized algorithms for graph spanners. ACM Transactions on Algorithms (TALG), 8(4):1–51, 2012. doi:10.1145/2344422.2344425.
- [9] Piotr Berman and Chris Coulston. On-line algorithms for steiner tree problems (extended abstract). In Proceedings of the Twenty-Ninth Annual ACM Symposium on the Theory of Computing, El Paso, Texas, USA, May 4-6, 1997, pages 344–353. ACM, 1997. doi:10.1145/258533.258618.
- [10] Aaron Bernstein, Sebastian Forster, and Monika Henzinger. A deamortization approach for dynamic spanner and dynamic maximal matching. ACM Transactions on Algorithms (TALG), 17(4):1–51, 2021. doi:10.1145/3469833.
- [11] Sujoy Bhore, Arnold Filtser, Hadi Khodabandeh, and Csaba D. Tóth. Online spanners in metric spaces. SIAM J. Discret. Math., 38(1):1030–1056, 2024. doi:10.1137/22m1534572.
- [12] Sujoy Bhore, Balázs Keszegh, Andrey Kupavskii, Hung Le, Alexandre Louvet, Dömötör Pálvölgyi, and Csaba D. Tóth. Spanners in planar domains via steiner spanners and non-steiner tree covers. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4292–4326. SIAM, 2025. doi:10.1137/1.9781611978322.145.
- [13] Sujoy Bhore and Lazar Milenkovic. Light spanners with small hop-diameter. In 52nd International Colloquium on Automata, Languages, and Programming, ICALP 2025, Aarhus, Denmark, July 8-11, 2025, volume 334 of LIPIcs, pages 30:1–30:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPIcs.ICALP.2025.30.
- [14] Sujoy Bhore and Csaba D. Tóth. Euclidean steiner spanners: Light and sparse. SIAM J. Discret. Math., 36(3):2411–2444, 2022. doi:10.1137/22m1502707.
- [15] Sujoy Bhore and Csaba D. Tóth. Online euclidean spanners. ACM Trans. Algorithms, 21(1):5:1–5:22, 2025. doi:10.1145/3681790.
- [16] Greg Bodwin. An alternate proof of near-optimal light spanners. In Merav Parter and Seth Pettie, editors, 2024 Symposium on Simplicity in Algorithms, SOSA 2024, Alexandria, VA, USA, January 8-10, 2024, pages 39–55. SIAM, 2024. doi:10.1137/1.9781611977936.5.
- [17] Greg Bodwin and Sebastian Krinninger. Fully dynamic spanners with worst-case update time. In Piotr Sankowski and Christos D. Zaroliagis, editors, 24th Annual European Symposium on Algorithms (ESA 2016), volume 57 of LIPIcs, pages 17:1–17:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPIcs.ESA.2016.17.
- [18] Glencora Borradaile, Hung Le, and Christian Wulff-Nilsen. Minor-free graphs have light spanners. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 767–778. IEEE, 2017. doi:10.1109/FOCS.2017.76.
- [19] Glencora Borradaile, Hung Le, and Christian Wulff-Nilsen. Greedy spanners are optimal in doubling metrics. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2371–2379. SIAM, 2019. doi:10.1137/1.9781611975482.145.
- [20] Prosenjit Bose, Joachim Gudmundsson, and Pat Morin. Ordered theta graphs. Computational Geometry, 28(1):11–18, 2004. doi:10.1016/J.COMGEO.2004.01.003.
- [21] T-H Hubert Chan and Anupam Gupta. Small hop-diameter sparse spanners for doubling metrics. Discrete & Computational Geometry, 41(1):28–44, 2009. doi:10.1007/S00454-008-9115-5.
- [22] Timothy M Chan, Sariel Har-Peled, and Mitchell Jones. On locality-sensitive orderings and their applications. SIAM Journal on Computing, 49(3):583–600, 2020. doi:10.1137/19M1246493.
- [23] Hsien-Chih Chang, Jonathan Conroy, Hung Le, Shay Solomon, and Cuong Than. Light tree covers, routing, and path-reporting oracles via spanning tree covers in doubling graphs. In STOC’25—Proceedings of the 57th Annual ACM Symposium on Theory of Computing, pages 2257–2268. ACM, 2025. doi:10.1145/3717823.3718312.
- [24] Shiri Chechik and Christian Wulff-Nilsen. Near-optimal light spanners. ACM Transactions on Algorithms (TALG), 14(3):1–15, 2018. doi:10.1145/3199607.
- [25] Vincent Cohen-Addad, Arnold Filtser, Philip N Klein, and Hung Le. On light spanners, low-treewidth embeddings and efficient traversing in minor-free graphs. In 2020 IEEE 61st Annual Symposium on Foundations of Computer Science (FOCS), pages 589–600. IEEE, 2020. doi:10.1109/FOCS46700.2020.00061.
- [26] Richard Cole and Lee-Ad Gottlieb. Searching dynamic point sets in spaces with bounded doubling dimension. In Proceedings of the thirty-eighth annual ACM symposium on Theory of computing, pages 574–583, 2006. doi:10.1145/1132516.1132599.
- [27] Michael Elkin. Streaming and fully dynamic centralized algorithms for constructing and maintaining sparse spanners. ACM Transactions on Algorithms (TALG), 7(2):1–17, 2011. doi:10.1145/1921659.1921666.
- [28] Michael Elkin, Ofer Neiman, and Shay Solomon. Light spanners. SIAM J. Discret. Math., 29(3):1312–1321, 2015. doi:10.1137/140979538.
- [29] Michael Elkin and Shay Solomon. Steiner shallow-light trees are exponentially lighter than spanning ones. SIAM J. Comput., 44(4):996–1025, 2015. doi:10.1137/13094791X.
- [30] Michael Elkin and Shay Solomon. Fast constructions of lightweight spanners for general graphs. ACM Trans. Algorithms, 12(3):29:1–29:21, 2016. doi:10.1145/2836167.
- [31] David Eppstein and Hadi Khodabandeh. Maintaining light spanners via minimal updates. In Proceedings of the 36th Canadian Conference on Computational Geometry (CCCG), pages 1–15, 2024.
- [32] Arnold Filtser and Ofer Neiman. Light spanners for high dimensional norms via stochastic decompositions. Algorithmica, 84(10):2987–3007, 2022. doi:10.1007/s00453-022-00994-0.
- [33] Arnold Filtser and Shay Solomon. The greedy spanner is existentially optimal. SIAM J. Comput., 49(2):429–447, 2020. doi:10.1137/18M1210678.
- [34] Sebastian Forster and Gramoz Goranci. Dynamic low-stretch trees via dynamic low-diameter decompositions. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, pages 377–388, 2019. doi:10.1145/3313276.3316381.
- [35] Jie Gao, Leonidas J. Guibas, and An Thai Nguyen. Deformable spanners and applications. Comput. Geom., 35(1-2):2–19, 2006. doi:10.1016/j.comgeo.2005.10.001.
- [36] Lee-Ad Gottlieb. A light metric spanner. In 2015 IEEE 56th Annual Symposium on Foundations of Computer Science, pages 759–772. IEEE, 2015. doi:10.1109/FOCS.2015.52.
- [37] Lee-Ad Gottlieb and Liam Roditty. Improved algorithms for fully dynamic geometric spanners and geometric routing. In Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2008, San Francisco, California, USA, January 20-22, 2008, pages 591–600. SIAM, 2008. URL: http://dl.acm.org/citation.cfm?id=1347082.1347148.
- [38] Lee-Ad Gottlieb and Liam Roditty. An optimal dynamic spanner for doubling metric spaces. In European Symposium on Algorithms, pages 478–489. Springer, 2008. doi:10.1007/978-3-540-87744-8_40.
- [39] Michelangelo Grigni and Papa Sissokho. Light spanners and approximate tsp in weighted graphs with forbidden minors. In SODA, volume 2, pages 852–857, 2002. URL: http://dl.acm.org/citation.cfm?id=545381.545492.
- [40] MohammadTaghi Hajiaghayi, Vahid Liaghat, and Debmalya Panigrahi. Online node-weighted steiner forest and extensions via disk paintings. SIAM J. Comput., 46(3):911–935, 2017. doi:10.1137/14098692X.
- [41] Sariel Har-Peled, Piotr Indyk, and Anastasios Sidiropoulos. Euclidean spanners in high dimensions. In Sanjeev Khanna, editor, Proceedings of the Twenty-Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2013, New Orleans, Louisiana, USA, January 6-8, 2013, pages 804–809. SIAM, 2013. doi:10.1137/1.9781611973105.57.
- [42] Sariel Har-Peled and Manor Mendel. Fast construction of nets in low-dimensional metrics and their applications. SIAM J. Comput., 35(5):1148–1184, 2006. doi:10.1137/S0097539704446281.
- [43] Robert Krauthgamer and James R. Lee. Navigating nets: simple algorithms for proximity search. In Proceedings of the Fifteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 798–807. ACM, New York, 2004. URL: http://dl.acm.org/citation.cfm?id=982792.982913.
- [44] Hung Le and Shay Solomon. A unified framework for light spanners. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 295–308. ACM, 2023. doi:10.1145/3564246.3585185.
- [45] Hung Le and Shay Solomon. Truly optimal euclidean spanners. SIAM J. Comput., 54(4):S19–135, 2025. doi:10.1137/20m1317906.
- [46] Joseph Naor, Debmalya Panigrahi, and Mohit Singh. Online node-weighted steiner tree and related problems. In IEEE 52nd Annual Symposium on Foundations of Computer Science, (FOCS), pages 210–219. IEEE Computer Society, 2011. doi:10.1109/FOCS.2011.65.
- [47] Giri Narasimhan and Michiel Smid. Geometric spanner networks. Cambridge University Press, Cambridge, 2007. doi:10.1017/CBO9780511546884.
- [48] David Peleg and Alejandro A Schäffer. Graph spanners. Journal of graph theory, 13(1):99–116, 1989. doi:10.1002/JGT.3190130114.
- [49] Satish Rao and Warren D. Smith. Approximating geometrical graphs via “spanners” and “banyans”. In Proceedings of the Thirtieth Annual ACM Symposium on the Theory of Computing, Dallas, Texas, USA, May 23-26, 1998, pages 540–550. ACM, 1998. doi:10.1145/276698.276868.
- [50] Liam Roditty. Fully dynamic geometric spanners. Algorithmica, 62(3):1073–1087, 2012. doi:10.1007/S00453-011-9504-7.
- [51] Michiel HM Smid. The weak gap property in metric spaces of bounded doubling dimension. Efficient Algorithms, 5760:275–289, 2009. doi:10.1007/978-3-642-03456-5_19.
