Approximate Single Source Fault Tolerant Shortest Path

Transcription

1 Approximate Single Source Fault Tolerant Shortest Path Surender Baswana Keerti Choudhary Moazzam Hussain Liam Roditty Abstract Let G = (V, E) be an n-vertices m-edges directed graph with edge weights in the range [1, W ] and L = log(w ). Let s V be a designated source. In this paper we address several variants of the problem of maintaining the (1 + ɛ)-approximate shortest path from s to each v V \ {s} in the presence of a failure of an edge or a vertex. From the graph theory perspective we show that G has a subgraph H with Õ(nL/ɛ) edges such that for any x, v V, the graph H \ x contains a path whose length is a (1 + ɛ)-approximation of the length of the shortest path from s to v in G \ x. We show that the size of the subgraph H is optimal (up to logarithmic factors) by proving a lower bound of Ω(nL/ɛ) edges. Demetrescu, Thorup, Chowdhury and Ramachandran [12] showed that the size of a fault tolerant exact shortest path subgraph in weighted directed/undirected graphs is Ω(m). Parter and Peleg [18] showed that even in the restricted case of unweighted undirected graphs the size of any subgraph for the exact shortest path is at least Ω(n 1.5 ). Therefore, a (1 + ɛ)-approximation is the best one can hope for. We consider also the data structure problem and show that there exists an Õ(nL/ɛ) size oracle that for any v V reports a (1 + ɛ)-approximate distance of v from s on a failure of any x V in O(log log 1+ɛ (nw )) time. We show that the size of the oracle is optimal (up to logarithmic factors) by proving a lower bound of Ω(nL/ɛ log n). Finally, we present two distributed algorithms. We present a single source routing scheme that can route on a (1 + ɛ)-approximation of the shortest path from a fixed source s to any destination t in the presence of a fault. Each vertex has a label and a routing table of Õ(L/ɛ) bits. We present also a labeling scheme that assigns each vertex a label of Õ(L/ɛ) bits. For any two vertices x, v V the labeling scheme outputs a (1 + ɛ)- approximation of the distance from s to v in G\x using only the labels of x and v. 1 Introduction In this paper we address several computational aspects of the problem of maintaining single-source approximate shortest paths for weighted directed graphs in the presence of failure. Let s be any designated source This research was partially supported by Israel Science Foundation (ISF) and University Grants Commission (UGC) of India. The research of the second author was partially supported by Google India under the Google India PhD Fellowship Scheme. Department of CSE, I.I.T. Kanpur, India. (sbaswana@cse.iitk.ac.in). Dept. of Comp. Sc., Weizmann Institute of Science, Israel. (keerti.india@gmail.com). WorldQuant Research, India. (moazzamh94@gmail.com). Department of Comp. Sc., Bar Ilan University, Israel. (liam.roditty@biu.ac.il). vertex in graph G = (V, E) and ɛ be any positive fraction. We first consider the problem of computing a sparse subgraph H of G that for any x, v V contains a (1+ɛ)-multiplicative approximation of the shortest path from s to v in G \ {x}. Such a subgraph H is referred as a fault tolerant (1 + ɛ)-shortest path subgraph. Demetrescu, Thorup, Chowdhury and Ramachandran [12] showed that the size of a fault tolerant exact shortest path subgraph in weighted directed/undirected graphs is Ω(m) and therefore a (1 + ɛ)-approximation is the best that one can hope for. Parter and Peleg [18] showed that even in the case of unweighted undirected graphs there are graphs such that the size of their fault tolerant exact shortest path subgraph is at least Ω(n 1.5 ). Bilò, Gualà, Leucci, and Proietti [5] showed that any weighted undirected graph has a fault tolerant (1 + ɛ)-shortest path subgraph of size O((1/ɛ 2 )n log n). Their result, however, uses techniques that rely heavily on the undirectedness of the graph and therefore cannot be extended to weighted directed graphs. A fault tolerant (1 + ɛ)-shortest path subgraph for directed graphs is important both from theoretical and practical point of views. From the theoretical point of view it is always an intriguing challenge to match or almost match in directed graphs the bounds that are known for undirected graphs. Finding small size subgraphs for directed graphs that preserve distance related properties of the graph is a hard task since many of the standard tools that are being used in undirected graphs rely on the fact that distances in undirected graphs are symmetric which is obviously not the case in directed graphs. Graph spanners are probably the most notable example for a separation between undirected and directed graphs. For every weighted undirected graph there is a subgraph with O(n 1+1/k ) edges that approximates the distances with a multiplicative stretch of 2k 1 [20]. It is very easy to see that such a general result is not possible for directed graphs since no subgraph can approximate all distances of a complete bipartite graph. The second problem that we address is designing a single source compact routing scheme that after any failure is able to route on paths that are stretched by a factor of at most (1 + ɛ). From the practical point of view there are network routing scenarios in

