Abstract 1 Introduction 2 Net trees and greedy spanners 3 Light Spanner with Worst-Case Recourse Bounds 4 Implementing Updates Quickly 5 Conclusion and Open Questions References

Dynamic Light Spanners in Doubling Metrics

Sujoy Bhore ORCID Department of Computer Science & Engineering, Indian Institute of Technology Bombay, India    Jonathan Conroy ORCID Department of Computer Science, Dartmouth College, Hanover, NH, USA    Arnold Filtser ORCID Department of Computer Science, Bar-Ilan University, Ramat Gan, Israel
Abstract

A t-spanner of a point set X in a metric space (𝒳,δ) is a graph G with vertex set P such that, for any pair of points u,vX, the distance between u and v in G is at most t times δ(u,v). We study the problem of maintaining a spanner for a dynamic point set X – that is, when X undergoes a sequence of insertions and deletions – in a metric space of constant doubling dimension. For any constant ε>0, we maintain a (1+ε)-spanner of P whose total weight remains within a constant factor of the weight of the minimum spanning tree of X. Each update (insertion or deletion) can be performed in poly(logΦ) time, where Φ denotes the aspect ratio of X. 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 metrics
Funding:
Sujoy Bhore: Work supported in part by ANRF ARG-MATRICS, Grant 002465.
Jonathan Conroy: Supported in part by U.S. National Science Foundation Grant No. CCF-2443017.
Arnold Filtser: This research was supported by the ISRAEL SCIENCE FOUNDATION (grant No. 1042/22).
Copyright and License:
[Uncaptioned image] © Sujoy Bhore, Jonathan Conroy, and Arnold Filtser; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Computational geometry
; Theory of computation Routing and network design problems
Related Version:
Full Version: https://arxiv.org/abs/2603.23490
Editors:
Hee-Kap Ahn, Michael Hoffmann, and Amir Nayyeri

1 Introduction

Let X𝒳 be a set of points in the metric (𝒳,δX). A graph G=(X,E,δ) with vertex set X 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 G is a geometric graph, then by the triangle inequality, for every x,yX, δG(x,y)δ(x,y). Given a parameter t, called the stretch, we say that G is a (geometric) t-spanner for X if δG(x,y)tδ(x,y) for every x,yX. The natural goal is to construct, for a given stretch t, a t-spanner with small number of edges and a small total weight.

Lightness and sparsity are two central measures for evaluating spanners. For a spanner G=(X,E), the lightness is the ratio w(G)/w(MST) between the total weight of G and the weight of a minimum spanning tree on X. The sparsity of G is the ratio |E(G)|/|E(MST)||E(G)|/|X|, comparing the number of edges of G to that of an MST. Since every spanner (with finite stretch) is connected and therefore contains a spanning tree, the lightness and sparsity of G constitute a measure of how close a spanner (specifically w(G) and |E(G)|) 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 B(x,r)={y|δ(x,y)r} be a ball of radius r0 centered at a point x𝒳. A metric (𝒳,δ) has doubling dimension d if for every r>0, every ball of radius r can be covered by at most 2d balls of radius r/2: xX,r>0,YX:|Y|2d and BX(x,r)yYBX(y,r/2). The study of spanners in doubling metrics was initiated by Gao, Guibas, and Nguyen [35], who proved that any n-point set in a metric space of doubling dimension d admits a (1+ε)-spanner with εO(d)n edges. Smid [51], via an analysis of the greedy algorithm, showed that greedy (1+ε)-spanners have εO(d)n edges and achieve lightness εO(d)logn. While it has long been known that d-dimensional Euclidean point sets admit (1+ε)-spanners with lightness εO(d), 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 d admits a (1+ε)-spanner with lightness (d/ε)O(d). 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 (d/ε)O(d) as well. Finally, Borradaile, Le, and Wulff-Nilsen [19] showed the greedy spanner has weight εO(d), which is optimal.

