Distributed Construction of Light Networks

TL;DR

This paper presents the first efficient distributed algorithms in the CONGEST model for constructing light spanners and shallow light trees in general graphs, achieving near-optimal parameters and extending to doubling graphs.

Contribution

It introduces distributed algorithms for light spanners and SLTs with near-optimal parameters, including for doubling graphs, and generalizes net construction to weighted graphs.

Findings

Constructed a $(2k-1)(1+ ext{epsilon})$-spanner with lightness $O(k imes n^{1/k})$ in near-optimal rounds.

Developed an $( ext{alpha}, 1+O(1)/( ext{alpha}-1))$-SLT in near-linear rounds.

Designed a distributed algorithm for nets in weighted graphs, extending previous unweighted algorithms.

Abstract

A $t$-{\em spanner} $H$ of a weighted graph $G=(V,E,w)$ is a subgraph that approximates all pairwise distances up to a factor of $t$. The {\em lightness} of $H$ is defined as the ratio between the weight of $H$ to that of the minimum spanning tree. An $(\alpha,\beta)$-{\em Shallow Light Tree} (SLT) is a tree of lightness $\beta$, that approximates all distances from a designated root vertex up to a factor of $\alpha$. A long line of works resulted in efficient algorithms that produce (nearly) optimal light spanners and SLTs. Some of the most notable algorithmic applications of light spanners and SLTs are in distributed settings. Surprisingly, so far there are no known efficient distributed algorithms for constructing these objects in general graphs. In this paper we devise efficient distributed algorithms in the CONGEST model for constructing light spanners and SLTs, with near optimal parameters. Specifically, for any $k\ge 1$ and $0<\epsilon<1$, we show a $(2k-1)\cdot(1+\epsilon)$-spanner with lightness $O(k\cdot n^{1/k})$ can be built in $\tilde{O}\left(n^{\frac12+\frac{1}{4k+2}}+D\right)$ rounds (where $n=|V|$ and $D$ is the hop-diameter of $G$). In addition, for any $\alpha>1$ we provide an $(\alpha,1+\frac{O(1)}{\alpha-1})$-SLT in $(\sqrt{n}+D)\cdot n^{o(1)}$ rounds. The running time of our algorithms cannot be substantially improved. We also consider spanners for the family of doubling graphs, and devise a $(\sqrt{n}+D)\cdot n^{o(1)}$ rounds algorithm in the CONGEST model that computes a $(1+\epsilon)$-spanner with lightness $(\log n)/\epsilon^{O(1)}$. As a stepping stone, which is interesting in its own right, we first develop a distributed algorithm for constructing nets (for arbitrary weighted graphs), generalizing previous algorithms that worked only for unweighted graphs.

Tables

Table 1. Table 1: A summary of our main results. Here n 𝑛 n is the number of vertices, k ≥ 1 𝑘 1 k\geq 1 and α ≥ 1 𝛼 1 \alpha\geq 1 are parameters and 0 < ϵ < 1 0 italic-ϵ 1 0<\epsilon<1 is a constant. For the nets γ > β > 0 𝛾 𝛽 0 \gamma>\beta>0 . All results are in the CONGEST model.

Object	Distortion	Lightness	Size	Run time
\hlineB3 Spanner	$\left(2k-1\right)\cdot \left(1+ϵ\right)$	$O\left(k\cdot n^{1/k}\right)$	$O\left(k\cdot n^{1+1/k}\right)$	$\tilde{O}\left(n^{\frac{1}{2}+\frac{1}{4k+2}}+D\right)$
SLT	$1+\frac{O\left(1\right)}{\alpha -1}$	$\alpha$	NA	$\tilde{O}\left(\sqrt{n}+D\right)\cdot \mathrm{poly}\left(\frac{1}{\alpha -1}\right)$
$(\gamma ,\beta )$-net	NA	NA	NA	$\left(\sqrt{n}+D\right)\cdot 2^{\tilde{O}\left(\sqrt{\log n}\cdot \log \frac{\beta }{\gamma -\beta }\right)}$
Spanner	$1+ϵ$	${ϵ}^{-O\left(\mathrm{ddim}\right)}\cdot \log n$	$n\cdot {ϵ}^{-O\left(\mathrm{ddim}\right)}\cdot \log n$	$\left(\sqrt{n}+D\right)\cdot {ϵ}^{-\tilde{O}\left(\sqrt{\log n}+\mathrm{ddim}\right)}$

Equations

$$g(r_i)=\ell (r_i)+\sum _{F\in {\mathcal{F}}^{\prime }}\left(\ell (r_F)+2\cdot w(e_F)\right).$$

$$g(v)=\sum _{i=1}^k\left(g({\tilde{z}}_i)+2\cdot w(v,{\tilde{z}}_i)\right).$$

$$t_i(z_j)=\left[a+\sum _{q<j}\left(g(z_q)+2w(v,z_q)\right)+w(v,z_j),a+\sum _{q<j}\left(g(z_q)+2w(v,z_q)\right)+w(v,z_j)+g(z_j)\right].$$

$$d_G(rt,v)\le d_{T_{rt}}(rt,v)\le (1+ϵ)\cdot d_G(rt,v).$$

$$d_{\mathcal{L}}(x_j,y)=R_{x_j}-R_y>ϵ\cdot d_{T_{rt}}(rt,x_j).$$

$$\sum _{j\ge 1}w(P_{b_j})=\sum _{j\ge 1}{d}_{T_{rt}}(rt,b_j)<\sum _{j\ge 1}\frac{1}{ϵ}\cdot d_{\mathcal{L}}(b_{j-1},b_j)\le \frac{1}{ϵ}\cdot w(\mathcal{L})=\frac{2}{ϵ}\cdot w(T).$$

$$d_{\mathcal{L}}(x,y)\le ϵ\cdot d_{T_{rt}}(rt,x).$$

$$d_{\mathcal{L}}(y,y^{\prime })\le ϵ\cdot d_{T_{rt}}(rt,y),$$

$$d_{\mathcal{L}}(x,y^{\prime })$$

$$\stackrel{\text{eqref}eq:y^{\prime }}{\le }{d}_{\mathcal{L}}(x,y)+ϵ\cdot d_{T_{rt}}(rt,y)$$

$$\stackrel{\text{eqref}eq:aspt}{\le }{d}_{\mathcal{L}}(x,y)+ϵ\cdot (1+ϵ)\cdot d_G(rt,y)$$

$$\le d_{\mathcal{L}}(x,y)+2ϵ\cdot (d_G(x,y)+d_G(rt,x))$$

$$\le (1+2ϵ)\cdot d_{\mathcal{L}}(x,y)+2ϵ\cdot d_G(rt,x)$$

$$\stackrel{\text{eqref}eq:y}{\le }(1+2ϵ)\cdot ϵ\cdot d_{T_{rt}}(rt,x)+2ϵ\cdot d_G(rt,x)$$

$$\stackrel{\text{eqref}eq:aspt}{\le }(1+2ϵ)\cdot ϵ\cdot (1+ϵ)\cdot d_G(rt,x)+2ϵ\cdot d_G(rt,x)$$

$$\le 8ϵ\cdot d_G(rt,x).$$

$$d_H(rt,x)$$

$$\le \left(1+ϵ\right)\cdot \left(d_G(rt,x)+d_G(x,y^{\prime })\right)+d_{\mathcal{L}}(x,y^{\prime })$$

$$\le \left(1+ϵ\right)\cdot d_G(rt,x)+3\cdot d_{\mathcal{L}}(x,y^{\prime })\le \left(1+25ϵ\right)\cdot d_G(rt,x).$$

$$d_{T_{\mathrm{SLT}}}(rt,v)\le (1+ϵ)\cdot d_H(rt,v)\le \left(1+ϵ\right)\cdot (1+25ϵ)\cdot d_G(rt,v)\le (1+51ϵ)\cdot d_G(rt,v).$$

$$t(u,v)=\{\begin{array}{ll}2& rt\in \left\{u,v\right\}\\ \infty & \text{otherwise}\end{array}.$$

$$O(|{\mathcal{C}}_i{|}^{1+\frac{1}{k}}+D)\le O\left({\left(n^{\frac{k}{2k+1}}\right)}^{\frac{k+1}{k}}+D\right)=O\left(n^{\frac{1}{2}+\frac{1}{4k+2}}+D\right).$$

$$O(n^{\frac{1}{k}}\log n+n^{\frac{1}{2}+\frac{1}{4k+2}})=O(n^{\frac{1}{2}+\frac{1}{4k+2}}),$$

$$d_H(u,v)\le d_{H_i\cup T}(u_0,v_t)$$

$$\le (t+1)\cdot ϵ\cdot w_i+t\cdot w_i$$

$$\le (2k-1)\cdot (1+O(ϵ))\cdot w(e).$$

$$w(H^{\prime })\le |H^{\prime }|\cdot \frac{L}{n}=O(k\cdot n^{1+\frac{1}{k}}\cdot \frac{L}{n})=O(k\cdot n^{\frac{1}{k}}\cdot L).$$

$$\sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }\mathbb{E}\left[w(H_i)\right]$$

$$=O\left(\frac{L}{{ϵ}^{1+1/k}}\right)\cdot \sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }(1+ϵ{)}^{\frac{i}{k}}=O\left(\frac{L}{{ϵ}^{1+1/k}}\right)\cdot \frac{(1+ϵ{)}^{\frac{\lceil {\log }_{1+ϵ}n\rceil +1}{k}}-1}{(1+ϵ{)}^{1/k}-1}$$

$$=O\left(\frac{L\cdot k\cdot n^{1/k}}{{ϵ}^{2+1/k}}\right),$$

$$\mathbb{E}[w(H)]\le w(T)+w(H^{\prime })+\sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }\mathbb{E}[w(H_i)]=O_{ϵ}\left(k\cdot n^{\frac{1}{k}}\cdot L\right).$$

$$\sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }\mathbb{E}[|H_i|]\le \sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }O\left({\left(\frac{(1+ϵ{)}^i}{ϵ}\right)}^{1+\frac{1}{k}}\right)=O\left(\frac{1}{{ϵ}^{1+\frac{1}{k}}}\cdot \frac{n^{1+\frac{1}{k}}}{(1+ϵ{)}^{1+\frac{1}{k}}-1}\right)=O\left(\frac{n^{1+\frac{1}{k}}}{{ϵ}^{2+\frac{1}{k}}}\right),$$

$$\mathbb{E}[|H|]\le |T|+|H^{\prime }|+\sum _{i=0}^{\lceil {\log }_{1+ϵ}n\rceil }\mathbb{E}[|H_i|]=O_{ϵ}\left(k\cdot n^{1+\frac{1}{k}}\right).$$

$${\text{LE}}_{G,A,\pi }(v)=\left\{(u,d_G(u,v)):u\in A,\nexists w\in A\text{ s.t. }{d}_G(v,w)\le d_G(v,u)\text{ and }\pi (w)<\pi (u)\right\}.$$

$$\mathrm{Pr}\left[\left\{u,v\right\}\notin {\mathcal{E}}_i\right]$$

$$\ge \frac{1}{2}\cdot \sum _{w\in A_i}\mathrm{Pr}\left(\left[w\text{ kills }u\right]+\mathrm{Pr}\left[w\text{ kills }v\right]\right).$$

$$\mathbb{E}\left[\left|{\mathcal{E}}_{i-1}\setminus {\mathcal{E}}_i\right|\right]$$

Full text

Some of the most notable algorithmic applications of light spanners and SLTs are in distributed settings. Surprisingly, so far there are no known efficient distributed algorithms for constructing these objects in general graphs. In this paper we devise efficient distributed algorithms in the CONGEST model for constructing light spanners and SLTs, with near optimal parameters. Specifically, for any $k\geq 1$ and $0<\epsilon<1$, we show a $(2k-1)\cdot(1+\epsilon)$-spanner with lightness $O(k\cdot n^{1/k})$ can be built in $\tilde{O}\left(n^{\frac{1}{2}+\frac{1}{4k+2}}+D\right)$ rounds (where $n=|V|$ and $D$ is the hop-diameter of $G$). In addition, for any $\alpha>1$ we provide an $(\alpha,1+\frac{O(1)}{\alpha-1})$-SLT in $(\sqrt{n}+D)\cdot n^{o(1)}$ rounds. The running time of our algorithms cannot be substantially improved.

We also consider spanners for the family of doubling graphs, and devise a $(\sqrt{n}+D)\cdot n^{o(1)}$ rounds algorithm in the CONGEST model that computes a $(1+\epsilon)$-spanner with lightness $(\log n)/\epsilon^{O(1)}$. As a stepping stone, which is interesting in its own right, we first develop a distributed algorithm for constructing nets (for arbitrary weighted graphs), generalizing previous algorithms that worked only for unweighted graphs.

1 Introduction