2 which routers only need to know which outgoing link to choose to get on a shortest path to a packet destination. More specifically, the Autonomous System s link-state database that is used by the Open Shortest Path First (OSPF) TCP/IP internet routing protocol is a directed graph [16]. Therefore, designing a single source routing scheme that is resilient to link failures in directed graphs is of real practical need. Lastly, we present an efficient oracle for reporting (1 + ɛ)-approximate distances from a source vertex after an occurrence of a failure. We also present a distributed implementation of this oracle (a labeling scheme). Next, we formally state our results. All our results hold for the general case of weighted directed graphs where edge weights are assumed to be in the range [1, W ]. Sparse subgraph. We show that it is possible to compute a subgraph H G with O(n log 3 (n) log 1+ɛ (nw )) edges such that for every v, x V, the distance of v from s in H \ {x} is at most (1 + ɛ) times the distance from s in G\{x}. Moreover, the in-degree of each vertex in H is bounded by O(log 4 (n) log 1+ɛ (nw )). We also establish a lower bound of Ω(n log 1+ɛ W ) on the size of such a subgraph. Oracle. We can build a data structure of size O(n log 1+ɛ (nw )) that can report in O(log log 1+ɛ (nw )) time, for every x, v V, a (1 + ɛ)-approximate distance of v from s in G\{x}. Also, we show that the size of the oracle is optimal (up to logarithmic factors) by proving a lower bound of Ω(n log 1+ɛ (W )/ log n). Our lower bound is independent of the time needed for reporting the (1 + ɛ)-approximate distances. Labeling scheme. Using this data structure we can also get a very compact labeling scheme for reporting approximate distances from s under any vertex failure. Each vertex will store a label of O(log 1+ɛ (nw ) log n) bits such that for any failing vertex x and a destination vertex v, it is possible to determine the (1 + ɛ)- approximate distance of v from s in G\{x} by processing the labels associated with v and x only. Routing. We provide a single source routing scheme that can route on a (1 + ɛ)-approximate shortest path from source s to any destination v V in the presence of a fault. Each vertex has a label of O(log 4 (n) log 1+ɛ (nw )) bits and a routing table of O(log 5 n log 1+ɛ (nw )) bits. When the routing is started at the source the labels of the faulty vertex and the destination vertex are assumed to be known. It must be noted that we describe all our constructions with respect to vertex failure only. Edge failure can be handled by inserting a vertex, say z uv, in middle of each tree edge (u, v) on the shortest path tree rooted at source s. So the deletion of tree edge (u, v) is equivalent to deletion of vertex z uv. 1.1 Related work For undirected graphs, Baswana and Khanna [2] showed a fault tolerant 3-shortest path subgraph with O(n log n) edges. Parter and Peleg [19] improved this result by showing that such a subgraph exists with 3n edges. Bilò, Gualà, Leucci, and Proietti [5] showed that any weighted undirected graph has a fault tolerant (1+ɛ)-shortest path subgraph of size O((1/ɛ 2 )n log n). Parter and Peleg [18] showed that any unweighted (un)directed graph has a fault tolerant exact shortest path subgraph with O(n 3/2 ) edges. They also showed a matching lower bound. Parter [17] extended this result to two edge failures with O(n 5/3 ) edges but only for undirected graphs. She also showed a lower bound of Ω(n 5/3 ). Recently, Gupta and Khan [15] extended the work of [17] to vertex failures and directed graphs. For the case of multiple edge faults, Bilò et al. [6] obtain a k-fault tolerant (2k+1)-shortest path subgraph with O(kn) edges again only for undirected graphs. They also showed that there is a data structure of size O(kn log 2 n) that reports the (2k + 1)-approximate distance from s in O(k 2 log 2 n) time. For preserving exact distances in (un)directed graphs, Bodwin et al. [7] obtain a construction of a k-fault tolerant subgraph with Õ(kn 2 1/2k ) 1 edges. In the case of all-pair shortest paths (APSP), Demetrescu, Thorup, Chowdhury and Ramachandran [12] showed that we can build an O(n 2 log n) size data structure that can report the distance from u to v avoiding x for any u, v, x V in O(1) time. The construction time of their data structure is O(mn 2 + n 3 log n). Bernstein and Karger further improved the preprocessing time to Õ( mn 2 ) [3] and finally to Õ(mn) [4]. The latter preprocessing time matches, up to poly-logarithmic factors, the best known runtime for the APSP in the same setting. Duan and Pettie [14] extended the result of [12] to dual failures by designing a data structure of O(n 2 log 3 n) space that can answer any distance query upon the failure of two vertices in O(log n) time. The authors of [14] comment that their techniques do not seem to be extensible beyond two failures, and even an oracle for three failures seem too hard to achieve. In undirected graphs, the questions of finding graph spanners, approximate distance oracles and compact routing schemes that are resilient to f vertex or edge failures have been studied in [8, 9, 10, 13]. 1.2 Organization of the Paper We describe notation and terminology in Section 2. In Section 3 we 1 Õ() hides the poly-logarithmic factors.

3 provide the main ideas used in our paper. We present a randomized algorithm for computing a fault tolerant (1 + ɛ)-shortest path subgraph in Section 4. In order to use it for routing, the subgraph should satisfy some additional property. We present a deterministic algorithm for computing the subgraph with this additional property in Section 5. As a byproduct we are also able to bound the in-degree of the vertices in the subgraph. The oracle and the labeling scheme are described in Section 6, and the routing scheme is described in Section 7. In Section 8, we present our lower bounds. 2 Preliminaries Let G = (V, E) be a directed graph on n = V vertices and m = E edges, and s V be the designated source vertex. We assume that the weight of each edge is a real number greater than one and bounded above by some threshold, say W. Below we introduce some of the notation that will be used throughout the paper. wt(u, v): Weight of edge (u, v) in G. wt(p ): Weight of path P in G, that is, if P is (u 0,..., u t ) then wt(p ) = t 1 i=0 wt(u i, u i+1 ). T : A shortest path tree of G rooted at s. T (v): Subtree of T rooted at a vertex v. parent T (v): Parent of vertex v in T. path T (a, b): Path from vertex a to vertex b in T. path T (ā, b): path T (a, b) \ {a}. path T (a, b): path T (a, b) \ {b}. depth T (v): Depth of vertex v in T. P [, b]: The prefix of path P up to vertex b, assuming that b lies in P. P [a, b]: The sub-path of path P lying between vertices a, b, assuming a precedes b on P. σ(p ): Subsequence of those vertices of path P whose incoming edge in the path is a non-tree edge. freq(w, C): The number of sequences of set C in which vertex w appears. P ::Q : The path formed by concatenating paths P and Q in G. Here it is assumed that the last vertex of P is the same as the first vertex of Q. dist H (u, v): Distance of v from u in graph H. G \ x: Graph obtained by deleting node x from G. powers(c): Set of all powers of c in range [1, nw ]. We start by defining a detour: Definition 2.1. A simple path P = (u 0,..., u t = v) in G is said to be a detour to v with respect to T if u 0 is an ancestor of v, and for 0 < i < t, none of the u i s is an ancestor of v in T. Notice that it follows from the above definition that tree edges and forward edges are also detours of size one. Next, we define a special class of detours, the tree-path favouring detours, that will be used in our constructions. Definition 2.2. A detour D from u to v is a tree-path favouring detour if for any a, b D \ {u, v}, where a precedes b in D and a is an ancestor of b in T, it holds that the segment D[a, b] is a tree path. It is easy to see that if a detour is not a treepath favouring detour then we can easily convert it into a tree-path favouring detour, by repeatedly replacing segment D(a, b) with the tree path path T (a, b). Since T is the shortest path tree, by doing this we do not increase the weight of the detour. So, henceforth we can assume that all the detours referred in paper are tree-path favouring detours. For the sake of simplicity we use the following alternative weight function (usually known as the Johnson transformation) which is quite popular in the literature of shortest paths. wt (u, v) := wt(u, v) + dist G (s, u) dist G (s, v) It is easy to see that for any edge (u, v), wt (u, v) is non-negative. Also if (u, v) is a tree edge then wt (u, v) must be zero. From the next lemma it follows that for any detour D, wt (D) must be bounded by nw. Lemma 2.1. Let a, b T be such that a is an ancestor of b, and let P be any path from a to b. Then, wt (P ) = wt(p ) dist G (a, b). Proof. Let P be equal to (a = a 0,..., a t = b). So wt (P ) = t i=1 wt (a i 1, a i ) = t i=1 (wt(a i 1, a i ) + dist G (s, a i 1 ) dist G (s, a i )) = dist G (s, a 0 ) dist G (s, a t ) + t i=1 wt(a i 1, a i ) = wt(p ) + dist G (s, a) dist G (s, b) Thus we get wt (P ) = wt(p ) dist G (a, b). In the next Lemma we show an important property of certain detours which we use for constructing our subgraph. This Lemma uses the new weight function and exemplifies its significance. Lemma 2.2. Let x, v V be such that x is an ancestor of v in T. There is a shortest path from s to v in

