Fault-Tolerant Spanners: Better and Simpler

A natural requirement of many distributed structures is fault-tolerance: after some failures, whatever remains from the structure should still be effective for whatever remains from the network. In this paper we examine spanners of general graphs that are tolerant to vertex failures, and significantly improve their dependence on the number of faults $r$, for all stretch bounds. For stretch $k \geq 3$ we design a simple transformation that converts every $k$-spanner construction with at most $f(n)$ edges into an $r$-fault-tolerant $k$-spanner construction with at most $O(r^3 \log n) \cdot f(2n/r)$ edges. Applying this to standard greedy spanner constructions gives $r$-fault tolerant $k$-spanners with $\tilde O(r^{2} n^{1+\frac{2}{k+1}})$ edges. The previous construction by Chechik, Langberg, Peleg, and Roddity [STOC 2009] depends similarly on $n$ but exponentially on $r$ (approximately like $k^r$). For the case $k=2$ and unit-length edges, an $O(r \log n)$-approximation algorithm is known from recent work of Dinitz and Krauthgamer [arXiv 2010], where several spanner results are obtained using a common approach of rounding a natural flow-based linear programming relaxation. Here we use a different (stronger) LP relaxation and improve the approximation ratio to $O(\log n)$, which is, notably, independent of the number of faults $r$. We further strengthen this bound in terms of the maximum degree by using the \Lovasz Local Lemma. Finally, we show that most of our constructions are inherently local by designing equivalent distributed algorithms in the LOCAL model of distributed computation.Comment: 17 page

Fault-tolerant additive weighted geometric spanners

Let S be a set of n points and let w be a function that assigns non-negative weights to points in S. The additive weighted distance d_w(p, q) between two points p,q belonging to S is defined as w(p) + d(p, q) + w(q) if p \ne q and it is zero if p = q. Here, d(p, q) denotes the (geodesic) Euclidean distance between p and q. A graph G(S, E) is called a t-spanner for the additive weighted set S of points if for any two points p and q in S the distance between p and q in graph G is at most t.d_w(p, q) for a real number t > 1. Here, d_w(p,q) is the additive weighted distance between p and q. For some integer k \geq 1, a t-spanner G for the set S is a (k, t)-vertex fault-tolerant additive weighted spanner, denoted with (k, t)-VFTAWS, if for any set S' \subset S with cardinality at most k, the graph G \ S' is a t-spanner for the points in S \ S'. For any given real number \epsilon > 0, we obtain the following results: - When the points in S belong to Euclidean space R^d, an algorithm to compute a (k,(2 + \epsilon))-VFTAWS with O(kn) edges for the metric space (S, d_w). Here, for any two points p, q \in S, d(p, q) is the Euclidean distance between p and q in R^d. - When the points in S belong to a simple polygon P, for the metric space (S, d_w), one algorithm to compute a geodesic (k, (2 + \epsilon))-VFTAWS with O(\frac{k n}{\epsilon^{2}}\lg{n}) edges and another algorithm to compute a geodesic (k, (\sqrt{10} + \epsilon))-VFTAWS with O(kn(\lg{n})^2) edges. Here, for any two points p, q \in S, d(p, q) is the geodesic Euclidean distance along the shortest path between p and q in P. - When the points in $S$ lie on a terrain T, an algorithm to compute a geodesic (k, (2 + \epsilon))-VFTAWS with O(\frac{k n}{\epsilon^{2}}\lg{n}) edges.Comment: a few update

Vertex Fault Tolerant Additive Spanners

