Approximate Single Source Dual Fault Tolerant Distance Oracle

Abstract: We are given an undirected weighted graph $G$ with $n$ vertices and $m$ edges, edge weights in $[1, W]$, and a designated source vertex $s$. We design a single source dual fault tolerant distance oracle for $G$. Given a destination vertex $t$ and a set $F$ of at most two faulty edges, the oracle returns a $(1 + O(ε))$-approximation of the weight of the shortest path from the source $s$ to $t$ avoiding $F$. Our oracle uses $\tilde{O}(n\sqrt{n})$ space and has $\tilde{O}(1)$ query time. Prior to our result, single source single fault tolerant oracles were known to return a $(1+ε)$ approximation of the weight of the shortest path using $\tilde{O}(n)$ space and $O(1)$ query time. However, extending these approaches to multiple faults remained an open problem. Indeed, all $(1+ε)$-approximate distance oracles that handle multiple faults require $Ω(n<sup>2)$ space. We break this bound by presenting the first dual fault tolerant distance oracle with $o(n<sup>2)$ space.

• The paper presents a hierarchical path decomposition that allows subquadratic space usage for dual fault tolerance.
• It employs recursive data structures and randomized sampling to achieve a (1+O(ε))-approximation with near-constant query time.
• The work distinguishes the single-source setting from all-pairs, enhancing practical applications in large, sparse networks.

Approximate Single Source Dual Fault Tolerant Distance Oracle: A Technical Summary

Problem Overview

The paper investigates the fundamental algorithmic challenge of computing approximate fault-tolerant shortest-path distances from a single source in undirected, weighted graphs subject to up to two edge failures. The specific goal is to design a Single-Source Distance Oracle ($Sdo(2)$) that, for query inputs $(t, F)$ (a destination and a set $F$ with $|F| \le 2$ faulty edges), returns a $(1 + O(\epsilon))$-approximation to the weight of the shortest $s$-$t$ path avoiding $F$, with subquadratic space and near-constant query time.

Whereas previous constructions for fault-tolerant oracles with $f \geq 2$ faults (e.g., all-pairs oracles) have space complexity $\Omega(n^2)$, this work provides the first $(t, F)$0-space $(t, F)$1, inducing a notable separation between the single-source and all-pairs settings for dual faults.

Context and Related Work

Previous results for fault-tolerant distance oracles demonstrate a sharp jump in space requirements when moving from single-fault ($(t, F)$2) to $(t, F)$3.

• Single fault ($(t, F)$4): $(t, F)$5-approximate single-source oracles can be constructed with $(t, F)$6 space and constant query time [Baswana, Khanna 2013].
• Multiple faults: All previous $(t, F)$7-approximate or exact constructions for $(t, F)$8, $(t, F)$9, required $F$0 space (directly or indirectly via all-pairs results, e.g., [Chechik et al. 2017]), which is prohibitive for sparse graphs and large $F$1.

Recent works have achieved subquadratic space for higher stretch $F$2 [Bilò et al.] or for restricted queries, but none for the $F$3 regime in the single-source, dual-fault setting. Thus, designing subquadratic-space oracles for low-stretch, multi-fault, single-source queries has been an open question.

Main Contributions

Data Structure

The construction introduces a hierarchical $F$4 structure for each destination $F$5. At a high level:

• For each $F$6, a tree of bounded depth is created, encoding recursively decomposable candidate replacement paths for up to 2 edge-faults.
• Oracle nodes store primary paths in a 2-decomposable encoding: each such path is a concatenation of at most three shortest subpaths interleaved with at most two edges, reflecting the structure of shortest paths in the presence of two faults.
• To control space, long subpaths are stored implicitly using a novel randomized sampling approach (landmark-based), so that all path representations are of $F$7 size.
• For each segment (a subpath between consecutive “netpoints”, i.e., exponentially spaced points along a path), the structure precomputes and indexes both segment and detour children, capturing both "global" (segment-missing) and "local" (detour) rerouting scenarios, supporting efficient queries that may recursively follow these alternatives.

Query Algorithm

The query algorithm follows the recursive decomposition principle:

• At each recursion step, it determines how the desired $F$8–$F$9 replacement path interacts with the current path's segments with respect to the faults.
• Depending on whether a fault lies on a segment, and whether the replacement path intersects that segment above, below, or avoids it, queries either recurse on child nodes or reconstruct the remaining path using previously stored detour or segment information.
• Crucially, recursion only happens on a small set of affected vertices (at most those incident to faults and $|F| \le 2$0). Lemmas bound the recursion depth to a constant, yielding polylogarithmic overall query time.

Space and Query Complexity

The resulting oracle achieves:

• Space complexity: $|F| \le 2$1, a substantial gain over all previous $|F| \le 2$2-stretch oracles for dual faults.
• Query time: $|F| \le 2$3, matching the optimal $|F| \le 2$4 up to logarithmic factors, and additive in the number of faults (not the number of vertices).

Approximation Ratio

The oracle provides a $|F| \le 2$5-approximation for the single-source, dual-fault tolerant shortest-path query.

Technical Innovations

Several technical features distinguish the construction:

• Hierarchical path decomposition via netpoints/segments: The structure of possible replacement paths after up to two faults—characterized as $|F| \le 2$6-decomposable— is encoded efficiently by leveraging properties of netpoints and path segmentation, as in prior work [Chechik et al.].
• Recursive oracle tree design: Detour and segment child nodes capture the combinatorial structure of rerouting at faults, and enable recursive solution assembly with bounded overhead.
• Space efficiency via path decomposition and sampling: Rather than storing all possible subpaths explicitly (which would require $|F| \le 2$7 space for $|F| \le 2$8 nodes), the construction applies a random sampling/landmark approach: long subpaths are referenced via sampled vertices, whose shortest-path trees are used for implicit reconstruction.
• Query pruning and efficient path membership checking: The scheme supports constant-time membership queries for edges in stored (explicit or implicit) paths through pre-processed LCA structures, enabling fast traversal and online decisions during queries.

Theoretical and Practical Implications

The main impact is the demonstration that dual-fault tolerant, low-stretch, single-source distance oracles escape the generic $|F| \le 2$9 barrier, contrary to all-pairs settings. For large real-world networks where typical queries center on a single source (e.g., datacenter, transportation, or comms routing), this enables considerably more compact and practical oracles for fault-resilient path queries.

On a theoretical level, the work refines our understanding of the interplay between number of faults, source specificity, stretch, and oracle size, and shows that the single-source restriction admits algorithmic structure that is essentially unavailable in the all-pairs case.

The techniques suggest avenues for generalization—e.g., whether higher fault-tolerance ($(1 + O(\epsilon))$0) or more general query models permit similar subquadratic-space oracles, and how the combinatorial decomposition principles scale with $(1 + O(\epsilon))$1. Closing the approximation gap for triple or larger numbers of faults, while maintaining low space and query time, remains an open direction.

Conclusion

This work presents the first subquadratic-space, single-source, dual-fault tolerant, $(1 + O(\epsilon))$2-approximate distance oracle for undirected weighted graphs, with polylogarithmic query time. It introduces new structural decompositions and data representations to achieve space efficiency, and reveals that the single-source setting is strictly easier than all-pairs for dual faults under low-stretch requirements. Fundamental questions for triple and higher fault tolerance, and for further improving space-query tradeoffs, remain open and promising for future study.