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 $\deg(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 $\deg(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 $\deg(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

Relaxed Byzantine Vector Consensus

Exact Byzantine consensus problem requires that non-faulty processes reach agreement on a decision (or output) that is in the convex hull of the inputs at the non-faulty processes. It is well-known that exact consensus is impossible in an asynchronous system in presence of faults, and in a synchronous system, n>=3f+1 is tight on the number of processes to achieve exact Byzantine consensus with scalar inputs, in presence of up to f Byzantine faulty processes. Recent work has shown that when the inputs are d-dimensional vectors of reals, n>=max(3f+1,(d+1)f+1) is tight to achieve exact Byzantine consensus in synchronous systems, and n>= (d+2)f+1 for approximate Byzantine consensus in asynchronous systems. Due to the dependence of the lower bound on vector dimension d, the number of processes necessary becomes large when the vector dimension is large. With the hope of reducing the lower bound on n, we consider two relaxed versions of Byzantine vector consensus: k-Relaxed Byzantine vector consensus and (delta,p)-Relaxed Byzantine vector consensus. In k-relaxed consensus, the validity condition requires that the output must be in the convex hull of projection of the inputs onto any subset of k-dimensions of the vectors. For (delta,p)-consensus the validity condition requires that the output must be within distance delta of the convex hull of the inputs of the non-faulty processes, where L_p norm is used as the distance metric. For (delta,p)-consensus, we consider two versions: in one version, delta is a constant, and in the second version, delta is a function of the inputs themselves. We show that for k-relaxed consensus and (delta,p)-consensus with constant delta>=0, the bound on n is identical to the bound stated above for the original vector consensus problem. On the other hand, when delta depends on the inputs, we show that the bound on n is smaller when d>=3

Near-Optimal Dispersion on Arbitrary Anonymous Graphs

Given an undirected, anonymous, port-labeled graph of n memory-less nodes, m edges, and degree ?, we consider the problem of dispersing k ? n robots (or tokens) positioned initially arbitrarily on one or more nodes of the graph to exactly k different nodes of the graph, one on each node. The objective is to simultaneously minimize time to achieve dispersion and memory requirement at each robot. If all k robots are positioned initially on a single node, depth first search (DFS) traversal solves this problem in O(min{m,k?}) time with ?(log(k+?)) bits at each robot. However, if robots are positioned initially on multiple nodes, the best previously known algorithm solves this problem in O(min{m,k?}? log ?) time storing ?(log(k+?)) bits at each robot, where ? ? k/2 is the number of multiplicity nodes in the initial configuration. In this paper, we present a novel multi-source DFS traversal algorithm solving this problem in O(min{m,k?}) time with ?(log(k+?)) bits at each robot, improving the time bound of the best previously known algorithm by O(log ?) and matching asymptotically the single-source DFS traversal bounds. This is the first algorithm for dispersion that is optimal in both time and memory in arbitrary anonymous graphs of constant degree, ? = O(1). Furthermore, the result holds in both synchronous and asynchronous settings

Wildcard dimensions, coding theory and fault-tolerant meshes and hypercubes

Hypercubes, meshes and tori are well known interconnection networks for parallel computers. The sets of edges in those graphs can be partitioned to dimensions. It is well known that the hypercube can be extended by adding a wildcard dimension resulting in a folded hypercube that has better fault-tolerant and communication capabilities. First we prove that the folded hypercube is optimal in the sense that only a single wildcard dimension can be added to the hypercube. We then investigate the idea of adding wildcard dimensions to d-dimensional meshes and tori. Using techniques from error correcting codes we construct d-dimensional meshes and tori with wildcard dimensions. Finally, we show how these constructions can be used to tolerate edge and node faults in mesh and torus networks

2-D Compass Codes

The compass model on a square lattice provides a natural template for building subsystem stabilizer codes. The surface code and the Bacon-Shor code represent two extremes of possible codes depending on how many gauge qubits are fixed. We explore threshold behavior in this broad class of local codes by trading locality for asymmetry and gauge degrees of freedom for stabilizer syndrome information. We analyze these codes with asymmetric and spatially inhomogeneous Pauli noise in the code capacity and phenomenological models. In these idealized settings, we observe considerably higher thresholds against asymmetric noise. At the circuit level, these codes inherit the bare-ancilla fault-tolerance of the Bacon-Shor code.Comment: 10 pages, 7 figures, added discussion on fault-toleranc

Engineering DFS-Based Graph Algorithms

Depth-first search (DFS) is the basis for many efficient graph algorithms. We introduce general techniques for the efficient implementation of DFS-based graph algorithms and exemplify them on three algorithms for computing strongly connected components. The techniques lead to speed-ups by a factor of two to three compared to the implementations provided by LEDA and BOOST. We have obtained similar speed-ups for biconnected components algorithms. We also compare the graph data types of LEDA and BOOST