Dynamic Spanners.

The problem of maintaining a sparse (1+ε)-spanner for a point set X 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 S, 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 O(logΦ), where Φ is the aspect ratio of the point set X, defined as the ratio between the maximum and minimum pairwise distances in X. 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 O(logn) update time. For doubling metrics, Roditty [50] presented the first fully dynamic algorithm for maintaining a geometric (1+ε)-spanner, with update time depending only on the number of points in X. The algorithm obtained in [50] supports insertions in amortized O(logn) time and deletions in amortized O~(n1/3) time where O~ hides polylogarithmic factors, and maintains spanner with O(n/εd) edges. Gotllieb and Roditty [37] gave a dynamic spanner that supports insertions in O(εO(d)log2n) amortized time and deletions in O(εO(d)log3n) 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 (1+ε)-spanner of constant degree that supports updates in εO(d)logn 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 Ω(logn).

Figure 1: On bottom: The path graph Pn. All edges are unit weight. On top: a depiction of the net tree T of Pn. There is a laminar hierarchy of nets; the 2i-net is Ni={vjPnjmod2i=0} (all vertices at hight i in the tree and above). The net-tree spanner contains all the tree edges, and many additional edges. The weight of the edge {vi,vj} is |ij|. The tree T has depth logn, and the total weight of the edges going from depth i vertices to depth i+1 is Θ(n). Thus w(T)=Θ(nlogn). As the weight of the MST of Pn is n1, the net-tree spanner has lightness Ω(logn).

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 1).

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 O(1) recourse per insertion and amortized O(logΦ) 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 X is (a,b)-bounded if minu,vXδ(u,v)a and maxu,vXδ(u,v)b.

Theorem 2.

Let (𝒳,δ) be a metric space with doubling dimension d, and let ε>0 and Φ>0 be parameters. Let X𝒳 be a set of points undergoing insertions and deletions, such that at all times X is (1,Φ)-bounded. We maintain a (1+ε)-spanner L of X with lightness at most εO(d), where each insertion/deletion to X can be processed in time (ε1logΦ)O(d).

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 X 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 X (see the full version of the paper). Additionally, we remark that we do not need to know the doubling dimension d in advance; the value d 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 X (crucially, this spanner is much more structured than just the greedy spanner on the complete geometric graph on X). 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 O(logΦ), 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 O(logΦ) edges (u,v) of our greedy spanner L which might have to change, to satisfy the greedy spanner invariants: roughly speaking, we examine the distance δL<(u,v) between u and v in the graph consisting of all of edges of L that are shorter than (u,v)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 δ(u,v) rather than δL<(u,v), as defined in Section 2.2. We do this to control cascading changes to L., and we insert or delete (u,v) to L based on whether δL<(u,v)(1+ε)δ(u,v). Our key technical contribution (in Section 4) is to show that we can efficiently maintain estimates of δL<(u,v) even as we insert or delete edges into L.

1.2 Related Work

Dynamic Graph Spanners.

In general graphs, the goal is to maintain, under edge updates, for any integer k2, a spanner with stretch 2k1 and O~(n1+1/k) 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 t-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 n 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 M=(𝒳,δ) be a metric space with constant doubling dimension d=O(1). For any vertex x𝒳 and radius r>0, we let B(x,r) denote the set of points within distance r of x; that is, B(x,r){y𝒳:δ(x,y)r}. If G is a (geometric) graph, we use the notation δG(,) to denote shortest-path distances on G. For any positive integer n, we write [n] to mean {i:0in}. Throughout this paper, we fix some sufficiently small positive integer ε>0 and aim to construct a light (1+O(ε))-spanner; our Theorem 2 will follow after rescaling εε/O(1).

2.1 Net-Tree Spanners

In this subsection, we review the classic net-tree spanner [35].

Net tree.