Let $G=(V,E,w)$ be a graph with edge weights $w:E\to\mathbb{R}_{+}$. For $u,v\in V$, denote by $d_{G}(u,v)$ the shortest path distance in $G$ between $u,v$ with respect to these weights. A subgraph $H=(V,E^{\prime})$ with $E^{\prime}\subseteq E$ is called a $t$-spanner of $G$, if for all $u,v\in V$, $d_{H}(u,v)\leq t\cdot d_{G}(u,v)$. The parameter $t$ is called the stretch of $H$. The most relevant and studied attributes of a $t$-spanner are its sparsity (i.e., the number of edges $|E^{\prime}|$), and the total weight of the edges $w(H)=\sum_{e\in E^{\prime}}w(e)$. Since any spanner with finite stretch must be connected, its weight is at least the weight of the Minimum Spanning Tree (MST) of $G$, and the lightness of $H$ is defined as $\frac{w(H)}{w(MST)}$.

Another useful notion of a subgraph that approximately preserves distances was introduced in [ABP92, KRY95]. Given a weighted graph $G=(V,E,w)$ with a designated root vertex $rt$, an $(\alpha,\beta)$-Shallow-Light Tree (SLT) $T$ of $G$ is a spanning tree which has lightness $\beta$, and approximates all distances from $rt$ to the other vertices up to a factor of $\alpha$.

In this paper we focus on the distributed CONGEST model of computation, where each vertex of the graph $G$ hosts a processor, and these processors communicate with each other in discrete rounds via short messages on the graph edges (typically the message size is $O(\log n)$ bits). We devise efficient distributed algorithms that construct light spanners and shallow-light trees for general graphs, and also light spanners for doubling graphs. See Table 1 for a succinct summary.

1.1 Light Spanners for General Graphs

Spanners are a fundamental combinatorial object. They have been extensively studied and have found numerous algorithmic applications [Awe85, PS89, PU89, ADD*+*93, Coh98, ACIM99, EP01, BS07, Elk07, EZ06, TZ06, Pet09, DGPV08, Pet10, MPVX15, AB16, EN17a]. The basic greedy algorithm [ADD*+*93], for a graph with $n$ vertices and any integer $k\geq 1$, provides a $(2k-1)$-spanner with $O(n^{1+1/k})$ edges, which is best possible (assuming Erdos’ girth conjecture). Spanners of low weight have received much attention in recent years [CDNS95, ES16, ENS15, Got15, CW18, BFN16, ADF*+*17, BLW17, FN18, BLW19], and are particularly useful in a distributed setting; efficient broadcast protocols, network synchronization and computing global functions [ABP90, ABP92], network design [MP98, SCRS01] and routing [WCT02] are a few examples. The state-of-the-art is a $(2k-1)\cdot(1+\epsilon)$-spanner of [CW18] with lightness $O(n^{1/k})$, for any constant $0<\epsilon<1$. In [FS16] it was shown that the greedy algorithm is existentially optimal, hence it also achieves such lightness.

The greedy algorithm provides a satisfactory answer to the existence of sparse and light spanners, but not to efficiently producing such a spanner (because the greedy algorithm has inherently large running time). Indeed, the problem of devising fast algorithms to construct spanners is very important in some algorithmic applications. For light spanners, [ES16] showed a near-linear time algorithm that constructs a $(2k-1)\cdot(1+\epsilon)$-spanner with $O(k\cdot n^{1+1/k})$ edges and lightness $O(k\cdot n^{1/k})$. The sparsity and lightness were improved (still in near-linear time) in [ADF*+*17] to $O(\log k\cdot n^{1+1/k})$ and $O(\log k\cdot n^{1/k})$ respectively. In the distributed setting, [BS07] devised a randomized algorithm for a $(2k-1)$-spanner with $O(k\cdot n^{1+1/k})$ edges in $O(k)$ rounds in the CONGEST model. This was recently improved for unweighted graphs by [MPVX15, EN17b] to $O(n^{1+1/k})$ edges. However, the weight of these spanners is not bounded. Surprisingly, none of the previous works in the CONGEST model has a bound on the lightness of spanners for general graphs.

Our results.

Unlike the sparsity of spanners, which can be preserved via a local algorithm, the lightness is a global measure. Indeed, we observe that the lower bound of [SHK*+*12] on the number of rounds required for any polynomial approximation of the MST weight, implies a lower bound for computing light spanners. In particular, for a graph with $n$ vertices and hop-diameter111The hop diameter of a weighted graph is the diameter of the underlying unweighted graph. $D$, any CONGEST algorithm requires at least $\tilde{\Omega}(\sqrt{n}+D)$ rounds for computing a light spanner (with any polynomial lightness).222The notations $\tilde{O}(\cdot)$ and $\tilde{\Omega}(\cdot)$ hide polylogarithmic factors.

We provide the first algorithm with sub-linear number of rounds for constructing light spanners for general graphs in the CONGEST model. Specifically, for any integer parameter $k\geq 1$ and constant $0<\epsilon<1$, we devise a randomized algorithm that w.h.p. outputs a $(2k-1)\cdot(1+\epsilon)$-spanner with $O(k\cdot n^{1+1/k})$ edges and lightness $O(k\cdot n^{1/k})$, within $\tilde{O}\left(n^{\frac{1}{2}+\frac{1}{4k+2}}+D\right)$ rounds in the CONGEST model, thus nearly matching the lower bounds.

1.2 Shallow-Light Trees

Shallow-Light trees are widely used for various distributed tasks, such as network design, broadcasting in ad-hoc networks and multicasting [PV04, BDS04, YCC06]. In [KRY95], an optimal tradeoff between the lightness of the SLT to the stretch of the root distances was obtained. Specifically, for any $\alpha>1$ they obtained an SLT with lightness $\alpha$ and stretch $1+\frac{2}{\alpha-1}$. In addition, [KRY95] exhibited an efficient algorithm for constructing such a tree in near-linear time, and also in $O(\log n)$ rounds in the PRAM (CREW) model. However, their techniques are inapplicable to the CONGEST model, and it remained an open question whether an SLT can be built efficiently in this model. (Roughly speaking, [KRY95] used pointer jumping techniques that require communication between non-adjacent vertices, hence this is unsuitable for the CONGEST model.)

Our result.

Here we answer this question, and devise a distributed deterministic algorithm, that for any $\alpha>1$, outputs an SLT with lightness $\alpha$ and stretch $1+\frac{O(1)}{\alpha-1}$, within $\tilde{O}\left(\sqrt{n}+D\right)\cdot{\rm poly}\left(\frac{1}{\alpha-1}\right)$ rounds. Once again, any distributed SLT algorithm must take at least $\tilde{\Omega}(\sqrt{n}+D)$ rounds [Elk04, SHK*+*12]. Thus our result is nearly optimal.

1.3 Light Spanners for Doubling Graphs

A graph $G$ has doubling dimension ${\rm ddim}$ if for every vertex $v\in V$ and radius $r>0$, the ball333A ball is defined as $B_{G}(v,r)=\{u\in V~{}:~{}d_{G}(u,v)\leq r\}$. $B_{G}(v,2r)$ can be covered by $2^{\rm ddim}$ balls of radius $r$. For instance, a $d$-dimensional $\ell_{p}$ space has ${\rm ddim}=\Theta(d)$, and every graph with $n$ vertices has ${\rm ddim}=O(\log n)$. This is a standard and well-studied notion of ”growth restriction” on a graph [Ass83, GKL03, HM06], and it is believed that such graphs occur often in real-life networks and data [TSL00, NZ02]. One notable motivation for light spanners in doubling graphs444A graph family is called doubling if its members have constant doubling dimension. is their application for polynomial approximation schemes for the traveling salesperson and related problems (see, e.g., [Kle05, Got15]). While spanners with $1+\epsilon$ stretch and constant lightness have been known to exists in low dimensional Euclidean space for a while [DHN93, ADD*+*93], only recently such $(1+\epsilon)$-spanners with constant lightness $({\rm ddim}/\epsilon)^{O({\rm ddim})}$ have been discovered for doubling graphs [Got15]. The lightness was improved by [BLW19] to the optimal $(1/\epsilon)^{O({\rm ddim})}$.

In the distributed LOCAL model555The LOCAL model is similar to CONGEST, but the size of messages is not bounded., [DPP06] devised light spanners for a certain graph family, called unit ball graphs in a doubling metric space666A unit ball graph is a graph whose vertices lie in a metric space, and edges connect vertices of distance at most 1. In this scenario the metric is doubling.. Specifically, they showed an $O(\log^{*}n)$ rounds algorithm for a $(1+\epsilon)$-spanner with lightness $(1/\epsilon)^{O({\rm ddim})}\cdot\log\Lambda$, where $\Lambda$ is the aspect ratio of $G$ (the ratio between the largest to smallest edge weights). We note that to obtain such a low number of rounds, they imposed restrictions on both the distributed model and the graph family.

Essentially all spanners for doubling graphs use nets in their construction. An $(\alpha,\beta)$-net of a graph is a set $N\subseteq V$ which is both $\alpha$-covering: for all $u\in V$ there is $v\in N$ with $d_{G}(u,v)\leq\alpha$, and $\beta$-separated: for all $x,y\in N$, $d_{G}(x,y)>\beta$. The standard definition of a net is when $\alpha=\beta$, but we shall allow $\alpha>\beta$ as well. The usefulness of nets in doubling graphs stems from the fact that any net restricted to a ball of certain radius has a small cardinality. While a simple greedy algorithm yields a net, it is not suitable for distributed models due to it being inherently sequential.

A ruling set is a net in an unweighted graph. There have been several works that compute a ruling set in distributed settings. In [AGLP89], a deterministic algorithm for a $(k\log n,k)$-ruling set running in $O(k\log n)$ rounds was developed, and a tradeoff extending this result was shown in [SEW13]. A consequence of the work of [AGLP89] provides a $(k,k)$-ruling set computed within $k\cdot 2^{\tilde{O}(\sqrt{\log n})}$ rounds. A randomized algorithm for a $(k,k)$-ruling set was given in [Lub86] with $O(k\log n)$ rounds, and the running time was improved for graphs of small maximum degree in [BEPS12, Gha16]. However, all these results apply only for unweighted graphs. The problem of efficiently constructing a net in distributed models remained unanswered.

Our results.

We design a randomized distributed algorithm, that for a given graph with $n$ vertices and hop-diameter $D$ and any $0<\beta<\alpha<2\beta$, w.h.p. finds an $(\alpha,\beta)$-net within $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n}\cdot\log\frac{\beta}{\alpha-\beta})}$ rounds in the CONGEST model. We show that the running time must be at least $\tilde{\Omega}(\sqrt{n}+D)$ for general graphs, via a reduction to the problem of approximating the MST weight. So our running time is best possible (up to lower order terms). However, we do not know if a faster algorithm is achievable when the input graph has a constant doubling dimension.

Then, we utilize this algorithm for constructing nets, and devise a randomized algorithm that for a graph with doubling dimension ${\rm ddim}$ and any $0<\epsilon<1$, w.h.p. produces a $(1+\epsilon)$-spanner with lightness $\epsilon^{-O({\rm ddim})}\cdot\log n$ in $(\sqrt{n}+D)\cdot\epsilon^{-\tilde{O}(\sqrt{\log n}+{\rm ddim})}$ rounds.

1.4 Overview of Techniques

In this section we provide an overview of the algorithms, techniques and ideas used in the paper. For the sake of brevity, some parts are over-simplified, or even completely neglected.

Eulerian Tour of the MST.

Let $T$ be the MST. The first step in both our constructions of an SLT and a light spanner for general graphs is a distributed computation of a DFS traversal $\mathcal{L}$ of $T$. As an outcome of this computation, each vertex knows all its visiting times in $\mathcal{L}$. Our algorithm is a simplification of a similar algorithm from [EN18].

In order to compute $\mathcal{L}$, we note that the distributed MST algorithm of [KP98] induces a partition of $T$ into $O(\sqrt{n})$ fragments, each with hop-diameter $O(\sqrt{n})$. We then create a virtual tree $T^{\prime}$ whose vertices are the fragments. As $T^{\prime}$ has only $O(\sqrt{n})$ vertices, it is possible to broadcast $T^{\prime}$ to the entire graph. We first compute a DFS tour locally in each fragment, and broadcast the $O(\sqrt{n})$ lengths of these tours. We use this information and the known structure of $T^{\prime}$ to globally compute the DFS visit times for the ”roots” of the fragments. Finally, locally in each fragment, we extend this to a traversal of the entire tree $T$.

Shallow Light Tree (SLT).

An SLT is a combination of the MST $T$ and a shortest path tree (SPT) rooted in $rt$. As currently the fastest known exact SPT algorithms [GL18, Elk17a] require more than $\tilde{O}(\sqrt{n}+D)$ rounds, we use instead an approximate SPT , $T^{\prime}$. Our basic strategy (following [ABP92, KRY95]) is to choose a subset of vertices called break points (BP). Then we construct a subgraph $H$ by taking $T$, and adding to $H$ the unique path in $T^{\prime}$ from $rt$ to every break point $v\in\rm BP$. The SLT is computed as yet another approximate SPT rooted in $rt$, but now using $H$ edges only.