4 G \ x of the form - path T (s, a)::d::path T (b, v), where D is a detour starting from a vertex a path T (s, x) and terminating at a vertex b path T ( x, v) for which wt (D) is minimum. Proof. Let P be some shortest path from s to v in G\x. Let a be the last vertex of P that is also in path T (s, x), and let b be the first successor of a in P that is in path T ( x, v). It is easy to see that such two vertices a, b must exist. By the detour definition it also follows that P [a, b] is a detour for b, as none of its internal vertices can be an ancestor of b. Thus we can set D to be P [a, b]. Since T is the shortest path tree we can replace the segments P [s, a] and P [b, v] with path T (s, a) and path T (b, v), respectively, without increasing the total weight. Thus the path Q = path T (s, a)::d::path T (b, v) forms a shortest path from s to v in G \ x. Note that wt(q) = dist G (s, v) + (wt(d) dist G (a, b)) which equals dist G (s, v) + wt (D). For every other path of the form path T (s, a )::D ::path T (b, v), where a path T (s, x) and b path T ( x, v), it holds that wt(q ) = dist G (s, v) + wt (D ). Now since wt(q) = wt(p ) and P is a shortest path it follows that D must be a detour with minimum wt value among all detours which starts at a vertex in path T (s, x) and terminates at a vertex in path T ( x, v). Q We now state a simple lemma that will be used to obtain a randomized construction for sparse subgraph. Lemma 2.3. Let C be a collection of at most n 2 subsets of V each of size exactly 4c ln(n). If we pick a subset S of V of size n/c uniformly at random, then with probability at least 1 1/n 2, for each set W C, W S is non-empty. Proof. Let t = (4c ln(n)). Note that there are a total of ( n n/c) possibilities for set S. Now for any subset A C, the probability that A S is empty is ( n t n/c ( n n/c ) ( n t ) n ) n/c ( = 1 1 ) n/c ( = n/t 1 4 ln(n) n/c ) n/c which is at most 1/n 4. On applying union bound we get that probability there exists a W C for which W S is non-empty is at most 1/n 2. 3 Main Ideas For any α > 0, let HD α (v) be a detour that originates from the highest possible ancestor of v in T and terminates at v such that its weight wt (HD α (v)) is less than or equal to α, that is, there is no other detour that ends at v and starts at a higher ancestor of v whose weight is bounded by α. We denote the first vertex of HD α (v) with first α (v). Consider the following subgraph: H = T ( ) HD α (b) b V α powers(1+ɛ) For any x, v V, the graph H \ x contains a (1 + ɛ)- approximation of the shortest path from s to v in G \ x. This is because if the shortest path takes a detour D from a to b to avoid x, then H will contain a detour D that starts at a or one of its ancestors, ends at b and wt (D ) (1 + ɛ)wt (D). Based on this key observation, we are able to compute an oracle of size O(n log 1+ɛ (nw )) for reporting (1 + ɛ)-approximate distance from the source upon failure of any vertex in O(log log 1+ɛ (nw )) time. Though the subgraph H can be seen as a fault tolerant (1+ɛ)-shortest path subgraph, its size can be as large as Θ(m). This is because even a single detour may contain n edges. So storing HD α (v) for each v and each α may require Ω(m) space in the worst case. In order to achieve sparseness for H, our starting point is the sub-structure property of HD α (v) stated in the following lemma. Lemma 3.1. Let D = HD α (v) be a detour for v, for some α > 0. Then for any vertex w σ(d), the segment D[, w] is also a detour. Proof. Let u be the first vertex on D, that is, u = first α (v). We first show that all the vertices of D must lie in the subtree T (u). Assume this is not the case, and let y be the last vertex of D that is not in the subtree T (u). Also let z be the Lowest Common Ancestor (LCA) of y and u. Consider the path D = path T (z, y)::d[y, v]. It is easy to see that D is a detour for v. Also the set of non-tree edges of D is a subset of the non-tree edges of D, thus wt (D ) wt (D) α. But this contradicts the definition of D, as D is a detour for v starting from an ancestor of u with wt at most α. From the above discussion it follows that u must be an ancestor of w. Therefore, it suffices to show now that none of the internal vertices of D[u, w] are ancestors of w. Let us suppose there exists a vertex z D[u, w] (z u, w) such that z is an ancestor of w. But in such a case we can replace the segment D[z, w] of detour D with path T (z, w), thereby contradicting the fact that D is a tree path favoring detour. Hence D[u, w] cannot pass through any ancestor of w, except for the starting vertex u. It follows from Lemma 3.1 that for any w σ(hd α (v)), if H contains a (1 + ɛ)-approximation of the detour HD α (v)[, w], then on including just the suffix HD α (v)[w, v], we can see that H will contain a