Let X𝒳 be a set of points. Assume that the smallest distance between points in X is 1, and the largest distance is Φ; for simplicity we assume Φ=2i for some integer i. A Δ-net of X is a set of points N such that every point xX is within distance Δ of some point in N, and any two net points in N are at distance greater than Δ. A Δ-net can be constructed greedily. A net hierarchy of X is a hierarchical sequence of nets (N0,N1,,NlogΦ) such that every Ni is a subset of Ni1, and Ni is a 2i-net of Ni1; we take N0=X. Observe that (by a geometric series) every point in X is within distance 2i+1 of some net point in Ni. 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 N be a set of points that are pairwise at distance at least Δ. For any α1 and x𝒳, there are at most αO(d) points in B(x,αΔ)N.

An implicit representation of the net hierarchy 𝒩 can be maintained using a data structure called the net tree [35, 43, 42]. We will sometimes abuse terminology and call 𝒩 a net tree.

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 X with respect to the net tree 𝒩=(N0,,NlogΦ) is the graph with vertex set X and with the following edge set: for every scale i[logΦ], add an edge between any two vertices u,vNi if δ(u,v)c2i, where c4+16ε1.

Lemma 4 ([35, Theorem 3.2]).

An ε-net-tree spanner of X is a (1+ε)-spanner of X.

For any pair of vertices (u,v), we say the scale of (u,v) is the value i such that δ(u,v)[2i1,2i). Observe that an edge (u,v) at scale i in an ε-net-tree spanner has both endpoints in the O(ε)2i-net of the net tree (not the 2i-net). The packing bound implies that every vertex in the ε-net-tree spanner has degree at most εO(d)logΦ. In fact, using a charging argument, one can show that the ε-net-tree spanner contains at most εO(d)n edges: that is, it is sparse. We frequently denote the ε-net-tree spanner as S.

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 𝒩=(N0,N1,,NlogΦ) of a point set X undergoing insertions and deletions. Each insertion or deletion can be processed in O(logΦ) 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 ε1-net-tree spanner of X and an ε2-net-tree spanner of X (for two different values ε1ε2) with respect to the same net tree 𝒩. This is possible using the data structure of [35]., for any constant ε>0, one can maintain an ε-net-tree spanner of X with respect to 𝒩, in O(logΦ) 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 x into X has the following result, described in Figure 2.

Figure 2: Pseudocode for [35] algorithm to update net 𝒩 after inserting point x into X.

Deleting a point x from X is described in Figure 3.

Figure 3: Pseudocode for [35] algorithm to update net 𝒩 after deleting point x from X.

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 x only changes 𝒩 “locally” nearby x.

Lemma 6.

Let 𝒩old=(N0old,,𝒩logΦold) be a net tree for point set X. Let 𝒩=(N0,,NlogΦ) be the net tree produced from 𝒩old by the [35] algorithm after a point x is inserted into (resp. deleted from) X. For any scale i[logΦ], every point y in the symmetric difference of Ni and Niold satisfies δ(y,x)2i.

Proof.

When x is inserted into X (according to the pseudocode in Figure 2), the lemma follows trivially from the [35] algorithm description: the only point that could differ between Ni and Niold is x. We now argue that the lemma holds when x is deleted from X (according to the pseudocode in Figure 3). By construction, the only point that could be removed from Niold is x; that is, the set NioldNi is either or {x}. So it remains to show that every point y in NiNiold satisfies δ(y,x)2i. The proof is by induction on i. When i=0, every point in DS.X is contained in N0old, so N0N0old= and the claim holds trivially. Now consider i>0. Consider some point yNiNiold. By the algorithm description, the point y satisfies

δ(y,Niold{x})>2i.

