1. Competitive fault tolerant Distance Oracles and Routing Schemes Weizmann Open U Weizmann Bar Ilan Shiri Chechik Michael Langberg David Peleg Liam Roditty

2. Formal framework A network G A service S(G) Desired properties represented by requirement predicate P(S,G) cost(S) of constructing / maintaining S Optimization problem: Select cheapest service S satisfying P(S,G)

3. Example: Connectivity oracle S = database maintained over graph G Requirement predicate P conn on S:  For every two vertices u,w in G: in response to a query Q conn (u,w), answer whether u and w are connected in G. Costs:  cost 1 (S) = total / max memory for S  cost 2 (S) = query time of S

4. Connectivity oracles The graph G Centralized connectivity oracle for G u u0 w v w v 1 S1S1.............

5. Connectivity oracles The graph G Distributed connectivity oracle for G 〈 w,3 〉 1 2 3 〈 u,1 〉 〈 v,3 〉 Assign each vertex v in connected component G i a label L(v) = 〈 v,i 〉 On query Q conn (L(u),L(w)): check labels 0 1

6. Cost of distributed connectivity oracle Memory = O(log n) per vertex Query time = O(1)

7. Fault Tolerance Assumption: vertices / edges may occasionally fail or malfunction Failure event: set F of failed vertices/edges

8. Fault Tolerance As a result of a failure event: G and S(G) are partially destroyed Surviving network: G' = G \ F Surviving service: S' = S \ F Requirement predicate P might no longer hold

9. Coping with failures in services Goal: Make S(G) competitive fault tolerant, i.e., ensure that the requirement predicate P(S’,G’) still holds subsequent to a failure event. Relaxed variant of problem: Construct service S(G) that can guarantee a weakened form of desired properties (i.e., some relaxed predicate P‘(S’,G’))

10. Rigid vs. competitive fault tolerance Rigid fault tolerance: Ensure that S(G) satisfies the requirement predicate w.r.t. the original G, i.e., that P(S’,G) still holds after a failure event. Competitive fault tolerance: S(G) satisfies the requirement predicate w.r.t. the surviving G’, i.e., P(S’,G’) must hold after a failure event. ⇨ Useful for structures (subgraphs,…) ⇨ Useful for services (oracles, routing,…)

11. Back to connectivity example Goal: Construct a competitive fault-tolerant connectivity oracle S capable of withstanding f edge failures (|F|≤f) (a.k.a. f-sensitivity connectivity oracle) Connectivity oracle: receives query Q conn (s,t) for vertices s, t answers whether s and t are connected

12. Dynamic connectivity oracle [Patrascu-Thorup- 07] Maintain a dynamic data structure Update after each edge deletion / failure Space O(|E(G)|) Query time O(f log 2 n loglogn) (following a batch of f edge deletions)

13. F-T connectivity oracles Note: Unlike dynamic connectivity oracles, in an F-T connectivity oracle, the faulty sets F for two consecutive queries could be very different. receive a query Q conn (s,t,F) for vertices s,t, and failure event F ⊆ E (for |F|≤f) answer whether s and t are connected in G’ = G \ F

14. F-T connectivity oracles Dynamic connectivity oracle: failures come one by one

15. F-T connectivity oracles F-T connectivity oracle: failure events F 1, F 2, … are separate F1F1 F2F2 F3F3 Q(s 1,t 1 )? s3s3 t3t3 t1t1 s1s1 t2t2 s2s2 Q(s 2,t 2 )? Q(s 3,t 3 )?

16. F-T connectivity oracles Claim: The dynamic connectivity oracle of [PT-07] can be modified into F-T connectivity oracle against f edge failures.

17. F-T connectivity oracles Given query Q conn (s,t,F) (with vertices s,t and failure event F ⊆ E) : Update the data structure, deleting all the edges of F While updating, record the changes made Answer the connectivity query Q conn (s,t) Undo all changes to the data structure Operation of the F-T connectivity oracle:

18. F-T connectivity oracles Claim: The resulting F-T connectivity oracle has: Space O(|E(G)|) Query time O(f log 2 n loglogn)

19. F-T connectivity oracles The connectivity oracle of [CLPR-10] : Space O(fkn 1+1/k log(nW)) Query time O(f log 2 n loglogn) (using the sparse spanner construction of [Chechik-Langberg-P-Roditty-10] )