5 (1 + ɛ)-approximation of HD α (v). A simple way to include a (1+ɛ)-approximation of the detour HD α (v)[, w] would be to add to H the detours HD β (w), for each β powers(1 + ɛ). However, to get a sparse subgraph instead of including each HD β (w), we can use the same trick recursively and include a further (1 + ɛ)- approximation of HD β (w). This motivates for a hierarchical computation of H in some k( 2) rounds where in a round we only add a short suffix of HD α (v) to the subgraph H, and we move its prefix (which is a detour in itself) to the next round to be processed recursively. This constitutes the main idea for constructing a sparse subgraph and a compact routing scheme for approximate shortest paths from s under failure of any vertex. 4 Sparse Subgraph For the sake of better exposition of the algorithm, we first present the construction of a subgraph with Õ(n 1.5 log 1+ɛ (nw )) edges using a hierarchy of two levels. In the next subsection, we extend it to a k- level hierarchical construction that achieves a bound of Õ(n log 1+ɛ (nw )) on the size of the subgraph. 4.1 Sparse subgraph with Õ(n1.5 log 1+ɛ (nw )) edges In this subsection, we give a construction of a sparse subgraph H with Õ(n1.5 log 1+ɛ (nw )) edges that with high probability 2 preserves the approximate shortest paths from s after a failure of any vertex. The underlying idea used in the construction of this subgraph is the following. We pick a small set S of vertices uniformly and at random. For each v S and for each α powers(1 + ɛ), we include HD α (v) in the subgraph H. We cannot afford to include HD α (u) for every u V \S so we include only a small suffix of HD α (u). Due to the random sampling used to construct S, it turns out that if HD α (u) is long, then its small suffix will have a vertex, say w, from S. The detour to w concatenated with the small suffix of HD α (u) will preserve HD α (u) approximately. In Algorithm 4.1 we present the pseudocode for computing a subgraph H with Õ(n1.5 log 1+ɛ (nw )) edges that is based on this idea. We first show that with high probability any long detour (> n) has in its n length suffix at least one vertex from set S. Lemma 4.1. With high probability the following holds - For each α powers(1+ɛ) and each v V, if HD α (v) contains more than n non-tree edges, then the last n vertices of σ(hd α (v)) contain a vertex from set S. 2 Throughout the paper we use the term with high probability (w.h.p.) to denote that the probability of the respective event is at least 1 1/n 2. Algorithm 4.1: Computation of subgraph with Õ(n 1.5 log 1+ɛ (nw )) edges. 1 H T ; 2 foreach v V and α powers(1 + ɛ) do 3 Add last n non-tree edges of HD α (v) to H; 4 S A uniformly random set of 4 n log e n vertices; 5 foreach v S and α powers(1 + ɛ) do 6 Add all non-tree edges of HD α (v) to H; Proof. Consider the collection C defined below. C = {last n vertices of σ(hd α (v)) v V, α powers(1 + ɛ), σ(hd α (v)) > n} The collection C will contain at most n 2 sets (each of size n), since for any vertex v we can have at most n detours corresponding to n ancestors of v in T. So, the result follows by simply applying Lemma 2.3. We will now show that upon a failure of any vertex x, the shortest paths from s in graph G\x are stretched by a factor of at most (1 + ɛ) 2 in H\x. Lemma 4.2. For every two vertices x, v V, w.h.p, dist H\x (s, v) (1 + ɛ) 2 dist G\x (s, v). Proof. Let P be the shortest path from s to v in G\x. If x is not an ancestor of v in T then P will be just the tree path from s to v in T. Thus let us consider the case when x is an ancestor of v. By Lemma 2.2, the path P can be represented as path T (s, a)::d::path T (b, v), where D is a detour avoiding x. We take α to be the smallest power of (1 + ɛ) greater than wt (D). Let us consider the following two cases separately. Case 1 : HD α (b) contains at most n non-tree edges. In this case HD α (b) will lie in subgraph H. Since α wt (D), first α (b) must be either equal to a or an ancestor of a. So instead of detour D, we can just follow the detour HD α (b). Thus the concatenation Q = path T (s, first α (b))::hd α (b)::path T (b, v) forms a path from s to v in H \ x. Also, wt (Q) is at most (1 + ɛ)wt (P ), as under the weight function wt, tree edges get zero weight. Case 2 : edges. HD α (b) contains more than n non-tree In this case Lemma 4.1 implies that w.h.p. the last n vertices of σ(hdα (b)) must contain a vertex, say

6 w, from set S. So the segment HD α (b)[w, b] will lie in H because the last n non-tree edges of HD α (b) are included in H. Also, by Lemma 3.1, the prefix HD α (b)[, w] is a detour for vertex w. We further consider the following subcases. (See Figure 1). (i) If x is not an ancestor of w, then simply take Q as path T (s, w)::hd α (b)[w, b]::path T (b, v). Since wt (HD α (b)[w, b]) wt (HD α (b)) (1 + ɛ)wt (D), we get that wt (Q) (1 + ɛ) wt (P ). (ii) We now consider the subcase when x is an ancestor of w in T. Notice that prefix HD α (b)[, w] is not included in H, but we can take a further (1 + ɛ)- approximation of it. Let β be the smallest power of (1 + ɛ) greater than wt (HD α (b)[, w]). Since w S, HD β (w) will lie in subgraph H. So we take Q as path T (s, first β (w))::hd β (w)::hd α (b)[w, b] concatenated with path T (b, v). Notice that HD β (w) cannot contain x, since first β (w) is either same as or an ancestor of the first vertex of HD α (b)[, w]. Finally wt (HD β (w)::hd α (b)[w, b]) is bounded by (1+ɛ)wt (HD α (b)) (1+ɛ) 2 wt (D). Hence, wt (Q) is at most (1 + ɛ) 2 wt (P ). In all the above cases/subcases, we were able to show that w.h.p. there exists a path Q such that wt (Q) (1 + ɛ) 2 wt (P ). Now as s is ancestor of v, on adding dist G (s, v) on both sides and applying Lemma 2.1, we get that wt(q) (1 + ɛ) 2 wt(p ). edges such that with high probability following relation holds: For any x, v V, dist H\x (s, v) (1 + ɛ) 2 dist G\x (s, v). 4.2 Sparse subgraph with Õ(n log 1+ɛ(nW )) edges In the Õ(n1.5 log 1+ɛ (nw )) size subgraph described in the previous subsection, we constructed a 2-level hierarchy of vertices, namely, S and V. The detour to vertices in set S and the short suffixes of detours of vertices in V could preserve every detour D up to a stretch of (1 + ɛ) 2. In order to further improve the size of the subgraph, we form a finer hierarchy of subsets of vertices: S 1,..., S k for some k > 2. As we go up in this hierarchy, the size of these sets decreases and thus we can afford to store longer suffixes of detours from their vertices. In particular, for a given i [1, k], S i will have at most n 1 (i 1)/k vertices and from each vertex v S i, we store suffixes of Õ(ni/k log 1+ɛ (nw )) length. Similar to the 2-level case, a combination of k types of these detour suffixes will preserve every detour D up to a factor (1 + ɛ) k. We now formalize this key idea by defining a (1 + ɛ, t)-preserver of a detour as follows. Definition 4.1. Let D be a detour from u to v, ɛ (0, 1) be some real number, and t be some positive integer. Also let α be the smallest power of (1+ɛ) greater than or equal to wt (D). Then a (1 + ɛ, t)-preserver of D is a path in G obtained as follows. (See Figure 2). 1. If t = 1, then a (1 + ɛ, 1)-preserver of D is just HD α (v). 2. If t > 1, then it is obtained by concatenating (i) a (1 + ɛ, t 1)-preserver of prefix HD α (v)[, w], and (ii) the suffix HD α (v)[w, v], for some vertex w σ(hd α (v)). (i) (ii) Remark 4.1. For Definition 4.1 to be well defined we require that HD α (v)[, w] is a detour for vertex w. This is indeed true since w σ(hd α (v)), and the proof follows from Lemma 3.1. Figure 1: Approximate shortest path from s to v in H\x in the subcases: (i) x is not an ancestor of w in T, and (ii) x is an ancestor of w. We conclude with the following theorem. Theorem 4.1. Let G be a directed weighted graph on n vertices with maximum edge weight W and s be the designated source vertex. Then we can compute in polynomial time a subgraph H with O ( n 1.5 log(n) log 1+ɛ (nw ) ) The following lemma (with proof in Appendix) shows the significance of a (1+ɛ, t)-preserver. The proof of the lemma is similar to proof of Lemma 4.2. Lemma 4.3. Let D be a detour from a to b, and H be a subgraph of G containing tree T and a (1 + ɛ, t)- preserver for D. Then for any internal vertex x lying on path T (a, b), the graph H \ x contains a path, say Q, from s to b whose weight (i.e. wt(q)) is at most (1+ɛ) t times wt(path T (s, u)::d).

