Parallel Metric Tree Embedding Based on an Algebraic View on Moore-Bellman-Ford Parallel Metric Tree Embedding Based on an Algebraic View on Moore-Bellman-Ford

We confine the discussion to undirected graphs.

Classical Distance Computations. The earliest—and possibly also most basic—algorithms for Single-Source Shortest Paths (SSSP) computations are Dijkstra's algorithm [21] and the MBF algorithm [11, 24, 40]. From the perspective of parallel algorithms, Dijkstra's algorithm performs excellently in terms of work, requiring $\operatorname{\tilde{O}}(m)$ computational steps, but suffers from being inherently sequential, processing one vertex at a time.

Algebraic Distance Computations. The MBF algorithm can be interpreted as a fixed-point iteration $Ax^{(i+1)} = Ax^{(i)}$, where $A$ is the adjacency matrix of the graph $G$ and “addition” and “multiplication” are replaced by $\min$ and $+$, respectively. This structure is known as the min-plus semiring (a.k.a. tropical semiring) (compare Section 1.2), which is a well-established tool for distance computations [3, 39, 43]. From this point of view, $\operatorname{SPD}(G)$ is the number of iterations until a fixed point is reached. MBF thus has depth $\operatorname{\tilde{O}}(\operatorname{SPD}(G))$ and work $\operatorname{\tilde{O}}(m\operatorname{SPD}(G))$, where small $\operatorname{SPD}(G)$ are possible.

One may overcome the issue of large depth entirely by performing the fixed-point iteration on the matrix by setting $A^{(0)} := A$ and iterating $A^{(i+1)} := A^{(i)} A^{(i)}$; after $\lceil \log \operatorname{SPD}(G) \rceil \le \lceil \log n \rceil$ iterations, a fixed point is reached [19]. The final matrix then has as entries exactly the pairwise node distances and the computation has polylogarithmic depth. This comes at the cost of $\operatorname{\Omega }(n^3)$ work (even if $m \ll n^2$) but is as work-efficient as $n$ instances of Dijkstra's algorithm for solving APSP in dense graphs without incurring depth $\operatorname{\Omega }(n)$.

Mohri [39] solved various shortest-distance problems using the $\mathcal {S}_{\min ,+}$ semiring and variants thereof. While Mohri's framework is quite general, our approach is different in crucial aspects:

1. Mohri uses an individual semiring for each problem and then solves it by a general algorithm. Our approach, on the other hand, is more generic as well as easier to use: We use off-the-shelf semirings—usually just $\mathcal {S}_{\min ,+}$—and combine them with appropriate semimodules carrying problem-specific information. Further problem-specific customization happens in the definition of a congruence relation on the semi-ring; it specifies which parts of a node's state can be discarded because they are irrelevant for the problem. We demonstrate the modularity and flexibility of the approach by various examples in Section 3, which cover a large variety of distance problems.
   
2. In our framework, node states are semimodule elements and edge weights are semiring elements; hence, there is no multiplication of node states. Mohri's approach, however, does not make this distinction and hence requires the introduction of an artificial “multiplication” of node states.
   
3. Mohri's algorithm can be interpreted as a generalization of Dijkstra's algorithm [21] because it maintains a queue and, in each iteration, applies a relaxation technique to the dequeued element and its neighbors. This strategy is inherently sequential; to the best of our knowledge, we are the first to present a general algebraic framework for distance computations that exploits the implicit parallelism of the MBF algorithm.
   
4. In Mohri's approach, choosing the global queueing strategy is not only an integral part of an algorithm, but it also simplifies the construction of the underlying semirings as one may rule that elements are processed in a “convenient” order. Our framework is flexible enough to achieve counterparts even of Mohri's more involved results without such assumptions; concretely, we propose a suitable semiring for solving the $k$-Shortest Distance Problem ($k$-SDP) and the $k$-Distinct-Shortest Distance Problem ($k$-DSDP) in Section 3.3.
   

Approximate Distance Computations. As metric embeddings reproduce distances only approximately, we may base them on approximate distance computation in the original graph. Using rounding techniques and embedding $\mathcal {S}_{\min ,+}$ into a polynomial ring, this enables us to use fast matrix multiplication to speed up the aforementioned fixed-point iteration $A^{(i+1)} := A^{(i)} A^{(i)}$ [43]. This reduces the work to $\operatorname{\tilde{O}}(n^{\omega })$ at the expense of only $(1 + \operatorname{o}(1))$-approximating distances, where $\omega \lt 2.3729$ [32] denotes the fast matrix-multiplication exponent. However, even if the conjecture that $\omega = 2$ holds true, this technique must result in $\operatorname{\Omega }(n^2)$ work simply because $\operatorname{\Omega }(n^2)$ pairwise distances are computed.

Regarding SSSP, there was no work-efficient low-depth parallel algorithm for a long time, even when allowing approximation. This was referred to as the “sequential bottleneck”: Matrix-matrix multiplication was inefficient in terms of work, while sequentially exploring (shortest) paths resulted in depth $\operatorname{\Omega }(\operatorname{SPD}(G))$. Klein and Subramanian [31] showed that depth $\operatorname{\tilde{O}}(\sqrt {n})$ can be achieved with $\operatorname{\tilde{O}}(m\sqrt {n})$ work, beating the $n^2$ work barrier with sublinear depth in sparse graphs. As an aside, similar bounds were later achieved for exact SSSP computations by Shi and Spencer [42].

In a seminal paper, Cohen [17] proved that SSSP can be $(1+\operatorname{o}(1))$-approximated with depth $\operatorname{polylog}n$ and near-optimal $\operatorname{\tilde{O}}(m^{1+\varepsilon })$ work for any constant choice of $\varepsilon \gt 0$; her approach is based on the aforementioned hop set construction. Similar guarantees can be achieved deterministically. Henziger et al. [29] focus on Congest algorithms, which can be interpreted in our framework to yield hop sets $(1 + 1 / \operatorname{polylog}n)$-approximating distances for $d \in 2^{\operatorname{O}(\sqrt {\log n})} \subset n^{\operatorname{o}(1)}$ and can be computed using depth $2^{\operatorname{O}(\sqrt {\log n}) }\subset n^{\operatorname{o}(1)}$ and work $m 2^{\operatorname{O}(\sqrt {\log n})}\subset m^{1+\operatorname{o}(1)}$. In a recent breakthrough, Elkin and Neiman obtained hop sets with substantially improved tradeoffs [22], both for the parallel setting and the Congest model. On the negative side, Abboud et al. [1] proved principal limitations of hop sets by providing lower bounds on the tradeoffs between the parameters.

Our embedding technique is formulated independently from the underlying hop set construction, whose performance is reflected in the depth and work bounds of our algorithms. While the improvements by Elkin and Neiman do not enable us to achieve a work bound of $m^{1+\operatorname{o}(1)}$ when sticking to our goals of depth $\operatorname{polylog}n$ and expected stretch $\operatorname{O}(\log n)$, they can be used to obtain better tradeoffs between the parameters.

Metric Tree Embeddings. When metrically embedding into a tree, it is, in general, impossible to guarantee a small stretch. For instance, when the graph is a cycle with unit edge weights, it is impossible to embed it into a tree without having at least one edge with stretch $\operatorname{\Omega }(n)$. However, on average, the edges in this example are stretched by a constant factor only, justifying the hope that one may be able to randomly embed into a tree such that, for each pair of nodes, the expected stretch is small. A number of elegant algorithms [4, 7, 8, 23] compute tree embeddings, culminating in the one by Fakcharoenphol, Rao, and Talwar [23] (FRT) that achieves stretch $\operatorname{O}(\log n)$ in expectation. This stretch bound is optimal in the worst case, as illustrated by expander graphs [8]. Mendel and Schwob show how to sample from the FRT distribution in $\operatorname{O}(m \log ^3 n)$ steps [37]. This upper bound has recently been improved: Blelloch et al. present an algorithm that requires time $\operatorname{O}(m \log n)$ w.h.p. Both algorithms match the trivial $\Omega (m)$ lower bound up to polylogarithmic factors. However, their approach relies on a pruned version of Dijkstra's algorithm for distance computations and hence does not lead to a low-depth parallel algorithm.

Several parallel and distributed algorithms compute FRT trees [14, 26, 30]. These algorithms and ours have in common that they represent the embedding by Least Element (LE) lists, which were first introduced in Cohen [16, 18]. In the parallel case, the state-of-the-art solution due to Blelloch et al. [14] achieves $\operatorname{O}(\log ^2 n)$ depth and $\operatorname{O}(n^2 \log n)$ work. However, Blelloch et al. assume the input to be given as an $n$-point metric, where the distance between two points can be queried at constant cost. Note that our approach is more general, as a metric can be interpreted as a complete weighted graph of SPD 1; a single MBF-like iteration reproduces the result by Blelloch et al. Moreover, this point of view shows that the input required to achieve subquadratic work must be a sparse graph. Furthermore, Blelloch et al. determine LE lists in $\operatorname{O}(D \log n)$ depth and $\operatorname{O}(W \log n)$ work, where $D$ and $W$ are the depth and work of an SSSP computation that is used as a black box [12]. However, to date only approximate SSSP algorithms simultaneously achieve $W\in \operatorname{\tilde{O}}(m)$ and $D\in \operatorname{polylog}n$; because calling an approximate SSSP algorithm multiple times does not result in approximate distances that respect the triangle inequality, this approach cannot be used to efficiently determine an FRT-style embedding. For graph inputs, we are not aware of any metric tree embedding algorithm achieving $\operatorname{polylog}n$ depth and a nontrivial work bound (i.e., not incurring the $\operatorname{\Omega }(n^3)$ work caused by relying on matrix-matrix multiplication).

