arXiv subjects

Greg Bodwin

Publications and source records attributed to Greg Bodwin.

At least 37 records · Page 2Linked to original sources

arXiv2023

Spanning Adjacency Oracles in Sublinear Time

Suppose we are given an $n$-node, $m$-edge input graph $G$, and the goal is to compute a spanning subgraph $H$ on $O(n)$ edges. This can be achieved in linear $O(m + n)$ time via breadth-first search. But can we hope for \emph{sublinear} runtime in some range of parameters? If the goal is to return $H$ as an adjacency list, there are simple lower bounds showing that $Ω(m + n)$ runtime is necessary. If the goal is to return $H$ as an adjacency matrix, then we need $Ω(n^2)$ time just to write down the entries of the output matrix. However, we show that neither of these lower bounds still apply if instead the goal is to return $H$ as an \emph{implicit} adjacency matrix, which we call an \emph{adjacency oracle}. An adjacency oracle is a data structure that gives a user the illusion that an adjacency matrix has been computed: it accepts edge queries $(u, v)$, and it returns in near-constant time a bit indicating whether $(u, v) \in E(H)$. Our main result is that one can construct an adjacency oracle for a spanning subgraph on at most $(1+\varepsilon)n$ edges, in $\tilde{O}(n \varepsilon^{-1})$ time, and that this construction time is near-optimal. Additional results include constructions of adjacency oracles for $k$-connectivity certificates and spanners, which are similarly sublinear on dense-enough input graphs. Our adjacency oracles are closely related to Local Computation Algorithms (LCAs) for graph sparsifiers; they can be viewed as LCAs with some computation moved to a preprocessing step, in order to speed up queries. Our oracles imply the first Local algorithm for computing sparse spanning subgraphs of general input graphs in $\tilde{O}(n)$ query time, which works by constructing our adjacency oracle, querying it once, and then throwing the rest of the oracle away. This addresses an open problem of Rubinfeld [CSR '17].

cs.DS↗

arXiv2023

Reachability Preservers: New Extremal Bounds and Approximation Algorithms

We abstract and study \emph{reachability preservers}, a graph-theoretic primitive that has been implicit in prior work on network design. Given a directed graph $G = (V, E)$ and a set of \emph{demand pairs} $P \subseteq V \times V$, a reachability preserver is a sparse subgraph $H$ that preserves reachability between all demand pairs. Our first contribution is a series of extremal bounds on the size of reachability preservers. Our main result states that, for an $n$-node graph and demand pairs of the form $P \subseteq S \times V$ for a small node subset $S$, there is always a reachability preserver on $O(n+\sqrt{n |P| |S|})$ edges. We additionally give a lower bound construction demonstrating that this upper bound characterizes the settings in which $O(n)$ size reachability preservers are generally possible, in a large range of parameters. The second contribution of this paper is a new connection between extremal graph sparsification results and classical Steiner Network Design problems. Surprisingly, prior to this work, the osmosis of techniques between these two fields had been superficial. This allows us to improve the state of the art approximation algorithms for the most basic Steiner-type problem in directed graphs from the $O(n^{0.6+\varepsilon})$ of Chlamatac, Dinitz, Kortsarz, and Laekhanukit (SODA'17) to $O(n^{4/7+\varepsilon})$.

cs.DS↗

arXiv2023

Fault-Tolerant Spanners against Bounded-Degree Edge Failures: Linearly More Faults, Almost For Free

We study a new and stronger notion of fault-tolerant graph structures whose size bounds depend on the degree of the failing edge set, rather than the total number of faults. For a subset of faulty edges $F \subseteq G$, the faulty-degree $°(F)$ is the largest number of faults in $F$ incident to any given vertex. We design new fault-tolerant structures with size comparable to previous constructions, but which tolerate every fault set of small faulty-degree $°(F)$, rather than only fault sets of small size $|F|$. Our main results are: - New FT-Certificates: For every $n$-vertex graph $G$ and degree threshold $f$, one can compute a connectivity certificate $H \subseteq G$ with $|E(H)| = \widetilde{O}(fn)$ edges that has the following guarantee: for any edge set $F$ with faulty-degree $°(F)\leq f$ and every vertex pair $u,v$, it holds that $u$ and $v$ are connected in $H \setminus F$ iff they are connected in $G \setminus F$. This bound on $|E(H)|$ is nearly tight. Since our certificates handle some fault sets of size up to $|F|=O(fn)$, prior work did not imply any nontrivial upper bound for this problem, even when $f=1$. - New FT-Spanners: We show that every $n$-vertex graph $G$ admits a $(2k-1)$-spanner $H$ with $|E(H)| = O_k(f^{1-1/k} n^{1+1/k})$ edges, which tolerates any fault set $F$ of faulty-degree at most $f$. This bound on $|E(H)|$ optimal up to its hidden dependence on $k$, and it is close to the bound of $O_k(|F|^{1/2} n^{1+1/k} + |F|n)$ that is known for the case where the total number of faults is $|F|$ [Bodwin, Dinitz, Robelle SODA '22]. Our proof of this theorem is non-constructive, but by following a proof strategy of Dinitz and Robelle [PODC '20], we show that the runtime can be made polynomial by paying an additional $\text{polylog } n$ factor in spanner size.

cs.DS↗

arXiv2023

Bridge Girth: A Unifying Notion in Network Design

A classic 1993 paper by Althőfer et al. proved a tight reduction from spanners, emulators, and distance oracles to the extremal function $γ$ of high-girth graphs. This paper initiated a large body of work in network design, in which problems are attacked by reduction to $γ$ or the analogous extremal function for other girth concepts. In this paper, we introduce and study a new girth concept that we call the bridge girth of path systems, and we show that it can be used to significantly expand and improve this web of connections between girth problems and network design. We prove two kinds of results: 1) We write the maximum possible size of an $n$-node, $p$-path system with bridge girth $>k$ as $β(n, p, k)$, and we write a certain variant for "ordered" path systems as $β^*(n, p, k)$. We identify several arguments in the literature that implicitly show upper or lower bounds on $β, β^*$, and we provide some polynomially improvements to these bounds. In particular, we construct a tight lower bound for $β(n, p, 2)$, and we polynomially improve the upper bounds for $β(n, p, 4)$ and $β^*(n, p, \infty)$. 2) We show that many state-of-the-art results in network design can be recovered or improved via black-box reductions to $β$ or $β^*$. Examples include bounds for distance/reachability preservers, exact hopsets, shortcut sets, the flow-cut gaps for directed multicut and sparsest cut, an integrality gap for directed Steiner forest. We believe that the concept of bridge girth can lead to a stronger and more organized map of the research area. Towards this, we leave many open problems, related to both bridge girth reductions and extremal bounds on the size of path systems with high bridge girth.