There are two cases. In the first case, suppose yNi1old. Because Niold is a 2i-net for Ni1old, we have δ(y,Niold)2i. We conclude that δ(y,x)2i as desired. In the second case, suppose yNi1old; thus yNi1Ni1old, and by induction we have that δ(y,x)2i1<2i.

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 (N0,N1,,NlogΦ) of X and an ε-net-tree spanner. Let cε=4+16ε1. Given a scale i[logΦ] and a query point x𝒳, one can find all vertices in NiB(x,100cε2i) in time εO(d)=O(1).

2.2 Invariants for Our Light Spanner: Delayed Greedy Spanner

While the net-tree spanner S is sparse and can be maintained dynamically, it could have lightness Ω(logn) (see Figure 1). We aim to find a subgraph of S with O(1) lightness. Intuitively, we want to maintain a greedy (1+ε)-spanner H of the graph S: the greedy spanner (and even the approximate greedy spanner) are light [19, 33]. Recall that the greedy spanner initializes H and processes edges in S from smallest to largest; when we process (u,v), we add (u,v) to H iff δH(u,v)>(1+ε)δS(u,v). In other words, the greedy spanner satisfies: for every edge (u,v) in S, letting H<(u,v) denote the set of edges in H with smaller555assume all edge lengths in S are distinct, by breaking ties arbitrarily lengths than (u,v), we have δH<(u,v)(u,v)>(1+ε)δS(u,v) iff (u,v)L.

Delayed greedy spanner.

We maintain a light spanner, denoted SS that doesn’t obey the greedy spanner invariants exactly; rather, we define a more robust set of invariants. For any scale i[logΦ], we define the set of edges L[i]L to be the set of all edges in L with scale strictly less than i; that is, every edge in L[i] has length at most 2i1. For any edge (u,v) of the ε-net-tree spanner at scale i, we define δ(u,v)δL[i](u,v); recall that δL[i](,) denotes the shortest-path metric in the geometric graph induced by L[i]. To construct our light spanner, we maintain a subset of edges LS with the following properties:

Invariant 8.

Every edge (u,v)SL satisfies δ(u,v)(1+ε)δ(u,v).

Invariant 9.

Every edge (u,v)L satisfies δ(u,v)>(1+ε3)δ(u,v).

