Presented By: Raquel S. Whittlesey-Harris Light Weight Spanners Presented By: Raquel S. Whittlesey-Harris

Contents Introduction Light, Low-Stretch Trees SLT Algorithm Algorithms for Producing Light, Sparse, Low-Stretch Trees WEIGHTED_SPAN (Tree Cover Based) GREEDY_SPAN (Greedy Sequential) LIGHT_SPAN 12/3/2018 Light Weight Spanners

Introduction The MST optimizes the total weight and the SPT optimizes the root-stretch (radius) of a tree. How do we handle situations in which it is desirable to have a spanning tree with both low weight and stretch simultaneously? These two factors are often contradictory. The weight of an SPT TS may be as much as n times as large as that of an MST ((Ts) = (n(MST)) The depth of an MST TM w.r.t a given root r may be up to n times larger than that of an SPT (Stretch(TM,r) = (n)). 12/3/2018 Light Weight Spanners

Introduction Example: Depth/Weight Anomalies The example graph below shows how the weight of the SPT w.r.t the root, 1, is (TS) = (n-1)W, Whereas (MST) = W + n-2 Yielding a ratio approaching n-1 as W tends to infinity 12/3/2018 Light Weight Spanners

Introduction MST and SPT (example 1) 12/3/2018 Light Weight Spanners

Introduction The example graph below shows the depth of the MST, TM is Depth(TM) = 1+(n-2)(1-) Whereas Depth(TS) = 1 Yielding a ratio approaching n-1 as  tends to zero 12/3/2018 Light Weight Spanners

Introduction MST and SPT (example 2) 12/3/2018 Light Weight Spanners

Introduction We will see Algorithm SLT – Shallow Light Tree Captures both properties of TM ((T)) and TS (Stretch(T)) within constant factors of optimal 12/3/2018 Light Weight Spanners

Introduction 12/3/2018 Light Weight Spanners

Introduction How do we achieve a sparse spanner for weighted graphs (chapter 16 introduced unweighted techniques)? How do we achieve sparsity as well as low total weight? We will see Algorithm WEIGHTED_SPAN(G,) Uses the Tree Cover Theorem (15.5.2) to derive results similar to the Spanner Theorem (16.1.2) with an additional logarithmic factor based on the edge weights. 12/3/2018 Light Weight Spanners

Introduction We will also see Algorithm GREEDY_SPAN(G,) More efficient greedy algorithm for constructing -spanners for arbitrary weighted graphs which bounds the number of edges and total weight. It is considered a generalization of Kruskal’s algorithm for constructing a MST. When  is , the algorithm is identical to Kruskal’s algorithm We will then see Algorithm LIGHT_SPAN() Produces an efficient distributed implementation with an added factor of . Fails to achieve the additional goal of constructing light-weight, low-overlap tree covers, but does produce a special structure which efficiently bounds the costs of the spanner. 12/3/2018 Light Weight Spanners

SLT Algorithm Definition 17.1.1: [Shallow-light tree]: A shallow light tree (SLT) for a weighted graph G = (V,E,) and a root vertex r0 is a spanning tree T with constant weight ratio and root-stretch, i.e., such that Stretch(T,r0) and are both bounded by a constant. SLT(r0,) Relies on the existence of trees that optimize each of the two parameters separately. First construct a shortest path tree and MST Combine the trees with a cut-and-paste method  > 0 controls the trade-off between the quality of the approximation of root-stretch and weight ratio 12/3/2018 Light Weight Spanners

SLT Algorithm For every G’ of G, and for every 2 vertices u,v  V, let denote an arbitrary path length distG’(u,v) connecting u and v in G’. Construct an MST TM for the entire graph G Preprocess it for further use throughout the algorithm Given r0 in G, create a “path version” L of TM Apply Procedure TOUR_MST TOUR_MST(r0) Construct an MST TM for G Traverse TM in a DFS fashion, starting from r0 Denote by v(i) (0  i  2(n-1)) the vertex visited by the tour in its ith step (v(0) = r0) 3. Construct the “path-version” L of TM, which is a weighted (2n-1)-vertex path containing vertices 0,1,…,2n-2, where a vertex i on the path corresponds to v(i) 4. For every edge e=(i,i+1) on the path L do: Set (e)  (v(i),v(i+1)) /* the weight of the corresponding edge in G */ 5. Output (TM,L) 12/3/2018 Light Weight Spanners

SLT Algorithm 12/3/2018 Light Weight Spanners

SLT Algorithm Tour MST Construct an SPT, TS for G rooted at r0 Use to construct shortcuts on the path L to improve the root-stretch Identify “break-points” Bi on the path L by scanning it from left to right according to the following rules B1 is vertex 0 on the path L Bi+1 is the 1st point to the right of Bi s.t. distL(Bi,Bi+1) >   distTS(r0,v(Bi+1)) *select when segment becomes too expensive (by a factor of at least  in TS) Create G’ by taking TM and adding for all breakpoints Bi, i>1 Construct a SPT, T, rooted at r0 in G’ Output T 12/3/2018 Light Weight Spanners

SLT Algorithm (T)  (1+2/)  (MST) Lemma 17.1.2: The Tree T constructed by the algorithm satisfies, (T)  (1+2/)  (MST) Proof: The tree T is a subgraph of G’, created by adding the paths Choosing Break-points Bi, for i>1, The Tour of the MST visits each tree edge twice the path weight is twice the weight of the MST, TM, (L) = 2  (TM) 12/3/2018 Light Weight Spanners

SLT Algorithm Lemma 17.1.3: The Tree T constructed by the algorithm satisfies Stretch(T,r0) 1+2 Proof: An Arbitrary vertex x  V, show that distT(r0,x)  (2+1)distTS(r0,x) Let j denote the point corresponding to x on L (i.e., v(j) = x) If Bi  j < Bi+1, the entire path is included in G’  distG’(r0,v(Bi)) = distTS(ro,v(Bi)), and distG’(v(Bi),x)  distL(Bi,j) – since G’ contains all of L  distG’(r0,x)  distTS(r0,v(Bi)) + distL(Bi,j) (17.1) 12/3/2018 Light Weight Spanners

SLT Algorithm Since TS is a shortest path tree w.r.t r0 distTS(r0,v(Bi))  distTS(r0,x) + distL(j,Bi) (17.2) Combine 17.1 and 17.2 to get, distG’(r0,x)  distTS(r0,x) + 2  distL(j,Bi) (17.3) If j  Bi, j was not selected as the (i+1)st break-point distL(Bi,j)    distTS(r0,x) And finally, distG’(r0,x)  (2+1)distTS(r0,x) Theorem 17.1.4 [SLT]: For every weighted graph G=(V,E, ) and vertex r0 there exists a spanning tree T with constant root-stretch Stretch(T,r0) and weight ratio 12/3/2018 Light Weight Spanners

WEIGHTED_SPAN WEIGTED_SPAN (G,k) produces results similar to the Spanner Theorem (16.1.2) for weighted graphs, with an additional logarithmic factor (based on the edge weights) With use of the Tree Cover Theorem (15.5.2) For every weighted graph G = (V,E,), |V| = n and integers ,   1, Algorithm TREE_COVER constructs a -tree cover TC = TC, for G with, Depth(TC)  (2-1) Overlap  2n1/k Sparse Spanner Theorem (16.1.2): For every unweighted n-vertex graph G and for every   1 (distance), Algorithm UNWEIGHTED_SPAN constructs an O()-spanner with at most n1+1/  edges. 12/3/2018 Light Weight Spanners

WEIGHTED_SPAN 2i-1 < distG(x,y)  2i Lemma 17.2.1 The subgraph G’ constructed by algorithm WEIGHTED_SPAN(G,k) has stretch factor Stretch(G’)  4k-2 Proof: Consider an arbitrary pair of vertices x,y  V. Suppose that, 2i-1 < distG(x,y)  2i 12/3/2018 Light Weight Spanners

WEIGHTED_SPAN The tree cover, TCk,2i constructed contains a tree, T, where 2i(x)  V(T).  x,y V(T), Depth(T)  (2k-1)2i T provides a path of length  2(2k-1) 2i  (4k-2) dist(x,y) connecting x and y in spanner G’ Lemma 17.2.2 The size of the spanner G’ is O(kn1+1/k) Proof: The number of edges in G’ is bounded from above by, where n = |V| 12/3/2018 Light Weight Spanners

WEIGHTED_SPAN The following Corollary is concluded, Corollary 17.2.3 For every n-vertex weighted graph G = (V,E,) and for every k1, Algorithm WEIGHTED_SPAN constructs an O(k)-spanner with O(kn1+1/k) edges 12/3/2018 Light Weight Spanners

GREEDY_SPAN GREEDY_SPAN(G,k) is a more efficient algorithm than WEIGHTED_SPAN, which bounds the number of edges and the total weight. Constructs a k-spanner Generalization of Kruskal’s MST algorithm (5.5.2) Identical, if k is infinite 12/3/2018 Light Weight Spanners

GREEDY_SPAN Sort the edges of the graph by non degreasing weights Scan the edges Place edge in spanner if it meets the desired stretch bound An edge, e, is included only if its weight < 1/k * dist(x,y) in the current spanner GREEDY_SPAN(G,k) Sort E by nondecreasing edge weight, obtaining E = {e1,…,em}. Set E’   For j = 1 to m do: (a) Let ej  (u,v). (b) Compute , the shortest path from u to v in G’ = (V,E’). (c) If ( )) > k(ej), then set E’  E’{ej}. End-for 4. Output G’ = (V,E’) 12/3/2018 Light Weight Spanners