In the distributed setting, Khan et al. [30] show how to compute LE lists in $\operatorname{O}(\operatorname{SPD}(G) \log n)$ rounds in the Congest model [41]. On the lower bound side, trivially $\operatorname{\Omega }(\operatorname{D}(G))$ rounds are required, where $\operatorname{D}(G)$ is the maximum hop distance (i.e., ignoring weights) between nodes. However, even if $\operatorname{D}(G) \in \operatorname{O}(\log n)$, $\operatorname{\tilde{\Omega }}(\sqrt {n}),$ rounds are necessary [20, 26]. Extending the algorithm by Khan et al. [26], it is shown how to obtain a round complexity of $\operatorname{\tilde{O}}(\min \lbrace n^{1/2+\varepsilon },\operatorname{SPD}(G)\rbrace + \operatorname{D}(G))$ for any $\varepsilon \gt 0$ at the expense of increasing the stretch to $\operatorname{O}(\varepsilon ^{-1}\log n)$. We partly build on these ideas; specifically, the construction in Section 4 can be seen as a generalization of the key technique from Khan et al. [26]. As detailed in Section 8, our framework subsumes these algorithms and can be used to improve on the result from Khan et al. [26]: Leveraging further results [29, 35], we obtain a metric tree embedding with expected stretch $\operatorname{O}(\log n)$ that is computed in $\min \lbrace n^{1/2+\operatorname{o}(1)} + \operatorname{D}(G)^{1+\operatorname{o}(1)}, \operatorname{\tilde{O}}(\operatorname{SPD}(G))\rbrace$ rounds.

We consider weighted, undirected graphs $G = (V, E, \operatorname{\omega })$ without loops or parallel edges with nodes $V$, edges $E$, and edge weights . Unless specified otherwise, we set $n := |V|$ and $m := |E|$. For an edge $e = \lbrace v,w\rbrace \in E$, we write $\operatorname{\omega }(v, w) := \operatorname{\omega }(e)$, $\operatorname{\omega }(v, v) := 0$ for $v \in V$, and $\operatorname{\omega }(v,w) := \infty$ for $\lbrace v,w\rbrace \notin E$. We assume that the ratio between maximum and minimum edge weight is polynomially bounded in $n$ and that each edge weight and constant can be stored with sufficient precision in a single register.⁵ We assume that $G$ is connected and given in the form of an adjacency list.

Let $p \subseteq E$ be a path. $p$ has $|p|$ hops and weight $\operatorname{\omega }(p) := \sum _{e \in p} \operatorname{\omega }(e)$. For the nodes $v, w \in V$ let $\operatorname{P}(v, w, G)$ denote the set of paths from $v$ to $w$ and $\operatorname{P}^h(v, w, G)$ the set of such paths using at most $h$ hops. We denote by $\operatorname{dist}^h(v, w, G) := \min \lbrace \operatorname{\omega }(p) \mid p \in \operatorname{P}^h(v, w, G) \rbrace$ the minimum weight of an $h$-hop path from $v$ to $w$, where $\min \emptyset := \infty$; the distance between $v$ and $w$ is $\operatorname{dist}(v,w,G):=\operatorname{dist}^n(v,w,G)$. The shortest path hop distance between $v$ and $w$ is $\operatorname{hop}(v, w, G) := \min \lbrace |p| \mid p\in \operatorname{P}(v, w, G) \wedge \operatorname{\omega }(p) = \operatorname{dist}(v, w, G) \rbrace$; $\operatorname{MHSP}(v, w, G) := \lbrace p \in \operatorname{P}^{\operatorname{hop}(v,w,G)}(v, w, G) \mid \operatorname{\omega }(p) = \operatorname{dist}(v, w, G) \rbrace$ denotes all min-hop shortest paths from $v$ to $w$. Finally, the Shortest Path Diameter (SPD) of $G$ is $\operatorname{SPD}(G) := \max \lbrace \operatorname{hop}(v, w, G) \mid v,w \in V \rbrace$, and is the unweighted hop diameter of $G$.

We sometimes use $\min$ and $\max$ as binary operators, assume , and define, for a set $N$ and , $\binom{N}{k} := \lbrace M \subseteq N \mid |M| = k \rbrace$ and denote by $\operatorname{id}:N \rightarrow N$ the identity function. Furthermore, we use weak asymptotic notation hiding polylogarithmic factors in $n$: $\operatorname{O}(f(n) \operatorname{polylog}(n)) = \operatorname{\tilde{O}}(f(n))$, etc.

Model of Computation. We use an abstract model of parallel computation similar to those used in circuit complexity; the goal here is to avoid distraction by details such as read or write collisions or load balancing issues typical to PRAM models, noting that these can be resolved with (at most) logarithmic overheads. The computation is represented by a Directed Acyclic Graph (DAG) with constantly bounded maximum indegree, where nodes represent words of memory that are given as input (indegree 0) or computed out of previously determined memory contents (non-zero indegree). Words are computed with a constant number of basic instructions (e.g., addition, multiplication, comparison, etc.); here, we also allow for the use of independent randomness. For simplicity, a memory word may hold any number computed throughout the algorithm. As pointed out earlier, $\operatorname{O}(\log n)$-bit words suffice for our purpose.

An algorithm defines, given the input, the DAG and how the nodes’ content is computed as well as which nodes represent the output. Given an instance of the problem, the work is the number of nodes of the corresponding DAG and the depth is its longest path. Assuming that there are no read or write conflicts, the work is thus (proportional to) the time required by a single processor (of uniform speed) to complete the computation, whereas the depth lower-bounds the time required by an infinite number of processors. Note that the DAG may be a random graph because the algorithm may use randomness, implying that work and depth may be random variables. When making probabilistic statements, we require that they hold for all instances (i.e., the respective probability bounds are satisfied after fixing an arbitrary instance).

Probability. A claim holds w.h.p. if it occurs with a probability of at least $1 - n^{-c}$ for any fixed choice of ; $c$ is a constant for the purposes of $\operatorname{O}$-notation. We use the following basic statement frequently and implicitly throughout this article:

Proof. We have $k \le an^b$ for fixed and choose that all $\mathcal {E}_i$ occur with a probability of at least $1 - n^{-c^{\prime }}$ with $c^{\prime } = c + b + \log _n a$ for some fixed $c \ge 1$. The union bound yields

(2)

hence $\mathcal {E}_1 \cap \dots \cap \mathcal {E}_k$ occurs w.h.p. as claimed.

Hop Sets. A graph $G = (V, E, \operatorname{\omega })$, contains a $(d, \hat{\varepsilon })$-hop set if

Distance Metrics. The min-plus semiring , also referred to as the tropical semiring, forms a semiring (i.e., a ring without additive inverses; see Definition A.2 in Appendix A). Unless explicitly stated otherwise, we associate $\oplus$ and $\odot$ with the addition and multiplication of the underlying ring throughout the article; in this case, we use $a \oplus b := \min \lbrace a,b\rbrace$ and $a \odot b := a+b$. Observe that $\infty$ and 0 are the neutral elements with respect to $\oplus$ and $\odot$, respectively. We sometimes write $x \in \mathcal {S}_{\min ,+}$ instead of to refer to the elements of a semiring. Furthermore, we follow the standard convention to occasionally leave out $\odot$ and give it priority over $\oplus$ (e.g., interpret $ab \oplus c$ as $(a \odot b) \oplus c$ for all $a,b,c \in \mathcal {S}_{\min ,+}$).

The min-plus semiring is a well-established tool to determine pairwise distances in a graph via the distance product (see, e.g., [3, 39, 43]). Let $G = (V, E, \operatorname{\omega })$ be a weighted graph and let $A \in \mathcal {S}_{\min ,+}^{V \times V}$ be its adjacency matrix $A$, given by

Let $M$ be the set of node states, i.e., the possible values that an MBF-like algorithm can store at a vertex. We represent propagation of $x \in M$ over an edge of weight by $s \odot x$, where , and aggregation of $x,y \in M$ at some node by $x \oplus y$, where $\oplus :M \times M \rightarrow M$; the discussion of filtering is deferred to Section 2.2. Concerning the aggregation of information, we demand that $\oplus$ is associative and has a neutral element $\bot \in M$ encoding “no available information,” hence $(M, \oplus)$ is a semigroup with neutral element $\bot$. Furthermore, we require for all and $x,y \in M$ (note that we “overload” $\oplus$ and $\odot$):

Altogether, this is equivalent to demanding that $\mathcal {M} = (M, \oplus , \odot)$ is a zero-preserving semimodule (see Definition A.3 in Appendix A) over $\mathcal {S}_{\min ,+}$. A straightforward choice of $\mathcal {M}$ is the direct product of $|V|$ copies of , which is suitable for most of the applications we consider.