cs.DS↗

arXiv2023

Restorable Shortest Path Tiebreaking for Edge-Faulty Graphs

The restoration lemma by Afek, Bremler-Barr, Kaplan, Cohen, and Merritt [Dist. Comp. '02] proves that, in an undirected unweighted graph, any replacement shortest path avoiding a failing edge can be expressed as the concatenation of two original shortest paths. However, the lemma is tiebreaking-sensitive: if one selects a particular canonical shortest path for each node pair, it is no longer guaranteed that one can build replacement paths by concatenating two selected shortest paths. They left as an open problem whether a method of shortest path tiebreaking with this desirable property is generally possible. We settle this question affirmatively with the first general construction of restorable tiebreaking schemes. We then show applications to various problems in fault-tolerant network design. These include a faster algorithm for subset replacement paths, more efficient fault-tolerant (exact) distance labeling schemes, fault-tolerant subset distance preservers and $+4$ additive spanners with improved sparsity, and fast distributed algorithms that construct these objects. For example, an almost immediate corollary of our restorable tiebreaking scheme is the first nontrivial distributed construction of sparse fault-tolerant distance preservers resilient to three faults.

cs.DS↗

arXiv2022

Epic Fail: Emulators can tolerate polynomially many edge faults for free

A $t$-emulator of a graph $G$ is a graph $H$ that approximates its pairwise shortest path distances up to multiplicative $t$ error. We study fault tolerant $t$-emulators, under the model recently introduced by Bodwin, Dinitz, and Nazari [ITCS 2022] for vertex failures. In this paper we consider the version for edge failures, and show that they exhibit surprisingly different behavior. In particular, our main result is that, for $(2k-1)$-emulators with $k$ odd, we can tolerate a polynomial number of edge faults for free. For example: for any $n$-node input graph, we construct a $5$-emulator ($k=3$) on $O(n^{4/3})$ edges that is robust to $f = O(n^{2/9})$ edge faults. It is well known that $Ω(n^{4/3})$ edges are necessary even if the $5$-emulator does not need to tolerate any faults. Thus we pay no extra cost in the size to gain this fault tolerance. We leave open the precise range of free fault tolerance for odd $k$, and whether a similar phenomenon can be proved for even $k$.

cs.DS↗

arXiv2022

New Additive Spanner Lower Bounds by an Unlayered Obstacle Product

For an input graph $G$, an additive spanner is a sparse subgraph $H$ whose shortest paths match those of $G$ up to small additive error. We prove two new lower bounds in the area of additive spanners: 1) We construct $n$-node graphs $G$ for which any spanner on $O(n)$ edges must increase a pairwise distance by $+Ω(n^{1/7})$. This improves on a recent lower bound of $+Ω(n^{1/10.5})$ by Lu, Wein, Vassilevska Williams, and Xu [SODA '22]. 2) A classic result by Coppersmith and Elkin [SODA '05] proves that for any $n$-node graph $G$ and set of $p = O(n^{1/2})$ demand pairs, one can exactly preserve all pairwise distances among demand pairs using a spanner on $O(n)$ edges. They also provided a lower bound construction, establishing that that this range $p = O(n^{1/2})$ cannot be improved. We strengthen this lower bound by proving that, for any constant $k$, this range of $p$ is still unimprovable even if the spanner is allowed $+k$ additive error among the demand pairs. This negatively resolves an open question asked by Coppersmith and Elkin [SODA '05] and again by Cygan, Grandoni, and Kavitha [STACS '13] and Abboud and Bodwin [SODA '16]. At a technical level, our lower bounds are obtained by an improvement to the entire obstacle product framework used to compose "inner" and "outer" graphs into lower bound instances. In particular, we develop a new strategy for analysis that allows certain non-layered graphs to be used in the product, and we use this freedom to design better inner and outer graphs that lead to our new lower bounds.

cs.DS↗

arXiv2021

Vertex Fault-Tolerant Emulators

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.

cs.DS↗

arXiv2021

Better Distance Preservers and Additive Spanners

We study two popular ways to sketch the shortest path distances of an input graph. The first is distance preservers, which are sparse subgraphs that agree with the distances of the original graph on a given set of demand pairs. Prior work on distance preservers has exploited only a simple structural property of shortest paths, called consistency, stating that one can break shortest path ties such that no two paths intersect, split apart, and then intersect again later. We prove that consistency alone is not enough to understand distance preservers, by showing both a lower bound on the power of consistency and a new general upper bound that polynomially surpasses it. Specifically, our new upper bound is that any $p$ demand pairs in an $n$-node undirected unweighted graph have a distance preserver on $O(n^{2/3}p^{2/3} + np^{1/3})$ edges. We leave a conjecture that the right bound is $O(n^{2/3}p^{2/3} + n)$ or better. The second part of this paper leverages these distance preservers in a new construction of additive spanners, which are subgraphs that preserve all pairwise distances up to an additive error function. We give improved error bounds for spanners with relatively few edges; for example, we prove that all graphs have spanners on $O(n)$ edges with $+O(n^{3/7 + \varepsilon})$ error. Our construction can be viewed as an extension of the popular path-buying framework to clusters of larger radii.

cs.DS↗

arXiv2021

Weighted Additive Spanners

A \emph{spanner} of a graph $G$ is a subgraph $H$ that approximately preserves shortest path distances in $G$. Spanners are commonly applied to compress computation on metric spaces corresponding to weighted input graphs. Classic spanner constructions can seamlessly handle edge weights, so long as error is measured \emph{multiplicatively}. In this work, we investigate whether one can similarly extend constructions of spanners with purely \emph{additive} error to weighted graphs. These extensions are not immediate, due to a key lemma about the size of shortest path neighborhoods that fails for weighted graphs. Despite this, we recover a suitable amortized version, which lets us prove direct extensions of classic $+2$ and $+4$ unweighted spanners (both all-pairs and pairwise) to $+2W$ and $+4W$ weighted spanners, where $W$ is the maximum edge weight. Specifically, we show that a weighted graph $G$ contains all-pairs (pairwise) $+2W$ and $+4W$ weighted spanners of size $O(n^{3/2})$ and $\widetilde{O}(n^{7/5})$ ($O(np^{1/3})$ and $O(np^{2/7})$) respectively. For a technical reason, the $+6$ unweighted spanner becomes a $+8W$ weighted spanner; closing this error gap is an interesting remaining open problem. That is, we show that $G$ contains all-pairs (pairwise) $+8W$ weighted spanners of size $O(n^{4/3})$ ($O(np^{1/4})$).

cs.DM↗

arXiv2021

Very Sparse Additive Spanners and Emulators

cs.DS↗

arXiv2021

On additive spanners in weighted graphs with local error

An \emph{additive $+β$ spanner} of a graph $G$ is a subgraph which preserves distances up to an additive $+β$ error. Additive spanners are well-studied in unweighted graphs but have only recently received attention in weighted graphs [Elkin et al.\ 2019 and 2020, Ahmed et al.\ 2020]. This paper makes two new contributions to the theory of weighted additive spanners. For weighted graphs, [Ahmed et al.\ 2020] provided constructions of sparse spanners with \emph{global} error $β= cW$, where $W$ is the maximum edge weight in $G$ and $c$ is constant. We improve these to \emph{local} error by giving spanners with additive error $+cW(s,t)$ for each vertex pair $(s,t)$, where $W(s, t)$ is the maximum edge weight along the shortest $s$--$t$ path in $G$. These include pairwise $+(2+\eps)W(\cdot,\cdot)$ and $+(6+\eps) W(\cdot, \cdot)$ spanners over vertex pairs $\Pc \subseteq V \times V$ on $O_{\eps}(n|\Pc|^{1/3})$ and $O_{\eps}(n|\Pc|^{1/4})$ edges for all $\eps > 0$, which extend previously known unweighted results up to $\eps$ dependence, as well as an all-pairs $+4W(\cdot,\cdot)$ spanner on $\widetilde{O}(n^{7/5})$ edges. Besides sparsity, another natural way to measure the quality of a spanner in weighted graphs is by its \emph{lightness}, defined as the total edge weight of the spanner divided by the weight of an MST of $G$. We provide a $+\eps W(\cdot,\cdot)$ spanner with $O_{\eps}(n)$ lightness, and a $+(4+\eps) W(\cdot,\cdot)$ spanner with $O_{\eps}(n^{2/3})$ lightness. These are the first known additive spanners with nontrivial lightness guarantees. All of the above spanners can be constructed in polynomial time.

cs.DM↗

arXiv2021

A Note on Distance-Preserving Graph Sparsification

We consider problems of the following type: given a graph $G$, how many edges are needed in the worst case for a sparse subgraph $H$ that approximately preserves distances between a given set of node pairs $P$? Examples include pairwise spanners, distance preservers, reachability preservers, etc. There has been a trend in the area of simple constructions based on the hitting set technique, followed by somewhat more complicated constructions that improve over the bounds obtained from hitting sets by roughly a $\log$ factor. In this note, we point out that the simpler constructions based on hitting sets don't actually need an extra $\log$ factor in the first place. This simplifies and unifies a few proofs in the area, and it improves the size of the $+4$ pairwise spanner from $\widetilde{O}(np^{2/7})$ [Kavitha Th. Comp. Sys. '17] to $O(np^{2/7})$.