GREEDY_SPAN Lemma 17.2.4 The output subgraph G’ has stretch factor Stretch(G’)  k Proof: Consider vertices x,y of graph G and let the shortest path be denoted by, , connecting x and y in G. Edge eij = (u,v) is along the path 12/3/2018 Light Weight Spanners

GREEDY_SPAN Lemma 17.2.4 The girth of G’ satisfies Girth(F’) > k+1 If eij is not included in G’ then E’ contained a path, , of a length at most k(eij) connecting u to v. Paths are never removed from E’ Lemma 17.2.4 The girth of G’ satisfies Girth(F’) > k+1 Proof: Consider cycle C in G’. Let ej = (u,v) be the last edge added to C. Path, , constructed by GREEDY_SPAN satisfies 12/3/2018 Light Weight Spanners

GREEDY_SPAN Corollary 17.2.6 |E’|  n1+2/k + n When ej is added to E’, . Thus, (C) > (k+1) (C-{ej}) And, |C| > k+1, Then Corollary 17.2.6 |E’|  n1+2/k + n Theorem 17.2.7 [Weighted Spanner]: For every integer k  1 and every n-vertex weighted graph G=(V,E,), Algorithm GREEDY_SPAN constructs a spanner G’ = (V,E’) for G with Stretch(G’)  2k+1, |E’|=O(n1+1/k) and (G’) = (MST(G))·O(n1/k). 12/3/2018 Light Weight Spanners