Let $\mathcal{L}=\{x_{0},x_{1},\dots,x_{2n-2}\}$ be an Eulerian traversal of the MST $\mathcal{L}$ (each vertex may appear several times). Ideally, we would like to choose $\rm BP=\{x_{0},x_{i_{1}},x_{i_{2}},\dots\}$ such that (1) every pair of consecutive points $x_{i_{j}},x_{i_{j+1}}\in\rm BP$ is far, specifically $d_{\mathcal{L}}(x_{i_{j}},x_{i_{j+1}})>\epsilon\cdot d_{G}(rt,x_{i_{j+1}})$, and (2) every node $x_{q}\in\mathcal{L}$ has a nearby break point $x_{i_{j}}\in\rm BP$, specifically $d_{\mathcal{L}}(x_{i_{j}},x_{q})\leq\epsilon\cdot d_{G}(rt,x_{q})$. The first condition is used to bound the lightness, while the second condition is used to bound the stretch.

The choice of BP  described above can be easily performed in a greedy manner by sequentially traversing the nodes in $\mathcal{L}$. Unfortunately, we cannot implement this sequential algorithm efficiently in a distributed manner. Instead, we break $\mathcal{L}$ into $O(\sqrt{n})$ intervals, each containing at most $\sqrt{n}$ nodes. We add the first node in each interval to a temporary break point set $\rm BP^{\prime}$. Using these temporary break points as an anchor, we perform the sequential algorithm simultaneously in all intervals, and add (permanent) break points. Finally, we broadcast $\rm BP^{\prime}$ to $rt$, which performs a local computation in order to sparsify this set. Specifically, it chooses a subset of $\rm BP^{\prime}$ to serve as permanent break points using the sequential algorithm, and broadcasts the chosen break points to the entire network. Intuitively, we are building a separate SLT for the set $\rm BP^{\prime}$, which filters out some of its points. Our analysis shows that this two-step choice of break points loses only a constant factor in the lightness. However, this constant factor loss implies that obtaining the full tradeoff (i.e., lightness close to 1) cannot be done trivially as before. To remedy this, we apply a reduction from [BFN16] adapted to the CONGEST model.

Light Spanner for General Graphs.

Our basic approach is similar to the algorithms of [CDNS95, ES16, ENS15]. We divide the graph edges into $O(\log n)$ buckets, according to their weight. Denote by $L$ the weight of the MST multiplied by 2 (for technical reasons). In the lowest level, we have all the edges of weight at most $L/n$. For this bucket we simply use the distributed spanner of [BS07] for weighted graphs. Even though the algorithm of [BS07] provides an upper bound only the sparsity of the spanner, we can use their construction as the weight of the edges in this bucket is sufficiently small.

Consider the $i$-th bucket $E_{i}$, where all edges have weight in $\left(\frac{L}{(1+\epsilon)^{i+1}},\frac{L}{(1+\epsilon)^{i}}\right]$. We use the MST traversal $\mathcal{L}$ to divide the graph into $O(\frac{(1+\epsilon)^{i}}{\epsilon})$ clusters of diameter $\frac{\epsilon\cdot L}{(1+\epsilon)^{i}}$. Next, define an unweighted cluster graph $\mathcal{G}_{i}$ whose vertices are the clusters, and inter-cluster edges are taken only from $E_{i}$. Intuitively, the diameter of clusters is an $\epsilon$-fraction of the edge weights, so using the MST edges to travel inside clusters will increase the distance by at most a $(1+\epsilon)$ factor.

We then simulate the spanner algorithm of [EN17b] for unweighted graphs on ${\cal G}_{i}$, and obtain a spanner ${\cal H}_{i}$. For every edge $e\in\mathcal{H}_{i}$, we add a corresponding edge $e^{\prime}\in E_{i}$ to the final spanner. The main technical part is this simulation, which is difficult since the communication graph $G$ is not the graph ${\cal G}_{i}$ for which we want a spanner. We distinguish between small and large clusters; for the former we use $\mathcal{L}$ to pipeline information inside the clusters, while for the latter we convergecast all the relevant information to a single vertex, and then broadcast the decisions made by this vertex to the entire graph. For this approach to be efficient we need to refine the partition to clusters, so that small clusters will have bounded hop-diameter, and also ensure there are few large clusters, to bound the convergecast and broadcast time.

Net Construction.

Our algorithm for an $(\alpha,\beta)$-net imitates, on a high level, previous ruling sets algorithms (like [Lub86, MRSZ11]).777In fact, these papers showed algorithms for Maximal Independent Sets (MIS), but a $(k,k)$-ruling set is an MIS for the graph $G^{k}$. Ideally, the net construction works as follows. Initially, all vertices are active. In each round, sample a permutation $\pi$. Each (active) vertex $v$ which is the first in the permutation with respect to (w.r.t.) its $\beta$-neighborhood joins the net. Every vertex for which some vertex from its $\alpha$-neighborhood joined the net, becomes inactive. Repeat until all vertices become inactive.

In order to check whether a vertex is the first in the permutation w.r.t. its $\beta$-neighborhood, we use Least Element (LE) lists [Coh97]. Given a permutation $\pi$, a vertex $u$ belongs to the LE list of a vertex $v$, if $u$ is the first in the permutation among all the vertices at distance at most $d_{G}(v,u)$ from $v$. In particular, given the LE list of $v$, we can check whether it should join the net or not. Efficient distributed computation of an LE list is presented in [FL16]. However, rather than computing the list w.r.t. the graph $G$, [FL16] compute LE list w.r.t. an auxiliary graph $H$ that approximates $G$ distances up to a $1+\epsilon$ factor. Fortunately, we can cope with the approximation by taking $\alpha>(1+\epsilon)\beta$. Once we compute the lists and choose which vertices will be added to the net, we compute an (approximate) shortest path tree rooted in the net points. All vertices at distance at most $\alpha$ from net points become inactive. This concludes a single round. After $O(\log n)$ rounds all vertices become inactive w.h.p.. The running time is dominated by the LE lists computations.

We also provide a lower bound on the number of rounds required to construct a net, by a reduction to the problem of approximating the weight of an MST.

Light Spanner for Doubling Metrics.

The basic idea for constructing spanners for doubling metrics is quite simple and well known. For every distance scale $\Delta$, construct an $(\alpha,\beta)$-net $N_{\Delta}$ where $\alpha,\beta\approx\epsilon\Delta$, and connect by a shortest path every pair of net points at distance at most $\Delta$. The stretch bound follows standard arguments, based on the covering property of nets. To prove lightness, we will use a packing argument, stating that every net point has at most $\epsilon^{-O({\rm ddim})}$ other net points at distance $\Delta$, and every net point must contribute to the MST weight at least $\epsilon\cdot\Delta$.

The main issue is implementing this algorithm efficiently in the CONGEST model. An efficient distributed construction of nets was already described above, and the remaining obstacle is to connect nearby net points. The problem is that the shortest path between nearby net points may contain many vertices, and we cannot afford to add these sequentially. We resolve this issue by conducting a $\Delta$-bounded multi-source approximate shortest paths (from each net point) based on hopsets. Roughly speaking, a hopset is a set of (virtual) edges added to the graph, so that every pair has an approximate shortest path containing few edges. We use the path-reporting hopsets of [EN16], so that the actual paths are added to the spanner. The running time is indeed bounded: we use the packing property of nets to show that every vertex participates in a bounded number of such approximate shortest path computations.

1.5 Organization

In Section 3 we devise an Eulerian traversal of the MST, which will be used in the following sections. In Section 4 we present our distributed construction of an SLT. In Section 5 we show our light spanners for general graphs. The construction of nets for general graphs is shown in Section 6, and their application to light spanners for doubling graphs is in Section 7. Finally, the lower bounds are in Section 8.

2 Preliminaries

Let $G=(V,E,w)$ be a weighted graph with $n$ vertices, and let $d_{G}$ be the induced shortest path metric with respect to the weights. We assume that the minimal edge weight is 1, and that the maximal weight is ${\rm poly}(n)$. For $v\in V$ denote by $N(v)=\{u\in V~{}:~{}\{u,v\}\in E\}$ its set of neighbors, and by $N^{+}(v)=N(v)\cup\{v\}$. For a set $C\subseteq V$, the induced graph on $C$ is $G[C]$. The weak diameter of $C$ is $\max_{u,v\in C}\{d_{G}(u,v)\}$ and its strong diameter is $\max_{u,v\in C}\{d_{G[C]}(u,v)\}$. The hop-diameter of $G$ is defined as its diameter while ignoring the weights.

In the CONGEST model of distributed computation, the graph $G$ represents a network, and every vertex initially knows only the edges incident on it. Communication between vertices occurs in synchronous rounds. On every round, each vertex may send a small message to each of its neighbors. Every message has size at most $O(\log n)$ bits. The time complexity is measured by the number of rounds it takes to complete a task (we assume local computation does not cost anything). Often the time depends on $n$, the number of vertices, and $D$, the hop-diameter of the graph. The following lemma formalizes the broadcast ability of a distributed network (see, e.g., [Pel00]).

Lemma 1**.**

Suppose every $v\in V$ holds $m_{v}$ messages, each of $O(1)$ words888We assume a word size is $\log n$ bits., for a total of $M=\sum_{v\in V}m_{v}$. Then all vertices can receive all the messages within $O(M+D)$ rounds.

A Breadth First Search (BFS) tree $\tau$ of $G$ of hop-diameter $D$ (ignoring the weights) can be computed in $O(D)$ rounds. Since all our algorithms have a larger running time, we always assume that we have such a tree at our disposal.

3 Eulerian Tour of the MST

Let $G=(V,E,w)$ be a weighted graph on $n$ vertices with hop-diameter $D$. Let $T$ be the minimum spanning tree of $G$ with a root vertex $rt\in V$. We compute an Eulerian path $\mathcal{L}=\{rt=x_{0},x_{1},\dots,x_{2n-2}\}$ drawn by taking a preorder traversal of $T$. The order between the children of a vertex is determined using their id. We remark that in [EN18] it was described how to compute a DFS search of a tree in $\tilde{O}(\sqrt{n}+D)$ rounds. However, that paper also had the property that each vertex uses at most $O(\log n)$ words of memory. We give the full details here for completeness, and also since the presentation is somewhat simpler without the bound on the memory usage.

For a vertex $x\in\mathcal{L}$, let $R_{x}=d_{\mathcal{L}}(rt,x)$ be the time visiting $x$ in $\mathcal{L}$. The total length of the traversal $\mathcal{L}$ (that is $R_{x_{2n-2}}$) equals $2\cdot w(T)$. The number of appearances of each vertex $v\in V$ in $\mathcal{L}$ equals to its degree in $T$ (other that the root $rt$ who has $\deg(rt)+1$ appearances). We will treat each such appearance as a separate vertex. That is $\mathcal{L}$ is a path graph. See figure on the right for an illustration. For a vertex $v\in V$, let $\mathcal{L}(v)\subseteq\mathcal{L}$ be the set of appearances of $v$ in $\mathcal{L}$. In the remainder of this section we will prove the following lemma, that computes the traversal $\mathcal{L}$ in $\tilde{O}(\sqrt{n}+D)$ rounds, meaning that each vertex $v$ will know $\mathcal{L}(v)$ and the visiting time of every vertex $x\in\mathcal{L}(v)$.

Lemma 2** (MST traversal).**

Let $G=(V,E,w)$ be a weighted graph with $n$ vertices, hop-diameter $D$ and root $rt\in V$, then there is a deterministic algorithm in the CONGEST model that computes $\mathcal{L}$ in $\tilde{O}(\sqrt{n}+D)$ rounds.

3.1 Computing the MST Fragments Tree

In [Elk17b], following [KP98], a deterministic MST construction in the CONGEST model with $\tilde{O}(\sqrt{n}+D)$ rounds was shown. The algorithm has two phases, according to the hop-diameter of the fragments. At the end of the first phase, there is a set of $O(\sqrt{n})$ fragments $\mathcal{F}=\{F_{1},F_{2},\dots\}$, each with hop-diameter $O(\sqrt{n})$. These fragments are called base fragments. The edges added in the first phase are called internal edges (as each such edge is internal to some base fragment). In the second phase of the algorithm, the remaining $O(\sqrt{n})$ edges are added and connect the fragments to a tree. We call these edges external edges, as they cross between base fragments.

Let $T^{\prime}$ be a virtual tree with the base fragments $\mathcal{F}$ as vertices, and with the external edges as its edge set (i.e. there is an edge between $F_{i}$ and $F_{j}$ if there is an external edge between a vertex in $F_{i}$ to a vertex in $F_{j}$). Since there are $O(\sqrt{n})$ vertices in $T^{\prime}$, in $O(\sqrt{n}+D)$ rounds we can broadcast $T^{\prime}$ to all the vertices $V$. We will think of the MST $T$ as a tree rooted in $rt$, and of $T^{\prime}$ as a tree rooted at the fragment $F_{1}$ containing $rt$. Using the information above, every vertex in each base fragment $F_{i}$ can learn the structure of the MST on the fragments $T^{\prime}$, and infer its parent base fragment $p(F_{i})$. If the MST edge connecting $F_{i}$ to $p(F_{i})$ is $(u,v)$ (where $u\in F_{i}$), then $p(u)=v$, and we set $r_{i}=u$ to be the root of the base fragment $F_{i}$. For $F_{1}$, $r_{1}=rt$ will be its root. Set $\mathcal{R}=\{r_{1},r_{2},\dots\}$ to be the set of base fragment root vertices. See Figure 1 for an illustration.