cs.DS↗

arXiv2021

Multi-level Weighted Additive Spanners

Given a graph $G = (V,E)$, a subgraph $H$ is an \emph{additive $+β$ spanner} if $\dist_H(u,v) \le \dist_G(u,v) + β$ for all $u, v \in V$. A \emph{pairwise spanner} is a spanner for which the above inequality only must hold for specific pairs $P \subseteq V \times V$ given on input, and when the pairs have the structure $P = S \times S$ for some subset $S \subseteq V$, it is specifically called a \emph{subsetwise spanner}. Spanners in unweighted graphs have been studied extensively in the literature, but have only recently been generalized to weighted graphs. In this paper, we consider a multi-level version of the subsetwise spanner in weighted graphs, where the vertices in $S$ possess varying level, priority, or quality of service (QoS) requirements, and the goal is to compute a nested sequence of spanners with the minimum number of total edges. We first generalize the $+2$ subsetwise spanner of [Pettie 2008, Cygan et al., 2013] to the weighted setting. We experimentally measure the performance of this and several other algorithms for weighted additive spanners, both in terms of runtime and sparsity of output spanner, when applied at each level of the multi-level problem. Spanner sparsity is compared to the sparsest possible spanner satisfying the given error budget, obtained using an integer programming formulation of the problem. We run our experiments with respect to input graphs generated by several different random graph generators: Erdős--Rényi, Watts--Strogatz, Barabási--Albert, and random geometric models. By analyzing our experimental results we developed a new technique of changing an initialization parameter value that provides better performance in practice.