A {\em fault-tolerant} structure for a network is required to continue functioning following the failure of some of the network's edges or vertices. In this paper, we address the problem of designing a {\em fault-tolerant} additive spanner, namely, a subgraph $H$ of the network $G$ such that subsequent to the failure of a single vertex, the surviving part of $H$ still contains an \emph{additive} spanner for (the surviving part of) $G$, satisfying $dist(s,t,H\setminus \{v\}) \leq dist(s,t,G\setminus \{v\})+\beta$ for every $s,t,v \in V$. Recently, the problem of constructing fault-tolerant additive spanners resilient to the failure of up to $f$ \emph{edges} has been considered by Braunschvig et. al. The problem of handling \emph{vertex} failures was left open therein. In this paper we develop new techniques for constructing additive FT-spanners overcoming the failure of a single vertex in the graph. Our first result is an FT-spanner with additive stretch $2$ and $\widetilde{O}(n^{5/3})$ edges. Our second result is an FT-spanner with additive stretch $6$ and $\widetilde{O}(n^{3/2})$ edges. The construction algorithm consists of two main components: (a) constructing an FT-clustering graph and (b) applying a modified path-buying procedure suitably adopted to failure prone settings. Finally, we also describe two constructions for {\em fault-tolerant multi-source additive spanners}, aiming to guarantee a bounded additive stretch following a vertex failure, for every pair of vertices in $S \times V$ for a given subset of sources $S\subseteq V$. The additive stretch bounds of our constructions are 4 and 8 (using a different number of edges)

Optimal Vertex Fault Tolerant Spanners (for fixed stretch)

A $k$-spanner of a graph $G$ is a sparse subgraph $H$ whose shortest path distances match those of $G$ up to a multiplicative error $k$. In this paper we study spanners that are resistant to faults. A subgraph $H \subseteq G$ is an $f$ vertex fault tolerant (VFT) $k$-spanner if $H \setminus F$ is a $k$-spanner of $G \setminus F$ for any small set $F$ of $f$ vertices that might "fail." One of the main questions in the area is: what is the minimum size of an $f$ fault tolerant $k$-spanner that holds for all $n$ node graphs (as a function of $f$, $k$ and $n$)? This question was first studied in the context of geometric graphs [Levcopoulos et al. STOC '98, Czumaj and Zhao SoCG '03] and has more recently been considered in general undirected graphs [Chechik et al. STOC '09, Dinitz and Krauthgamer PODC '11]. In this paper, we settle the question of the optimal size of a VFT spanner, in the setting where the stretch factor $k$ is fixed. Specifically, we prove that every (undirected, possibly weighted) $n$-node graph $G$ has a $(2k-1)$-spanner resilient to $f$ vertex faults with $O_k(f^{1 - 1/k} n^{1 + 1/k})$ edges, and this is fully optimal (unless the famous Erdos Girth Conjecture is false). Our lower bound even generalizes to imply that no data structure capable of approximating $dist_{G \setminus F}(s, t)$ similarly can beat the space usage of our spanner in the worst case. We also consider the edge fault tolerant (EFT) model, defined analogously with edge failures rather than vertex failures. We show that the same spanner upper bound applies in this setting. Our data structure lower bound extends to the case $k=2$ (and hence we close the EFT problem for $3$-approximations), but it falls to $\Omega(f^{1/2 - 1/(2k)} \cdot n^{1 + 1/k})$ for $k \ge 3$. We leave it as an open problem to close this gap.Comment: To appear in SODA 201

Small Cuts and Connectivity Certificates: A Fault Tolerant Approach