3.2 Computing Tour Lengths

For $v\in F_{i}$, let $\ell(v)$ denote the length of the tour of the subtree of $F_{i}$ rooted at $v$. This is the local tour length for $v$, which is simply twice the sum of edge weights in that subtree. In addition, denote by $g(x)$ the length of the tour of the subtree of $T$ rooted at $v$, which is the global tour length for $v$. See Figure 1 for an example.

The computations of the local tour lengths is done locally in each base fragment, i.e. in all the base fragments in parallel. Consider $F_{i}$. Initially $\ell(v)=0$ for every leaf $v\in F_{i}$. Every intermediate vertex $u\in F_{i}$ that received messages from all its children in $F_{i}$, denoted $z_{1},\dots,z_{k}$, computes $\ell(u)=\sum_{i=1}^{k}\left(\ell(z_{i})+2\cdot w(u,z_{i})\right)$, and sends $\ell(u)$ to its own parent. Using the bounded hop-diameter of the base fragments, this procedure will terminate in $O(\sqrt{n})$ rounds. When this stage concludes, every $v\in V$ knows $\ell(v)$.

After the computation of the local tour lengths, all the root vertices $\mathcal{R}$ broadcast to the entire graph their local tour lengths $\ell(r_{1}),\ell(r_{2})\dots$ in $O(\sqrt{n}+D)$ rounds. As the tree $T^{\prime}$ is known to the entire graph, all the vertices can compute locally the global tour lengths $g(r_{1}),g(r_{2})\dots$ of the roots. Specifically, for $r_{i}$ the root of the base fragment $F_{i}$, consider its descendent base fragments $\mathcal{F}^{\prime}$ in $T^{\prime}$. Denote by $r_{F}$ the root of the base fragment $F$ and by $e_{F}$ the external edge connecting $F$ to $p(F)$, its parent fragment. Then

[TABLE]

The computation of the global tour lengths for non-roots is done locally in a similar manner as the local tour lengths. For a vertex $v\in F_{i}$, let $\tilde{z}_{1},\dots,\tilde{z}_{k}$ be its children in $T$, then

[TABLE]

If $v$ is a leaf of some $F_{i}$ then it can compute $g(v)$ (since all its children are in ${\cal R}$), and then send $g(v)$ to it parent. Every intermediate vertex $v$ of $F_{i}$ can compute $g(v)$ as soon as it received messages from all its children in $F_{i}$, and then send $g(v)$ to its own parent. As we run this procedure in all the fragments in parallel, it terminates in $O(\sqrt{n})$ rounds. When this stage concludes, every $v\in V$ knows $g(v)$.

3.3 Computing Tour Visit Times

Finally we compute for every vertex $v\in V$ the set $\mathcal{L}(v)$ and all its tour visiting times. This can be achieved by running a DFS search from the root $rt$. Direct implementation of the DFS algorithm will take $\Omega(n)$ rounds. Instead, we will use a similar idea to the one above to speed-up the computation. First we will compute “local” DFS in the base fragments. Then aggregate these times into a global DFS, first for the roots $\mathcal{R}$, and afterwards to all of $V$.

First we compute the “local” DFS visiting times. We will compute the visiting times in all the fragments in parallel. Consider $F_{i}$. For every $v\in F_{i}$ we will compute the entering and exit DFS time, for the global subtree of $T$ rooted at $r_{i}$ (rather than only in $F_{i}$). For a vertex $v\in F_{i}$, denote by $t_{i}(v)$ the interval between the first “local” entrance to the last exit. The computation is performed top to bottom. First for $r_{i}$, $t_{i}(r_{i})=[0,g(r_{i})]$. Next, consider a vertex $v\in F_{i}$ that received its interval $t_{i}(v)=[a,b]$. By induction $b-a=g(v)$. Denote by $z_{1},\dots,z_{k}$ all the children of $v$ in $T$ (inside and outside $F_{i}$). Then $v$ will send each child $z_{j}$ its interval, where

[TABLE]

Note that the length of the interval $t_{i}(z_{j})$ is exactly $g(z_{j})$. (We remark that roots in ${\cal R}$ do not initiate another interval assignment when they receive message from their parent in $T$.) This procedure will terminate in $O(\sqrt{n})$ rounds (the hop-diameter of any base fragment), where each vertex $v\in F_{i}$ knows $t_{i}(v)$. Moreover, consider a root vertex $r_{i}$ (other than $rt$), such that $p(r_{i})\in F_{j}$. Then by the description of the algorithm, in addition to $t_{i}(r_{i})$, $t_{i}$ also knows $t_{j}(r_{i})$, its interval in the DFS tour in the subtree rooted in $r_{j}$.

Finally we are ready to compute the global DFS intervals. Note that all we are actually missing here, is the first time visit of each root vertex. That is, we will compute a shift $s_{i}$ for every root $r_{i}$. First, each root vertex $r_{i}$ broadcasts to $rt$ (through $\tau$), its local interval $t_{i}(r_{i})$ and its local interval in its parent fragment $t_{j}(r_{i})$ (assuming $p(r_{i})\in F_{j}$). This take $O(\sqrt{n}+D)$ rounds. Now, $rt$ has all the required information in order to compute the DFS intervals for $\mathcal{R}$. Initially $t(rt)=t_{1}(rt)$. Next, by induction assume that $rt$ computed the interval $t(r_{j})=[s_{j},s_{j}+g(r_{j})]$ for some $r_{j}\in\mathcal{R}$. Then for every $r_{i}\in\mathcal{R}$ such $p(r_{i})\in F_{j}$ and $t_{j}(r_{i})=[b,b+g(r_{i})]$, we compute $t(r_{i})=[s_{j}+b,s_{j}+b+g(r_{i})]=[s_{i},s_{i}+g(r_{i})]$. Eventually $rt$ knows the global DFS intervals of all the roots $\mathcal{R}$ and can broadcast it to all the vertices in $O(\sqrt{n}+D)$ rounds. Consider a vertex $v\in F_{j}$. Given its local interval $t_{j}(v)=[a,b]$ and the shift $s_{j}$, $v$ computes its global interval $t(v)=[s_{j}+a,s_{j}+b]$. This is done locally in all the fragments.

We conclude that in $\tilde{O}(\sqrt{n}+D)$ rounds every vertex $v$ can know its DFS interval. As every vertex can also compute the DFS intervals of it’s children (in $T$), both $\mathcal{L}(v)$ and the visiting times of $\mathcal{L}(v)$ are easily computed.

4 Shallow Light Tree (SLT)

In this section we present our SLT construction. Recall that an $(\alpha,\beta)$-SLT of $G$ with a root $rt$ is a tree $T_{\rm SLT}$ that satisfies: 1) $\forall~{}v\in V,~{}d_{T_{\rm SLT}}(rt,v)\leq\alpha\cdot d_{G}(rt,v)$, and 2) $w(T_{\rm SLT})\leq\beta\cdot w(MST)$. We show the following theorem.

Theorem 1** (SLT).**

There is a deterministic distributed algorithm in the CONGEST model, that given a weighted graph $G$ with $n$ vertices and hop-diameter $D$, root vertex $rt$ and parameter $\epsilon>0$, constructs an $(1+\epsilon,1+O(\frac{1}{\epsilon}))$-SLT in $\tilde{O}\left(\sqrt{n}+D\right)\cdot{\rm poly}(\epsilon^{-1})$ rounds.

Initially we will assume that $\epsilon\in(0,1)$. Afterwards, we will show how to generalize our result to $\epsilon\geq 1$.

Intuitively, in order to construct an SLT, one should combine the MST tree $T$ of $G$ with a shortest path tree rooted at $rt$. Unfortunately, currently existing algorithms for constructing exact shortest path tree [Elk17a, GL18] require more than $\tilde{O}(\sqrt{n}+D)$ rounds. Instead, we will use an approximate shortest path tree of [BKKL17]. Specifically, they show that given a root vertex $rt$ and a parameter $\epsilon\in(0,1]$, one can compute an approximate shortest path tree $T_{rt}$ in $\tilde{O}((\sqrt{n}+D)/{\rm poly}(\epsilon))$ rounds. The approximation here is in the sense that for every vertex $v$,

[TABLE]

Our strategy to construct the SLT is similar to the framework of [ABP92, KRY95]. First, construct an MST $T$ and an approximate shortest path $T_{rt}$ (rooted at $rt$). Next, choose a subset of vertices $\rm BP$ called Break Points. An intermediate graph $H$ will be constructed as a union of $T$, and the paths in $T_{rt}$ from $rt$ to all the vertices in $\rm BP$. We will argue that $H$ has lightness $O(\frac{1}{\epsilon})$, and approximate distance to $rt$ up to a $1+O(\epsilon)$ factor. Our final SLT will be constructed as yet another approximate shortest path tree in $H$ (rooted at $rt$). The main difference from previous works is that a refined selection of breakpoints is required, in order to ensure efficient implementation in the CONGEST model. In previous algorithms $\rm BP$ was chosen sequentially, i.e., break points were determined one after another. In contrast, we have two phases. In the first phase we choose the $\rm BP$ locally, while in the second phase we somewhat sparsify the set $\rm BP$ using a global computation.

We remark that [KRY95] gave an efficient implementation of their algorithm in the PRAM CREW model with $n$ processors in $O(\log n)$ rounds. However, this implementation uses pointer jumping techniques which cannot be translated to the CONGEST model.

4.1 Break Points Selection

Before picking the break points, we create traversal $\mathcal{L}$ of the MST $T$ (rooted at $rt$) as in Section 3, such that each vertex $v\in V$ knows its appearances $\mathcal{L}(v)$ and visiting times $R_{x}$ for any $x\in\mathcal{L}(v)$. We will treat vertices with duplications according to their appearances on $\mathcal{L}$. That is, $v$ will simulate different vertices in $\mathcal{L}$ (and even can be chosen to $\rm BP$ several times). Note that every neighbor $u$ of $v$ in $G$ is a neighbor of exactly two vertices in $\mathcal{L}(v)$ (w.r.t $\mathcal{L}$), and therefore $v$ indeed can act in several roles without congestion issues. In addition, each vertex $x_{i}\in\mathcal{L}$ will know its index $i$ (i.e., how many vertices precede him in $\mathcal{L}$ an not only the weighted visiting time $R_{x_{i}}$). This information can be obtained by running the same algorithm that finds visiting times, ignoring the weights.

Set $\alpha=\left\lceil\sqrt{n}\right\rceil$. We will construct $\rm BP$ in several steps. The initial set of break points will be $\rm BP^{\prime}=\{x_{0},x_{\alpha},x_{2\alpha},x_{3\alpha},\dots\}$, i.e., all the vertices whose index is a multiple of $\alpha$. Next, we create a break point set $\rm BP_{1}$ from $\mathcal{L}\setminus\rm BP^{\prime}$. In each interval $I_{i}=\{x_{i\alpha},x_{i\alpha+1},\dots,x_{(i+1)\alpha-1}\}$ in parallel we will add points to $\rm BP_{1}$. Initially, for every $i$, $x_{i\alpha}$ sends a message to $x_{i\alpha+1}$ with the information $\left(x_{i\alpha},R_{x_{i\alpha}}\right)$. Generally, each vertex $x_{j}\in I_{i}$ will get at some point a message $\left(y,R_{y}\right)$ from $x_{j-1}$. The interpretation is that $y$ is the most recent addition to $\rm BP_{1}$, with the additional information of $R_{y}$. Now, $x_{j}$ will join $\rm BP_{1}$ if the following condition holds:

[TABLE]

Note that $d_{T_{rt}}(rt,x_{j})$ is an information locally known to $x_{j}$ from the approximate shortest path computation. Now, $x_{j}$ will send a message to $x_{j+1}$. If $x_{j}$ joined $\rm BP_{1}$, the message will be $\left(x_{j},R_{x_{j}}\right)$. Otherwise the message will be $\left(y,R_{y}\right)$. After $\alpha-1$ rounds this procedure ends, and each internal vertex $x\notin\rm BP^{\prime}$ knows whether it joins $\rm BP_{1}$ or not.