cs.DM↗

arXiv2021

Partially Optimal Edge Fault-Tolerant Spanners

Recent work has established that, for every positive integer $k$, every $n$-node graph has a $(2k-1)$-spanner on $O(f^{1-1/k} n^{1+1/k})$ edges that is resilient to $f$ edge or vertex faults. For vertex faults, this bound is tight. However, the case of edge faults is not as well understood: the best known lower bound for general $k$ is $Ω(f^{\frac12 - \frac{1}{2k}} n^{1+1/k} +fn)$. Our main result is to nearly close this gap with an improved upper bound, thus separating the cases of edge and vertex faults. For odd $k$, our new upper bound is $O_k(f^{\frac12 - \frac{1}{2k}} n^{1+1/k} + fn)$, which is tight up to hidden $poly(k)$ factors. For even $k$, our new upper bound is $O_k(f^{1/2} n^{1+1/k} +fn)$, which leaves a gap of $poly(k) f^{1/(2k)}$. Our proof is an analysis of the fault-tolerant greedy algorithm, which requires exponential time, but we also show that there is a polynomial-time algorithm which creates edge fault tolerant spanners that are larger only by factors of $k$.

cs.DS↗

arXiv2020

New Results on Linear Size Distance Preservers

Given $p$ node pairs in an $n$-node graph, a distance preserver is a sparse subgraph that agrees with the original graph on all of the given pairwise distances. We prove the following bounds on the number of edges needed for a distance preserver: - Any $p$ node pairs in a directed weighted graph have a distance preserver on $O(n + n^{2/3} p)$ edges. - Any $p = Ω\left(\frac{n^2}{rs(n)}\right)$ node pairs in an undirected unweighted graph have a distance preserver on $O(p)$ edges, where $rs(n)$ is the Ruzsa-Szemerédi function from combinatorial graph theory. - As a lower bound, there are examples where one needs $ω(σ^2)$ edges to preserve all pairwise distances within a subset of $σ= o(n^{2/3})$ nodes in an undirected weighted graph. If we additionally require that the graph is unweighted, then the range of this lower bound falls slightly to $σ\le n^{2/3 - o(1)}$.