We revisit classical connectivity problems in the {CONGEST} model of distributed computing. By using techniques from fault tolerant network design, we show improved constructions, some of which are even "local" (i.e., with O~(1) rounds) for problems that are closely related to hard global problems (i.e., with a lower bound of Omega(Diam+sqrt{n}) rounds). Distributed Minimum Cut: Nanongkai and Su presented a randomized algorithm for computing a (1+epsilon)-approximation of the minimum cut using O~(D +sqrt{n}) rounds where D is the diameter of the graph. For a sufficiently large minimum cut lambda=Omega(sqrt{n}), this is tight due to Das Sarma et al. [FOCS \u2711], Ghaffari and Kuhn [DISC \u2713]. - Small Cuts: A special setting that remains open is where the graph connectivity lambda is small (i.e., constant). The only lower bound for this case is Omega(D), with a matching bound known only for lambda <= 2 due to Pritchard and Thurimella [TALG \u2711]. Recently, Daga, Henzinger, Nanongkai and Saranurak [STOC \u2719] raised the open problem of computing the minimum cut in poly(D) rounds for any lambda=O(1). In this paper, we resolve this problem by presenting a surprisingly simple algorithm, that takes a completely different approach than the existing algorithms. Our algorithm has also the benefit that it computes all minimum cuts in the graph, and naturally extends to vertex cuts as well. At the heart of the algorithm is a graph sampling approach usually used in the context of fault tolerant (FT) design. - Deterministic Algorithms: While the existing distributed minimum cut algorithms are randomized, our algorithm can be made deterministic within the same round complexity. To obtain this, we introduce a novel definition of universal sets along with their efficient computation. This allows us to derandomize the FT graph sampling technique, which might be of independent interest. - Computation of all Edge Connectivities: We also consider the more general task of computing the edge connectivity of all the edges in the graph. In the output format, it is required that the endpoints u,v of every edge (u,v) learn the cardinality of the u-v cut in the graph. We provide the first sublinear algorithm for this problem for the case of constant connectivity values. Specifically, by using the recent notion of low-congestion cycle cover, combined with the sampling technique, we compute all edge connectivities in poly(D) * 2^{O(sqrt{log n log log n})} rounds. Sparse Certificates: For an n-vertex graph G and an integer lambda, a lambda-sparse certificate H is a subgraph H subseteq G with O(lambda n) edges which is lambda-connected iff G is lambda-connected. For D-diameter graphs, constructions of sparse certificates for lambda in {2,3} have been provided by Thurimella [J. Alg. \u2797] and Dori [PODC \u2718] respectively using O~(D) number of rounds. The problem of devising such certificates with o(D+sqrt{n}) rounds was left open by Dori [PODC \u2718] for any lambda >= 4. Using connections to fault tolerant spanners, we considerably improve the round complexity for any lambda in [1,n] and epsilon in (0,1), by showing a construction of (1-epsilon)lambda-sparse certificates with O(lambda n) edges using only O(1/epsilon^2 * log^{2+o(1)} n) rounds

Sparse Fault-Tolerant BFS Trees

This paper addresses the problem of designing a sparse {\em fault-tolerant} BFS tree, or {\em FT-BFS tree} for short, namely, a sparse subgraph $T$ of the given network $G$ such that subsequent to the failure of a single edge or vertex, the surviving part $T'$ of $T$ still contains a BFS spanning tree for (the surviving part of) $G$. Our main results are as follows. We present an algorithm that for every $n$-vertex graph $G$ and source node $s$ constructs a (single edge failure) FT-BFS tree rooted at $s$ with O(n \cdot \min\{\Depth(s), \sqrt{n}\}) edges, where \Depth(s) is the depth of the BFS tree rooted at $s$. This result is complemented by a matching lower bound, showing that there exist $n$-vertex graphs with a source node $s$ for which any edge (or vertex) FT-BFS tree rooted at $s$ has $\Omega(n^{3/2})$ edges. We then consider {\em fault-tolerant multi-source BFS trees}, or {\em FT-MBFS trees} for short, aiming to provide (following a failure) a BFS tree rooted at each source $s\in S$ for some subset of sources $S\subseteq V$. Again, tight bounds are provided, showing that there exists a poly-time algorithm that for every $n$-vertex graph and source set $S \subseteq V$ of size $\sigma$ constructs a (single failure) FT-MBFS tree $T^*(S)$ from each source $s_i \in S$, with $O(\sqrt{\sigma} \cdot n^{3/2})$ edges, and on the other hand there exist $n$-vertex graphs with source sets $S \subseteq V$ of cardinality $\sigma$, on which any FT-MBFS tree from $S$ has $\Omega(\sqrt{\sigma}\cdot n^{3/2})$ edges. Finally, we propose an $O(\log n)$ approximation algorithm for constructing FT-BFS and FT-MBFS structures. The latter is complemented by a hardness result stating that there exists no $\Omega(\log n)$ approximation algorithm for these problems under standard complexity assumptions