Distance maps can be represented by only storing the non-$\infty$ distances (and their indices from $V$). This is of interest when there are few non-$\infty$ entries, which can be ensured by filtering (see below). In the following, we denote by $|x|$ the number of non-$\infty$ entries of $x \in \mathcal {D}$. The following lemma shows that this representation allows for efficient aggregation.

While $\mathcal {S}_{\min ,+}$ and $\mathcal {D}$ suffice for most applications and are suitable to convey our ideas, it is sometimes necessary to use a different semiring. We elaborate on this in Section 3. Hence, rather than confining the discussion to semimodules over $\mathcal {S}_{\min ,+}$, in the following we make general statements about an arbitrary semimodule $\mathcal {M} = (M, \oplus , \odot)$ over an arbitrary semiring $\mathcal {S} = (S, \oplus , \odot)$ wherever it does not obstruct the presentation. It is, however, helpful to keep $\mathcal {S} = \mathcal {S}_{\min ,+}$ and $\mathcal {M} = \mathcal {D}$ in mind.

MBF-like algorithms achieve efficiency by maintaining and propagating—instead of the full amount of information nodes are exposed to—only a filtered (small) representative of the information they obtained. Our goal in this section is to capture the properties that a filter must satisfy to not affect output correctness. We start with a congruence relation, an equivalence relation compatible with propagation and aggregation, on $\mathcal {M}$. A filter $r:\mathcal {M} \rightarrow \mathcal {M}$ is a projection mapping all members of an equivalence class to the same representative within that class; compare Definition 2.6.

A congruence relation induces a quotient semimodule.

An MBF-like algorithm performs efficient computations by implicitly operating on this quotient semimodule (i.e., on suitable, typically small, representatives of the equivalence classes). Such representatives are obtained in the filtering step using a representative projection, also referred to as a filter. We refer to this step as filtering since, in all our applications and examples, it discards a subset of the available information that is irrelevant to the problem at hand.

In the following, we typically first define a suitable projection $r$; this projection in turn defines equivalence classes $[x]:=\lbrace y \in \mathcal {M} \mid r(x)=r(y) \rbrace$. The following lemma is useful when we need to show that equivalence classes defined this way yield a congruence relation (i.e., are suitable for MBF-like algorithms).

An MBF-like algorithm has to behave in a compatible way for all vertices in that each vertex follows the same propagation, aggregation, and filtering rules. This induces a semimodule structure on the (possible) state vectors of the algorithm in a natural way.

The following definition connects the properties introduced and motivated earlier:

Note that the definition of the adjacency matrix $A \in \mathcal {S}^{V \times V}$ depends on the choice of the semiring $\mathcal {S}$. For the standard choice of $\mathcal {S} = \mathcal {S}_{\min ,+}$, which suffices for all our core results, we define $A$ in Equation (4); examples using different semirings and the associated adjacency matrices are discussed in Sections 3.2–3.4.

The $(i+1)$-th iteration of an MBF-like algorithm $\mathcal {A}$ determines $x^{(i+1)} := r^V A x^{(i)}$ (propagate, aggregate, and filter). Thus, $h$ iterations yield $(r^V A)^h x^{(0)}$, which we show to be identical to $r^V A^h x^{(0)}$ in Corollary 2.17 of Section 2.4.

As motivated earlier, MBF-like algorithms filter intermediate results; a representative projection $r^V$ determines a small representative of each node state. This maintains efficiency: Nodes propagate and aggregate only small representatives of the relevant information instead of the full amount of information they are exposed to. However, as motivated in, for example, Section 2.2, filtering is only relevant regarding efficiency, but not the correctness of MBF-like algorithms.

In this section, we formalize this concept in the following steps.

1. We introduce the functions needed to iterate MBF-like algorithms without filtering (i.e., multiplications with [adjacency] matrices). These Simple Linear Functions (SLFs) are a proper subset of the linear⁷ functions on $\mathcal {M}^V$.
   
2. The next step is to observe that SLFs are well-behaved with respect to the equivalence classes ${\mathcal {M}^V}/_{\sim }$ of node states.
   
3. Equivalence classes of SLFs mapping equivalent inputs to equivalent outputs yield the functions required for the study of MBF-like algorithms. These form a semiring of (a subset of) the functions on ${\mathcal {M}^V}/_{\sim }$.
   
4. Finally, we observe that $r^V \sim \operatorname{id}$, formalizing the concepts of “operating on equivalence classes of node states” and “filtering being optional with respect to correctness.”
   

An SLF $f$ is “simple” in the sense that it corresponds to matrix-vector multiplications; thatis, it maps $x \in \mathcal {M}^V$ such that $(f(x))_v$ is a linear combination of the coordinates $x_w$, $w \in V$, of $x$.

Thus, each iteration of an MBF-like algorithm is an application of an SLF given by an adjacency matrix followed by an application of the filter $r^V$. In the following, fix a semiring $\mathcal {S}$, a semimodule $\mathcal {M}$ over $\mathcal {S}$, and a congruence relation $\sim$ on $\mathcal {M}$. Furthermore, let $F$ denote the set of SLFs (i.e., matrices $A \in \mathcal {S}^{V \times V}$), each defining a function $A:\mathcal {M}^V \rightarrow \mathcal {M}^V$.

Let $A,B \in F$ be SLFs. Denote by $A(x) \mapsto Ax$ the application of the SLF $A$ to the argument $x \in \mathcal {M}^V$. Furthermore, we write $(A \oplus B)(x) \mapsto A(x) \oplus B(x)$ and $(A \circ B)(x) \mapsto A(B(x))$ for the addition and concatenation of SLFs, respectively. We proceed to Lemma 2.14, in which we show that matrix addition and multiplication are equivalent to the addition and concatenation of SLF functions, respectively. It follows that the SLFs form a semiring that is isomorphic to the matrix semiring of SLF matrices. Hence, we may use $A(x)$ and $Ax$ interchangeably in the following.

Proof. Let $A, B \in F$ and $x \in \mathcal {M}^V$ be arbitrary. Regarding Equations (26) and (27), observe that we have

\begin{equation} (A \oplus B)x = Ax \oplus Bx = A(x) \oplus B(x) = (A \oplus B)(x)\text{ and}\\ \end{equation} (28)

\begin{equation} ABx = A(Bx) = A(B(x)) = (A \circ B)(x), \end{equation} (29)

respectively; addition and concatenation of SLFs are equivalent to addition and multiplication of their respective matrices. It follows that $\mathcal {F}$ is isomorphic to the matrix semiring $(\mathcal {S}^{V \times V}, \oplus , \odot)$ and hence $\mathcal {F}$ is a semiring as claimed.

Recall that MBF-like algorithms project node states to appropriate equivalent node states. SLFs correspond to matrices and (adjacency) matrices correspond to MBF-like iterations. Hence, it is important that SLFs are well-behaved with respect to the equivalence classes ${\mathcal {M}^V}/_{\sim }$ of node states. Lemma 2.15 states that this is the case (i.e., that $Ax \sim Ax^{\prime }$ for all $x^{\prime } \in [x]$).

Proof. First, for , let $x_1, \dots , x_k, x^{\prime }_1, \dots , x^{\prime }_k \in \mathcal {M}$ be such that $x_i \sim x^{\prime }_i$ for all $1 \le i \le k$. We show that for all $s_1, \dots , s_k \in \mathcal {S}$ it holds that

\begin{equation} \bigoplus _{i=1}^k s_i x_i \sim \bigoplus _{i=1}^k s_i x^{\prime }_i. \end{equation} (31)

We argue that Equation ( 31) holds by induction over $k$. For $k = 1$, the claim trivially follows from Equation ( 14). Regarding $k \ge 2$, suppose the claim holds for $k - 1$. Since $x_k \sim x_k^{\prime }$, we have that $s_k x_k \sim s_k x_k^{\prime }$ by ( 2.8). The induction hypothesis yields $\bigoplus _{i=1}^{k-1} s_i x_i \sim \bigoplus _{i=1}^{k-1} s_i x_i^{\prime }$. Hence,

\begin{equation} \bigoplus _{i=1}^k s_i x_k = \left(\bigoplus _{i=1}^{k-1} s_i x_i \right) \oplus s_k x_k \stackrel{(2.9)}{\sim } \left(\bigoplus _{i=1}^{k-1} s_i x^{\prime }_i \right) \oplus s_k x^{\prime }_k = \bigoplus _{i=1}^k s_i x^{\prime }_k. \end{equation} (32)

As for the original claim, let $v \in V$ be arbitrary and note that we have

\begin{equation} (Ax)_v = \bigoplus _{w \in V} a_{vw} x_v \stackrel{(2.25)}{\sim } \bigoplus _{w \in V} a_{vw} x^{\prime }_v = (Ax^{\prime })_v. \end{equation} (33)

Due to Lemma 2.15, each SLF $A \in F$ not only defines a function $A:\mathcal {M}^V \rightarrow \mathcal {M}^V$, but also a function $A:{\mathcal {M}^V}/_{\sim } \rightarrow {\mathcal {M}^V}/_{\sim }$ with $A[x] := [Ax]$ ($A[x]$ does not depend on the choice of the representant $x^{\prime } \in [x]$). This is important since MBF-like algorithms implicitly operate on ${\mathcal {M}^V}/_{\sim }$ and because they do so using adjacency matrices, which are SLFs. As a natural next step, we rule for SLFs $A,B \in F$ that