7 Algorithm 4.2: Computation of subgraph with Õ(n log 1+ɛ (nw )) edges. 1 H T ; 2 S 1 V (G); 3 for i = 1 to k-1 do 4 S i+1 A uniformly random subset of V of size O(n/n i/k ); 5 foreach v S i and α powers(1 + ɛ) do 6 foreach w suffix ( σ(hd α (v)), S i+1 ) do 7 Add incoming edge of w in HD α (v) to H; Figure 2: The path highlighted in yellow color depicts a (1 + ɛ, 3)-preserver of detour D. Here α, β, γ are respectively smallest powers of (1 + ɛ) greater than or equal to weight of (i) D, (ii) HD α (b)[, w], and (iii) HD β (w)[, u]. We now describe the algorithm for computing the sparse subgraph H. The algorithm consists of k rounds that operate on k sets, namely, S 1, S 2,..., S k as follows. Let S 1 = V be the initial set. In any round i < k, we first compute a uniformly random subset of V of size O(n/n i/k ), and move these vertices to S i+1. Next for each each v S i and each α powers(1 + ɛ), 1. If σ(hd α (v)) does not contain any vertex from S i+1, then the complete detour HD α (v) is added to H. 2. Otherwise, if z is the last vertex of σ(hd α (v)) that lies in S i+1, then only the suffix HD α (w)[z, w] is added to H. Finally in round k, for each each v S k and each α powers(1 + ɛ), we add HD α (v) to H. Also the shortest path tree T is added to the graph H. Algorithm 4.2 presents the pseudocode for this construction. In the algorithm, we use the notation suffix(σ, A) to denote the maximal suffix of σ that does not contain an element of A, where σ is any sequence of vertices and A is a subset of V. Notice that, instead of step 1 and step 2 stated above, we can equivalently just say that for each w suffix ( ) σ(hd α (v)), S i+1, the incoming edge of w in HD α (v) is added to H. The following lemma (with proof in Appendix) shows that the subgraph H contains a (1+ɛ, k)-preserver for each possible detour D in G. Lemma 4.4. The graph H computed by Algorithm 4.2 contains a (1 + ɛ, k)-preserver for each possible detour D in G. 8 foreach v S k and α powers(1 + ɛ) do 9 Add HD α (v) to H; Lemma 4.3 along with Lemma 4.4 implies that upon failure of any vertex x, the shortest paths from s in graph G\{x} are stretched by a factor of at most (1 + ɛ) k in H\{x}. We now do the analysis of the size of subgraph H. Lemma 4.5. With high probability, H = O(k n 1+1/k log n log 1+ɛ (nw )). Proof. It is easy to see that for any i [1, k], S i = O( n1+1/k ). Consider the collection defined below. n i/k C = {σ(hd α (v)) v S i, α powers(1 + ɛ)} The collection C will contain at most n 2 sets as for any vertex v we can have at most n detours corresponding to n ancestors of v in T. From Lemma 2.3 it follows that for each σ(hd α (v)) of size greater than n i/k log n, w.h.p. the last n i/k log n vertices of σ(hd α (v)) will contain a vertex from S i+1. In other words, w.h.p. for each v S i and each α powers(1+ɛ), suffix ( σ(hd α (v)), S i+1 ) is of size at most n i/k log n. So for any vertex v in S i we add at most n i/k log n log 1+ɛ (nw ) edges in Step 7. Since S i = O( n1+1/k ), and i ranges from 1 to k, w.h.p. n i/k H contains O(k n 1+1/k log n log 1+ɛ (nw )) edges. We thus get the following lemma. Lemma 4.6. Let G be a directed weighted graph on n vertices with maximum edge weight W and s be the designated source vertex. Then we can compute in polynomial time a subgraph H satisfying the following: for any x, v V, dist H\x (s, v) (1 + ɛ) k dist G\x (s, v). The size of H is O ( kn 1+1/k log(n) log 1+ɛ (nw ) ) with high probability.

8 On substituting ɛ new = ɛ old /(2k), and k = log 2 (n) in Lemma 4.6 we get the following theorem. Theorem 4.2. Let G be a directed weighted graph on n vertices with maximum edge weight W and s be the designated source vertex. Then we can compute in polynomial time a subgraph H satisfying the following relation: for any x, v V, dist H\x (s, v) (1 + ɛ)dist G\x (s, v). The size of H is O ( n log 3 (n) log 1+ɛ (nw ) ) with high probability. 5 Precursor to a Compact Routing In the last section, we showed a construction of a sparse subgraph H that contained a (1+ɛ, k)-preserver of each detour in G. In this section we slightly modify the construction of subgraph H which will help us later in obtaining an efficient routing scheme. Recall that a (1+ɛ, k)-preserver in H is a concatenation of at most k suffixes of detours, that were added to H in the k distinct rounds of Algorithm 4.2. Our routing scheme upon failure of any node x will route packets along these suffixes. In order to efficiently route along a suffix of a (1 + ɛ, k) preserver, we require that each vertex on the suffix knows its successor on the suffix. Now if the frequency of a vertex w in all the suffixes included in H by Algorithm 4.2 is small, then the routing table required at w will be small. Thus as a precursor to routing we require that the frequency of any vertex in the suffixes added to H is bounded. More formally, if Q 1,..., Q t are the suffixes added in a round i of Algorithm 4.2, then we need that the frequency of each vertex in {σ(q 1 ),.., σ(q t )} is small. Though Algorithm 4.2 ensures that the average frequency of a vertex is Õ(log 1+ɛ (nw )), it fails to provide any bound on the maximum frequency. Recall that in any round, say i, of Algorithm 4.2, we compute the next subset S i+1 using random sampling. Instead of building this hierarchy of subsets randomly, we present in this section a deterministic algorithm that employs more insight into the structure of the suffixes. We now explain our algorithm for deterministically computing the set S i+1 from the set S i. The input to the algorithm is the collection C = {σ(hd α (v)) v S i, α powers(1 + ɛ)} and a parameter d to be fixed later on. Given a sequence σ, let first-half(σ) and second-half(σ) respectively denote the subsequences of σ obtained by splitting it at midpoint. Our first step is to compute collections C 1 and C 2 by splitting each σ C at midpoint, and adding first-half(σ) to C 1 and second-half(σ) to C 2. Next we repeat the following two steps as long as there exists a vertex whose frequency in C 2 is greater than d log n: (i) Pick such a vertex (say w) and add it to set S; (ii) Remove from C 2 each sequence σ in which w is present. It easy to see that set S will be of size at most C 2 /(d log n) = C /(d log n). Algorithm 5.1: Det-Construction(C, d) 1 C 1 {first-half(σ) σ C}; 2 C 2 {second-half(σ) σ C}; 3 S ; 4 while w V s.t. freq(w, C 2 ) > d log n do 5 S S {w}; 6 Remove all those σ from C 2 that contains vertex w; 7 C new ; 8 foreach σ C do 9 if second-half(σ) S then add suffix(σ, S) to C new ; 10 if second-half(σ) S = then add first-half(σ) to C new ; 11 Return ( S Det-Construction(C new, d) ) ; a sequence in Collection of sequences in which frequency of every vertex is bounded Collection of sequences left to be processed Figure 3: Divide and conquer approach: vertices in red color represent the set S. Consider any sequence σ C. Let us first consider the case when second-half(σ) S is non empty. (See Figure 3). If suffix(σ, S) has no vertex of large frequency, then we are done with this sequence. However, it is quite possible that suffix(σ, S) may still have vertices of large frequency. But, in this case, we are left to take care of only suffix(σ, S), whose length is at most σ /2, for the computation of the set S i+1. We now show how to take care of those sequences whose second-half does not contain any vertex from S. Let C denote the set of all those σ in C for which second-half(σ) S is empty. Notice that the frequency of each vertex in the collection {second-half(σ) σ C } is bounded by d log n. So for any σ C, we can safely discard second-half(σ) and consider only first-half(σ) for the computation of S i+1. Thus, in this case also the length of sequence has been reduced to at most half.