We cannot allow all the vertices in $\rm BP^{\prime}$ to become break points (as we have no bound on the weight of all the shortest paths from $rt$ towards them). Filtering which vertices among $\rm BP^{\prime}$ will actually join $\rm BP$ will be done in a centralized fashion. All the vertices $x_{i\alpha}\in\rm BP^{\prime}$ will broadcast to $rt$ the message $\left(x_{i\alpha},R_{x_{i\alpha}}\right)$. By Lemma 1 this can be done in $O(\sqrt{n}+D)$ rounds (since there are at most $2\sqrt{n}$ relevant indices $0<i\leq 2n-2$). The root $rt$ locally creates the set $\rm BP_{2}\subseteq\rm BP^{\prime}$ as follows. Initially $rt=x_{0}$ joins $\rm BP_{2}$. Next, sequentially, for $x_{i\alpha}$ where $y\in\rm BP^{\prime}$ was the last vertex to join $\rm BP_{2}$, $x_{i\alpha}$ will join $\rm BP_{2}$ if $d_{\mathcal{L}}(x_{i\alpha},y)=R_{x_{i\alpha}}-R_{y}>\epsilon\cdot d_{T_{rt}}(rt,x_{i\alpha})$. After this local computation, $rt$ will broadcast to the entire graph the set $\rm BP_{2}$ in $O(\sqrt{n}+D)$ rounds. Define the final set of breakpoints as $\rm BP=\rm BP_{1}\cup\rm BP_{2}$. (Intuitively, this step computes an SLT for the submetric of the original metric, induced by the set $\rm BP^{\prime}$.)

4.2 The Creation of $H$

For a point $b\in\rm BP$, let $P_{b}$ be the unique path from $rt$ to $b$ in $T_{rt}$. Let $H=T\cup\bigcup_{b\in\rm BP}P_{b}$. Denote by $A_{\rm BP}$ the set of vertices whose subtree in $T_{rt}$ contains a vertex of $\rm BP$. Each vertex knows whether it belongs to $\rm BP$, and we would like to ensure that every $v\in A_{\rm BP}$ will add an edge to its parent in $T_{rt}$. Then adding the MST edges will conclude the construction of $H$. In the remaining part of this sub-section we show the computation of $A_{\rm BP}$.

We start by creating a set $\mathcal{F}$ of $O(\sqrt{n})$ fragments, which are subtrees of $T_{rt}$ of hop-diameter $O(\sqrt{n})$ (this could be done by applying the first phase of the MST algorithm of [KP98], see Section 3.1 for more details). Each fragment can locally (in parallel) compute in $O(\sqrt{n})$ rounds whether it contains a break point, since it has bounded hop-diameter. Next, each fragment sends to $rt$ its id, whether it contains a break point, and all of its outgoing edges in $T_{rt}$. Note there is a total of $O(\sqrt{n})$ messages in this broadcast, so by Lemma 1 this will take $O(\sqrt{n}+D)$ rounds (in fact, all vertices will receive all these messages). Now, $rt$ can form a virtual tree $T^{\prime}$ whose vertices are the fragments $\mathcal{F}=\{F_{1},F_{2},\dots\}$, and its edges connect fragments $F_{i},F_{j}$ if there is an edge of $T_{rt}$ between a vertex of $F_{i}$ to a vertex of $F_{j}$. Now, we can also assign roots $r_{1},r_{2},\dots$ (where $r_{i}\in F_{i}$ and $r_{1}=rt$), so that $r_{i}$ is the vertex with an edge in $T_{rt}$ to a vertex in the parent of $F_{i}$ in $T^{\prime}$. (See Section 3 for more details and a picture of the virtual tree and its roots.)

Then, $rt$ is able to compute locally for every root $r_{i}\in F_{i}$ whether $r_{i}\in A_{\rm BP}$ (i.e. its subtree contains a break point), simply by inspecting whether $F_{i}$ has a descendant in $T^{\prime}$ with a break point. Then broadcast this information on all roots in $O(\sqrt{n}+D)$ rounds. Note that now every local leaf $v\in F_{i}$ knows whether its subtree contains a break point. Finally, locally in parallel in $O(\sqrt{n})$ rounds, in all the fragments $F_{i}$ we can compute for every vertex $v\in F_{i}$ whether $v\in A_{\rm BP}$.

4.3 Stretch and Lightness Analysis

In this subsection we argue that $H$ has the desired lightness and stretch. We name the break points $\rm BP_{1}=\{b_{0},b_{1},\dots\}$, $\rm BP_{2}=\{\tilde{b}_{0},\tilde{b}_{1},\dots\}$ according to the order of their appearance in $\mathcal{L}$. It is clear by construction that for every pair of consecutive break points $\tilde{b}_{j-1},\tilde{b}_{j}\in\rm BP_{2}$, $d_{\mathcal{L}}(\tilde{b}_{j},\tilde{b}_{j-1})>\epsilon\cdot d_{T_{rt}}(rt,\tilde{b}_{j})$. We claim that this property remain true also for every consecutive break points $b_{j-1},b_{j}\in\rm BP_{1}$. Indeed, let $i$ such that $b_{j}\in I_{i}$. If $b_{j-1}\in I_{i}$ then it follows by construction. Otherwise, $b_{j}$ is the first break point in $I_{i}$, and by Equation 2 it holds that $d_{\mathcal{L}}(b_{j},b_{j-1})>d_{\mathcal{L}}(b_{j},x_{i\alpha})>\epsilon\cdot d_{T_{rt}}(rt,b_{j})$.

Corollary 3**.**

$w(H)\leq(1+\frac{4}{\epsilon})\cdot w(T)$.

Proof.

The graph $H$ consists of three parts, $w(H)\leq w(T)+\sum_{b\in\rm BP_{1}}w(P_{b})+\sum_{\tilde{b}\in\rm BP_{2}}w(P_{\tilde{b}})$. We first bound the weight of the edges added due to $\rm BP_{1}$:

[TABLE]

Similarly for $\rm BP_{2}$, $\sum_{j\geq 1}w(P_{\tilde{b}_{j}})\leq\frac{2}{\epsilon}\cdot w(T)$. The corollary follows. ∎

Lemma 4**.**

For every $v\in V$, $d_{H}(rt,v)\leq(1+25\epsilon)\cdot d_{G}(rt,v)$.

Proof.

Consider a vertex $v\in V$. Let $x$ be an arbitrary vertex from $\mathcal{L}(v)$. By construction there is a point $y\in\rm BP^{\prime}\cup\rm BP_{1}$ such that

[TABLE]

Moreover, for $y$ there is a point $y^{\prime}\in\rm BP$ such that

[TABLE]

(it might be that $x=y$ or $y=y^{\prime}$). We first bound $d_{\mathcal{L}}(x,y^{\prime})$, using that $d_{G}\leq d_{\mathcal{L}}$ and the assumption $\epsilon\leq 1$.

[TABLE]

We conclude,

[TABLE]

∎

4.4 Finishing the Construction and Generalization to $\epsilon>1$

After creating the subgraph $H$, we create a $(1+\epsilon)$-shortest path tree $T_{\rm SLT}$ (using [BKKL17]) of $H$ rooted at $rt$ in $\tilde{O}(\sqrt{n}+D)/{\rm poly}(\epsilon)$ rounds. The tree $T_{\rm SLT}$ has weight at most $w(T_{\rm SLT})\leq w(H)\leq(1+\frac{4}{\epsilon})\cdot w(T)$ by Corollary 3. Moreover, by Lemma 4 for every vertex $v\in V$ it holds that

[TABLE]

By rescaling $\epsilon$, we conclude that for every $\epsilon\in(0,1)$ we can construct an $(1+\epsilon,O(\frac{1}{\epsilon}))$-SLT. This is the right behavior (up to constant factors) when the distortion is small, as shown in [KRY95]. We would like to obtain the inverse tradeoff, when the lightness is close to 1, say $1+\gamma$ for $0<\gamma<1$. If we will directly apply our construction for large $1<\epsilon=1/\gamma$, then it can be checked that we will get distortion $O(1/\gamma^{2})$ and lightness $1+\gamma$, instead of the desired $O(1/\gamma)$ distortion (roughly speaking, this is because a breakpoint in $BP^{\prime}$ may have been removed, so in the analysis we applied a chain of two breakpoints). Fortunately, we can use a reduction due to [BFN16].

Lemma 5** ([BFN16]).**

Let $G=(V,E)$ be a graph, $0<\delta<1$ a parameter and $t:{V\choose 2}\rightarrow\mathbb{R}_{+}$ some function. Suppose that we have an algorithm that for any given weight function $w:E\rightarrow\mathbb{R}_{+}$ constructs a spanner $H$ with lightness $\ell$ such that every pair $u,v\in V$ suffers distortion at most $t(u,v)$. Then for every weight function $w$ there exists a spanner $H$ with lightness $1+\delta\ell$ and such that every pair $u,v$ suffers distortion at most $t(u,v)/\delta$.

The reduction algorithm works by first changing the edge weights, and then executing the original algorithm. To compute the new weight of an edge $e\in E$, we only need to know the parameter $\delta$, the original weight $w(e)$ and whether $e$ belongs the MST. Thus we can easily use this reduction in the CONGEST model as well.

We presented an algorithm that constructs a subgraph $H$ with constant lightness (say $c$) and distortion $2$ from $rt$. We will use distortion function below,

[TABLE]

Thus, given any $0<\gamma<1$, we can apply Lemma 5 with the parameter $\delta=\gamma/c$, and obtain lightness $1+\gamma$ and distortion $O(1/\gamma)$. Theorem 1 now follows.

5 Distributed Light Spanner

In this section we devise an efficient distributed algorithm for light spanners in general graphs. In particular, we prove the following:

Theorem 2** (Light Spanner).**

There is an randomized distributed algorithm in the CONGEST model, that given a weighted graph $G=(V,E,w)$ with $n$ vertices and hop-diameter $D$, and parameters $k\in\mathbb{N}$, $\epsilon\in(0,1)$, in $\tilde{O}_{\epsilon}\left(n^{\frac{1}{2}+\frac{1}{4k+2}}+D\right)$ rounds, w.h.p. returns a $(2k-1)(1+\epsilon)$ spanner $H$ with $O_{\epsilon}(k\cdot n^{1+\frac{1}{k}})$ edges and lightness $O_{\epsilon}(k\cdot n^{\frac{1}{k}})$.

Our algorithm is similar in spirit to the algorithms of [CDNS95, ES16, ENS15]. It begins by computing a traversal $\mathcal{L}=\{rt=x_{0},x_{1},\dots,x_{2n-2}\}$ of the MST $T$, as in Section 3. In particular, every vertex $v$ knows the set of its appearances $\mathcal{L}(v)$, and the visiting times and indices of every $x\in\mathcal{L}(v)$. Let $L=w(\mathcal{L})=2w(T)$ denote the length of $\mathcal{L}$. Note that the value $L$ is known to all the vertices (or can be broadcasted in $O(D)$ rounds).

Set $E^{\prime}=\{e\in E~{}:~{}w(e)\leq L/n\}$, and for every $i\in\{0,1,\dots,\left\lceil\log_{1+\epsilon}n\right\rceil\}$ set $E_{i}=\{e\in E~{}:~{}\frac{L}{(1+\epsilon)^{i+1}}<w(e)\leq\frac{L}{(1+\epsilon)^{i}}\}$. The algorithm constructs a different spanner for each edge set, and the final spanner will be a union of all these spanners. First, build a spanner $H^{\prime}$ for the low weight edges $E^{\prime}$. This is done using the algorithm of Baswana and Sen [BS07]. Specifically we run [BS07] on the graph $G^{\prime}=(V,E^{\prime})$. In $O(k)$ rounds999The original paper claimed $O(k^{2})$ rounds, but it has been observed that their algorithm can be implemented in $O(k)$ rounds. we get a $(2k-1)$-spanner $H^{\prime}$ of $G^{\prime}$, where the expected number of edges is bounded by $O(k\cdot n^{1+1/k})$.

Next, for every $i\in\{0,1,\dots,\left\lceil\log_{1+\epsilon}n\right\rceil\}$ we will define a cluster graph ${\cal G}_{i}$, on which we will simulate a spanner for unweighted graphs. For each $i$, we partition $V$ into clusters ${\cal C}_{i}$. Let $\mathcal{G}_{i}$ be an unweighted graph with $\mathcal{C}_{i}$ as its vertex set, and there is an edge between two clusters $A,B$ if there are vertices $a\in A,~{}b\in B$ such that $\{a,b\}\in E_{i}$.

In [ES16, ENS15] the greedy spanner was applied on each ${\cal G}_{i}$. However, we cannot do so efficiently in a distributed setting. Instead, we will use the randomized algorithm of [EN17b] on each ${\cal G}_{i}$. For an unweighted graph with $N$ vertices, that algorithm provides (with constant probability) a $(2k-1)$-spanner with $O(N^{1+1/k})$ edges, computed in $k$ rounds. Even though [EN17b] gave an efficient distributed implementation, the input graph ${\cal G}_{i}$ is not the communication graph $G$. Our main technical contribution in this section is an adaptation of that algorithm for the cluster graphs ${\cal G}_{i}$, which also requires some changes in the partition that generates these graphs.