If L satisfies Invariants 8 and 9, we call L a delayed greedy spanner of S (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 H: in our invariants, the choice of adding (u,v) to the spanner depends on L[i] (the set of edges in L with scale strictly smaller than the scale of (u,v)), rather than H<(u,v) (the set of edges in the greedy spanner H that are strictly shorter than δ(u,v)). Nevertheless, we show that any set of edges L that satisfies Invariants 8 and 9 is a (1+O(ε))-spanner (Lemma 2.2) and has constant lightness (Lemma 2.2).

Lemma 10.

Let S be an ε-net-tree spanner for X, and let LS. If Invariant 8 holds, then L is a (1+3ε)-approximate spanner for (X,δ).

Proof.

By Lemma 2.1, the ε-net-tree spanner S is a (1+ε)-spanner for (X,δ). Moreover, Invariant 8 implies that L is a (1+ε)-spanner for S: by triangle inequality it suffices to check that every edge of S is preserved up to 1+ε approximation in L, and indeed, for every edge (u,v)S, we have δL(u,v)δ(u,v)(1+ε)δ(u,v)(1+ε)δS(u,v). We conclude that L is a spanner for (X,δ) with stretch (1+ε)2(1+3ε).

Lemma 11.

Let S be an ε-net-tree spanner for X, and let LS. If Invariants 8 and 9 hold, then L has lightness εO(d).

Proof.

We use, as a black box, the fact that the greedy (1+ε3)-spanner in a metric space of doubling dimension d has lightness εO(d) [19]. We consider the shortest-path metric δL induced by the edges of L; because (X,δ) has doubling dimension d, the stretch bound of Lemma 2.2 together with the definition of doubling dimension implies that the doubling dimension of (X,δL) is O(d) (see [33, Observation 7]). Consider building the greedy (1+ε3)-spanner L^ of L: that is, we initialize L^, then iterate over the edges of L from smallest to largest666by triangle inequality, it suffices to examine only the edges of L when building the greedy spanner, rather than all pairs of vertices in L, and add an edge (u,v)L into the spanner L^ iff δL^(u,v)>(1+ε3)δL(u,v). The greedy spanner L^ has lightness εO(d). We now charge every edge of L to an edge of L^. If an edge (u,v)L is added to L^, then charge (u,v) to itself. Otherwise, suppose (u,v)L is not added to L^. This means that there is a path P between u and v in L^ (at the instant that (u,v) is considered) with length at most (1+ε3)δL(u,v). Because S is a geometric graph, δS(u,v)=δ(u,v); i.e., P has length at most (1+ε3)δ(u,v). Let i be the scale of (u,v), meaning that δ(u,v)[2i1,2i). The path P contains some scale-i edge (u,v) in the greedy spanner L^: otherwise, if P contained only scale-j edges with j<i, we would have δ(u,v)(1+ε3)δ(u,v), contradicting Invariant 9. Charge (u,v) to the scale-i edge (u,v).

We now claim that every edge (u,v) in L^ is charged at most εO(d) times. Indeed, whenever a scale-i edge (u,v) is charged by a scale-i edge (u,v), we have δ(u,u)(1+ε3)2i; this is because, by definition of charging, u lies on a path u and v with length at most (1+ε3)δ(u,v)(1+ε3)2i. The packing bound (Observation 2.1) implies that there are only εO(d) scale-i edges that could charge (u,v). Because we only charge scale-i edges in L to scale-i edges in L^, we conclude that L is at most εO(d) times heavier than L, which is εO(d) times heavier than the minimum spanning tree on X.

3 Light Spanner with Worst-Case Recourse Bounds

We now describe how to maintain our light spanner L, 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 DS.X

  • a net-tree DS.𝒩 on the points DS.X

  • an ε-net-tree spanner DS.S of DS.X with respect to DS.𝒩

  • a subgraph DS.LDS.S called the light spanner, such that Invariants 8 and 9 hold.

All these variables are initialized as . The data structure supports two operations – insertion and deletion of a point x. We say that a procedure Insert(x) correctly implements insertion of point x if the procedure assigns DS.XDS.X{x} and updates DS.𝒩, DS.S, and DS.L to satisfy the descriptions above. Similarly, a procedure Delete(x) correctly implement deletion of a point x if it assigns DS.XDS.X{x} and updates DS.𝒩, DS.S, and DS.L.

3.1 Insertion

To insert a point x, we first update the net-tree according to [35] (as summarized in our Lemma 2.1) and then recompute the spanner edges DS.L nearby x to satisfy the invariants. The pseudocode is given below. Our key insight is that when we recompute spanner edges at level i, we only need to recompute edges with endpoints in B(x,O(2i)).

Lemma 12.

The procedure DS.Insert(x) correctly implements the insertion of a point x.

Proof.

Let 𝒩old, Sold, Lold, and Xold denote DS.𝒩, DS.S, DS.L, and DS.X (respectively) before the insertion process. For brevity, we write 𝒩, S, L, and X instead of DS.𝒩, DS.S, DS.L, and DS.X. By Lemma 2.1, the variables DS.X, DS.𝒩 and DS.S are correctly maintained. Moreover, we have that LS, because (by description of the algorithm) SoldS and (by assumption) LoldSold.

It remains to show that that every edge (u,v) in S satisfies Invariants 8 and 9. Suppose that edge (u,v) is at scale i (that is, δ(u,v)(2i1,2i]). Note that the distance δ(u,v)=δL[i](u,v) depends only on the edges in L with scale strictly less than i; thus, it suffices to show that (u,v) satisfies the two invariants at the moment after the for-loop processes scale i. If u,vB(x,42i), then (u,v) satisfies the two invariants by description of the algorithm. Now suppose that some endpoint, without loss of generality u, is not in B(x,42i). In this case, (u,v) is in L if and only if (u,v) is in Lold. There are two cases:

  • Suppose that (u,v) is not in L. Thus (u,v) is not in Lold. To satisfy Invariant 8, we must show δL[i](u,v)(1+ε)δ(u,v). In fact, we show that either δL[i](u,v)δLold[i](u,v) or δLold[i](u,v)>2δ(u,v); see Figure 4. This suffices, as Lold satisfies Invariant 8: we conclude that δL[i](u,v)δLold[i](u,v)(1+ε)δ(u,v) as desired. Consider a shortest path P in Lold[i] between u and v. The description of the algorithm implies that the only edges that that change between L[i] and Lold[i] are in the ball B(x,42i1). Because we assumed δ(u,x)>42i, triangle inequality implies that endpoints of any edge (u,v) in Lold[i]L[i] are far from u: specifically, δ(u,u)42i42i1=22i, and so δLold(u,u)22i. If P has length 22i then we are done; otherwise, P does not include any edges in Lold[i]L[i], and so P is also a path in L[i] as desired.

    Figure 4: A light spanner Lold. For a given scale i, the spanners L[i] and Lold[i] differ only within the ball B(x,42i1). A scale-i pair (u,v) outside of B(x,42i). A short path P between u and v in Lold does not wander inside B(x,42i1), so P is also in L.
  • Suppose (u,v) is in L. Thus (u,v) is in Lold. To satisfy Invariant 9, we must show that δL[i](u,v)>(1+ε3)δ(u,v). We claim that either δL[i](u,v)δLold[i](u,v), or δL[i](u,v)2δ(u,v). This suffices to prove the claim, because Lold satisfies Invariant 9 and so δLold[i](u,v)>(1+ε3)δ(u,v); thus, in either case, δL[i](u,v)>(1+ε3)δ(u,v). Let P be a shortest path between u and v in L[i]. If δL[i](u,v)δLold[i](u,v) then we are done. Otherwise, if δL[i](u,v)<δLold[i](u,v), then P must contain some edge of L[i] that is not in Lold[i]. But the description of the algorithm implies that any such edge has endpoints in B(x,42i1). By triangle inequality and our assumption that δ(u,x)42i, we have δ(u,u)22i, and so P has length at least 22i as desired.

We remark that the Insert procedure has bounded recourse: at most εO(d)logΦ edges change in the spanner L. This is because, for every scale ilogΦ, there are at most εO(d) scale-i edges in the ε-net-tree spanner in B(x,42i), by definition of net-tree spanner and packing bound (Observation 2.1).

3.2 Deletion

The procedure for deleting a point x is similar to insertion. The procedure DS.Delete(x) first updates the net tree according to [35], then deletes all edges in L that were incident to x, and finally recompute the spanner edges nearby x using the DS.Recompute 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 DS.Delete(x) correctly implements the deletion of a point x.

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 DS.Insert(x) or DS.Delete(x). Let Sold (resp. Lold) denote DS.S (resp. DS.L) before the insertion/deletion is performed. Let (u,v) be a scale-i edge in DS.S, with some endpoint outside of B(x,42i). Then (u,v) is an edge in Sold, and either (1) δDS.L[i](u,v)=δLold[i](u,v), or (2) both δDS.L[i](u,v) and δLold[i](u,v) are larger than 2δ(u,v).

4 Implementing Updates Quickly

In this section, we show how to modify the data structure so that the DS.Insert and DS.Delete procedures can be executed quickly. By prior work on the net-tree spanner (Lemma 2.1), the net-tree DS.𝒩 and the ε-net-tree spanner DS.S can be maintained in O(logΦ) time. The DS.Recompute procedure iterates over each of the logΦ scales. For each scale i, it examines the εO(d)logΦ many scale-i edges in B(x,42i); by Claim 2.1 these edges can be found in εO(d)=O(1) time. Each examined edge (u,v) is added or removed from DS.L depending on δ(u,v). This means that the bottleneck for a fast update time is the computation of δ(u,v):

Lemma 15.

The procedure DS.Insert and DS.Delete run in εO(d)O~(logΦ) time, plus the time needed for εO(d)logΦ many computations of δ(u,v).

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 δ(u,v).

Definition 16.

We say a value d~ is an α-approximation for a value d if dd~αd. For any function d(u,v) on pairs of points (we will take d(u,v)=δ(u,v) and d(u,v)=δDS.L(u,v)), we say that d~(u,v) is a coarse α-approximation for d(u,v) if:

d~(u,v)={if d(u,v)2δ(u,v) then d(u,v)d~(u,v)αd(u,v)if d(u,v)>2δ(u,v) then d~(u,v)2δ(u,v)

In other words, a coarse α-approximation d~(u,v) for δ(u,v) lets us either detect when δ(u,v) is very large or provides an α-approximation for δ(u,v). Throughout this section, we set α1+ε3. As we show in Lemma 4, even if we used coarse α-approximations ~δ(u,v) instead of the real distances δ(u,v) in the DS.Recompute procedure, our spanner L 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 δ(u,v) for every edge (u,v) in the ε-net-tree DS.S. In fact, we maintain something stronger: we need to store several auxiliary values in order to maintain the coarse approximations. Let κ 10243 be a sufficiently large constant, and let εsmall ε3κlogΦ. Our data structure DS maintains (in addition to the points DS.X, the net-tree DS.𝒩, the ε-net-tree spanner DS.S, and the light spanner DS.L) the following objects:

  • An εsmall-net tree spanner DS.Ssmall for DS.𝒩

  • For every scale i[logΦ] and every edge (u,v) in DS.Ssmall at scale i, a value DS.~δ(u,v) which is a coarse (1+κiεsmall)-approximation for δ(u,v).

  • For every scale i[(logΦ)2] and every edge (u,v) in DS.Ssmall at scale i, a value DS.~δL(u,v) which is a (1+κiεsmall)-approximation for δDS.L(u,v).

Observe that this data structure does indeed maintain a coarse ε3-approximation for every edge in DS.S: this is because DS.SDS.Ssmall, and κiεsmall<ε3 so the estimates DS.~δ(u,v) are coarse ε3-approximations for δ(u,v). The reason we maintain estimates for every edge in DS.Ssmall and not just every edge in DS.S is to control the distortion, which will accumulate by a (1+O(εsmall)) factor at each scale.

We highlight two differences between the estimates DS.~δ(u,v) and DS.~δL(u,v), for a scale-i edge (u,v). First, the value DS.~δ(u,v) seeks to estimate δ(u,v), which is the distance between u and v in the subgraph DS.L[i] which consists of all edges in DS.L with scale strictly smaller than i. On the other hand, DS.~δL(u,v) estimates distances in the graph DS.L; note that the shortest path between u and v in DS.L may include edges in DS.L at scale i and i+1, in addition to edges in DS.L[i]. The second key difference is that DS.~δ(u,v) is only required to be a (1+κiεsmall)-approximation of δ(u,v) when δ(u,v)2δ(u,v), whereas DS.~δL(u,v) is always a (1+κiεsmall)-approximation of δDS.L(u,v). Why do we need these two types of estimates? Ultimately, our algorithm for Insert and Delete will only use the estimates DS.~δ(u,v), to determine whether or not the edge (u,v) should be added. But in order to compute DS.~δ(u,v) for some pair (u,v) at scale i, we will need to estimate δDS.L(u,v) for pairs (u,v) at scale i3.

The fast insert/delete procedures.

Below, we give pseudocode for a modified DS.Recompute procedure called DS.RecomputeFast, which uses the estimates DS.~δ(u,v) instead of the true distances δ(u,v). We define the procedures DS.InsertFast and DS.DeleteFast to be identical to DS.Insert and DS.Delete, except that they use DS.RecomputeFast instead of DS.Recompute, and they also maintain a εsmall-net-tree spanner DS.Ssmall in addition to the ε-net-tree spanner DS.S.

In Section 4.1, we describe the procedure DS.UpdateDistEstimates and prove that it correctly maintains estimates for δ(u,v) and δL(u,v). 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.

DS.UpdateDistEstimates runs in time (ε1logΦ)O(d).

Lemma 18.

Consider the execution of DS.InsertFast(x) or DS.DeleteFast(x). Let i[logΦ] be a scale, and consider the data structure DS at the instant after the execution of the call DS.UpdateDistEstimates(x,i) during the insertion/deletion process. Assume that every edge (u,v) of DS.S with scale strictly smaller than i satisfies Invariants 8 and 9. Then:

  • for every scale-i edge (u,v) in the εsmall-net-tree spanner DS.Ssmall, the value DS.~δ(u,v) is a coarse (1+κiεsmall)-approximation for δ(u,v).

  • for every scale-(i2) edge (u,v) in the εsmall-net-tree spanner DS.Ssmall, the value DS.~δL(u,v) is a (1+κiεsmall)-approximation δDS.L(u,v).

Lemma 19.

The procedure DS.InsertFast(x) (resp. DS.DeleteFast(x)) correctly implements insertion (resp. deletion) of x. It runs in time (ε1logΦ)O(d).

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-i edge (u,v) in DS.S with both endpoints in B(x,42i) satisfies Invariants 8 and 9.

For every such edge (u,v), the algorithm checks if DS.~δ(u,v)>(1+ε)δ(u,v) and includes (u,v) in L iff the inequality holds. At the instant the algorithm makes the check, we may assume (by induction) that every edge (u,v) in DS.S with scale strictly smaller than i satisfies Invariants 8 and 9. Thus, by Lemma 4, the value of DS.~δ(u,v) is a coarse (1+κiεsmall)-approximation for δ(u,v). As i[logΦ], in particular we conclude that DS.~δ(u,v) is a coarse (1+ε3)-approximation for δ(u,v). There are two cases.

Case 1: DS.~𝜹(𝒖,𝒗)(𝟏+𝜺)𝜹(𝒖,𝒗).

In this case, (u,v) is not in DS.L. We claim that δ(u,v)(1+ε)δ(u,v), so that (u,v) satisfies Invariant 8. Indeed, we have δ(u,v)<2δ(u,v); otherwise, the definition of coarse α-approximation means that DS.~δ(u,v)>2δ(u,v), which contradicts our assumption that DS.~δ(u,v)(1+ε)δ(u,v). Thus, the definition of coarse α-approximation implies δ(u,v)DS.~δ(u,v) and so δ(u,v)(1+ε)δ(u,v) as desired.

Case 2: DS.~𝜹(𝒖,𝒗)>(𝟏+𝜺)𝜹(𝒖,𝒗).

In this case, (u,v) is added to DS.L. We claim that δ(u,v)>(1+ε3)δ(u,v), so that (u,v) satisfies Invariant 9. For contradiction, suppose that δ(u,v)(1+ε3)δ(u,v). The definition of coarse (1+ε3)-approximation implies DS.~δ(u,v)(1+ε3)δ(u,v). Combining these two inequalities, we conclude that DS.~δ(u,v)(1+ε3)(1+ε3)δ(u,v)(1+ε)δ(u,v), contradicting the Case 2 assumption. Theorem 2 follows from Lemmas 4, 2.2, and 2.2 (after rescaling εε/3).

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 (logΦ)O(d). 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 n=|X|? Second, can we obtain a runtime bound where the exponent of logΦ (or logn) is independent of d? Ideally, we would like to handle updates in time εO(d)logn, 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.