GREEDY_SPAN Theorem 17.2.8 For every k3, there exists (infinitely many) n-vertex graphs G = (V,E,) such that every spanner G’=(V,E’) for G with Stretch(G’) k-2 requires |E’| = (n1+1/k) and (G’) = ((MST(G))·n1/k) Proof: By Theorem 16.2.3, for every k3, there exists (infinitely many) unweighted n-vertex graphs G=(V,E) for which every (k-2)-spanner requires (n1+1/k) edges. If , we get the lower bound 12/3/2018 Light Weight Spanners

GREEDY_SPAN Theorem 17.2.8 For every k1/2 and every n-vertex weighted planar graph G=(V,E,) there is a polynomially constructible spanner G’=(V,E’) for G with Stretch(G’) 2k+1, |E’|<(n-1)(1+1/k) and (G’) < (MST(G))(1+1/k) 12/3/2018 Light Weight Spanners

LIGHT_SPAN LIGHT_SPAN(k) is a distributed algorithm for Construction of a low-stretch, sparse, light-weight spanner for an arbitrary weighted graph, G. Follows same structure as TREE_COVER. We reduce the total weight by constructing a sparse (but perhaps heavy) tree cover and an MST and combining them as in SLT. 12/3/2018 Light Weight Spanners

LIGHT_SPAN Construct an MST, TM for graph, G Construct a corresponding tour, L, with an arbitrary root vertex with TOUR_MST Construct a 2i-tree-cover, TCi, for G using LIGHT_TC Take the union of all edges in the trees of these covers to form the spanner G’. 12/3/2018 Light Weight Spanners