The algorithm of [EN17b] runs in $k$ rounds. Initially, every vertex $x$ independently samples a value $r(x)$ from some distribution. In the first round $x$ initializes $m(x)=r(x)$, $s(x)=x$ and sends $(s(x),m(x)-1)$ to all its neighbors. In each following round, every vertex $x$ that received messages $\{(s(v),m(v))\}_{v\in N(x)}$ from its neighbors in the previous round, computes $u=\rm argmax_{v\in N^{+}(x)}\{m(v)\}$, updates $m(x)=m(u)$ and $s(x)=s(u)$, and sends $(s(x),m(x)-1)$ to all its neighbors. After $k$ rounds, each vertex $x$ adds to the spanner edges: for every vertex $y$, add one edge to an arbitrary vertex in the set $\{v\in N(x)~{}:~{}m(v)\geq m(x)-1\wedge s(v)=y\}$, if exists (in other words, for every source $y$ whose message reached $x$ with value at least $m(x)-1$, we add 1 edge to the spanner, from $x$ to a neighbor $v$ that sent $x$ the message on $y$). A useful property of the algorithm is that the stretch is guaranteed101010For the stretch bound, the random samples $r(x)$ need to satisfy $r(x)<k$, which can be verified locally. The stretch analysis in [EN17b] is conditioned on the event $\forall x\in V~{}:~{}r(x)<k$. while the number of edges is bounded in expectation.

In order to implement this algorithm in ${\cal G}_{i}$, the vertices in each cluster $C\in{\cal C}_{i}$ need to compute the maximum over all the values they received from their neighbors in the previous round, and then send this value. Finally, we need to make sure that for every pair of clusters we want to connect, only one edge is added. We will distinguish between two cases, as long as the hop diameter of clusters is not too large, they can compute locally the maximum value. When the hop diameter is too large, we will ensure that there are few clusters, and all the relevant information will be broadcasted to the entire graph.

Case 1: $i<\log_{1+\epsilon}(\epsilon\cdot n^{\frac{k}{2k+1}})$.

Set $w_{i}=\frac{L}{(1+\epsilon)^{i}}$. We now describe the partition of $V$ into clusters $\mathcal{C}_{i}$. Each cluster $C\in{\cal C}_{i}$ has a name in $\{0,1,2,\dots,\frac{L}{\epsilon\cdot w_{i}}\}$, and its weak diameter is at most $\epsilon\cdot w_{i}$ w.r.t the MST metric (i.e. for any $u,v\in C$, $d_{T}(u,v)\leq\epsilon\cdot w_{i}$). Let $v\in V$, and $x\in\mathcal{L}(v)$ be an arbitrary appearance. Then $v$ will belong to the cluster $\left\lceil\frac{R_{x}}{\epsilon\cdot w_{i}}\right\rceil$ (recall that $R_{x}=d_{\cal L}(rt,x)$). The weak diameter is indeed bounded, as for every $v,u\in V$ which both belong to the same cluster $j$, it holds that there are $x^{\prime}\in\mathcal{L}(v)$, $x^{\prime\prime}\in\mathcal{L}(u)$ such that $\left|R_{x^{\prime}}-R_{x^{\prime\prime}}\right|\leq\epsilon\cdot w_{i}$, hence $d_{T}(u,v)\leq d_{\mathcal{L}}(x^{\prime},x^{\prime\prime})\leq\epsilon\cdot w_{i}$. Note that each vertex belongs to a single cluster. The number of clusters is bounded by $\left\lceil\frac{L}{\epsilon\cdot w_{i}}\right\rceil+1=\left\lceil\frac{(1+\epsilon)^{i}}{\epsilon}\right\rceil+1\leq\left\lceil n^{\frac{k}{2k+1}}\right\rceil+1$.

Before the rounds simulations, each vertex $v\in V$ sends the identity of its cluster to all its neighbors. Additionally, $rt$ samples a value $r_{A}$ for every cluster $A\in\mathcal{C}_{i}$, and broadcasts all these values to all the vertices in $O(|\mathcal{C}_{i}|+D)$ rounds, using Lemma 1. Next, we describe how to implement a single round. In the beginning of the round, each vertex knows the message $(s(A),m(A))$ that all clusters $A\in{\cal C}_{i}$ sent in the previous round. The simulation has three phases: (1) Local phase: each vertex $v\in A$, computes the maximum $m(B)$ over all neighboring clusters $B$. No communication required, as $v$ knows the clusters of its neighbors and their messages. (2) Convergecast phase: we convergecast $(s(A),m(A))$ towards $rt$ on the BFS tree $\tau$. Each vertex $v$ that received all messages from its children in $\tau$ for a cluster $A$, will only forward the one with maximum $m(A)$. Therefore each vertex will forward only $|\mathcal{C}_{i}|$ messages, and we can pipeline all the messages of the second phase in $O(|\mathcal{C}_{i}|+D)$ rounds. (3) Broadcast phase: the root $rt$ broadcasts all the new messages $(s(A),m(A))$ for all clusters $A\in{\cal C}_{i}$ to all the graph in $O(|\mathcal{C}_{i}|+D)$ rounds.

After $k$ such rounds we add edges to the spanner by a convergecast of all the spanner edges towards $rt$ using $\tau$. Let $\mathcal{H}_{i}$ be the spanner of $\mathcal{G}_{i}$. In [EN17b] it is shown that in expectation $|\mathcal{H}_{i}|=O(|\mathcal{C}_{i}|^{1+\frac{1}{k}})$. Consider a vertex $v\in A$. For every cluster $B$ such that $\{A,B\}\in\mathcal{H}_{i}$ and there is a neighbor $u\in B$ of $v$, $v$ will send $((u,v),(A,B))$ towards $rt$. On the other hand, each vertex receiving edges from $A\times B$, will forward only a single such edge. After $O(|\mathcal{C}_{i}|^{1+\frac{1}{k}}+D)$ rounds the center $rt$ knows $\mathcal{H}_{i}$, and for every edge $(A,B)\in\mathcal{H}_{i}$ it knows a representative $(a,b)\in A\times B$. In additional $O(|\mathcal{C}_{i}|^{1+\frac{1}{k}}+D)$ rounds $rt$ broadcasts all these edges and $H_{i}$ is created accordingly. The total number of rounds to implement each iteration of [EN17b] is

[TABLE]

Case 2: $\log_{1+\epsilon}(\epsilon\cdot n^{\frac{k}{2k+1}})<i\leq\log_{1+\epsilon}(n)$.

Set $w_{i}=\frac{L}{(1+\epsilon)^{i}}$. Similarly to the previous regime, we will partition the graph into clusters $\mathcal{C}_{i}$ with weak diameter $\epsilon\cdot w_{i}$. However, as the number of clusters will be large, computations will be done locally in the clusters. In order to make the local computations efficient, we will refine the partition into clusters such that each cluster will have bounded (weak) hop-diameter . We start by choosing cluster centers. A vertex $x_{j}\in\mathcal{L}$ is a cluster center if one of the following conditions is fulfilled:

There is an integer $s$ such that $R_{x_{j-1}}<s\cdot(\epsilon\cdot w_{i})\leq R_{x_{j}}$. 2. 2.

$j$ is a multiple of $\left\lceil\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}\right\rceil$ (that is, there is an integer $q$ such that $j=q\cdot\left\lceil\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}\right\rceil$).

Note that $x_{0}$ is a center. For every vertex $x_{b}\in\mathcal{L}$, consider the closest center $x_{a}$ left of $x_{b}$ (w.r.t $\mathcal{L}$). It holds that $R_{x_{b}}-R_{x_{a}}<\epsilon\cdot w_{i}$ and $b-a<\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}$. Moreover, the total number of centers is bounded by $\frac{L}{\epsilon\cdot w_{i}}+\frac{n}{\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}}=\frac{2\cdot(1+\epsilon)^{i}}{\epsilon}$. In particular, each vertex can compute whether it is a center locally. For every vertex $v\in V$, pick an arbitrary $x_{j}\in\mathcal{L}(v)$, and let $j^{\prime}\leq j$ be the largest such that $x_{j^{\prime}}$ is a center. Then $v$ joins the cluster $C(x_{j^{\prime}})$ of $x_{j^{\prime}}$. If $x_{a},x_{b}$ are two consecutive cluster centers, then $I(x_{a})=\{x_{a},x_{a+1},x_{a+2},\dots,x_{b-1}\}$ will be the communication interval for the cluster $C(x_{a})$. Note that $C(x_{a})\subseteq I(x_{a})$ (they need not be equal, since each vertex $u\in V$ has several possible representatives in $\mathcal{L}(u)$).

Note that the hop-diameter of $I(x_{a})$ is bounded by $\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}\leq n^{\frac{1}{2}+\frac{1}{4k+2}}$, and also for any $u,v\in C(x_{a})$ we have $d_{T}(u,v)\leq\epsilon\cdot w_{i}$. Each vertex $v\in V$ belongs to a single cluster. However, $v$ might belong to many communication intervals. Nevertheless, every MST edge appears twice in $\mathcal{L}$, and therefore it belongs to at most two communication intervals.

In order to enable the partition to clusters, each cluster center $x_{a}$ declares itself via $I(x_{a})$. That is, it sends to the right neighbor (on $\mathcal{L}$) a message declaring itself, which is forwarded until it reaches the next center $x_{b}$. This declaration takes $\frac{\epsilon\cdot n}{(1+\epsilon)^{i}}$ rounds. At the end, each vertex chooses to which cluster it joins, becomes aware of all the communication intervals it belongs to, and sends its cluster i.d. to all its neighbors.

Now that we have defined the clustering, the simulation of each iteration of [EN17b] is done in essentially the same manner as the previous case, with the communication interval taking the role of the global BFS tree $\tau$. That is, in parallel for every cluster $C(x_{a})$ we find the maximum over the $m(v)$ by convergecast in $I(x_{a})$. In the last round we convergecast the spanner edges touching the cluster $C(x_{a})$, so we need a bound on that number. In [EN17b] it is shown that w.h.p. every vertex (cluster) adds at most $O(|{\cal C}_{i}|^{1/k}\log n)=O(n^{1/k}\log n)$ edges to the spanner. So the number of rounds required for a simulation of a single iteration is at most

[TABLE]

(assuming $k>1$.) The total number of rounds (for each $i$ in this range) is thus $O\left(k\cdot n^{\frac{1}{2}+\frac{1}{4k+2}}\right)$. This concludes the second case.

Our final spanner $H$ will be a union of the MST $T$, with the spanner $H^{\prime}$ of $G^{\prime}$, and with the spanners $H_{i}$ for all $0\leq i\leq\lceil\log_{1+\epsilon}n\rceil$. As the there are $O(\log_{1+\epsilon}n)$ different scales, we conclude that the total construction of the spanner $H$ of $G$ takes $\tilde{O}(n^{\frac{1}{2}+\frac{1}{4k+2}}+D)$ rounds.

5.1 Analysis

In this section we finish the proof of Theorem 2 by analyzing the stretch, lightness, and sparsity of the spanner $H$.

Stretch.

By the triangle inequality, it suffices to show that for every edge $\{u,v\}=e\in E$, it holds that $d_{H}(u,v)\leq(2k-1)(1+\epsilon)w(e)$. In fact, we will show a bound of $(2k-1)(1+O(\epsilon))$ on the stretch. This can be fixed later by rescaling $\epsilon$. Fix $\{u,v\}=e\in E$. We can assume that $w(e)\leq L$, as otherwise we fulfill the requirement using the MST edges only. If $e\in E^{\prime}$, then $d_{H}(u,v)\leq d_{H^{\prime}}(u,v)\leq(2k-1)\cdot w(e)$. Otherwise, let $i\geq 0$ such that $e\in E_{i}$, that is $\frac{w_{i}}{(1+\epsilon)}<w(e)\leq w_{i}$ for $w_{i}=\frac{L}{(1+\epsilon)^{i}}$. Let $A_{u},A_{v}\in\mathcal{C}_{i}$ be the clusters containing $u,v$ respectively. If $A_{u}=A_{v}$, then $d_{H}(u,v)\leq d_{T}(u,v)\leq\epsilon\cdot w_{i}\leq w(e)$ (assuming $\epsilon<1/2$, say). Otherwise, $\{A_{u},A_{v}\}$ is an edge of $G_{i}$, and therefore there is a path $A_{u}=A_{0},A_{1},\dots,A_{t}=A_{v}$ between $A_{u},A_{v}$ in $\mathcal{H}_{i}$ where $t\leq 2k-1$. In particular, for every $0\leq j<t$, we added some edge $\{v_{j},u_{j+1}\}\in A_{j}\times A_{j+1}\cap E_{i}$ to $H_{i}$. Let $u_{0}=u$ and $v_{t}=v$. As the distance between every pair of vertices in any cluster is bounded by $\epsilon\cdot w_{i}$ and the weight of all the edges in $H_{i}$ is bounded by $w_{i}$ we conclude

[TABLE]

Lightness.

We bound the lightness of $H^{\prime}$ and each of the spanners $H_{i}$. First consider $H^{\prime}$. Since the weight of every edge $e\in E^{\prime}$ is at most $L/n$, we have

[TABLE]

Next consider $H_{i}$, which has expected $O(|\mathcal{C}_{i}|^{1+\frac{1}{k}})=O\left(\left(\frac{(1+\epsilon)^{i}}{\epsilon}\right)^{1+\frac{1}{k}}\right)$ edges, all of weight bounded by $w_{i}=\frac{L}{(1+\epsilon)^{i}}$. So the expected weight of all these $H_{i}$ together is