20. (Approximate) Distance Oracle: Data-structure that can answer (approximate) distance queries Q dist (s,t) for any two vertices s, t (with a stretch of at most k) Distance oracles

21. Distance Oracles Thm [Thorup-Zwick-05]: For every weighted undirected graph G it is possible to construct a data structure of size O(n 1+1/k ) that is capable of answering distance queries Q dist (s,t) in O(k) time, with multiplicative approximation factor ≤ 2k-1 (returns a distance estimate đ such that dist(s,t,G)  đ  (2k-1)dist(s,t,G) )

22. Distributed distance oracles – Distance labeling schemes [P-99] Data structure stored in pieces at the graph vertices (as vertex labels) To answer distance query Q dist (s,t), it suffices to consult the labels L(s), L(T)

23. Distributed distance oracles – Distance labeling schemes [P-99] Thm [P-99]: For every weighted undirected graph G it is possible to construct an approximate distance labeling scheme of size Õ (n 1/k ) capable of answering distance queries Q dist (s,t) with multiplicative approximation factor O(k)

24. F-T distance oracle: Data structure capable of answering distance queries Q dist (s,t,F) between vertex pairs s,t, on the surviving graph G\F, subsequent to a failure event F F-T distance oracles

25. Related work [Demetrescu et al-08]: It is possible to preprocess a weighted graph in time Õ(mn 2 ) to produce a data structure of size O(n 2 logn) for answering 1-failure distance queries Q dist in O(1) time F-T distance oracles

26. Related work [Karger-Bernstein-09] improved preprocessing time for 1-failure queries, to O(n 2 √m), then to Õ(mn), with same size and query time. [Duan-Pettie-09] oracle for 2-failure queries, of size O(n 2 log 3 n) and query time in O(log n) F-T distance oracles

27. Thm [CLPR-10] There exists a polynomial-time constructible data structure of size O(kn 1+8(f+1)/(k+2(f+1)) log(nW)), that given a set of edges F of size |F|≤f and two vertices s,t, returns in time O(f  log 2 n  loglogn  loglogd) a distance estimate đ such that dist(s,t,G\F)  đ  (2k-1)dist(s,t,G\F) F-T distance oracles

28. Neighborhoods B ρ (v) = ρ -neighborhood of v = vertices at distance ρ or less from v B 0 (v) B 1 (v) B 2 (v)

29. Tree covers Basic notion: A tree T covering the ρ -neighborhood of v v B 2 (v) covering T

30. G = weighted undirected graph A tree cover TC( ,k) : collection of trees {T 1,…,T l } such that 1. For every v there exists a tree T i such that B  (v)  T i 2. For every T i and every v  T i, dist(v,r i,T i )  (2k-1)  3. For every v, the number of trees that contain v is O(kn 1/k ). Tree Covers TiTi B  (v) (2k-1)  v O(kn 1/k )

31. Lemma [Awerbuch-Kutten-P-91, Cohen-93] A tree cover TC( ,k) can be constructed in time Õ(mn 1/k ) Tree Covers

32. Lemma (F-T connectivity oracle [CLPR-10]) There exists a poly time constructible data structure of size O(fkn 1+1/k log(nW)), that given a set of failed edges F of size f and two vertices s,t, replies in time O(f log 2 n loglogn) whether s and t are connected in G\F Connectivity Oracle (reminder)

33. Construction The algorithm has log(nW) iterations Iteration i handles distances ≤ 2 i G i = graph obtained by removing from G all edges of weight > 2 i f-Sensitivity Distance Oracles

34. Iteration i: Construct a tree cover TC i with ρ= 2 i and k G i | T = subgraph of G i induced by T vertices For each T  TC i, construct connectivity oracle Conn_Or T on G i | T For each vertex v store pointer to tree T i (v)  TC i containing B ρ (v) f-Sensitivity Distance Oracles

35. Lemma The size of the data structure is O(fkn 1+1/k log(nW)) f-Sensitivity Distance Oracles

36. Q dist (s,t,F) For i  1 to log(nW) if Conn_Or Ti(s) (s,t,F) = true, then return đ=(8k-2)(f+1)2 i-1 Return  Answering Queries

37. Lemma Consider vertices s,t and failure set F. Let d=dist(s,t,G\F). The estimated distance đ returned by Q dist (s,t,F) satisfies d  đ  (8k-2)(f+1)d f-Sensitivity Distance Oracles