9 The above discussion motivates us to design a recursive algorithm that performs at most log n recursions to obtain the desired set S i+1. In Algorithm 5.1 we present the pseudocode of our construction. Since in each recursive call of Det-Construction, the set S included into S i+1 is of size at most C /(d log n), the size of the set S i+1 is at most C /d. Also in each recursive call the frequency of vertices increases by at most d log n, thus the set S i+1 will satisfy the condition that frequency of each vertex in {suffix(σ, S i+1 ) σ C} is bounded by d log 2 n. Recall that in Algorithm 4.2, S i n/n (i 1)/k, and thus C n/n (i 1)/k log 1+ɛ (nw ). By our construction in Algorithm 5.1, we will have that S i+1 is at most C /d, which we required to be bounded by n/n i/k. This shows that d must be n 1/k log 1+ɛ (nw ). Finally notice that the frequency of each vertex v in the set of all suffixes added during round i will be bounded by d log 2 n = n 1/k log 1+ɛ (nw ) log 2 n. We thus have the following lemma. Lemma 5.1. Let G be a directed graph on n vertices. There exists a construction for sets S 1, S 2,..., S k in Algorithm 4.2 satisfying the following conditions. 1. For any index i, S i+1 n/n i/k. 2. For any index i, frequency of each vertex in {suffix(σ(hd α (v)), S i+1 ) v S i, α powers(1 + ɛ)} is at most n 1/k log 2 n log 1+ɛ (nw ). 5.1 A sparse subgraph with bounded in-degree We here show that the alternative construction of sets S 1,..., S k also gives a bound on the in-degree of each vertex in the sparse subgraph H. Notice that in Algorithm 4.2, an incoming edge is added to a vertex w only if w suffix ( ) σ(hd α (v)), S i+1, for some v in Si and α powers(1 + ɛ). So the number of incoming edges added to a vertex in round i is exactly equal to frequency of that vertex in {suffix(σ(hd α (v)), S i+1 ) v S i, α powers(1 + ɛ)}. Therefore, Lemma 5.1 gives a bound of kn 1/k log 2 n log 1+ɛ (nw ) on the in-degree of each vertex in the sparse subgraph preserving distances (1 + ɛ) k approximately. On substituting ɛ new = ɛ old /(2k), and k = log 2 n we get the following theorem. Theorem 5.1. Let G be a directed weighted graph on n vertices with maximum edge weight W and s be the designated source vertex. Then in polynomial time we can compute a sparse subgraph H satisfying the following. 1. For any x, v V, dist H\x (s, v) is less than or equal to (1 + ɛ)dist G\x (s, v). 2. The in-degree of each vertex in graph H is at most O ( log 4 (n) log 1+ɛ (nw ) ). 6 An Oracle and a Labeling Scheme We first describe a fault tolerant oracle for reporting approximate distances from s. Let v be the query vertex and x be the failed vertex. If x is not an ancestor of v, then the shortest path is the tree path path T (s, v) which remains intact in G\x. So let us consider the more interesting case in which x is an ancestor of v. From Lemma 2.2 it follows that one of the shortest paths to v in G \ x is of the form - path T (s, a)::d::path T (b, v), where D is a detour avoiding x, and its weight is dist G (s, v) + wt (D). Notice that if α 0 is the smallest power of (1 + ɛ) for which there exists a vertex b 0 path T ( x, v) with HD α0 (b 0 ) starting from an ancestor of x in T, then the value dist G (s, v) + α 0 would be a (1 + ɛ) approximation of dist G\x (s, v). Thus in order to compute an approximation of dist G\x (s, v) we need to compute this α 0 efficiently. We now describe our data structure that accomplishes this task. For each α powers(1 + ɛ), we create a copy of T and denote it by T α. For each vertex y T α, we set the weight of edge (parent Tα (y), y) as depth T (first α (y)). Thus the edge weights in any tree T α are integers in the range [0, n 1]. Notice that for any α powers(1+ɛ), there will exist a detour starting from an ancestor of x and terminating at a vertex of path T ( x, v) with wt at most α if and only if the weight of the minimum weight edge on path Tα ( x, v) is smaller than depth T (x). The smallest such α can be easily computed using the Bottleneck Edge Query (BEQ) data structure of Demaine et al. [11] for each of the trees T α. Theorem 6.1. (Demaine et al. [11]) Given a tree on n vertices with edge weights from the range [0, n] it is possible to create in O(n) time a data structure of O(n) size so that given any u, v V, the edge of smallest weight on the unique path from u to v in the tree can be found in O(1) time. In Algorithm 6.1 we present the pseudocode for determining approximate s v distance in G \ x. Since the BEQ query on a single tree can be answered in O(1) time, the time for querying all the trees will be O(log 1+ɛ (nw )). However, instead of linearly checking all the powers of (1 + ɛ) in the increasing order, if we perform a binary search on powers(1 + ɛ), then query time is improved to O(log 2 log 1+ɛ (nw )). Finally notice that the space complexity is O(n log 1+ɛ (nw )). The following theorem stems from the above discussion.