[TABLE]

where the last equality follows as $(1+\epsilon)^{\frac{1}{k}}-1\geq e^{\frac{\epsilon}{2}\cdot\frac{1}{k}}-1\geq\frac{\epsilon}{2k}$. We conclude that the expected weight of $H$ is

[TABLE]

Sparsity.

Following the analysis of the lightness, we have

[TABLE]

We conclude,

[TABLE]

Remark 1**.**

We note that the number of edges mostly comes from the spanner $H^{\prime}$. We can in fact use the techniques developed here in order to efficiently implement the algorithm of [EN17b] for weighted graphs in the CONGEST model, which provides a $(2k-1)\cdot(1+\epsilon)$-spanner with $O_{\epsilon}(\log k\cdot n^{1+1/k})$ edges. That algorithm partitions the edges $E$ to $\approx\log k$ sets, and for each set, applies the unweighted version on a cluster graph. Since we already have an efficient distributed implementation of that unweighted algorithm, we conclude that our sparsity bound may be improved to $O_{\epsilon}(\log k\cdot n^{1+1/k})$. We leave the details to the full version.

Successes Probability.

Note that once the computation concludes, we can easily compute the size and lightness of the spanner in $O(D)$ rounds via the BFS tree $\tau$. Thus we can repeat the computation for $H^{\prime}$ and each $H_{i}$ until they meet the required bounds, which will happen w.h.p. after at most $O(\log n)$ tries. Recall that the stretch bound is guaranteed to hold.

6 Distributed Construction of Nets

In this section we devise an efficient distributed algorithm for computing nets in general graphs. Let $G=(V,E,w)$ be a weighted graph. Recall that for $\alpha>0$, a set $N\subseteq V$ is $\alpha$-covering * if for every vertex $x\in V$ there is $y\in N$ with $d_{G}(x,y)\leq\alpha$. A set $N\subseteq V$ is $\beta$-separated* if for every $x,y\in N$, $d_{G}(x,y)>\beta$. We say that a set $N$ is an $(\alpha,\beta)$-net if it is both $\alpha$-covering and $\beta$-separated. (In the literature nets are often defined with $\alpha=\beta$, but we will need the more general definition, since we will only be able to provide nets with $\alpha>\beta$.)

Our construction of nets is inspired by the MIS (maximal independent set) algorithm of [MRSZ11] (which itself is inspired by [Lub86]). The MIS algorithm works in $O(\log n)$ rounds, where in each round a permutation is sampled. A vertex joins the MIS iff it is local minimum (i.e., it appears before all its neighbors in the permutation). We will also sample a permutation. However, instead of checking only the neighbors, a vertex $v$ will join the net iff it is a local minimum in a geometric sense. I.e., $v$ appears before all the vertices of $B_{G}(v,\beta)$ in the permutation.

In order to implement this algorithm efficiently we will require several tools that have found distributed constructions recently, such as Least-Element lists and shortest path trees. However, we do not know how to compute these exactly in the allotted number of rounds, so we will settle for approximations. The rest of the section is dedicated to proving the following theorem.

Theorem 3**.**

Given a weighted graph $G=(V,E,w)$ with hop-diameter $D$ and parameters $\Delta>0$, $\delta\in(0,1)$, there is a randomized algorithm in the CONGEST model that computes w.h.p. a $\left((1+\delta)\cdot\Delta,\frac{\Delta}{1+\delta}\right)$-net in $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n}\cdot\log(1/\delta))}$ rounds.

Least Element Lists.

LE lists were introduced by [Coh97]:

Definition 1**.**

Given a weighted graph $G=(V,E,w)$, a set $A\subseteq V$ of vertices, and a permutation $\pi:A\rightarrow[|A|]$ on $A$, the LE list of a vertex $v\in A$ is defined as

[TABLE]

In words, a vertex $u\in A$ joins $\text{LE}_{G,A,\pi}(v)$, the LE list of $v$, if $u$ is first in the permutation among all the vertices at distance at most $d_{G}(v,u)$ from $v$ (alternatively, $u$ is the closest vertex to $v$ among the first $\pi(u)$ vertices in the permutation.).

Khan et. al. [KKM*+*12] showed that with high probability over the choice of the permutation $\pi$, it holds that $|\text{LE}_{G,A,\pi}(v)|=O(\log|A|)$ simultaneously for all the vertices $v\in A$. Using hopsets, Friedrichs and Lenzen [FL16] were able to efficiently compute LE lists in the CONGEST model (improving upon Ghaffari and Lenzen [GL14]) for a graph $H$ that is a good approximation of $G$. (We remark that their algorithm was given in the case $A=V$, but it is a simple adaptation to adjust it to the more general case.)

Theorem 4** ([FL16]).**

Consider a graph $G=(V,E)$ with $n$ vertices and hop-diameter $D$, a set $A\subseteq V$, and let $\delta\in(0,1)$ be any parameter. There is a randomized algorithm in the CONGEST model that uniformly samples a permutation $\pi$ and computes $\{\text{LE}_{H,A,\pi}(v)\}_{v\in V}$ for a graph $H$ such that $d_{G}(u,v)\leq d_{H}(u,v)\leq(1+\delta)\cdot d_{G}(u,v)$. The algorithm is successful w.h.p., and the number of rounds is $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n}\cdot\log(1/\delta))}$.

Algorithm.

Here we describe the algorithm promised in Theorem 3. The algorithm will run in $O(\log n)$ iterations. Initially, set $A_{1}=V$ the set of active vertices, and $N=\emptyset$. We denote by $A_{i}$ the set of active vertices for the $i$’th iteration, and by $N_{i}$ the net just after the $i$’th iteration (so $N_{0}=\emptyset$). In the $i$’th iteration, apply Theorem 4 on the graph $G$ with the set $A_{i}$ and the parameter $\delta$. We obtain a (uniformly random) permutation $\pi_{i}$ on $A_{i}$, alongside with LE lists for all $v\in A_{i}$ w.r.t $\pi_{i}$ and the graph $H_{i}$ (which is a $1+\delta$ approximation of $G$). Every $v\in A_{i}$ will join $N_{i}$ iff it is the first in the permutation order among its $\Delta$-neighborhood (w.r.t $H_{i}$). In other words, $v$ joins $N_{i}$ if there is no $u\in\text{LE}_{H_{i},A_{i},\pi_{i}}(v)$, $u\neq v$, such that $d_{H_{i}}(u,v)\leq\Delta$.

Next, we will construct an $1+\delta$ approximate shortest path tree $T_{i}$ (using [BKKL17], say) rooted in $N_{i}$. Remove from $A_{i}$ every vertex at distance at most $(1+\delta)\cdot\Delta$ from $N_{i}$ (in $T_{i}$), to form $A_{i+1}$. This concludes a single iteration. Continue until iteration $i$ where $A_{i}=\emptyset$.

Running time.

The number of rounds for computing the LE lists is $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n}\cdot\log(1/\delta))}$, and the shortest path tree takes $\tilde{O}((\sqrt{n}+D)/{\rm poly}(\delta))$ rounds. (Deciding whether to join $N_{i}$ is done locally once the LE lists are computed.) We will soon show that w.h.p. there are $O(\log n)$ iterations, thus the total number of rounds is $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n}\cdot\log(1/\delta))}$.

Analysis.

First we argue that once the algorithm concludes, $N$ is a $\left((1+\delta)\cdot\Delta,\frac{\Delta}{1+\delta}\right)$-net. To see the packing property, consider $u,v\in N$, and we want to show that $d_{G}(u,v)>\frac{\Delta}{1+\delta}$. If $u$ and $v$ joined $N$ in the same iteration $i$, then they both were maximal in their $\Delta$ neighborhoods w.r.t $H_{i}$, and therefore $d_{G}(u,v)\geq\frac{d_{H_{i}}(u,v)}{1+\delta}>\frac{\Delta}{1+\delta}$. Otherwise, assume w.l.o.g that $u$ joined $N$ at iteration $i$, while $v$ joined $N$ at iteration $i^{\prime}>i$. As $v$ remained active, necessarily $(1+\delta)\cdot\Delta<d_{T_{i}}(v,N_{i})\leq(1+\delta)\cdot d_{G}(u,v)$. For the covering property, let $v$ be some vertex that becomes inactive at iteration $i$. Then there is a vertex $u\in N$ such that $d_{G}(u,v)\leq d_{T_{i}}(u,v)\leq(1+\delta)\cdot\Delta$.

It remains to show that after $O(\log n)$ iterations w.h.p. no active vertices remain. We say that a pair of vertices $\{u,v\}$ at distance at most $\Delta$ (w.r.t. $d_{G}$) is active if both $u,v$ are active. Set $\mathcal{E}_{0}=\left\{\{u,v\}\mid d_{G}(u,v)\leq\Delta\right\}$ to be the set of initially active pairs. $\mathcal{E}_{i}$ will denote the set of pairs at distance at most $\Delta$ that remain active after the $i$’th iteration. For an active vertex $v\in A_{i}$, denote by $A_{i}(v)=A_{i}\cap B_{G}(v,\Delta)$. Note that $u\in A_{i}(v)\iff\{v,u\}\in\mathcal{E}_{i-1}$. We say that $w\in A_{i}(v)$ kills $v$ at the $i$’th iteration if $w$ is first in the permutation among $A_{i}(v)\cup A_{i}(w)$. Suppose that $w$ kills $v$ in the $i$’th iteration. Then we claim that $w$ joins $N_{i}$, as for every vertex $w^{\prime}\in A_{i}$ such that $d_{H_{i}}(w,w^{\prime})\leq\Delta$ it holds that $d_{G}(w,w^{\prime})\leq\Delta$ as well, and therefore $\pi(w)<\pi(w^{\prime})$. In particular, $v$ will cease to be active as $d_{T_{i}}(v,N_{i})\leq(1+\delta)\cdot d_{G}(v,w)\leq(1+\delta)\cdot\Delta$. Note that at most one vertex $w$ can kill $v$ (as it must be the first in the permutation in $A_{i}(v)$). 111111Note also that it is possible for a vertex to cease to be active without being killed. This can happen if the first vertex in the permutation among $A_{i}(v)$ does not join $N_{i}$, while a different vertex in $A_{i}(v)$ does join. We do not take advantage of this possibility. Therefore the probability that $v$ becomes inactive in iteration $i$ is at least $\sum_{w\in A_{i}}\Pr\left[v\text{ is killed by }w\right]$. As we pick the permutation $\pi$ uniformly at random, the probability that $w$ kills $v$ is exactly $\left|A_{i}(v)\cup A_{i}(w)\right|^{-1}$.

Our next goal is to show that in expectation, the number of active pairs is halved in each iteration. Consider a pair $\{u,v\}\in\mathcal{E}_{i-1}$. Then

[TABLE]

$\mathcal{E}_{i-1}\setminus\mathcal{E}_{i}$ is the set of pairs who cease to be active in the $i$’th iteration. We conclude

[TABLE]

Set $p=\Pr\left[\left|\mathcal{E}_{i-1}\setminus\mathcal{E}_{i}\right|>\frac{1}{4}\cdot\left|\mathcal{E}_{i-1}\right|\right]$. Then $\frac{1}{2}\cdot\left|\mathcal{E}_{i-1}\right|\leq\mathbb{E}\left[\left|\mathcal{E}_{i-1}\setminus\mathcal{E}_{i}\right|\right]\leq p\cdot\left|\mathcal{E}_{i-1}\right|+(1-p)\cdot\frac{1}{4}\cdot\left|\mathcal{E}_{i-1}\right|$, which implies $p\geq\frac{1}{3}$. After $O(\log n)$ iterations, by Chernoff inequality we had w.h.p. at least $\log_{\frac{4}{3}}n$ iterations where $\left|\mathcal{E}_{i-1}\setminus\mathcal{E}_{i}\right|>\frac{1}{4}\cdot\left|\mathcal{E}_{i-1}\right|$, and therefore $\mathcal{E}_{O(\log n)}=\emptyset$. Note that if no active edges remain, then each active vertex is the only active vertex in its entire $\Delta$ neighborhood. In particular, in the next iteration all the active vertices will join $N$ and cease to be active, as required.

7 Light Spanner for Doubling Metrics

In this section we show a distributed algorithm that produces light spanners for doubling metrics.

Theorem 5** (Light Spanner for Doubling Graphs).**

There is an randomized distributed algorithm in the CONGEST model, that given a weighted graph $G=(V,E,w)$ with $n$ vertices, hop-diameter $D$, doubling dimension ${\rm ddim}$, and parameter $\epsilon\in(0,1)$, in $(\sqrt{n}+D)\cdot\epsilon^{-\tilde{O}(\sqrt{\log n}+{\rm ddim})}$ rounds, w.h.p. returns a $(1+\epsilon)$-spanner $H$ with $O\left(n\cdot\epsilon^{-O({\rm ddim})}\cdot\log n\right)$ edges and lightness $\epsilon^{-O({\rm ddim})}\cdot\log n$.