Proof. As argued earlier, for any $A\in F$, $[A]\in {F}/_{\sim }$ is well-defined on ${\mathcal {M}^V}/_{\sim }$ by Lemma 2.15. Equations (35) and (36) follow from Equations (26) and (27), respectively:

\begin{equation} {}[A \oplus B][x] = [(A \oplus B)x] \stackrel{(2.20)}{=} [(A \oplus B)(x)] = ([A] \oplus [B])([x]) \\ \end{equation} (37)

\begin{equation} {}[AB][x] = [ABx] \stackrel{(2.21)}{=} [(A \circ B)(x)] = [A \circ B]([x]). \end{equation} (38)

To see that $[A]$ is linear, let $s \in \mathcal {S}$ and $x,y \in \mathcal {M}^V$ be arbitrary and compute

\begin{eqnarray} [A][x] \oplus [A][y] = [Ax] \oplus [Ay] = [Ax \oplus Ay] = [A(x \oplus y)] = [A][x \oplus y]\nonumber\\ = [A]([x] \oplus [y])\text{ and} \end{eqnarray} (39)

\begin{equation} [A](s[x]) = [A(sx)] = [s(Ax)] = s[Ax] = s[A][x]. \end{equation} (40)

This implies that ${\mathcal {F}}/_{\sim }$ is a semiring of linear functions. As each function $[A]$ is represented by multiplication with (any) SLF $A^{\prime }\in [A]$, $[A]$ is an SLF.

The following corollary is a key property used throughout this article. It allows us to apply filter steps whenever convenient. We later use this to simulate MBF-like iterations on an implicitly represented graph whose edges correspond to entire paths in the original graph. This is efficient only because we have the luxury of applying intermediate filtering repeatedly without affecting the output.

Finally, we stress that both the restriction to SLFs and the componentwise application of $r$ in $r^V$ are crucial for Corollary 2.17.

We demonstrate that the min-plus semiring $\mathcal {S}_{\min ,+}$ (a.k.a. the tropical semiring) is the semiring of choice to capture many standard distance problems. Note that we also use $\mathcal {S}_{\min ,+}$ in our core result (i.e., for sampling FRT trees). For the sake of completeness, first recall the adjacency matrix $A$ of the weighted graph $G$ in the semiring $\mathcal {S}_{\min ,+}$ from Equation (4) and the distance-map semimodule $\mathcal {D}$ from Definition 2.1; consider the initialization $x^{(0)} \in \mathcal {D}^V$ with

It is well-known that the min-plus semiring can be used for distance computations [3, 39, 43]. Nevertheless, for the sake of completeness, we prove Lemma 3.1 in terms of our notation in Appendix B.

As a first example, we turn our attention to source detection. It generalizes all examples covered in this section, saving us from proving each one of them correct; well-established examples like SSSP and APSP follow. Source detection was introduced by Lenzen and Peleg [36]. Note, however, that we include a maximum considered distance $d$ in the definition.

Since it may not be obvious that $r$ is a representative projection, we prove it in Appendix B.

Equivalently, one may use $(\lbrace s\rbrace , h, \infty , 1)$-source detection, effectively resulting in $\mathcal {M} = \mathcal {S}_{\min ,+}$. When only storing the non-$\infty$ entries, only the $s$-entry is relevant; however, the vertex ID of $s$ is stored as well—and $r = \operatorname{id}$, too.

Example 3.7 can be handled differently by using $(S,n,d,1)$-source detection, where $S$ are the nodes on fire. This also reveals the closest node on fire, whereas the solution from Example 3.7 works in anonymous networks. One can interpret both solutions as instances of SSSP with a virtual source $s \notin V$ that is connected to all nodes on fire by an edge of weight 0. This, however, requires a simulation argument and additional reasoning if the closest node on fire is to be determined.

Some problems require using a semiring other than $\mathcal {S}_{\min ,+}$. As an example, consider the Widest Path Problem (WPP), also referred to as the bottleneck shortest path problem: Given two nodes $v$ and $w$ in a weighted graph, find a $v$-$w$-path maximizing the lightest edge in the path. More formally, we are interested in the widest-path distance between $v$ and $w$:

An application of the WPP are trust networks: The nodes of a graph are entities, and an edge $\lbrace v,w\rbrace$ of weight $0 \lt \operatorname{\omega }(v,w) \le 1$ encodes that $v$ and $w$ trust each other with $\operatorname{\omega }(v,w)$. Assuming trust to be transitive, $v$ trusts $w$ with $\max _{p \in \operatorname{P}(v,w,G)} \min _{e \in p} \operatorname{\omega }(e) = \operatorname{width}(v,w,G)$. The WPP requires a semiring supporting the $\max$ and $\min$ operations:

Proof in Appendix B.

As adjacency matrix of $G = (V, E, \operatorname{\omega })$ with respect to $\mathcal {S}_{\max ,\min }$, we propose $A \in \mathcal {S}_{\max ,\min }^{V \times V}$ with

Proof in Appendix B.

Mohri discusses $k$-SDP, where each $v \in V$ is required to find the $k$ shortest paths to a designated source node $s \in V$, in the light of his algebraic framework for distance computations [39]. Our framework captures this application as well but requires a different semiring than $\mathcal {S}_{\min ,+}$: While $\mathcal {S}_{\min ,+}$ suffices for many applications (see Section 3.1), it cannot distinguish between different paths of the same length. This is a problem in the $k$-SDP because there may be multiple paths of the same length among the $k$ shortest.

This does not mean that the framework of MBF-like algorithms cannot be applied, but rather it indicates that the toolbox needs a more powerful semiring than $\mathcal {S}_{\min ,+}$. The motivation of this section is to add such a semiring, the all-paths semiring $\mathcal {P}_{\min ,+}$, to the toolbox. Having established $\mathcal {P}_{\min ,+}$, the advantages of the previously established machinery are available: pick a semimodule (or use $\mathcal {P}_{\min ,+}$ itself) and define a representative projection. We demonstrate this for $k$-SDP and a variant.

The basic concept of $\mathcal {P}_{\min ,+}$ is simple: remember paths instead of adding up “anonymous” distances. Instead of storing the sum of the traversed edges’ weight, store the string of edges. We also add the ability to remember multiple paths into the semiring. This includes enough features in $\mathcal {P}_{\min ,+}$; we do not require dedicated semimodules for $k$-SDP, and we use the fact that $\mathcal {P}_{\min ,+}$ is a zero-preserving semimodule over itself.

We begin the technical part with a convenient representation of paths: Let $P \subset V^+$ denote the set of non-empty, loop-free, directed paths on $V$, denoted as tuples of nodes. Furthermore, let $\circ \subseteq P^2$ be the relation of concatenable paths defined by

As motivated earlier, the all-paths semiring can store multiple paths. We represent this using vectors in storing a non-$\infty$ weight for every encountered path and $\infty$ for all paths not encountered so far. This can be efficiently represented by implicitly leaving out all $\infty$ entries.

Summation picks the smallest weight associated with each path in either operand; multiplication $(x \odot y)_\pi$ finds the lightest estimate for $\pi$ composed of two-splits $\pi = \pi ^1 \circ \pi ^2$, where $\pi ^1$ is picked from $x$ and $\pi ^2$ from $y$. Observe that $\mathcal {P}_{\min ,+}$ supports upper bounds on path lengths; we do not, however, use this feature. Intuitively, $\mathcal {P}_{\min ,+}$ stores all encountered paths with their exact weights; in this mindset, summation corresponds to the union and multiplication to the concatenability-obeying Cartesian product of the paths contained in $x$ and $y$.

Proof in Appendix B.

Computations on a graph $G = (V, E, \operatorname{\omega })$ with respect to $\mathcal {P}_{\min ,+}$ require (this is a generalization of Equation (4)) an adjacency matrix $A \in \mathcal {P}_{\min ,+}^{V \times V}$ defined by

Proof in Appendix B.

With the all-paths semiring $\mathcal {P}_{\min ,+}$ established, we turn to the $k$-SDP, our initial motivation for adding $\mathcal {P}_{\min ,+}$ to the toolbox of MBF-like algorithms in the first place.

Observe that with the preceding definitions of $A$ and $x^{(h)}$, we always associate a path $\pi$ with either its weight $\operatorname{\omega }(\pi)$ or with $\infty$; in particular, invalid paths always are associated with $\infty$. Formally, $G$ induces a subsemiring of $\mathcal {P}_{\min ,+}$. In addition to being an interesting observation, these properties are required for the representative projections defined later $(r$ breaks for the $k$-DSDP when facing inconsistent non-$\infty$ values for the same path) so we formalize them. Let $G = (V, E, \operatorname{\omega })$ be a graph and let be the restriction of to exact path weights and $\infty$:

The next step is to show that $\mathcal {P}_{\min ,+}(G)$ is a semiring.⁸

Proof in Appendix B.