38. Lemma The f-sensitivity distance query (s,t,F) can be implemented to return a distance estimate in time O(f  log 2 n  loglogn  loglogd) f-Sensitivity Distance Oracles

39. Main result [CLPR-10] 2-sensitive compact routing scheme: Given a message M at a source vertex s and a destination t, in the presence of failed edges F={e 1,e 2 }, routes M from s to t over a path of length O(k ⋅ dist(s,t,G\{e 1,e 2 }). Total information stored in vertices: O(kn 1+1/k log(nW)logn). 2-sensitivity routing

40. Use hierarchy of tree covers as in distance oracle. To route from s to t, try increasingly higher levels Suppose dist(s,t,G) ≤ 2 i There is a tree T  TC i that contains B  (s) for  =2 i ⇨ T contains also the destination t 2-sensitivity routing T B  (s) t

41. T is of depth ≤ (2k-1) ⋅ 2 i The route from s to t is at most k ⋅ 2 i+2 = O(k ⋅ dist(s,t,G)) Only remaining problem: handle edge disconnections… 2-sensitivity routing T B  (s) t

42. Consider this tree T u v 2-sensitivity routing Each edge e=(u,v)  T – if failed - T u (e) T v (e) disconnects T into two connected components, T u (e) and T v (e)

43. A recovery edge of e is any edge e’ of G that connects T u (e) and T v (e). Define for each edge e  T a recovery edge rec(e). u v rec(e) 2-sensitivity routing T u (e) T v (e)

44. Slight simplification for analysis: Assume the graph edges are sorted -  e 1,…, e m , and choose rec(e) for every e to be the first recovery edge e i of e 2-sensitivity routing

45. Consider the recovery edge rec(e) = (u',v‘) of the edge e. Denote by P(u,u‘) (resp., P(v,v‘)) the path connecting u and u’ (resp., v and v’) in the tree T u (e) (resp., T v (e)) Denote the entire alternative path for e=(u,v) by P(e) = P(u,u‘) ∙ (u',v') ∙ P(v',v). rec(e) P(u,u’) P(v,v’) e 2-sensitivity routing

46. Failed edges: e 1 = ( u 1, v 1 ) and e 2 = ( u 2, v 2 ) Simplest case: e 1 and e 2 are not in T : just route on T. 2-sensitivity routing

47. Still simple case: e 1  T, e 2  T. 2-sensitivity routing ⇨ T ⋃ rec(e 1 ) \ { e 1, e 2 } is broken into two connected components only when rec(e 1 ) = e 2 To overcome this, it suffices to store, for each edge e  T, one additional recovery edge.

48. Hard case: both e 1, e 2  T.  Subcase 1 (not too hard): e 2 does not appear on the alternative path P(e 1 ) via rec(e 1 ) (and s,t are connected in G i | T \{e 1,e 2 }): 2-sensitivity routing ⇨ rec(e 1 ), rec(e 2 ) suffice for routing from s to t

49.  Subcase 2 (hardest): both e 1 is on P(e 2 ) and e 2 is on P(e 1 ). 2-sensitivity routing ⇨ rec(e 1 ) = rec(e 2 )

50. Store for e 1 (similarly, for each edge e  T) two additional recovery edges rec u1 (e 1 ) and rec v1 (e 1 ). Choose rec u1 (e 1 ) to be the edge that “bypasses” as many edges on P(u 1,u 1 ‘) as possible. 2-sensitivity routing

51. Specifically: Consider the path P’ from u 1 to any other recovery edge e’ ≠ rec(e 1 ) P’ has some common prefix with P(u 1,u 1 ‘). rec u1 (e 1 ) ← recovery edge e’ of e 1 that minimizes the length of the common prefix rec v1 (e 1 ) chosen analogously w.r.t P(v 1,v 1 ‘) 2-sensitivity routing

52. These choices ensure successful routing (requires detailed case analysis) The routing process

53. T1T1 T2T2 T3T3

54. T1T1 T2T2 T3T3 First subcase: The routing process

55. T1T1 T2T2 T3T3 Second subcase: The routing process

56. Thm [CLPR-10] There exists a 2-sensitive compact routing scheme that given a message M at a source vertex s and a destination t, in the presence of failed edges e 1 and e 2, routes M from s to t in a distributed manner over a path of length at most O(k ⋅ dist(s,t,G\{e 1,e 2 }). The total amount of information stored in vertices of G is O(kn 1+1/k log(nW)logn). The routing process