[Paper Review] Parallel Approximate Undirected Shortest Paths Via Low Hop Emulators

Alexandr Andoni, Clifford Stein+1 more|arXiv (Cornell University)|Nov 5, 2019

Complexity and Algorithms in Graphs55 references4 citations

TL;DR

This paper presents a parallel $(1+\epsilon)$-approximate shortest path algorithm for undirected graphs with $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work, resolving a 25-year open problem. It introduces low hop emulators—graphs with $O(\log\log n)$ hop bounds that preserve $\operatorname{poly}(\log n)$-approximate distances—and uses compressible preconditioners within Sherman’s framework to achieve near-optimal work and depth.

ABSTRACT

We present a $(1+\varepsilon)$-approximate parallel algorithm for computing shortest paths in undirected graphs, achieving $\mathrm{poly}(\log n)$ depth and $m\mathrm{poly}(\log n)$ work for $n$-nodes $m$-edges graphs. Although sequential algorithms with (nearly) optimal running time have been known for several decades, near-optimal parallel algorithms have turned out to be a much tougher challenge. For $(1+\varepsilon)$-approximation, all prior algorithms with $\mathrm{poly}(\log n)$ depth perform at least $Ω(mn^{c})$ work for some constant $c>0$. Improving this long-standing upper bound obtained by Cohen (STOC'94) has been open for $25$ years. We develop several new tools of independent interest. One of them is a new notion beyond hopsets --- low hop emulator --- a $\mathrm{poly}(\log n)$-approximate emulator graph in which every shortest path has at most $O(\log\log n)$ hops (edges). Direct applications of the low hop emulators are parallel algorithms for $\mathrm{poly}(\log n)$-approximate single source shortest path (SSSP), Bourgain's embedding, metric tree embedding, and low diameter decomposition, all with $\mathrm{poly}(\log n)$ depth and $m\mathrm{poly}(\log n)$ work. To boost the approximation ratio to $(1+\varepsilon)$, we introduce compressible preconditioners and apply it inside Sherman's framework (SODA'17) to solve the more general problem of uncapacitated minimum cost flow (a.k.a., transshipment problem). Our algorithm computes a $(1+\varepsilon)$-approximate uncapacitated minimum cost flow in $\mathrm{poly}(\log n)$ depth using $m\mathrm{poly}(\log n)$ work. As a consequence, it also improves the state-of-the-art sequential running time from $m\cdot 2^{O(\sqrt{\log n})}$ to $m\mathrm{poly}(\log n)$.

Motivation & Objective

• Address the longstanding open problem of achieving $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work for parallel approximate shortest paths in undirected graphs.
• Overcome the $\Omega(mn^c)$ work barrier of prior $\operatorname{poly}(\log n)$-depth algorithms for $(1+\epsilon)$-approximation.
• Develop new algorithmic tools—specifically low hop emulators and compressible preconditioners—that enable efficient parallel computation.
• Improve the sequential running time for uncapacitated minimum cost flow from $m \cdot 2^{O(\sqrt{\log n})}$ to $m\operatorname{poly}(\log n)$.

Proposed method

• Introduce the concept of a low hop emulator: a $\operatorname{poly}(\log n)$-approximate emulator where every shortest path has at most $O(\log\log n)$ hops.
• Use low hop emulators to design parallel algorithms for $\operatorname{poly}(\log n)$-approximate SSSP, Bourgain’s embedding, metric tree embedding, and low-diameter decomposition with $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work.
• Apply Sherman’s framework for uncapacitated minimum cost flow (transshipment) by introducing compressible preconditioners to reduce the approximation error and enable efficient parallelization.
• Combine randomized path sampling and iterative flow computation with success probability amplification via $\Theta(\epsilon^{-1}\log n)$ repetitions to ensure high-probability correctness.
• Leverage induction and expectation analysis to bound the expected weight of the computed path, showing it is within $(1+\epsilon)$ of the true shortest path distance.
• Use a recursive contraction scheme on the graph, reducing the number of vertices by at least half in each iteration, to maintain low depth and work bounds.

Experimental results

Research questions

• RQ1 Can a parallel algorithm compute $(1+\epsilon)$-approximate shortest paths in $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work?
• RQ2 What structural properties of graphs enable efficient parallel approximate shortest path computation beyond hopsets?
• RQ3 Can compressible preconditioners be used to bridge the gap between approximate flow computation and shortest path approximation in parallel models?
• RQ4 Is it possible to construct low hop emulators that preserve $\operatorname{poly}(\log n)$-approximate distances with $\operatorname{poly}(\log n)$ work and depth?
• RQ5 What is the sequential time complexity of solving the uncapacitated minimum cost flow problem using the new framework?

Key findings

• The paper resolves the 25-year-old open question by presenting the first parallel $(1+\epsilon)$-approximate shortest path algorithm with $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work.
• Low hop emulators enable parallel computation of $\operatorname{poly}(\log n)$-approximate SSSP, Bourgain’s embedding, metric tree embedding, and low-diameter decomposition in $\operatorname{poly}(\log n)$ depth and $m\operatorname{poly}(\log n)$ work.
• The algorithm computes a $(1+\epsilon)$-approximate uncapacitated minimum cost flow in $\epsilon^{-2}\operatorname{poly}(\log(n\Lambda))$ parallel time using expected $\epsilon^{-3}m\operatorname{poly}(\log(n\Lambda))$ work with probability at least 0.99.
• The sequential running time for uncapacitated minimum cost flow is improved from $m \cdot 2^{O(\sqrt{\log n})}$ to $m\operatorname{poly}(\log n)$ using the new framework.
• The expected weight of the computed path satisfies $\mathbb{E}[w(p)] \leq (1+\epsilon) \cdot \operatorname{dist}_G(s,t)$ with high probability, achieved through $\Theta(\epsilon^{-1}\log n)$ repetitions of a base path-finding subroutine.
• The analysis shows that the expected path weight is bounded by $(1+2\epsilon)^{\lceil \log n \rceil} \cdot \operatorname{dist}_G(s,t)$, which is at most $(1+\epsilon) \cdot \operatorname{dist}_G(s,t)$ for sufficiently small $\epsilon$.