Our spanner construction will go as follows. We take an $\epsilon\Delta$-net for every distance scale $\Delta$, and connect net points that are within distance $\Delta$ of each other. An efficient construction of nets was described in Section 6. To efficiently implement the net point connections, we use approximate shortest path computations based on hopsets from every net point. This will ensure that every such approximate shortest path has few edges, thus the running time can be controlled.

The following lemma gives the standard packing property of doubling metrics (see, e.g., [GKL03]).

Lemma 6**.**

Let $(M,\rho)$ be a metric space with doubling dimension ${\rm ddim}$. If $S\subseteq M$ is a subset of points with minimum interpoint distance $r$ that is contained in a ball of radius $R$, then $|S|\leq\left(\frac{2R}{r}\right)^{O({\rm ddim})}$.

7.1 Spanner Construction

Let $L$ be the weight of the MST of $G$. For every $\Delta\in\{1,1+\epsilon,(1+\epsilon)^{2},\dots,(1+\epsilon)^{\log_{1+\epsilon}L}\}$ we compute a $(2\epsilon\cdot\Delta,\frac{\epsilon}{2}\cdot\Delta)$-net as in Theorem 3 (e.g., we can take $\delta=1/2$). Let $N_{i}$ be the net for $\Delta=(1+\epsilon)^{i}$, and for every net point $u\in N_{i}$, run in parallel a $2\Delta$-bounded $(1+\epsilon)$-approximate shortest path tree rooted at $u$, and add to the spanner $H$ a $(1+\epsilon)$-approximate shortest path from $u$ to all other net points $v\in N_{i}$ found within this distance bound.

Shortest paths via hopsets.

To implement these bounded shortest paths computations, we use the algorithm of [EN16] based on hopsets. A $(\beta,\epsilon)$-hopset $F$ for a graph $G^{\prime}=(V^{\prime},E^{\prime})$, is a set of edges $F$ that do not reduce distances, and for every $u,v\in V^{\prime}$

[TABLE]

where $d^{(\beta)}(\cdot,\cdot)$ is the length of the shortest path containing at most $\beta$ edges. The graph $G^{\prime}$ is created by choosing the set $V^{\prime}\subseteq V$ of size $\approx\sqrt{n}\ln n$ at random, so that w.h.p. it intersects every shortest path in $G$ of length at least $\sqrt{n}$. The edges $E^{\prime}$ are the $\sqrt{n}$-bounded distances in $G$ between the vertices of $V^{\prime}$. Fix $\beta=1/\epsilon^{\tilde{O}(\sqrt{\log n})}$. In [EN16] it is shown how to compute a $(\beta,\epsilon)$ hopset for $G^{\prime}$ of size $O(\sqrt{n}\cdot\beta^{2})$ in $O((\sqrt{n}+D)\cdot\beta^{2})$ rounds. Furthermore, that hopset is path reporting, that is, there is a path $P_{e}$ in $G$ for every hopset edge $e\in F$, such that the length of $P_{e}$ is exactly $w(e)$, and every vertex in $P_{e}$ knows it lies on a path implementing $e$.

Once a hopset $F$ is computed for $G^{\prime}$, computing $(1+\epsilon)$-approximate shortest paths in $G$ from a root $v\in V$ amounts to running $\beta$ iterations of Bellman-Ford in $G\cup E^{\prime}\cup F$ In order to perform a single Bellman-Ford iteration, we first send messages over the edges of $E$ for $2\sqrt{n}$ rounds (to reach a vertex of $V^{\prime}$, and then discover the relevant edges of $E^{\prime}$). Second, every $u\in V^{\prime}$ broadcasts its distance estimate to the root $d(v)$ to all the graph using the BFS tree $\tau$ of depth $D$ (to implement the hopset edges). Since there are only $O(\sqrt{n}\cdot\ln n)$ vertices in $V^{\prime}$, this can be done in $O(\sqrt{n}\cdot\ln n+D)$ rounds via Lemma 1.

In our setting we would like to compute in parallel multiple source $2\Delta$-bounded approximate shortest paths. To this end, we will use the fact the shortest path metric is doubling, hence every vertex will participate in a small number of such computations.

7.2 Analysis

Running Time.

Fix some $\Delta=(1+\epsilon)^{i}$. Computing the $(2\epsilon\cdot\Delta,\frac{\epsilon}{2}\cdot\Delta)$-net $N_{i}$ takes $(\sqrt{n}+D)\cdot 2^{\tilde{O}(\sqrt{\log n})}$ rounds. We next analyze the running time of the shortest paths computation from all net points in $N_{i}$, which is conducted in parallel. By Lemma 6 we have that the number of net points $N_{i}$ in any ball of radius $2\Delta$ is $\epsilon^{-O({\rm ddim})}$. This suggests that for any $v\in V$ and any hopset edge $(x,y)\in F$, there are at most $\epsilon^{-O({\rm ddim})}$ sources of shortest paths computations that will reach them. Thus the number of rounds required to implement in parallel all approximate shortest path computations is $O\left((\sqrt{n}+D)\cdot\beta\cdot\epsilon^{-O({\rm ddim})}\right)=(\sqrt{n}+D)\cdot\epsilon^{-\tilde{O}(\sqrt{\log n}+{\rm ddim})}$. This is proportional to the time required to compute the hopset, and as there are $O(\log L)=O(\log n)$ different scales, the final running time is $(\sqrt{n}+D)\cdot\epsilon^{-\tilde{O}(\sqrt{\log n}+{\rm ddim})}$.

Stretch Bound.

For simplicity, we will prove stretch $1+c\cdot\epsilon$ for some constant $c$ to be determined later. One can get stretch $1+\epsilon$ by rescaling $\epsilon$. Consider a pair $u,v\in V$ such that $(1+\epsilon)^{i-1}<d_{G}(u,v)\leq(1+\epsilon)^{i}=\Delta$. Assume by induction that every pair $u^{\prime},v^{\prime}$ at distance at most $(1+\epsilon)^{i-1}$ already enjoys stretch at most $1+c\cdot\epsilon$ in $H$. The base case $i=0$ is trivial since there are no pairs $u^{\prime}\neq v^{\prime}$ of distance less than 1. Let $\tilde{u},\tilde{v}\in N_{i}$ be net points such that $d_{G}(u,\tilde{u}),d_{G}(v,\tilde{v})\leq 2\epsilon\cdot\Delta$. By the triangle inequality $d_{G}(\tilde{u},\tilde{v})\leq(1+4\epsilon)\cdot\Delta$, and since $\epsilon<1/8$ we have that $(1+\epsilon)\cdot(1+4\epsilon)\cdot\Delta\leq 2\Delta$, so the $2\Delta$-bounded shortest path exploration from $\tilde{u}$ must have discovered $\tilde{v}$. Therefore we added a $1+\epsilon$ approximate shortest path between $\tilde{u}$ and $\tilde{v}$ to $H$. Using the induction hypothesis on the pairs $\{u,\tilde{u}\}$ and $\{v,\tilde{v}\}$, we conclude

[TABLE]

where the inequality $(*)$ follows for any constant $c\geq 30$, using that $\epsilon<1/8$.

Lightness bound.

Let $n_{i}=|N_{i}|$. In [FN18] the following claim was shown.

Claim 7** ([FN18]).**

Consider a weighted graph $G$ with MST of weight $L$, such that there is an $r$-separated set $N$. Then $|N|\leq\left\lceil\frac{2L}{r}\right\rceil$.

It follows that $n_{i}=O(\frac{L}{\epsilon\Delta})$. Recall that Lemma 6 implies that the number of net points $N_{i}$ in a ball of radius $2\Delta$ is $\epsilon^{-O({\rm ddim})}$. So for every net point $u\in N_{i}$ we added at most $\epsilon^{-O({\rm ddim})}$ paths of weight at most $2\Delta$ each. Thus the total weight of edges added for the $i$’th scale is bounded by $n_{i}\cdot\epsilon^{-O({\rm ddim})}\cdot 2\Delta=\epsilon^{-O({\rm ddim})}\cdot L$. In particular, the sum of weights of the edges added in the $2\log_{1+\epsilon}n$ scales $i\in\{\log_{1+\epsilon}\frac{L}{n^{2}},\dots,\log_{1+\epsilon}L\}$ is bounded by $\epsilon^{-O({\rm ddim})}\cdot\log n\cdot L$. The contribution of all the other scales is negligible as all these scales adds at most $n^{2}$ edges of weight less than $\frac{L}{n^{2}}$. The bound on the lightness follows.

Sparsity bound.

Consider a vertex $v\in V$ and the set of edges added for scale $\Delta=(1+\epsilon)^{i}$. Consider the ball $B$ of radius $2\Delta$ around $v$, recall that $|B\cap N_{i}|=\epsilon^{-O({\rm ddim})}$. We added a path to the spanner only between net points of distance at most $2\Delta$. Therefore $v$ can participate in such paths only when both net points are in $B$ (as otherwise the length of a path going through $v$ will be greater than $2\Delta$). Therefore $v$ might participate in at most $(\epsilon^{-O({\rm ddim})})^{2}=\epsilon^{-O({\rm ddim})}$ such paths. As we added at most $2$ edges touching $v$ per path, the number of edges added which are incident on $v$ is bounded by $\epsilon^{-O({\rm ddim})}$. As there are $\log_{1+\epsilon}L$ scales (and $n$ vertices), we can bound the total number of edges added to the spanner by $n\cdot\epsilon^{-O({\rm ddim})}\cdot\log n$ (recall we assumed $G$ has diameter ${\rm poly}(n)$, thus also $L={\rm poly}(n)$).

8 Lower Bounds

In a seminal paper, Das Sarma et al. [SHK*+*12] showed that approximating the weight of an MST up to polynomial factors takes $\tilde{\Omega}(\sqrt{n})$ rounds. As both an SLT and a light spanner provide such an approximation to the weight of the MST, we conclude:

Theorem 6**.**

Every distributed algorithm in the CONGEST model that computes an SLT or a spanner with polynomial lightness, takes $\tilde{\Omega}(\sqrt{n}+D)$ rounds.

Next we argue that computing nets takes $\tilde{\Omega}(\sqrt{n}+D)$ rounds as well. Our lower bound is for general graphs. Therefore, it is possible that computing nets for graphs with bounded doubling dimension can be performed faster. Nevertheless, we conclude that Theorem 3 is tight (up to lower order terms).

Theorem 7**.**

Suppose that there is a distributed algorithm in the CONGEST model that for every parameter $\Delta$ computes an $(\alpha\cdot\Delta,\Delta)$-net  for some $1\leq\alpha\leq{\rm poly}(n)$. Then the algorithm runs in $\tilde{\Omega}(\sqrt{n}+D)$ rounds.

Proof.

Let $G$ be a graph from the family [SHK*+*12] used for their lower bound for approximating the weight of the MST. The only property we will use is that $G$ has polynomial diameter $\Lambda$. (W.l.o.g. the minimal distance is 1, and $\Lambda$ is the largest distance in $G$.) We will create nets in all the distance scales, and use their cardinality in order to provide a polynomial approximation to the weight of the MST. As there are only $O(\log n)$ distance scales, and the cardinality of all the nets can be computed in $O(D+\log n)$ time, the lower will follow.

For every $i\geq-\lceil\log\alpha\rceil$, compute an $(\alpha\cdot 2^{i},2^{i})$-net  $N_{i}$. We stop in the first time that $|N_{i}|=1$. Note that we compute at most $O(\log n)$ nets, since $\log\alpha=O(\log n)$, and when $2^{i}$ is larger than $\Lambda={\rm poly}(n)$, there can be only a single net point. Next, we compute the cardinality of all the net points and return $\Psi=\sum_{i}n_{i}\cdot\alpha\cdot 2^{i+1}$ where $n_{i}=|N_{i}|$. To finish the proof, we will argue that $L\leq\Psi\leq O(\alpha\cdot\log n)\cdot L$ (where $L$ is the weight of the MST).

For every $i$, as $N_{i}$ is $2^{i}$-separated, by 7 $n_{i}\leq\left\lceil\frac{2L}{2^{i}}\right\rceil$. In particular, $\Psi=\sum_{i}n_{i}\cdot\alpha\cdot 2^{i+1}\leq\alpha\cdot\sum_{i}\left\lceil\frac{2L}{2^{i}}\right\rceil\cdot 2^{i+1}=O(\alpha\cdot\log n)\cdot L$.

For the second inequality, we will construct a connected subgraph $H$ of $G$. For every net point $x\in N_{i}$, let $y\in N_{i+1}$ be the closest point to $x$ among points in $N_{i+1}$. Then by the covering property $d_{G}(x,y)\leq\alpha\cdot 2^{i+1}$. Add to $H$ the shortest path from $x$ to $y$. Do this for all the nets. Note that $N_{-\lceil\log\alpha\rceil}=V$ (since any point can cover only itself), and that the maximal net consist of a single point. Therefore $H$ is connected. We conclude $L\leq w(H)\leq\sum_{i}n_{i}\cdot\alpha\cdot 2^{i+1}=\Psi$. ∎