cs.DS↗

arXiv2020

Optimal Vertex Fault-Tolerant Spanners in Polynomial Time

Recent work has pinned down the existentially optimal size bounds for vertex fault-tolerant spanners: for any positive integer $k$, every $n$-node graph has a $(2k-1)$-spanner on $O(f^{1-1/k} n^{1+1/k})$ edges resilient to $f$ vertex faults, and there are examples of input graphs on which this bound cannot be improved. However, these proofs work by analyzing the output spanner of a certain exponential-time greedy algorithm. In this work, we give the first algorithm that produces vertex fault tolerant spanners of optimal size and which runs in polynomial time. Specifically, we give a randomized algorithm which takes $\widetilde{O}\left( f^{1-1/k} n^{2+1/k} + mf^2\right)$ time. We also derandomize our algorithm to give a deterministic algorithm with similar bounds. This reflects an exponential improvement in runtime over [Bodwin-Patel PODC '19], the only previously known algorithm for constructing optimal vertex fault-tolerant spanners.

cs.DS↗

arXiv2020

The 4/3 Additive Spanner Exponent is Tight

A spanner is a sparse subgraph that approximately preserves the pairwise distances of the original graph. It is well known that there is a smooth tradeoff between the sparsity of a spanner and the quality of its approximation, so long as distance error is measured multiplicatively. A central open question in the field is to prove or disprove whether such a tradeoff exists also in the regime of \emph{additive} error. That is, is it true that for all $\varepsilon>0$, there is a constant $k_{\varepsilon}$ such that every graph has a spanner on $O(n^{1+\varepsilon})$ edges that preserves its pairwise distances up to $+k_{\varepsilon}$? Previous lower bounds are consistent with a positive resolution to this question, while previous upper bounds exhibit the beginning of a tradeoff curve: all graphs have $+2$ spanners on $O(n^{3/2})$ edges, $+4$ spanners on $\tilde{O}(n^{7/5})$ edges, and $+6$ spanners on $O(n^{4/3})$ edges. However, progress has mysteriously halted at the $n^{4/3}$ bound, and despite significant effort from the community, the question has remained open for all $0 < \varepsilon < 1/3$. Our main result is a surprising negative resolution of the open question, even in a highly generalized setting. We show a new information theoretic incompressibility bound: there is no function that compresses graphs into $O(n^{4/3 - \varepsilon})$ bits so that distance information can be recovered within $+n^{o(1)}$ error. As a special case of our theorem, we get a tight lower bound on the sparsity of additive spanners: the $+6$ spanner on $O(n^{4/3})$ edges cannot be improved in the exponent, even if any subpolynomial amount of additive error is allowed. Our theorem implies new lower bounds for related objects as well; for example, the twenty-year-old $+4$ emulator on $O(n^{4/3})$ edges also cannot be improved in the exponent unless the error allowance is polynomial.

cs.DS↗