LIGHT_SPAN LIGHT_TC(L,k,,) Constructs a -tree-cover, where  > 0 (controls the trade-off; thought of as 1 here) Set separation parameter, s, to  Construct a cover, , which coarsens with a s-separated partial partition for each “layer” of the cover Theorem 12.4.4 – Given a weighted graph G = (V,E,), |V|=n, and integers ,s,k1, it is possible to construct a cover  that satisfies the following properties  coarsens , Rad()  (2k-1) +ks, c()  2kn1/k, and Each of the c() layers of partial partitions composing the cover  is s-separated Cover is composed of up to 2kn1/k individual s-separated partial partitions, Si, and the radius of each cluster in the partitions are bounded from above by (3k-1) 12/3/2018 Light Weight Spanners

LIGHT_SPAN Construct a spanning tree for each cluster of each partial partition (as in Algorithm Tree Cover) Each partial partition contributes a collection of trees to the tree cover  Here, the trees constructed in a single partition are not necessarily disjoint. Identify the segment L relevant to the cluster S r0 denotes the “entry point” of the path into the cluster S re denotes the “exit” point Path L(S) may enter and exit S several times and may even visit other vertices besides those of S Construct an SPT, Ts(S) for the cluster S, rooted at r0, according to the following rules B1 is vertex r0 on the path L Bi+1 is the first point in the cluster S to the right of Bi distL(Bi,Bi+1) > distTS(S)(r0 ,v(Bi+1)) Continue selecting break-points until the path exits the cluster, S, for the last time The only breakpoints selected are those that belong to cluster, S Create a subgraph G’(S) by adding to the path segment L(S) (for all Bi, i>1) (tree will span the entire cluster but may contain external vertices – increases the bounds on the total weight and overlap!) Taking only the intersection of L and S may cause G’(S) to be disconnected and may exclude certain vertices in S. (see example below) The output, TC, will consist of the union of all of these trees 12/3/2018 Light Weight Spanners

LIGHT_SPAN 12/3/2018 Light Weight Spanners

LIGHT_SPAN Lemma 17.20.10 The collection of trees TC constructed by Procedure LIGHT_TC is a p-tree cover with Depth(TC) (2+1)(6k-2) Proof: Since TC is a -tree-cover, it follows as the proof of Algorithm TREE_COVER (15.5.2) Each tree, TS(S) is a spanning tree for the induced subgraph G’(S) Depth(TC): Consider a cluster S in a partial partition S. To bound the depth of the spanning tree T(S), Lemma 17.1.3 shows that for an arbitrary vertex x  S, 12/3/2018 Light Weight Spanners

