Optimal Vertex Fault Tolerant Spanners (for fixed stretch)

@article{Bodwin2017OptimalVF,
  title={Optimal Vertex Fault Tolerant Spanners (for fixed stretch)},
  author={Gregory Bodwin and Michael Dinitz and Merav Parter and Virginia Vassilevska Williams},
  journal={ArXiv},
  year={2017},
  volume={abs/1710.03164}
}
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… 

Figures from this paper

Deterministic Replacement Path Covering

A unified and simplified approach to derandomize central results in the area of fault-tolerant graph algorithms by presenting efficient deterministic constructions of $(L,f)-RPCs whose covering values almost match the randomized ones, for a wide range of parameters.

Optimal Vertex Fault-Tolerant Spanners in Polynomial Time

The first algorithm that produces vertex fault tolerant spanners of optimal size and which runs in polynomial time is given, which reflects an exponential improvement in runtime over [Bodwin-Patel PODC '19], the only previously known algorithm for constructing optimal vertex fault-tolerance spanners.

Approximate Distance Oracles Subject to Multiple Vertex Failures

These results are the first approximate distance oracles of poly-logarithmic query time for any constant number of vertex failures in general undirected graphs.

A Polynomial Time Algorithm for Almost Optimal Vertex Fault Tolerant Spanners

The first polynomial time algorithm for the f vertex fault tolerant spanner problem is presented, which achieves almost optimal spanner size and is at most a $\log n$ factor away from the upper bound on the worst-case size.

Vertex Fault-Tolerant Emulators

A natural definition of vertex fault-tolerant emulators is introduced, and a three-way tradeoff between size, stretch, and fault-Tolerance for these emulators that polynomially surpasses the tradeoff known to be optimal for spanners.

Se p 20 21 Vertex Fault-Tolerant Emulators

A natural definition of vertex fault-tolerant emulators is introduced, and a three-way tradeoff between size, stretch, and fault-Tolerance for these emulators that polynomially surpasses the tradeoff known to be optimal for spanners is shown.

Efficient and Simple Algorithms for Fault-Tolerant Spanners

A surprisingly simple algorithm is given which runs in polynomial time and constructs fault-tolerant spanners that are extremely close to optimal (off by only a linear factor in the stretch) by modifying the greedy algorithm to run in poynomial time.

Nearly optimal vertex fault-tolerant spanners in optimal time: sequential, distributed, and parallel

The time complexity for computing vertex fault-tolerant (VFT) spanners with optimal sparsity (up to polylogarithmic factors) is settled, with near optimal running time in several computational models.

Partially Optimal Edge Fault-Tolerant Spanners

This paper shows that there is a polynomial-time algorithm which creates edge fault tolerant spanners that are larger only by factors of k, and an analysis of the fault-tolerant greedy algorithm, which requires exponential time.

Approximating Spanners and Directed Steiner Forest

This work gives an O(n3/5 + ε)-approximation for distance preservers and pairwise spanners and proves Label Cover hardness for approximating additive spanners, even for the cases of additive 1 stretch.

References

SHOWING 1-10 OF 55 REFERENCES

Multiple-Edge-Fault-Tolerant Approximate Shortest-Path Trees

The problem of designing a sparse f -edge-fault-tolerant ( f -EFT) σ -approximate single-source shortest-path tree (ASPT) is studied, namely a subgraph of G having as few edges as possible and which contains paths from a fixed source that are stretched by a factor of at most σ .

Approximate Shortest Paths Avoiding a Failed Vertex: Optimal Size Data Structures for Unweighted Graph

The problem of building a compact data structure for a given graph which is capable of answering the following query for any two vertices of that graph is considered and data structures for the single source as well all-pairs versions of this problem are presented.

Region-Fault Tolerant Geometric Spanners

AbstractWe introduce the concept of region-fault tolerant spanners for planar point sets and prove the existence of region-fault tolerant spanners of small size. For a geometric graph $\mathcal{G}$

Oracles for Distances Avoiding a Failed Node or Link

A deterministic oracle with constant query time for this problem that uses $O (n^2\log n)$ space, where $n$ is the number of vertices in $G$ and the construction time for the oracle is $O(mn^{2} + n^{3}\ log n)$.

Fault-tolerant spanners for general graphs

An f-vertex fault tolerant (2k-1)-spanner of size O(f <sup>2</sup> k<sup>f+1</Sup> · n<sup><sup>1+1/k</sup>) (only f times larger than standard spanners) is presented.

Improved Algorithms for Constructing Fault-Tolerant Spanners

Algorithms are given that construct k -fault-tolerant spanners for S, a set of n points in a metric space, whose total edge length is O(ck) times the weight of a minimum spanning tree of S, for some constant c .

Connectivity Oracles for Graphs Subject to Vertex Failures

This is the first connectivity oracle for general graphs that can efficiently deal with an unbounded number of vertex failures and also develops a more efficient Monte Carlo edge-failure connectivity oracles.

Computing Graph Spanners in Small Memory: Fault-Tolerance and Streaming

This paper shows how to compute efficiently (3,2)- and (2,1)- spanners of G, using only very small internal memory and a slow access external memory device, which have asymptotically optimal size and the I/O complexity of their algorithms is optimal up to a polylogarithmic factor.

Efficient algorithms for constructing fault-tolerant geometric spanners

This paper presents an algorithm with running time O(n logdB1 n + kn log log n + k2n) that constructs a spanner with O(k2n), whose total edge length is bounded by G(2) times the weight of a miuimum spanning tree of S, and that is resilient to k edge or vertex faults.

New Results of Fault Tolerant Geometric Spanners

A construction of a k-vertex fault tolerant spanner with O(kn) edges which is a tight bound and a more natural but stronger definition of k-edge fault tolerance which not necessarily can be satisfied if one allows only simple edges between the points of S.
...