Observe that we have $A \in \mathcal {P}^{V \times V}_{\min ,+}(G)$ as well as $x^{(0)} \in \mathcal {P}^V_{\min ,+}(G)$. It follows that Lemma 3.20 holds for $\mathcal {P}_{\min ,+}(G)$ as much as it does for $\mathcal {P}_{\min ,+}$. Furthermore, observe that the restriction to $\mathcal {P}_{\min ,+}(G)$ happens implicitly, simply by starting with the preceding initialization. There is no information about $\mathcal {P}_{\min ,+}(G)$ that needs to be distributed in the graph in order to run an MBF-like algorithm over $\mathcal {P}_{\min ,+}(G)$.

In order to solve the $k$-SDP, we require a representative projection that reduces the abundance of paths stored in an unfiltered $x^{(h)}$ to the relevant ones. Relevant in this case simply means to keep the $k$ shortest $v$-$s$-paths in $x^{(h)}_v$. In order to formalize this, let $P(v,w,x)$ denote, for $x \in \mathcal {P}_{\min ,+}(G)$ and $v,w \in V$, the set of all $v$-$w$-paths contained in $x$:

Proof in Appendix B.

Observe that $r$ is defined to maintain the $k$ shortest $v$-$s$-paths for all $v \in V$, potentially storing $k|V|$ paths instead of just $k$. Intuitively, one could argue that $r^V x^{(h)}_v$ only needs to contain $k$ paths since they all start in $v$, which is what the algorithm should actually be doing. This objection is correct in that this is what actually happens when running the algorithm with initialization $x^{(0)}$: By Lemma 3.20, $x^{(h)}_v$ contains the $h$-hop shortest paths starting in $v$ and $r$ removes all that do not end in $s$ or are too long. On the other hand, the objection is flawed. In order for $r$ to behave correctly with respect to all $x \in \mathcal {P}_{\min ,+}$, especially those less nicely structured than $x^{(h)}_v$ where all paths start at $v,$ we must define $r$ as it is; otherwise, the proof of Lemma 3.25 fails for mixed starting-node inputs.

By Lemma 3.20 and due to $h = \operatorname{SPD}(G)$, $x^{(h)}_v$ contains all paths that start in $v$, associated with their weights. Since $\mathcal {A}^h(G) = r^V x^{(h)}$, by definition of $r$ in Equation (69), $(r^V x^{(h)})_v = r(x^{(h)}_v)$ contains the subset of those paths that have the $k$ smallest weights and start in $v$ (i.e., precisely what $k$-SDP asks for).

We remark that solving a generalization of $k$-SDP looking for the $k$ shortest $h$-hop distances is straightforward using $h$ iterations. Furthermore, note that our approach reveals the actual paths along with their weights.

In order for this to work, the definition of $P_k(v,w,x)$ in Equation (68) needs to be adjusted. For each of the $k$ smallest weights in $x$, the modified $\bar{P}_k(v, w, x)$ contains only one representative: the path contained in $x$ of that weight that is first with respect to lexicographical order on $P$. This results in

A well-known semiring is the Boolean semiring $\mathcal {B} = (\lbrace 0,1\rbrace , \vee , \wedge)$. By Lemma A.4, $\mathcal {B}^V$ is a zero-preserving semimodule over $\mathcal {B}$. It can be used to check for connectivity in a graph⁹ using the adjacency matrix

The idea is to simulate each iteration of an MBF-like algorithm $\mathcal {A}$ on $H$ using $d$ iterations on $G$. This is done for each level $\lambda \in \lbrace 0, \dots , \Lambda \rbrace$ in parallel. For level $\lambda$, we run $\mathcal {A}$ for $d$ iterations on $G$ with edge weights scaled up by $(1 + \hat{\varepsilon })^{\Lambda - \lambda }$, where the initial vector is obtained by discarding all information at nodes of level smaller than $\lambda$. Afterward, we again discard everything stored at vertices with a level smaller than $\lambda$. Since $(A_G^d)_{vw} = \operatorname{dist}^d(v,w,G)$, this ensures that we propagate information between nodes $v,w \in V$ with $\operatorname{\lambda }(v,w) = \lambda$ with the corresponding edge weight while discarding any exchange between nodes with $\operatorname{\lambda }(v,w) \lt \lambda$ (which is handled by the respective parallel run). While we also propagate information between $v$ and $w$ if $\operatorname{\lambda }(v,w) \gt \lambda$ (over too long a distance because edge weights are scaled by $(1 + \hat{\varepsilon })^{\Lambda - \lambda } \gt (1 + \hat{\varepsilon })^{\Lambda - \operatorname{\lambda }(v,w)}$) the parallel run for $\operatorname{\lambda }(v,w)$ correctly propagates values. Therefore, aggregating the results of all levels (i.e., applying $\oplus$, the source-wise minimum) and applying $r^V$ completes the simulation of an iteration of $\mathcal {A}$ on $H$.

This approach resolves two complexity issues. First, we multiply (polylogarithmically often) with $A_G$, which, as opposed to the dense $A_H,$ has $\operatorname{O}(m)$ non-$\infty$ entries only. Second, Corollary 2.17 shows that we are free to filter using $r^V$ at any time, keeping the entries of intermediate state vectors small.

We formalize the preceding intuition. Recall that

Proof. Since $(A^d_G)_{vw} = \operatorname{dist}^d(v, w, G)$, it holds that $(A_\lambda ^d)_{vw} = (1 + \hat{\varepsilon })^{\Lambda - \lambda } \operatorname{dist}^d(v, w, G)$. Therefore,

\begin{equation} (A_\lambda ^d P_\lambda)_{vw} = \min _{u \in V} \left\lbrace (A_\lambda ^d)_{vu} + (P_\lambda)_{uw}\right\rbrace = { \left\lbrace \begin{array}{@{}l@{\quad }l@{}}(1 + \hat{\varepsilon })^{\Lambda - \lambda } \operatorname{dist}^d(v, w, G) & \text{if $w \in V_\lambda $ and} \\ \infty & \text{otherwise,} \end{array}\right. } \end{equation} (95)

and hence

\begin{equation} (P_\lambda A_\lambda ^d P_\lambda)_{vw} = \min _{u \in V} \left\lbrace (P_\lambda)_{vu} + (A_\lambda ^d P_\lambda)_{uw} \right\rbrace = { \left\lbrace \begin{array}{@{}l@{\quad }l@{}}(1 + \hat{\varepsilon })^{\Lambda - \lambda } \operatorname{dist}^d(v, w, G) & \text{if $v, w \in V_\lambda $ and} \\ \infty & \text{otherwise.} \end{array}\right. } \end{equation} (96)

We conclude that

\begin{equation} \ \left(\bigoplus _{\lambda = 0}^\Lambda P_\lambda A_\lambda ^d P_\lambda \right)_{vw} = \min \left\lbrace (1 + \hat{\varepsilon })^{\Lambda - \lambda } \operatorname{dist}^d(v, w, G)\,\big |\,\lambda \in \lbrace 0,\ldots ,\lambda (v,w)\rbrace \right\rbrace \\ \end{equation} (97)

\begin{equation} = (1 + \hat{\varepsilon })^{\Lambda - \operatorname{\lambda }(v,w)} \operatorname{dist}^d(v, w, G) \\ \end{equation} (98)

Having decomposed $A_H$, we continue with $\mathcal {A}^h(H)$, taking the freedom to apply filters intermediately. For all , we have

The oracle determines iterations of $\mathcal {A}$ on $H$ using iterations on $G$ while only introducing a polylogarithmic overhead with respect to iterations in $G$. With the decomposition from Lemma 5.1 at hand, it can be implemented as follows.

Given a state vector $x^{(i)} \in \mathcal {M}^V$, simulate one iteration of $\mathcal {A}$ on $H$ for edges of level $\lambda$; that is, determine $y_\lambda := P_\lambda (r^V A_\lambda)^d P_\lambda x^{(i)}$ by

1. discarding entries at nodes of a level smaller than $\lambda$,
   
2. running $d$ iterations of $\mathcal {A}$ with distances stretched by $(1 + \hat{\varepsilon })^{\Lambda - \lambda }$ on $G$, applying the filter after each iteration, and
   
3. again discarding entries at nodes with levels smaller than $\lambda$.
   

After running this procedure in parallel for all $0 \le \lambda \le \Lambda$, perform the $\oplus$-operation and apply the filter; that is, for each node $v \in V$ determine $x^{(i+1)}_v = r(\bigoplus _{\lambda = 0}^\Lambda y_\lambda)_v$.

We use this section to introduce the (distribution over) metric tree embeddings of Fakcharoenphol, Rao, and Talwar, referred to as FRT embedding, which has expected stretch $\operatorname{O}(\log n)$ [23].

Definition 7.1 (Metric Embedding). Let $G = (V, E, \operatorname{\omega })$ be a graph. A metric embedding of stretch $\alpha$ of $G$ is a graph $G^{\prime } = (V^{\prime }, E^{\prime }, \operatorname{\omega }^{\prime })$, such that $V \subseteq V^{\prime }$ and

\begin{equation} \forall v,w \in V:\quad \operatorname{dist}(v, w, G) \le \operatorname{dist}(v, w, G^{\prime }) \le \alpha \operatorname{dist}(v, w, G), \end{equation} (104)