LIGHT_SPAN Lemma 17.2.11 The constructed spanner G’ satisfies(G’)12(3k-1) Proof: Consider an arbitrary pair of vertices x,y V. Suppose that, 2i-1 < distG(x,y)  2i Since the ith level tree-cover, TCk,2i, constructed contains a tree T(S) s.t. 2i(x)  S (x,y  S) Depth(T(S))  6(3k-1)2i, by the previous lemma, so, 12/3/2018 Light Weight Spanners

LIGHT_SPAN Lemma 17.2.12 In the constructed spanner G’, |E(G’)| = O(kn1+1/k) Proof: Since the shortcuts constructed in a cluster, S, are segmented of the shortest-paths tree TS(S), the edges, F(S), are internal to S. So, for a single partial partition, S, the collection of Trees F(S) contains less than n-1 edges (clusters in S are disjoint). Since each cover TCi is composed of at most 2kn1/k partial partitions, collection F(TCi) contains O(k n1+1/k) edges. The spanner consists of edges from the tree covers TCi constructed on each of the  levels. 12/3/2018 Light Weight Spanners

LIGHT_SPAN Lemma 17.2.13 The collection of trees F(TC) constructed by Procedure LIGHT_TC satisfies Proof: Collection of trees, F(S) constructed by LIGHT_TC for a partial partition S with 1 cluster, S, in it, satisfies, Charge each shortcut to a segment of TM. Let L(S,Bi-1,Bi) denote the segment of L between Bi-1 and Bi, computed for S Let Lin(S,Bi-1,Bi) denote the parts of this segment that are in the /2 vicinity of S. Formally, let N(S)= Lin(S,Bi-1,Bi) = L(S,Bi-1,Bi)  N(S) An imaginary vertex is introduced along the edge, e, of the path, L, if e has one endpoint inside N(S) and another outside it. Placed precisely on the border of N(S) Splitting e into ein and eout Breaking the weight, w(e) between ein and eout Note, an edge may connect one endpoint in N(S) with another endpoint in N(S’) It may be broken twice in this way (distance between S and S’ > separation parameter, s) 12/3/2018 Light Weight Spanners

LIGHT_SPAN By choice of Breakpoints, This is shown by two cases, (17.4) (17.5) This is shown by two cases, Path segment Bi-1 to Bi never leaves the 2-neighborhood of S Lin(S,Bi-1,Bi) – L(S,Bi-1,Bi) (their weights are equal) 17.5 follows Path segment L(S,Bi-1,Bi) leaves the 2-neighborhood of S and returns Total weight of the internal path segment satisfies (Lin(S,Bi-1,Bi)) But, is bounded above by k 17.5 follows, 12/3/2018 Light Weight Spanners

LIGHT_SPAN from which it follows that the total weight of the shortcuts added to the cluster S is bounded as, Summing up the weights of all the trees F(S) constructed for all the clusters S in the partial partition S, Segments Lin charged against separate bounds for each cluster are all disjoint (s-separated at distance  & segments Lin are confined to 2-neighborhoods) Total sum of the shortcuts added is bounded by, 12/3/2018 Light Weight Spanners

LIGHT_SPAN Lemma 17.2.14 The constructed spanner G’ satisfies Proof: Follows from the fact that there are at most 2kn1k partial partitions participating in TCi Proof: Let =1, the weight of the edges added to the spanner on behalf of each of the  tree collections F(TCi) is bounded, by the previous lemma (17.2.13), by 4·k2·n1/ k(MST) MST component, L, adds at most (TM) 12/3/2018 Light Weight Spanners

LIGHT_SPAN Theorem 17.2.15 For every integer k1 and every n-vertex weighted graph G=(V,E,), Algorithm LIGHT_SPAN constructs a spanner G’ for G with Stretch(G’) = O(k), |E(G’)| = O(k··n¹/k)and (G’) = O(k²··n¹/k·(MST)) Polylogarithmic factor away from optimality (sparsity & total weight) 12/3/2018 Light Weight Spanners