## No full-text available

To read the full-text of this research,

you can request a copy directly from the authors.

Chapter

To read the full-text of this research,

you can request a copy directly from the authors.

... The technical details of this analysis get surprisingly tricky, and it turns out that we actually cannot consider all k-paths in the algorithm and analysis outlined above, but only a carefully selected subset of them that we call "SALAD" paths. The technical details of these paths are responsible for the exp(k) factors and the even/odd k distinction (a similar even/odd distinction appears in [12], for a similar technical reason). ...

... Hence E[σ ′′ ] ≤ σ d k+1 . Our second inequality needs the following lemma, which was proved implicitly in [12] (it is a generalization of the "intermediate counting lemma" of [12]; we include the proof here for completeness). Lemma 3.9. ...

... Hence E[σ ′′ ] ≤ σ d k+1 . Our second inequality needs the following lemma, which was proved implicitly in [12] (it is a generalization of the "intermediate counting lemma" of [12]; we include the proof here for completeness). Lemma 3.9. ...

A $k$-spanner of a graph $G$ is a sparse subgraph that preserves its shortest path distances up to a multiplicative stretch factor of $k$, and a $k$-emulator is similar but not required to be a subgraph of $G$. A classic theorem by Thorup and Zwick [JACM '05] shows that, despite the extra flexibility available to emulators, the size/stretch tradeoffs for spanners and emulators are equivalent. Our main result is that this equivalence in tradeoffs no longer holds in the commonly-studied setting of graphs with vertex failures. That is: we introduce a natural definition of vertex fault-tolerant emulators, and then we show a three-way tradeoff between size, stretch, and fault-tolerance for these emulators that polynomially surpasses the tradeoff known to be optimal for spanners. We complement our emulator upper bound with a lower bound construction that is essentially tight (within $\log n$ factors of the upper bound) when the stretch is $2k-1$ and $k$ is either a fixed odd integer or $2$. We also show constructions of fault-tolerant emulators with additive error, demonstrating that these also enjoy significantly improved tradeoffs over those available for fault-tolerant additive spanners.

... We note even the (fault-free) Baswana-Sen algorithm provides (2k − 1) spanner with O(kn 1+1/k ) edges. Providing optimal algorithms for optimal EFT-spanners is also a major open problem, in light of the recent work by Bodwin, Dinitz and Robelle [BDR21b]. ...

We (nearly) settle the time complexity for computing vertex fault-tolerant (VFT) spanners with optimal sparsity (up to polylogarithmic factors). VFT spanners are sparse subgraphs that preserve distance information, up to a small multiplicative stretch, in the presence of vertex failures. These structures were introduced by [Chechik et al., STOC 2009] and have received a lot of attention since then. We provide algorithms for computing nearly optimal $f$-VFT spanners for any $n$-vertex $m$-edge graph, with near optimal running time in several computational models: - A randomized sequential algorithm with a runtime of $\widetilde{O}(m)$ (i.e., independent in the number of faults $f$). The state-of-the-art time bound is $\widetilde{O}(f^{1-1/k}\cdot n^{2+1/k}+f^2 m)$ by [Bodwin, Dinitz and Robelle, SODA 2021]. - A distributed congest algorithm of $\widetilde{O}(1)$ rounds. Improving upon [Dinitz and Robelle, PODC 2020] that obtained FT spanners with near-optimal sparsity in $\widetilde{O}(f^{2})$ rounds. - A PRAM (CRCW) algorithm with $\widetilde{O}(m)$ work and $\widetilde{O}(1)$ depth. Prior bounds implied by [Dinitz and Krauthgamer, PODC 2011] obtained sub-optimal FT spanners using $\widetilde{O}(f^3m)$ work and $\widetilde{O}(f^3)$ depth. An immediate corollary provides the first nearly-optimal PRAM algorithm for computing nearly optimal $\lambda$-\emph{vertex} connectivity certificates using polylogarithmic depth and near-linear work. This improves the state-of-the-art parallel bounds of $\widetilde{O}(1)$ depth and $O(\lambda m)$ work, by [Karger and Motwani, STOC'93].

We show how to construct a \((1+\varepsilon )\)-spanner over a set \({P}\) of n points in \({\mathbb {R}}^d\) that is resilient to a catastrophic failure of nodes. Specifically, for prescribed parameters \({\vartheta },\varepsilon \in (0,1)\), the computed spanner \({G}\) has $$\begin{aligned} {{\mathcal {O}}}\bigl (\varepsilon ^{-O(d)} {\vartheta }^{-6} n(\log \log n)^6 \log n \bigr ) \end{aligned}$$edges. Furthermore, for anyk, and any deleted set \({{B}}\subseteq {P}\) of k points, the residual graph \({G}\setminus {{B}}\) is a \((1+\varepsilon )\)-spanner for all the points of \({P}\) except for \((1+{\vartheta })k\) of them. No previous constructions, beyond the trivial clique with \({{\mathcal {O}}}(n^2)\) edges, were known with this resilience property (i.e., only a tiny additional fraction of vertices, \(\vartheta |B|\), lose their distance preserving connectivity). Our construction works by first solving the exact problem in one dimension, and then showing a surprisingly simple and elegant construction in higher dimensions, that uses the one-dimensional construction in a black-box fashion.

This paper concerns eecient broadcast in communication networks, where eeciency is measured with respect to both the total communication cost and the speed of message delivery at all destinations. It is shown that this task can be performed eciently using sparse, light w eight, low stretch spanners. It is then shown how to eciently construct a family of spanners that are near optimal with respect to these three properties. Previous constructions were at least (p n) a way from the lower bounds in at least one of the parameters, and required O(n 2) initialization cost. In comparison, the parameters of our construction as well as its initialization cost are within poly-logarithmic factors from the corresponding lower bounds.

This paper concerns graph spanners that are resistant to vertex or edge failures. In the failure-free setting it is known how to efficiently construct a (2k-1)-spanner of size O(n 1+1/k ), and this size-stretch trade-off is conjectured to be tight. The notion of fault tolerant spanners was introduced a decade ago in the geometric setting by C. Levcopoulos, G. Narasimhan and M. Smid [in: STOC ’98. Proceedings of the 30th annual ACM symposium on theory of computing, Dallas, TX, USA, May 23-26, 1998. New York, NY: ACM, Association for Computing Machinery. 186–195 (1998; Zbl 1027.68978)]. A subgraph H is an f-vertex fault tolerant k-spanner of the graph G if for any set F⊆V of size at most f and any pair of vertices u,v∈V∖F, the distances in H satisfy δ H∖F (u,v)≤k·δ G∖F (u,v). A fault tolerant geometric spanner with optimal maximum degree and total weight was presented in [A. Czumaj and H. Zhao, Discrete Comput. Geom. 32, No. 2, 207–230 (2004; Zbl 1095.68125)]. This paper also raised as an open problem the question of whether it is possible to obtain a fault tolerant spanner for an arbitrary undirected weighted graph. The current paper answers this question in the affirmative, presenting an f-vertex fault tolerant (2k-1)-spanner of size O(f 2 k f+1 ·n 1+1/k log 1-1/k n). Interestingly, the stretch of the spanner remains unchanged, while the size of the spanner increases only by a factor that depends on the stretch k, on the number of potential faults f, and on logarithmic terms in n. In addition, we consider the simpler setting of f-edge fault tolerant spanners (defined analogously). We present an f-edge fault tolerant (2k-1)-spanner with edge set of size O(f·n 1+1/k ) (only f times larger than standard spanners). For both edge and vertex faults, our results are shown to hold when the given graph G is weighted.

Given a graphG, a subgraphG' is at-spanner ofG if, for everyu,v ɛV, the distance fromu tov inG' is at mostt times longer than the distance inG. In this paper we give a simple algorithm for constructing sparse spanners for arbitrary weighted graphs. We then apply this algorithm to obtain specific results for planar graphs and Euclidean graphs. We discuss the optimality of our results and present several nearly matching lower bounds.

Two conflicting goals play a crucial role in the design of routing schemes for communication networks. A routing scheme should use paths that are as short as possible for routing messages in the network, while keeping the routing information stored in the processors' local memory as succinct as possible. The efficiency of a routing scheme is measured in terms of its stretch factor -the maximum ratio between the length of a route computed by the scheme and that of a shortest path connecting the same pair of vertices.
Most previous work has concentrated on finding good routing schemes (with a small fixed stretch factor) for special classes of network topologies. In this paper the problem for general networks is studied, and the entire range of possible stretch factors is examined. The results exhibit a trade-off between the efficiency of a routing scheme and its space requirements. Almost tight upper and lower bounds for this trade-off are presented. Specifically, it is proved that any routing scheme for general n -vertex networks that achieves a stretch factor k ≥ 1 must use a total of Ω( n 1+1/(2 k +4) ) bits of routing information in the networks. This lower bound is complemented by a family K ( k ) of hierarchical routing schemes (for every k ≥ l) for unit-cost general networks, which guarantee a stretch factor of O ( k ), require storing a total of O ( k ³ n 1+(1/h) log n )- bits of routing information in the network, name the vertices with O (log ² n )-bit names and use O (log n )-bit headers.

The synchronizer is a simulation methodology for simulating a synchronous network by an asynchronous one, thus enabling the execution of a synchronous algorithm on an asynchronous network. Previously known synchronizers require each processor in the network to participate in each pulse of the synchronization process. The resulting communication overhead depends linearly on the number n of network nodes. A synchronizer with overhead only polylogarithmically dependent on n is introduced. This synchronizer can also be realized with polylog( n ) space. The polylog-overhead synchronizer is based on involving only the relevant portions of the network in the synchronization process

We investigate the problem of constructing spanners for a given set of points that are tolerant for edge/vertex faults. Let ℝd
be a set of n points and let k be an integer number. A k-edge/vertex fault tolerant spanner for S has the property that after the deletion of k arbitrary edges/vertices each pair of points in the remaining graph is still connected by a short path. Recently it was shown that for each set S of n points there exists a k-edge/vertex fault tolerant spannerwith O(k
2n) edges which can be constructed in O(n log n + k
2n) time. Furthermore, it was shown that for each set S of n points there exists a k-edge/vertex fault tolerant spannerwhose degree is bouned by O(c
k+1) for some constant c.
Our first contribution is a construction of a k-vertex fault tolerant spanner with O(kn) edges which is a tight bound. The computation takes O(nlogd−1n + kn log log n) time. Then we show that the same k-vertex fault tolerant spanner is also k-edge fault tolerant. Thereafter, we construct a k-vertex fault tolerant spanner with O(k
2n) edges whose degree is bounded by O(k
2). Finally, we give 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. We investigate the question whether Steiner points help.We answer this question affirmatively and prove Θ(kn) bounds on the number of Steiner points and on the number of edges in such spanners.

We show that every weighted connected graph G contains as a subgraph a spanning tree into which the edges of G can be embedded with average stretch O (log n log log n). Moreover, we show that this tree can be constructed in time O (m log n + n log 2 n) in general, and in time O(m log n) if the input graph is unweighted. The main ingredient in our construction is a novel graph decomposition technique. Our new algorithm can be immediately used to improve the running time of the recent solver for symmetric diagonally dominant linear systems of Spielman and Teng from m2(√ to m log O(1) n, and to O(n log 2 n log log n) when the system is planar. Our result can also be used to improve several earlier approximation algorithms that use low-stretch spanning trees.

We give a short and easy upper bound on the worst-case size of fault tolerant spanners, which improves on all prior work and is fully optimal at least in the setting of vertex faults.

We present two new results about vertex and edge fault-tolerant
spanners in Euclidean spaces.
We describe the first construction of vertex and edge
fault-tolerant spanners having optimal bounds for maximum degree
and total cost. We present a greedy algorithm that for any t > 1
and any non-negative integer k, constructs a k-fault-tolerant
t-spanner in which every vertex is of degree O(k) and whose
total cost is O(k2) times the cost of the minimum spanning tree;
these bounds are asymptotically optimal.
Our next contribution is an efficient algorithm for constructing
good fault-tolerant spanners. We present a new, sufficient
condition for a graph to be a k-fault-tolerant spanner. Using
this condition, we design an efficient algorithm that finds
fault-tolerant spanners with asymptotically optimal bound for the
maximum degree and almost optimal bound for the total cost.

Highly connected and yet sparse graphs (such as expanders or graphs of high
treewidth) are fundamental, widely applicable and extensively studied
combinatorial objects. We initiate the study of such highly connected graphs
that are, in addition, geometric spanners. We define a property of spanners
called robustness. Informally, when one removes a few vertices from a robust
spanner, this harms only a small number of other vertices. We show that robust
spanners must have a superlinear number of edges, even in one dimension. On the
positive side, we give constructions, for any dimension, of robust spanners
with a near-linear number of edges.

We give an elementary construction of Ree's family of finite simple groups , avoiding the need for the machinery of Lie algebras, algebraic groups, or buildings. We calculate the group orders and prove simplicity from first principles. Moreover, this is a practical construction in the sense that it gives an explicit description of the generalized octagon, and from it generators for many of the maximal subgroups may be easily obtained.

An L-length-bounded cut in a graph G with source s, and sink t is a cut that destroys all s-t-paths of length at most L. An L-length-bounded flow is a flow in which only flow paths of length at most L are used. We show that the minimum length-bounded cut problem in graphs with unit edge lengths is NP-hard to approximate within a factor of at least 1.1377 for L ≧ 5 in the case of node-cuts and for L ≧ 4 in the case of edge-cuts. We also give approximation algorithms of ratio min{L, n/L} in the node case and min{L, n2/L2,√m} in the edge case, where n denotes the number of nodes and m denotes the number of edges. We discuss the integrality gaps of the LP relaxations of length-bounded flow and cut problems, analyze the structure of optimal solutions, and present further complexity results for special cases.

Aimed at an audience of researchers and graduate students in computational geometry and algorithm design, this book uses the Geometric Spanner Network Problem to showcase a number of useful algorithmic techniques, data structure strategies, and geometric analysis techniques with many applications, practical and theoretical. The authors present rigorous descriptions of the main algorithms and their analyses for different variations of the Geometric Spanner Network Problem. Though the basic ideas behind most of these algorithms are intuitive, very few are easy to describe and analyze. For most of the algorithms, nontrivial data structures need to be designed, and nontrivial techniques need to be developed in order for analysis to take place. Still, there are several basic principles and results that are used throughout the book. One of the most important is the powerful well-separated pair decomposition. This decomposition is used as a starting point for several of the spanner constructions. © Giri Narasimhan, Michiel Smid 2007 and Cambridge University Press, 2009. All rights reserved.

The synchronizer is a simulation methodology introduced by B. Awerbuch for simulating a synchronous network by an asynchronous one, thus enabling the execution of a synchronous algorithm on an asynchronous network. In this paper a novel technique for constructing network synchronizers is presented. This technique is developed from some basic relationships between synchronizers and the structure of a t-spanning subgraph over the network. As a special result, a synchronizer for the hypercube with optimal time and communication complexities is obtained.

Let G=(V,E) be an undirected weighted graph with |V|=n and |E|=m. Let k≥1 be an integer. We show that G=(V,E) can be preprocessed in O(kmn 1/k ) expected time, constructing a data structure of size O(kn 1+1/k ), such that any subsequent distance query can be answered, approximately, in O(k) time. The approximate distance returned is of stretch at most 2k-1, that is, the quotient obtained by dividing the estimated distance by the actual distance lies between 1 and 2k-1. A 1963 girth conjecture of Erdős, implies that Ω(n 1+1/k ) space is needed in the worst case for any real stretch strictly smaller than 2k+1. The space requirement of our algorithm is, therefore, essentially optimal. The most impressive feature of our data structure is its constant query time, hence the name “oracle”. Previously, data structures that used only O(n 1+1/k ) space had a query time of Ω(n 1/k ). Our algorithms are extremely simple and easy to implement efficiently. They also provide faster constructions of sparse spanners of weighted graphs, and improved tree covers and distance labelings of weighted or unweighted graphs.

What is the maximal number of edges in a bipartite graph of girth g whose left and right sides are of size nL , nR ? We generalize the known results for g = 6; 8 to an arbitrary girth. Keywords: graph, bipartite, girth, random walk. Institute of Computer Science, Hebrew University Jerusalem 91904 Israel shlomoh@cs.huji.ac.il 1 1

Optimal vertex fault tolerant spanners (for fixed stretch)

- G Bodwin
- M Dinitz
- M Parter
- V V Williams

G. Bodwin, M. Dinitz, M. Parter, and V. V. Williams. Optimal vertex fault tolerant spanners (for fixed stretch). In
A. Czumaj, editor, Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA
2018, New Orleans, LA, USA, January 7-10, 2018, pages 1884-1900. SIAM, 2018.

Optimal vertex fault-tolerant spanners in polynomial time

- G Bodwin
- M Dinitz
- C Robelle

G. Bodwin, M. Dinitz, and C. Robelle. Optimal vertex fault-tolerant spanners in polynomial time. In Proceedings of
the Thirty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, 2021.

Fault-tolerant spanners: better and simpler

- M Dinitz
- R Krauthgamer

M. Dinitz and R. Krauthgamer. Fault-tolerant spanners: better and simpler. In Proceedings of the 30th Annual
ACM Symposium on Principles of Distributed Computing, PODC 2011, San Jose, CA, USA, June 6-8, 2011, pages
169-178, 2011.
Copyright © 2022 by SIAM
Unauthorized reproduction of this article is prohibited.

Spectral sparsification via random spanners

- M Kapralov
- R Panigrahy

M. Kapralov and R. Panigrahy. Spectral sparsification via random spanners. In Proceedings of the 3rd Innovations
in Theoretical Computer Science Conference, pages 393-398. ACM, 2012.

Efficient algorithms for constructing fault-tolerant geometric spanners

- C Levcopoulos
- G Narasimhan
- M Smid

C. Levcopoulos, G. Narasimhan, and M. Smid. Efficient algorithms for constructing fault-tolerant geometric spanners.
In Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing, pages 186-195. ACM, 1998.

From hierarchical partitions to hierarchical covers: Optimal fault-tolerant spanners for doubling metrics

- S Solomon

S. Solomon. From hierarchical partitions to hierarchical covers: Optimal fault-tolerant spanners for doubling metrics.
In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 363-372, 2014.