10 Algorithm 6.1: Determining (1+ɛ) approximate distance of v from s in graph G\{x}. 1 if (x is not an ancestor of v) then 2 Return dist G (s, v); 3 i depth T (x); 4 for α powers(1 + ɛ) in increasing order do 5 j BEQ(x, v, T α ); 6 if j < i then Return (dist G (s, v) + α); 7 Return Unreachable ; Theorem 6.2. Given a directed graph G on n vertices with maximum edge weight W and a source vertex s V, it is possible to compute a data structure of O(n log 1+ɛ (nw )) size that for any failing vertex x and any destination vertex v, reports a (1 + ɛ) approximation of the distance of v from s in G \ {x} in O(log 2 log 1+ɛ (nw )) time. 6.1 Compact labeling scheme for Oracle We now present the labeling scheme for oracle. Let v be a query vertex, and x be the failed vertex. Recall Algorithm 6.1. Our first step is to check whether x is an ancestor of v in T. One simple method to achieve this is to perform the pre-order and the post-order traversal of T, and store the pre-order as well as the post-order numbering of each vertex in its label. Now x will be ancestor of v in T if and only if the pre-order numbering of x is smaller than that of v, and the post order numbering of x is greater than that of v. Next we assign i as depth T (x), extracting out this is also easy since depth information can also be made part of the label. Thus the only thing that is left is to obtain a labeling scheme for BEQ problem. Demaine et al. [11] showed that the BEQ problem on any tree T α is reducible to LCA problem on a cartesian tree, say T α, which is related to tree T α as follows. 1. The vertices of T α constitute the leaves of T α. 2. The edges of T α constitute the internal nodes of T α. 3. For any two vertices u, v T α, the least weight edge on path Tα (u, v) is the LCA of the leaf nodes corresponding to u and v in T α. Hence the bottleneck edge query for any two vertices u and v in T α can be answered by performing an LCA query for leaves u and v in T α. However, notice that given the labels of u and v in tree T α, we are not interested in computing the label of the edge stored at the LCA of u and v, rather we are interested in knowing the weight of the edge stored at the LCA. Alstrup et al. [1] established a labeling scheme for LCA that given the labels of any two vertices u and v in a tree, returns a predefined label associated with the LCA of u and v in the tree. If each predefined label consist of M-bits, then the labels in this scheme for LCA consists of O(M log n 0 ) bits, where n 0 is the number of nodes in the tree. In our case, the number of nodes in T α is O(n) only. Also the predefined labels of internal nodes in T α stores just the depth value, thus M is O(log n). Therefore, label of any vertex v stores: (i) the preorder and the post-order numbering of v, (ii) the depth of v in T, and (iii) the label of v corresponding to LCA queries in each tree T α, where α powers(1+ɛ). Hence the label of each vertex consists of O(log 2 n log 1+ɛ (nw )) bits. We thus have the following theorem. Theorem 6.3. Given a directed graph G on n vertices with maximum edge weight W and a source vertex s V it is possible to compute vertex labels of O(log 2 n log 1+ɛ (nw )) bits such that for any failing vertex x and any destination vertex v, the (1 + ɛ) approximate distance of v from s in G \ {x} can be determined by processing the labels associated with v and x only. Notice that in the above construction, the predefined label of an internal node of T α, which corresponds to an edge in T α, say (parent Tα (y), y), just stores the value depth T (first α (y)). However, we can also store in the predefined label other relevant information associated with either the detour HD α (y), or a (1 + ɛ, k) preserver of HD α (y). Then, the result of Alstrup et al. [1] implies the following lemma, which would be used in the construction of the routing scheme. Lemma 6.1. For each y in V and α powers(1 + ɛ), let Φ α (y) be the M-bit information associated with a (1 + ɛ, k) preserver of HD α (y). Then there exists a labeling scheme with labels of O(M log n log 1+ɛ (nw )) bits such that given the label of any two vertices x, v V, where x is an ancestor of v in T, the following information can be retrieved. (i) Smallest α powers(1 + ɛ) such that there exists a vertex b path T ( x, v) whose HD α (b) starts from an ancestor of x, (ii) Vertex b stated in (i), and the M-bit information, i.e. Φ α (b), associated with the (1 + ɛ, k) preserver of HD α (b). 7 A Compact Routing Scheme Let v be a query vertex and x be a failed vertex. Let us consider the case in which x is an ancestor of v in T.