for some . If $G^{\prime }$ is a tree, we refer to it as metric tree embedding. For a random distribution of metric embeddings $G^{\prime }$, we require $\operatorname{dist}(v,w,G) \le \operatorname{dist}(v,w,G^{\prime })$ and define the expected stretch as

(105)

We show how to efficiently sample from the FRT distribution for the graph $H$ introduced in Section 4. As $H$ is an embedding of $G$ with a stretch in $1 + \operatorname{o}(1)$, this results in a tree embedding of $G$ of stretch $\operatorname{O}(\log n)$. Khan et al. [30] show that a suitable representation of (a tree sampled from the distribution of) the FRT embedding [23] can be constructed as follows.

1. Choose $\beta \in [1,2)$ uniformly at random.
   
2. Choose uniformly at random a total order of the nodes (i.e., a uniformly random permutation). In the following, $v \lt w$ means that $v$ is smaller than $w$ with respect to to this order.
   
3. Determine for each node $v \in V$ its LE list: This is the list obtained by deleting from $\lbrace (\operatorname{dist}(v,w,H), w) \mid w \in V \rbrace$ all pairs $(\operatorname{dist}(v,w,H), w)$ for which there is some $u \in V$ with $\operatorname{dist}(v,u,H) \le \operatorname{dist}(v,w,H)$ and $u \lt w$. Essentially, $v$ learns, for every distance $d$, the smallest node within distance at most $d$, i.e., $\min \lbrace w \in V \mid \operatorname{dist}(v,w,G) \le d \rbrace$.
   
4. Denote by $\operatorname{\omega }_{\min } := \min _{e \in E}\lbrace \operatorname{\omega }(e)\rbrace$ and $\operatorname{\omega }_{\max } := \max _{e \in E}\lbrace \operatorname{\omega }(e)\rbrace$ the minimum and maximum edge weight, respectively; recall that $\operatorname{\omega }_{\max }/\operatorname{\omega }_{\min } \in \operatorname{poly}n$ by assumption. From the LE lists, determine for each $v \in V$ and distance $\beta 2^i \in [\operatorname{\omega }_{\min }/2, 2\operatorname{\omega }_{\max }]$, , the node $v_i := \min \lbrace w \in V \mid \operatorname{dist}(v,w,H) \le \beta 2^i\rbrace$. Without loss of generality, we assume that $i \in \lbrace 0, \dots , k\rbrace$ for $k \in \operatorname{O}(\log n)$ (otherwise, we shift the indices of the nodes $v_i$ accordingly). Hence, for each $v \in V$, we obtain a sequence of nodes $(v_0, v_1,\dots , v_k)$. $(v_0, v_1, \dots , v_k)$ is the leaf corresponding to $v = v_0$ of the tree embedding, $(v_1, \dots , v_k)$ is its parent, and so on; the root is $(v_k)$. The edge from $(v_i, \dots , v_k)$ to $(v_{i+1}, \dots , v_k)$ has weight $\beta 2^i$.
   

We refer to Ghaffari and Lenzen [26] for a more detailed summary.

The preceding procedure implicitly specifies a random distribution over tree embeddings with expected stretch $\operatorname{O}(\log n)$ [23], which we call the FRT distribution. We refer to following the procedure 1–4 as sampling from the FRT distribution. Once the randomness is fixed (i.e., steps 1–2 are completed), the tree resulting from steps 3–4 is unique; we refer to them as constructing an FRT tree.

The next lemma shows that step 4 (i.e., constructing the FRT tree from the LE lists) is easy.

Picking $\beta$ is trivial and choosing a random order of the nodes can be done w.h.p. by assigning to each node a string of $\operatorname{O}(\log n)$ uniformly and independently chosen random bits. Hence, in the following, we assume this step to be completed, without loss of generality, resulting in a random assignment of the vertex IDs $\lbrace 1, \dots , n\rbrace$. It remains to establish how to efficiently compute LE lists.

We establish that LE lists can be computed by an MBF-like algorithm (compare Definition 2.11) using the parameters in Definition 7.3; the claim that Equations (106) and (107) define a representative projection and a congruence relation is shown in Lemma 7.5.

Hence, $r(x)$ is the LE list of $v \in V$ if $x_w = \operatorname{dist}(v,w,H)$ for all $w \in V,$ and we consider two lists equivalent if and only if they result in the same LE list. This allows us to prepare the proof that retrieving LE lists can be done by an MBF-like algorithm in the following lemma. It states that filtering keeps the relevant information: If a node–distance pair is dominated by an entry in a distance map, the filtered distance map also contains a—possibly different—dominating entry.

Equipped with this lemma, we can prove that $\sim$ is a congruence relation on $\mathcal {D}$ with representative projection $r$. We say that a node–distance pair $(v, d)$ dominates $(v^{\prime }, d^{\prime })$ if and only if $v \lt v^{\prime }$ and $d \le d^{\prime }$; in the context of $x \in \mathcal {D}$, we say that $x_w$ dominates $x_v$ if and only if $(w, x_w)$ dominates $(v, x_v)$.

Having established that determining LE lists can be done by an MBF-like algorithm allows us to apply the machinery developed in Sections 2–5. Next, we establish that LE list computations can be performed efficiently, which we show by bounding the length of LE lists.

Our course of action is to show that LE list computations are efficient using Theorem 5.2 (i.e., the oracle theorem). The purpose of this section is to prepare the lemmas required to apply Theorem 5.2. We stress that the key challenge is to perform each iteration in polylogarithmic depth; this allows us to determine $\mathcal {A}(H)$ in polylogarithmic depth due to $\operatorname{SPD}(H) \in \operatorname{O}(\log ^2 n)$. To this end, we first establish the length of intermediate LE lists to be logarithmic w.h.p. (Lemma 7.6). This permits us to apply $r^V$ and determine the matrix-vector multiplication with $A_{\lambda }$ (the scaled version of $A_G$, the adjacency matrix of $G$ from Section 5) in a sufficiently efficient manner (Lemmas 7.7 and 7.8). Section 7.4 plugs these results into Theorem 5.2 to establish our main result.

We remark that LE lists are known to have length $\operatorname{O}(\log n)$ w.h.p. throughout intermediate computations [26, 30], assuming that LE lists are assembled using $h$-hop distances. Lemma 7.6, while using the same key argument, is more general since it makes no assumption about $x$ except for its independence of the random node order; we need the more general statement due to our decomposition of $A_H$.

Recall that by $|x|$ we denote the number of non-$\infty$ entries of $x \in \mathcal {D}$ and that we only need to keep the non-$\infty$ entries in memory. Lemma 7.6 shows that any LE list $r(x) \in \mathcal {D}$ has length $|r(x)| \in \operatorname{O}(\log n)$ w.h.p., provided that $x$ does not depend on the random node ordering. Observe that, in fact, the lemma is quite powerful as it suffices that there is any $y \in [x]$ that does not depend on the random node ordering: as $r(x)=r(y)$, then $|r(x)|=|r(y)|\in \operatorname{O}(\log n)$ w.h.p.

Proof. Order the non-$\infty$ values of $x$ by ascending distance, breaking ties independently of the random node order. Denote for $i \in \lbrace 1, \dots , |x| \rbrace$ by $v_i \in V$ the $i$th node with respect to this order (i.e., $x_{v_i}$ is the $i$th smallest entry in $x)$. Furthermore, denote by $X_i$ the indicator variable which is 1 if $v_i \lt v_j$ for all $j \in \lbrace 1, \dots , i-1 \rbrace$ and 0 otherwise. As the node order and $x$ are independent, we obtain . For $X := \sum _{i=1}^{|x|} X_i$, this implies

(116)

Observe that $X_i$ is independent of $\lbrace X_1, \dots , X_{i-1} \rbrace$, as whether $v_i \lt v_j$ for all $j \lt i$ is independent of the internal order of the set $\lbrace v_1, \dots , v_{i-1} \rbrace$. We conclude that all $\lbrace X_1, \dots , X_{|x|} \rbrace$ are independent; this can be checked by inductively verifying that for any possible assignment $(b_1, \dots , b_k) \in \lbrace 0,1\rbrace ^k$. Applying Chernoff's bound yields $X \in \Theta (\log n)$ w.h.p. As , this concludes the proof.

Hence, filtered, possibly intermediate LE lists $r(x)$ w.h.p. comprise $\operatorname{O}(\log n)$ entries. We proceed to show that, under these circumstances, $r(x)$ can be computed efficiently.

Any intermediate result used by the oracle is of the form $r^V A_\lambda y$ with

Determining LE lists on $H$ yields a probabilistic tree embedding of $G$ with expected stretch $\operatorname{O}(\log n)$ (Section 7.1), is the result of an MBF-like algorithm (Section 7.2), and each iteration of this algorithm is efficient (Theorem 5.2 and Section 7.3). We assemble these pieces in Theorem 7.9, which relies on $G$ containing a suitable hop set. Corollaries 7.10 and 7.11 remove this assumption by invoking known algorithms to establish this property first. Note that Theorem 7.9 serves as a blueprint yielding improved tree embedding algorithms when provided with improved hop set constructions.