11 Let D be the detour corresponding to the shortest s-v path in G \ x, and let α be the smallest power of (1 + ɛ) greater than or equal to wt (D). So there must exist a vertex b path T ( x, v) such that HD α (b) starts from an ancestor of x. Such a vertex can be easily extracted out using the labels of v and x described in Section 6. Since we can not afford to store the information of HD α (t) explicitly for each t V, we take help of a (1 + ɛ, k)- preserver of HD α (b) to route the packets to destination v. (i) Figure 4: (i) Depiction of segments Q 1, Q 2, Q 3 and vertices b 1, b 2, b 3, b 4 in a (1 + ɛ, 3)-preserver of HD α (b), (ii) A finer description of Q i showing the first non-tree edge (c i, d i ). Recall that a (1 + ɛ, k)-preserver of a HD α (b) can be seen as a concatenation of at most l( k) paths, say Q l, Q l 1, Q 2, Q 1. (See Figure 4 (i)). If b l+1, b l,..., b 2, b 1 are the endpoints of these paths, then (i) For each i < l, Q i is a suffix of detour to b i that is added in the i th round of Algorithm 4.2, (ii) Q l is a detour to b l added in the l th round. Also notice that for each i [1, l], vertex b i belongs to set S i. Now for i [1, l], let us denote by (c i, d i ) the first non-tree edge in Q i. (See Figure 4 (ii)). So, d i is also the first vertex in σ(q i ). We first extend the labeling scheme described in Section 6 to obtain a labeling scheme for routing. 7.1 Labeling scheme for routing The label of each node consists of two subcomponents L 0 and L 1 as described below. 1. In [21], Thorup and Zwick gave a construction of labeling scheme for rooted trees with O(log n) bit labels such that given the labels of any two nodes w and y (with w being ancestor of y), one can compute the port number of the child of w on (ii) path T (w, y). The first component of the labels, i.e. L 0, would comprise of these labels. This will facilitate easy routing of packets along the tree paths. Also the component L 0 would store the pre-order number, the post-order number, and the depth of vertex in T, so that ancestor descendant relationships can be easily verified. Thus the label L 0 consists of O(log n) bits. 2. The second component of the labels, that is L 1, will comprise of the labels described in Lemma 6.1, with Φ α (y) of a vertex y storing the at most k + 1 vertices and k non-tree edges associated with a (1 + ɛ, k) preserver of HD α (y), described above. (See Figure 4). So given the labels of v and x, we can extract out the value α equal to the smallest power of (1 + ɛ) for which there exists a vertex b path T ( x, v) with HD α (b) starting from an ancestor of x in T. Also we can compute the L 0 label of vertices b l+1, b l,..., b 1, and edges (c l, d l ),..., (c 1, d 1 ) associated with the (1 + ɛ, k)- preserver of HD α (b). Finally, notice that Φ α (y) consists of O(k log n) bits of information, thus the label L 1 consists of O(k log 2 (n) log 1+ɛ (nw )) bits. 7.2 Description of routing table We now give the construction of the routing table of a vertex w V. The routing table of w stores: (i) the label L 0 (w), and (ii) k segments, where i th segment corresponds to i th round of Algorithm 4.2. Below we describe these k segments. Let us fix an i [1, k]. Consider the detour HD α (u) for some vertex u S i and an α powers(1 + ɛ). Let u S i+1 be the last vertex in σ(hd α (u)) S i+1, if it exists, else let u be first α (u). Then the suffix HD α (u)[u, u] is added to H in the i th round of Algorithm 4.2. Now let us suppose w σ ( HD α (u)[u, u] ) and let (y, z) be the first non-tree edge appearing after w on HD α (u). So z is the successor of w in the sequence σ(hd α (u)). Through our routing table we need to ensure that if a packet reaches w then it can easily find the route to vertex z. This route will be just the concatenation path T (w, y)::(y, z). So corresponding to the triplet (i, u, u) in the routing table of w we need to store the label of the edge (y, z). Finally notice that in Lemma 5.1 we showed that the frequency of each vertex in the set of all suffixes added in a round is O(n 1/k log 2 (n) log 1+ɛ (nw )). To store a non-tree edge (y, z), it suffices to store just the labels L 0 (y) and L 0 (z) that are of O(log n) bits. Thus the size any of the k segments of the routing table of vertex w will be O(n 1/k log 3 (n) log 1+ɛ (nw )) bits, and the size of the routing table will be O(kn 1/k log 3 (n) log 1+ɛ (nw )) bits.

12 7.3 Routing algorithm We now describe the routing algorithm. Let j [1, l] be the maximal index such that x is an ancestor of vertices b 1,..., b j. It follows from the proofs of Lemma 4.3 and Lemma 4.4, that the concatenation P = path T (s, b j+1 )::(Q j,..., Q 1 )::path T (b, v) is a path from s to v in H \ x whose length is at most (1 + ɛ) k times the length of the shortest s-v path in G\x. In our routing scheme, the packets from s to v will traverse this path P. Before starting the routing process we use the labels of x and v to compute the vertices b 1,..., b j and the edges (c 1, d 1 ),..., (c j, d j ), also this information is added to the header of the packet. Now path P can be seen as a sequence of segments of tree paths joined through nontree edges. So, whenever we reach any vertex w σ(p ), our first step is to calculate the next non-tree edge, say (y, z), appearing after w in P. Once this edge is computed, we traverse the tree path from w to y using L 0 labels. Once we reach y, the packet traverses the edge (y, z). On reaching any vertex w σ(p ), the next non-tree edge, say (y, z), on the path P can be computed as follows. 1. If w is an internal vertex of some Q i, i [1, j], then we can just use the routing table stored at w to find the edge (y, z). 2. If w = b i for some 1 < i j, the next non-tree edge will be (c i 1, d i 1 ) lying in segment Q i 1. This information can be retrieved from the header of the packet itself. Till now we described that if we are at a vertex w in σ(p ) then how to navigate to the next vertex in σ(p ). Notice that (c j, d j ) is the first non tree edge in P. So to reach the first vertex d j in σ(p ), path path T (s, c j )::(c j, d j ) can be traversed using L 0 labels. Finally when we reach the last vertex in σ(p ), that is b 1, then again we use L 0 labels to traverse path path T (b 1, v) to reach vertex v. The pseudocode of this routing procedure is described in Algorithm 7.1. Notice that the size of each label is O(k log 2 (n) log 1+ɛ (nw )) bits, and the size of each routing table is O(kn 1/k log 3 (n) log 1+ɛ (nw )) bits. Also the size of header attached to the packets is O(k log n) bits and the stretch achieved is (1 + ɛ) k. On substituting ɛ new = ɛ old /(2k) and k = log 2 (n) we get the following theorem. Theorem 7.1. For a directed network, there exists a fault tolerant scheme for routing packets from a fixed source vertex s with the following properties. Algorithm 7.1: Route(w, v, j, b l,.., b 1, c l,.., c 1, d l,.., d 1, nextedge) 1 if (w = v) then Return Packet received ; 2 if (j = 0 or w = b 1 ) then 3 w new child of w on path T (w, v); 4 Route(w new, v, 0, <>,null); 5 if (nextedge = null) then 6 if (w = b j ) then 7 nextedge (c j 1, d j 1 ); 8 j j 1; 9 else 10 nextedge Routing-Table-Look-Up(w, j, b j+1, b j ); 11 (y, z) nextedge; 12 if (w y) then 13 w new child of w on path T (w, y); 14 else 15 w new = z; 16 nextedge = null; 17 Route(w new, v, j, b l,.., b 1, c l,.., c 1, d l,.., d 1, nextedge); 1. The label of each vertex consists of O(log 4 (n) log 1+ɛ (nw )) bits and the routing table consists of O(log 5 (n) log 1+ɛ (nw )) bits. 2. While routing, each packet has to have extra O(log 2 n) bits as a header. 3. To route packets from s to a destination v under failure of a vertex x, s should know labels (identity) of both v and x. 4. The route taken by packets have a stretch of at most (1 + ɛ) times that of the shortest path possible in G \ x. 8 Lower Bounds Let ɛ, W, n be such that ɛ lies in interval (0, 1), and W, n > 1. We first show the construction of a graph G on O(n) vertices with edge weights in range [1, 2W ] such that its (1 + ɛ)-distance preserving subgraph requires at least Ω ( n min{n, log 1+ɛ W } ) edges. 8.1 A lower bound on the size of subgraph Let L, l be integers to be fixed later on. We construct a graph G on n + L l vertices as follows. The vertex set of G is {u l+1, u l+2,..., u L, v 1,..., v n }, and the edge set of G is the union of the following two sets (see Figure 5). 1. E 1 = {(u L, u L 1 ),..., (u i, u i 1 ),..., (u l+2, u l+1 )},