Proof. We first w.h.p. compute the LE lists of $H$. To this end, by Lemma 7.8, we may apply Theorem 5.2 with parameters $D \in \operatorname{O}(\log ^2 n)$, $W \in \operatorname{O}(m \log ^2 n)$, $D_\oplus \in \operatorname{O}(\log ^2 n)$, and $W_\oplus \in \operatorname{O}(n \log ^4 n)$; we arrive at depth $\operatorname{O}(d \log ^4 n)$ and work $\operatorname{O}(m(d + \log n) \log ^5 n)$. As shown in Fakcharoenphol et al. [23], the FRT tree $T$ represented by these lists has expected stretch $\operatorname{O}(\log n)$ with respect to the distance metric of $H$. By Theorem 4.5, w.h.p. $\operatorname{dist}(v,w,G) \le \operatorname{dist}(v,w,H) \le \alpha ^{\operatorname{O}(\log n)} \operatorname{dist}(v,w,G)$ and hence

\begin{equation} \operatorname{dist}(v,w,G) \le \operatorname{dist}(v,w,T) \in \operatorname{O}\left(\alpha ^{\operatorname{O}(\log n)} \log n \operatorname{dist}(v,w,G) \right) \end{equation} (125)

in expectation (compare Definition 7.1). Observe that, by Lemma 7.2, explicitly constructing the FRT tree is possible within the stated bounds.

As stated earlier, we require $G$ to contain a $(d, 1 / \operatorname{polylog}n)$-hop set with $d \in \operatorname{polylog}n$ in order to achieve polylogarithmic depth. We also need to determine such a hop set using $\operatorname{polylog}n$ depth and near-linear work in $m$ and that it does not significantly increase the problem size by adding too many edges. Cohen's hop sets [17] meet all these requirements, yielding the following corollary.

Adding a hop set to $G$, embedding the resulting graph in $H$, and sampling an FRT tree on $H$ is a three-step sequence of embeddings of $G$. Still, in terms of stretch, the embedding of Corollary 7.10 is—up to a factor in $1 + \operatorname{o}(1)$—as good as directly constructing an FRT tree of $G$: (1) Hop sets do not stretch distances. (2) By Theorem 4.5 and Equation (91), $H$ introduces a stretch of $1 + 1 / \operatorname{polylog}n$. (3) Together, this ensures that the expected stretch of the FRT embedding with respect to $G$ is $\operatorname{O}(\log n)$.

It is possible to reduce the work at the expense of an increased stretch by first applying the spanner construction by Baswana and Sen [9]:

Given that we only deal with distances and not with paths in the FRT construction, there is one concern: Consider an arbitrary graph $G = (V, E, \operatorname{\omega })$, its augmentation with a hop set resulting in $G^{\prime }$, which is then embedded into the complete graph $H$ and finally into an FRT tree $T = (V_T, E_T, \operatorname{\omega }_T)$. How can an edge $e \in E_T$ of weight $\operatorname{\omega }_T(e)$ be mapped to a path $p$ in $G$ with $\operatorname{\omega }(p) \le \operatorname{\omega }_T(H)$? Note that this question has to be answered in polylogarithmic depth and without incurring too much memory overhead. Our purpose is not to provide specifically tailored data structures, but we propose a three-step approach that maps edges in $T$ to paths in $H$, edges in $H$ to paths in $G$, and finally edges from $G^{\prime }$ to paths in $G$.

Concerning a tree edge $e \in E_T$, observe that $e$ maps back to a path $p$ of at most $\operatorname{SPD}(H)$ hops in $H$ with $\operatorname{\omega }_H(p) \le 3 \operatorname{\omega }_T(e)$ as follows. First, to keep the notation simple, identify each tree node—given as tuple $(v_i, \dots , v_j)$—w ith its “leading” node $v_i \in V$; in particular, each leaf has $i = 0$ and is identified with the node in $V$ that is mapped to it. A leaf $v_0$ has an LE entry $(\operatorname{dist}(v_0, v_1, H), v_1),$ and we can trace the shortest $v_0$-$v_1$-path in $H$ based on the LE lists (nodes locally store the predecessor of shortest paths just like in APSP). Moreover, $\operatorname{dist}(v_i, v_{i+1}, H) \le \operatorname{\omega }_T(v_i, v_{i+1})$ (i.e., we may map the tree edge back to the path without incurring larger cost than in $T$). If $i \gt 0$, $v_i$ and $v_{i+1}$ are inner nodes. Choose an arbitrary leaf $v_0$ that is a common descendant (this choice can, e.g., be fixed when constructing the tree from the LE list without increasing the asymptotic bounds on depth or work). We then can trace shortest paths from $v_0$ to $v_i$ and from $v_0$ to $v_{i+1}$ in $H$, respectively. The cost of their concatenation is $\operatorname{dist}(v_0, v_i, H) + \operatorname{dist}(v_0, v_{i+1}, H) \le \beta 2^i + \beta 2^{i+1} = 3(\beta 2^i) = 3\operatorname{\omega }_T(v,w)$ by the properties of LE lists and the FRT embedding. Note that, due to the identification of each tree node with its “leading” graph node, paths in $T$ map to concatenable paths in $H$.

Regarding the mapping from edges in $H$ to paths in $G$, recall that we compute the LE lists of $H$ by repeated application of the operations $r^V$, $\oplus$, $P_\lambda$, and $A_\lambda$ with $0 \le \lambda \le \Lambda$. Observe that $r^V$, $\oplus$, and $P_\lambda$ discard information; that is, distances to nodes that do not make it into the final LE lists and therefore are irrelevant to routing. $A_\lambda$, on the other hand, is an MBF step. Thus, we may store the necessary information for backtracing the induced paths at each node; specifically, we can store, for each iteration $h \in \operatorname{O}(\log ^2 n)$ with respect to $H$, each of the intermediate $d$ iterations in $G$, and each $\lambda \in \operatorname{O}(\log n)$, the state vector $y$ of the form in Equation (117) in a lookup table. This requires $\operatorname{\tilde{O}}(d)$ memory and efficiently maps edges of $H$ to $d$-hop paths in $G$—or rather to $d$-hop paths in $G^{\prime }$ if we construct $H$ after augmenting $G$ to $G^{\prime }$ using a hop set.

Mapping edges of $G^{\prime }$ to edges in $G$ depends on the hop set. Cohen [17] does not discuss this in her article, but her hop set edges can be efficiently mapped to paths in the original graph by a lookup table: Hop set edges either correspond to a shortest path in a small cluster or to a cluster that has been explored using polylogarithmic depth. Regarding other hop set algorithms, we note that many techniques constructing hop set edges using depth $D$ allow for reconstruction of corresponding paths at depth $\operatorname{O}(D)$ (i.e., that polylogarithmic-depth algorithms are compatible analogously to Cohen's hop sets). For instance, this is the case for the hop set construction by Henziger et al. [29], which we leverage in Section 8.3.

In our terminology, the algorithm of Khan et al. [30] performs $\operatorname{SPD}(G)$ iterations of the MBF-like algorithm for collecting LE lists implied by Definition 7.3; that is,

The strongest lower bound regarding the round complexity for constructing a (low-stretch) metric tree embedding of $G$ in the Congest model is $\operatorname{\tilde{\Omega }}(\sqrt {n} + \operatorname{D}(G))$ [20, 26]. If $\operatorname{SPD}(G) \gg \max \lbrace \operatorname{D}(G), \sqrt {n}\rbrace$, one may thus hope for a solution that runs in $\operatorname{\tilde{o}}(\operatorname{SPD}(G))$ rounds. For any , in Ghaffari and Lenzen [26], it is shown that expected stretch $\operatorname{O}(\varepsilon ^{-1}\log n)$ can be achieved in $\operatorname{\tilde{O}}(n^{1/2 + \varepsilon } + \operatorname{D}(G))$ rounds; below, we summarize this algorithm.

The strategy is to first determine the LE lists of a constant-stretch metric embedding of (the induced submetric of) an appropriately sampled subset of $V$. The resulting graph is called the skeleton spanner, and its LE lists are then used to jump-start the computation on the remaining graph. When sampling the skeleton nodes in the right way, stretching non-skeleton edges analogously to Section 4, and fixing a shortest path for each pair of vertices, w.h.p. all of these paths contain a skeleton node within a few hops. Ordering skeleton nodes before non-skeleton nodes with respect to the random ordering implies that each LE list has a short prefix accounting for the local neighborhood, followed by a short suffix containing skeleton nodes only. This is due to the fact that skeleton nodes dominate all non-skeleton nodes for which the respective shortest path passes through them. Hence, no node has to learn information that is further away than $d_S\in \operatorname{\tilde{O}}(\sqrt {n})$, an upper bound on the number of hops when a skeleton node is encountered on a shortest path that holds w.h.p.

The Graph $H$ . In Ghaffari and Lenzen [26], $G$ is embedded into $H$ and an FRT tree is sampled on $H$, where $H$ is derived as follows. Abbreviate $\ell := \lceil \sqrt {n} \rceil$. For a sufficiently large constant $c$, sample $\lceil c \ell \log n \rceil$ nodes uniformly at random; call this set $S$. Define the skeleton graph

FRT Trees of $H$ . Observe that min-hop shortest paths in $H$ contain only a single maximal subpath consisting of spanner edges, where the maximal subpaths of non-spanner edges have at most $\ell$ hops w.h.p. This follows analogously to Lemma 4.4 with two levels and a sampling probability of $\operatorname{\tilde{\Theta }}(1 / \ell)$. Assuming $s \lt v$ for all $s \in S$ and $v \in V \setminus S$ (we discuss this below) for each $v \in V$ and each entry $(w, \operatorname{dist}(v, w, H))$ of its LE list, w.h.p. there is a min-hop shortest $v$-$w$-path with a prefix of $\ell$ non-spanner edges followed by a shortest path in $G^{\prime }_S$. This entails that w.h.p.

In order to construct an FRT tree, suppose we have sampled uniform permutations of $S$ and $V \setminus S$ and a random choice of $\beta$. We extend the permutations to a permutation of $V$ by ruling that, for all $s \in S$ and $v \in V \setminus S$, we have $s \lt v$, fulfilling the above assumption. Lemma 4.9 of Ghaffari and Lenzen [26] shows that the introduced dependence between the topology of $H$ and the resulting permutation on $V$ does not increase the expected stretch of the embedding beyond $\operatorname{O}(\log n)$. The crucial advantage of this approach lies in the fact that now the LE lists of nodes in $S$ may be used to jump-start the construction of LE lists for $H$, in accordance with Equation (134).

The Algorithm. In Ghaffari and Lenzen [26], it is shown that LE lists of $H$ can be determined quickly in the Congest model as follows.

1. Some node $v_0$ starts by broadcasting $k$ and a random choice of $\beta$, constructing a BFS tree on the fly. Upon receipt, each node generates a random ID of $\operatorname{O}(\log n)$ bits which is unique w.h.p. Querying the amount of nodes with an ID of less than some threshold via the BFS tree, $v_0$ determines the bottom $\ell$ node IDs via binary search; these nodes form the set $S$ and satisfy the assumption that went into Equation (134). All of these operations can be performed in $\operatorname{\tilde{O}}(\operatorname{D}(G))$ rounds.
   
2. The nodes in $S$ determine $G^{\prime }_S$, which is possible in $\operatorname{\tilde{O}}(\operatorname{D}(G) + \ell ^{1 + 1/k}) \subseteq \operatorname{\tilde{O}}(\operatorname{D}(G) + n^{1/2 + \varepsilon })$ rounds, such that all $v \in V$ learn $E^{\prime }_S$ and $\operatorname{\omega }_S$ [26, 33]. After that, $G^{\prime }_S$ is global knowledge and each $v \in V$ can locally compute $\bar{x}^{(0)}_v$.
   
3. Subsequently, nodes w.h.p. determine their component of $r^V A_{G,2k-1}^\ell \bar{x}^{(0)} = (r^V A_{G,2k-1})^\ell \bar{x}^{(0)}$ via $\ell$ MBF-like iterations of
   \begin{equation} \bar{x}^{(i+1)} := r^V A_{G,2k-1} \bar{x}^{(i)}. \end{equation} (135)
   Here, one exploits that, for all $i$, $|\bar{x}^{(i)}_v| \in \operatorname{O}(\log n)$ w.h.p. by Lemma 7.6,¹⁰ and thus each iteration can be performed by sending $\operatorname{O}(\log n)$ messages over each edge (i.e., in $\operatorname{O}(\log n)$ rounds); the entire step thus requires $\operatorname{\tilde{O}}(\ell) \subseteq \operatorname{\tilde{O}}(n^{1/2})$ rounds.
   

Together, this w.h.p. implies the round complexity of $\operatorname{\tilde{O}}(n^{1/2 + \varepsilon } + \operatorname{D}(G))$ for an embedding of expected stretch $\operatorname{O}(\varepsilon ^{-1}\log n)$.

The multiplicative overhead of $n^{\varepsilon }$ in the round complexity is due to constructing and broadcasting the skeleton spanner $G^{\prime }_S$. We can improve upon this by relying on hop sets, just as we do in our parallel construction. Henziger et al. [29] show how to compute an $(n^{\operatorname{o}(1)}, \operatorname{o}(1))$-hop set of the skeleton graph in the Congest model using $n^{1/2 + \operatorname{o}(1)} + \operatorname{D}(G)^{1 + \operatorname{o}(1)}$ rounds.

Our approach is similar to the one outlined in Section 8.2. The key difference is that we replace the use of a spanner by combining a hop set of the skeleton graph with the construction from Section 4; using the results from Section 5, we can then efficiently construct the LE lists on $S$ to jump-start the construction of LE lists for all nodes.

The Graph $H$ . Let $\ell$, $c$, and the skeleton graph $G_S = (S, E_S, \operatorname{\omega }_S)$ be defined as in Section 8.2 and Equations (127)–(128), w.h.p. yielding $\operatorname{dist}(s, t, G_S) = \operatorname{dist}(s, t, G)$ for all $s,t \in S$. Suppose for all $s,t\in S$, we know approximate weights $\operatorname{\omega }^{\prime }_S(s,t)$ with

FRT Trees of $H$ . Analogously to Section 8.2, assume that the node IDs of $S$ are ordered before those of $V \setminus S$; then min-hop shortest paths in $H$ contain a single maximal subpath of edges in $E_{H_S}$. To determine the LE lists for $H$, we must therefore compute

The Algorithm. We determine the LE lists of $H$ as follows, adapting the approach from Ghaffari and Lenzen [26] outlined in Section 8.2.

1. A node $v_0$ starts the computation by broadcasting a random choice of $\beta$. The broadcast is used to construct a BFS tree, nodes generate distinct random IDs of $\operatorname{O}(\log n)$ bits w.h.p., and $v_0$ figures out the ID threshold of the bottom $c\ell$ nodes $S$ with respect to the induced random ordering. This can be done in $\operatorname{\tilde{O}}(\operatorname{D}(G))$ rounds.
   
2. Each skeleton nodes $s\in S$ computes $\operatorname{\omega }^{\prime }_S(s,t)$ as above for all $t\in S$, using the $(1 + 1 / \log ^2 n)$-approximate $(S,\ell ,|S|)$-detection algorithm given in Lenzen and Patt-Shamir [35]. This takes $\operatorname{\tilde{O}}(\ell +\ell)=\operatorname{\tilde{O}}(n^{1/2})$ rounds.
   
3. Run the algorithm of Henzinger et al. [29] to compute an $(n^{\operatorname{o}(1)}, \operatorname{o}(1))$-hop set of $G_S^{\prime }$, in the sense that nodes in $S$ learn their incident weighted edges. This takes $n^{1/2 + \operatorname{o}(1)} + \operatorname{D}(G)^{1 + \operatorname{o}(1)}$ rounds.
   
4. Next, we (implicitly) construct $H_S$. To this end, nodes in $S$ locally determine their level and broadcast it over the BFS tree, which takes $\operatorname{O}(|S| + \operatorname{D}(G)) \subset \operatorname{\tilde{O}}(\sqrt {n} + \operatorname{D}(G))$ rounds; thus, $s \in S$ knows the level of $\lbrace s,t\rbrace \in E_{H_S}$ for each $t \in S$.
   
5. To determine $\bar{x}^{(0)}$, we follow the same strategy as in Theorem 5.2; that is, we simulate matrix-vector multiplication with $A_{H_S}$ via matrix-vector multiplications with $A_{G^{\prime }_S}$. Hence, it suffices to show that we can efficiently perform a matrix-vector multiplication $A_{G^{\prime }_S} x$ for any $x$ that may occur during the computation—applying $r^V$ is a local operation and thus free—assuming each node $v \in V$ knows $x_v$ and its row of the matrix.
   Since multiplications with $A_{G^{\prime }_S}$ only affects lists at skeleton nodes, this can be done by local computations once all nodes know $x_s$ for each $s \in S$. As before, $|x_s| \in \operatorname{O}(\log n)$ w.h.p., so $\sum _{s \in S} |x_s| \in \operatorname{O}(|S| \log n)\subset \operatorname{\tilde{O}}(\sqrt {n})$ w.h.p. We broadcast these lists over the BFS tree of $G$, taking $\operatorname{\tilde{O}}(\sqrt {n} + \operatorname{D}(G))$ rounds per matrix-vector multiplication. Due to $\operatorname{SPD}(H_S) \in \operatorname{\tilde{O}}(\log ^2 n),$ by Theorem 4.5, this results in a round complexity of $\operatorname{\tilde{O}}(n^{1/2 + \operatorname{o}(1)} + \operatorname{D}(G)^{1 + \operatorname{o}(1)})$.
   
6. Applying $r^V A_{G,\alpha }^{\ell }$ is analogous to step 3 in Section 8.2 and takes $\operatorname{\tilde{O}}(\ell) \subseteq \operatorname{\tilde{O}}(n^{1/2})$ rounds.
   

Altogether, this yields a round complexity of $n^{1/2 + \operatorname{o}(1)} + \operatorname{D}(G)^{1 + \operatorname{o}(1)}$. Combining this result with the algorithm by Khan et al. [30], which terminates quickly if $\operatorname{SPD}(G)$ is small, yields the following result.