Routing Schemes and Distance Oracles in the Hybrid Model

by   Fabian Kuhn, et al.
University of Freiburg

The 𝖧𝖸𝖡𝖱𝖨𝖣 model was introduced as a means for theoretical study of distributed networks that use various communication modes. Conceptually, it is a synchronous message passing model with a local communication mode, where in each round each node can send large messages to all its neighbors in a local network (a graph), and a global communication mode, where each node is allotted limited (polylogarithmic) bandwidth per round which it can use to communicate with any node in the network. Prior work has often focused on shortest paths problems in the local network, as their global nature makes these an interesting case study how combining communication modes in the 𝖧𝖸𝖡𝖱𝖨𝖣 model can overcome the individual lower bounds of either mode. In this work we consider a similar problem, namely computation of distance oracles and routing schemes. In the former, all nodes have to compute local tables, which allows them to look up the distance (estimates) to any target node in the local network when provided with the label of the target. In the latter, it suffices that nodes give the next node on an (approximately) shortest path to the target. Our goal is to compute these local tables as fast as possible with labels as small as possible. We show that this can be done exactly in O(n^1/3) communication rounds and labels of size Θ(n^2/3) bits. For constant stretch approximations we achieve labels of size O(log n) in the same time. Further, as our main technical contribution, we provide computational lower bounds for a variety of problem parameters. For instance, we show that computing solutions with stretch below a certain constant takes Ω(n^1/3) rounds even for labels of size O(n^2/3).



page 1

page 2

page 3

page 4


Near-Shortest Path Routing in Hybrid Communication Networks

Hybrid networks, i.e., networks that leverage different means of communi...

Shortest Paths in a Hybrid Network Model

We introduce a communication model for hybrid networks, where nodes have...

Computing Shortest Paths and Diameter in the Hybrid Network Model

The 𝖧𝖸𝖡𝖱𝖨𝖣 model, introduced in [Augustine et al., SODA '20], provides a...

Fast Hybrid Network Algorithms for Shortest Paths in Sparse Graphs

We consider the problem of computing shortest paths in hybrid networks, ...

The Topology of Local Computing in Networks

Modeling distributed computing in a way enabling the use of formal metho...

Distance Computations in the Hybrid Network Model via Oracle Simulations

The Hybrid network model was introduced in [Augustine et al., SODA '20] ...

Fast Interpolation-based Globality Certificates for Computing Kreiss Constants and the Distance to Uncontrollability

The Kreiss constant of a matrix and the distance to uncontrollability ca...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

Hybrid Networks

Real networks often employ multiple communication modes. For instance, mobile devices combine high-bandwidth, short-range wireless communication with relatively low-bandwidth cellular communication (c.f., 5G [AMG16]). Other examples are hybrid data centers, which combine wireless and wired communication [HHLX15] or optical circuit switching and electrical packet switching [WAK10], or software defined networking [VVB14].

In this article we utilize the theoretical abstraction of such hybrid communication networks provided by [AHK20] which became known as hybrid model and was designed to reflect a high-bandwidth local communication mode and a low-bandwidth global communication mode, capturing one of the main aspects of real hybrid networks. Fundamentally, the hybrid model builds on the concept of synchronous message passing, a classic model to investigate communication complexity in distributed systems.

Definition 1.1 (Synchronous Message Passing, c.f., [Lyn96]).

Let be a set of nodes with unique identifiers .111 for . Time is slotted into discrete rounds consisting of the following steps. First, all nodes receive the set of messages addressed to them in the last round. Second, nodes conduct computations based on their current state and the set of received messages to compute their new state (randomized algorithms also include the result of some random function). Third, based on the new state the next set of messages is sent.

Synchronous message passing has a clear focus on investigating communication complexity, i.e., the number of communication rounds required to solve a problem with an input distributed over all nodes (usually a graph problem). For this purpose, nodes are usually assumed to be computationally unbounded.222Occasionally this model is “overexploited”, e.g., nodes are supposed solve -complete problems on their local data. We will refrain from that. The hybrid model then places additional restrictions on the messages size and which pairs of nodes can exchange them.

Definition 1.2 (Hybrid model [Ahk20]).

The model is a synchronous message passing model (Def. 1.1), subject to the following restrictions. Local mode: nodes may send one message per round of maximum size bits to each of their neighbors in a graph. Global mode: nodes can send and receive messages of total size at most bits per round to/from any other node(s) in the network. If the restrictions are not adhered to then a strong adversary333The strong adversary knows the states of all nodes, their source codes and even the outcome of all random functions. selects the messages that are delivered.

Note that the parameter spectrum of the model covers the standard models , , (aka “Congested Clique”) and (“Node Capacitated Clique”) as marginal cases.444: , : , (+ Lenzen’s Routing scheme [Len13]): , : . Given the ramifications of investigating in its entirety, we narrow our scope (for our upper bounds) to a particular parametrization that pushes both communication modes to one extreme end of the spectrum. Following the argumentation of [AHK20] we leave the size of local messages unrestricted (modeling high local bandwidth) and allow only bits of global communication per node per round (modeling severely restricted global bandwidth). Formally, we define the “standard” hybrid model as combination of the standard and [AHK19] models: .555Choosing is due to convenience. It allows nodes to exchange global messages of size bits, which often makes randomized algorithms more concise. The slight arbitrariness of this choice is one reason to resort to the notation for analyzing the round complexity. Note that our lower bounds are parametrized for the more general model (which also yields lower bounds for the weaker model).

Routing Schemes & Distance Oracles

A fundamental aspect of the Internet Protocol is packet forwarding, where every node has to compute a routing function, which – when combined with target-specific information stored in the packet header – must indicate the neighbor which the packet has to be forwarded to such that it reaches its intended destination. A correct routing scheme consists of these routing functions and a unique label per node, such that the packet forwarding procedure induces a path in the network from any source node to any destination node specified by the corresponding label attached to the packet.

Typically, a distinction is made between stateful and stateless routing schemes. In the former, routing can be based on additional information accumulated in the packet header as the packet is forwarded, whereas in the latter routing decisions are completely oblivious to the previous routing path. A related problem is the computation of distance oracles, which has some similarities to the all pairs shortest paths problem. Each node must compute an oracle function that provides the distance (or an estimate) to any other node when provided with the corresponding label. Formal definitions are given in Section 1.3 (Def. 1.3, 1.4 and 1.5).

Our first goal is to gather the necessary information for labels, routing and oracle functions with as few communication rounds as possible. This is particularly important for dynamic or unreliable networks where changes in distances or topology necessitates (frequent) re-computation. In this work we allow that node labels666Allowing relabeling is also called a labeling scheme. may contain information that help with distance estimation and routing decisions, which gives rise to our second goal; keeping node labels small.777Usually the amount of information stored at nodes for routing and distance estimation is also considered. Since the nodes in our model are computationally unbounded we do not focus on that. Our lower bounds have also no restriction on the local information. The third goal is to speed up the actual packet forwarding process to minimize latency and alleviate congestion. Given a graph with edge weights corresponding to (e.g.) link-latencies, we want to minimize the largest detour any packet takes in relation to the corresponding shortest path. This is also known as stretch. Analogously, for distance oracles we want to minimize the worst estimation error relative to the true distance.

Routing Schemes & Distance Oracles in Distributed Networks

In this work we are interested solving the above problems in a distributed setting (c.f., Definition 1.1). This has particular importance given the distributed nature of many real networks where routing problems are relevant (most prominently, the Internet) and where providing a centralized view of the whole network is prohibitively expensive. Note that we are interested in computing routing schemes and distance oracles for the local communication network, which is motivated by the fact that typically lots of packets are routed during an ongoing session and due bandwidth and cost constraints of the global mode. However, the global mode can be used to send the (relatively small) destination label to the source of a packet quickly, which can then be stored at that node for the duration of a session.

From an algorithmic standpoint, computing routing schemes and distance oracles is an inherently global problem. That is, allowing only local communication (i.e., the model) it takes rounds to accomplish this (we provide a proof of this in Lemma D.1).888Any graph problem can be solved in rounds in by collecting the graph and solving the problem locally at some node. This makes global problems uninteresting for the model, unless communication restrictions are increased (c.f., ) or decreased (c.f., ). A similar observation can be made for the global communication mode ( model). If we are only allowed to use global communication and each node initially only knows its incident edges in the local network, it takes 999The notation suppresses multiplicative terms that are polylogarithmic in . rounds to compute routing schemes and distance oracles (we show that in Lemma D.2).101010Computing routing schemes in is somewhat artificial, as the need for routing schemes for a local network suggests that it exists and can be used. This article addresses the question whether the combination of the two communication modes in the model can overcome the lower bound of the individual modes and .

Our answer to this is two-pronged. First we show that indeed, we can compute routing schemes and distance oracles significantly faster, for instance, we show rounds and labels of size suffice (c.f., Theorem 2.5). Second, we show that the model is not arbitrarily powerful by giving polynomial lower bounds for these problems (depending on the stretch) that hold even for relatively large labels and unbounded local memory. For instance, we show that it takes rounds to solve either problem exact, even for unweighted graphs and labels of size (c.f., Theorem 4.3). We provide numerous, more nuanced results, depending on stretch and the type of problem, summarized in the following.

1.1. Contributions and Overview

Our contributions and results are summarized in Table 1, which gives a simplified overview of our complexity results for the various forms of routing scheme and distance oracle problems. Here we also want to give some intuition into how our techniques work and highlight how some of the results are generalized in the main part.

problem stretch complexity label-size reference
distance oracles Thm. 5.6
Thm. 5.6, 5.7
stateless routing schemes Thm. 5.9
Thm. 5.9
Thm. 5.9
stateful routing schemes Thm. 5.11
Thm. 5.11
Thm. 5.11
Thm. 5.11
all on unw. graphs exact Thm. 4.3
Thm. 2.9
all on weigh. graphs exact Thm. 2.5
3 Thm. 2.9
  • The lower bound on round complexity holds any node labeling of at most that size.

  • For some function that is linear in .

Table 1. Selected and simplified contributions of this paper.

Lower Bounds Summary

Our main contribution revolves around computational lower bounds for computing distance oracles and stateless and stateful routing schemes in the model. Lower bounds for approximations are summarized in the first three groups of Table 1. We also provide a lower bound on unweighted graphs, given in the first row of the fourth group of Table 1

. Note that all lower bounds hold regardless of the allowed local memory. Moreover, our lower bounds hold for randomized algorithms with constant success probability.

In the main part, our results are formulated for the more general model, that is appears as a parameter. For instance, our lower bound on unweighted graphs is in fact rounds for labels of size up to for some (c.f., Theorem 4.3), that is, we get a polynomial lower bound for the model for any . For easier readability we plug in the “standard” model with , which lets us hide by using the notation.

Lower Bounds Overview

The general proof idea is based on information theory and plays out roughly as follows. We start out with a two party communication problem, where Alice is given the state of some random variable

and needs to communicate it to Bob (c.f., Definition 3.2). Any communication protocol that achieves this needs to communicate (Shannon entropy of [Sha48]) bits in expectation (c.f., Corollary B.2), which is a consequence of the source coding theorem (replicated in Lemma B.1).

In Section 3 we translate this to the setting into what we call the node communication problem. There, we have two sets of nodes and , where nodes in “collectively know” the state of some random variable and need to communicate it to (for more precise information see Definition 3.1). We show a reduction (via a simulation argument) where a algorithm that solves the node communication problem on sets and that are at sufficiently large distance in the local graph, can be used to derive a protocol for the two party communication problem (c.f., Lemma 3.3). We conclude that for sets with distance at least it takes rounds to solve this problem (Theorem 3.4).

In Section 4 we give a reduction from the node communication problem to distance oracle and routing scheme computation. The goal is to encode some random variable with large entropy (super-linear in ) into some randomized part of our local communication graph such that some node set knows by vicinity. We construct such a graph (see Figure 1) from the complete bipartite graph and a (i.i.d.) random -bit-string with . Then an edge of is present in iff .

The nodes in collectively know since they are incident to the edges sampled from . We designate nodes of (one side of the bipartition in ) as the “target nodes”. Then we connect each target with a path of length to one of “source nodes” which will take the role of (see Figure 1). We show that if the nodes in learn the distances to the source nodes they also learn about the (non-)existence of the edges sampled from and can conclude the state of and thus have solved the node communication problem. Choosing the trade-off between and appropriately (roughly and ) we conclude rounds of communication must have taken place to solve the (exact) distance oracle problem (Theorem 4.3).

One caveat is that in the distance oracle problem the nodes are only supposed to give a distance to a target when also provided with the target-label. So we choose the labels sufficiently small such that the “free information”, given in form of the labels of all targets, is negligible. We can allow labels of size without changing the above narrative, see Theorem 4.3. For routing schemes we have to adapt the graph a bit. We add a slightly longer alternative route from sources to targets (Figure 1, left side) and show that the existence of edges and thus the state of can be concluded from the first routing decision the sources have to make.

So far we got lower bounds only for exact solutions with the advantage that they hold on unweighted graphs. In Section 5 we show how to use graph weights to get lower bounds for approximation algorithms. For this we replace with a balanced, bipartite graph with nodes and girth (length of the shortest cycle in ). As before, the existence of an edge in is determined by to a random bit string , c.f., Figure 2. If some edge is not in , then the detour in between the endpoints of is at least edges (otherwise closes a loop of less than edges). By assigning large weights to edges sampled from , we can transform this into multiplicative detour of almost . Similar to the idea in the unweighted case, any algorithm for distance oracles that has stretch slightly smaller than can be used to solve the node communication problem, which takes rounds.

To optimize the lower bound we need to maximize the entropy of , i.e., the density of . However, it is well known that girth and density of a graph are opposing goals: a graph with girth can have at most edges (c.f., [AHL01], simplified in Lemma C.2). This inherently limits the amount of information we can encode in and we show in Lemma 5.4 how graph density affects lower bounds for the node communication problem. The good news is, that for some girth values, graphs that achieve their theoretical density limit actually exist and have been constructed (c.f., Ben66, Sin66, simplified form given in Lemma C.3). For higher girth values, graphs that come close to that limit are known (c.f., [LUW97], simplified form in Lemma C.4).111111There is a long standing conjecture that for each girth there exists a graph that reaches the theoretical limit of edges ([ES82], c.f., Conjecture C.1). Our tools can be used to generate new lower bounds in case new such graphs are found.

Utilizing these graphs we achieve polynomial lower bounds for the distance oracle problem for some small stretch values (c.f., Theorem 5.6) and for arbitrary constant stretch (c.f., Theorem 5.7). Theorem 5.7 is heavily parametrized, but to sum it up in a simpler way: for any constant stretch we attain a polynomial lower bound of , that is, is constant as well (roughly ).

For approximate routing schemes we have to be more careful and also make a distinction between the stateless and stateful variant (c.f., Definitions 1.4, 1.5). The idea is the same as in the exact, unweighted case, however, since a wrong routing decision at the source can still be completed into a routing path of relatively good quality, the best stretch that can be achieved for lower bounds is limited (even more so for stateful routing, where a packet may “backtrack”). In particular, allowing too much stretch can open up unwanted routing paths that mislead the sources in their conclusions about . We forbid these unwanted routing paths using inequalities parametrized by the stretch and graph weights. Maximizing the stretch subject to these conditions we obtain the lower bounds for stretch values that are given in the second and third group of Table 1 with details in Theorems 5.9 and 5.11.

Upper Bounds Summary & Overview

Our computational upper bounds (Given in Appendix 2) can be expressed more concisely due to the existence of efficient randomized algorithms for shortest path problems in the model. In particular we draw on fast solutions for the so called random sources shortest paths problem (RSSP) [CHLP21a], where all nodes must learn their distance to a set of i.i.d. randomly sampled nodes, say . After solving RSSP, our strategy is to use the distance between a node and the nodes in as its label .

Roughly speaking, provided that is sufficiently “far away”, a node can combine with its own distances to to compute its distance (estimate) to . If is “close” then we can use the local network to compute the distance directly. While this gives us only distance oracles, it is relatively straight forward to also derive routing schemes. Simply speaking, we can always send a packet to a neighbor that has the best distance (estimate) to (some care must be taken for approximations). Note that this process is oblivious to previous routing decisions so the obtained routing scheme is stateless (c.f., Definition 1.4).

A trade-off arises from the local exploration around nodes and the global computation depending on the size of (since we solve RSSP on ), which balances out to a round complexity of with (similar trade-offs were observed for shortest paths problems in [AHK20, KS20, CHLP21a]). For exact algorithms (distance oracles and routing schemes) we require labels of size (however we can decrease the label size to at a cost of rounds, c.f., Theorem 2.5). This is tight up to factors as is shown by the corresponding lower bound in Table 1 group 4 line 1 (which holds even on unweighted graphs).

For smaller labels we show that restricting to ’s closest node in gives good approximations. We obtain a 3-approximation on weighted graphs and a approximation on unweighted graphs in rounds (assuming is constant) with labels of size (c.f., Theorem 2.9). Compare this to our lower bounds: even much larger labels of size do not help to improve the runtime or the stretch by much, as this still takes rounds for stretch of for distance oracles on weighted graphs, and stretch on unweighted graphs (see Table 1).

1.2. Related Work

There was an early effort to approach hybrid networks from a theoretic angle [ALSY90], with a conceptually different model.121212Essentially [ALSY90] combines with a global channel where in each round one node may broadcast a message, making it much weaker than the model. Research on the current take of the model was initiated by [AHK20] in the context of shortest paths problems, which most of the research has focused on so far. As shortest paths problems problems are closely related, we give a brief account of the recent developments.

Shortest Paths in the Hybrid Model

[AHK20] introduced an information dissemination scheme to efficiently broadcast small messages to all nodes in the network. Using this protocol, they derive various solutions for shortest paths problems. For instance, for SSSP:131313In the sources shortest paths problem (-SSP) all nodes must learn their distance to dedicated source nodes. Then SSSP -SSP, APSP -SSP. a stretch, -round algorithm and a -stretch, -round algorithm.141414[AHK20] also gives an exact, -round SSSP algorithm depending on the shortest path diameter SPD, using a completely different approach. Further, an approximation of APSP with stretch 3 in rounds, which closely matches their corresponding lower bound (which holds for much larger stretch). Subsequently, [KS20] introduced a protocol for efficient routing of small messages between dedicated source-target pairs in the model (not to be confused with routing schemes), which they use to solve APSP and SSSP exactly in and rounds, respectively. For computing the diameter they provide algorithms (e.g., a approximation in rounds) and a lower bound. [CHLP21a] combines the techniques of [KS20] with a densitiy sensitive approach, to solve -SSP (thus SSSP) exactly and compute a -approximation of the diameter in rounds.151515As we reuse some techniques of [AHK20, KS20, CHLP21a], we explain them in a bit more detail in Section 2). [CHLP21b] uses density awareness in a different way to improve SSSP to rounds for a small stretch of . [AG21] derandomized the dissemination protocol of [AHK20] to obtain a deterministic APSP-algorithm with stretch in rounds. For classes of sparse graphs (e.g., cactus graphs) [FHS20] demonstrates that solutions are possible even in the harsher hybrid combination and .

Routing Schemes in Distributed Models

Routing schemes in a hybrid network model have been pioneered in [CCF21]. Their work can be contrasted to this article in three main ways: First, they consider specific types of local graphs, namely “hole-free” grid graphs and unit disc graphs (UDGs) (which have practical relevance in the context of wireless local networks), whereas this work focuses on general graphs. Second, [CCF21] provides upper bounds based on a routing scheme on a grid-graph abstraction of UDGs, whereas the main technical contribution of this work are lower bounds. Third, we consider hybrid networks with unlimited edges (which strengthens our lower bounds), whereas [CCF21] gives a round algorithm with labels and local tables of size and stretch 1 and constant stretch on certain grid-graphs and UDGs, respectively, which holds even for the stricter combination of and . Note that our lower bounds supplement the work of [CCF21] in that it shows the necessity to narrow the scope (for instance to particular graph classes) in order to achieve round algorithms with small labels and stretch.

A related line of work investigates the round complexity of implementing routing schemes and distance oracles in the model, where the challenge is that only small local messages can be used. Here, a lower bound for computing routing schemes is implied by [SHK12] (even for polynomial labels, whereas is the diameter of ). For distance oracles in , [IW14] gives a lower bound of with stretch for graphs with small diameter assuming Erdős’ girth conjecture (c.f., Conjecture C.1). Their bound holds for small labels without this assumption. A line of papers narrows the gap to these lower bounds [LPS13, LPS15, EN16]. For instance [EN16] achieves a routing scheme with stretch , routing tables of size , labels of size in rounds.

Routing Schemes as Distributed Data Structure

In this branch of research the goal is often to optimize the trade-off between stretch and the size of the local routing tables. It is well established that bit of memory per node always suffices for routing schemes161616As bit of memory allows each node to store the next node for every destination. [PU89]. For routing schemes on general graphs with small stretch () bit are required [PU89, TZ01].171717With local memory a -degree node has to “forget” neighbors, necessarily generating a detour when routing to the neighbors that have been forgotten. This lower bound is part of the reason why we do not analyze local memory in this work. More generally, for a stretch smaller than it is known that local tables of size bit are required for small values , see [TZ01]. This is true for all parameters of if one believes Erdős’ girth conjecture (see Conjecture C.1) [TZ01]. The reliance on this conjecture can be dropped for weaker name-independent routing schemes, where nodes can not be re-labeled and [AGM06a] shows that this requires memory for any stretch smaller than . On the positive side, [TZ01] shows that a stretch of with memory can be achieved. The concrete stretch is or even (i.e., almost optimal) if handshaking is allowed (an initial exchange of a message between source and destination before a packet is routed). The lower bound for name independent routing has been contrasted with a scheme that achieves stretch with memory size [AGM06b].

1.3. Preliminaries

General Definitions

The scope of this paper is solving graph problems, typically in the undirected communication graph. Let be undirected. Edges have weights , where is at most polynomial in , thus the weight of an edge and of a simple path fits into a bit message.181818In this article, functions are always to the base of 2. A graph is considered unweighted if . Let denote the length of a path . Then the distance between two nodes is

A path with smallest length between two nodes is called a shortest path. Let be the number of edges (or hops) of a path . The hop-distance between two nodes and is defined as:

We generalize this for sets (whereas ):

The diameter of is defined as:

Let the -hop distance from to be:

If there is no - path with we define . We drop the subscript , when is clear from the context. In this paper we consider the following problem types:

Definition 1.3 (Distance Oracles).

Every node of a graph needs to compute a label and an oracle function , such that for all . An oracle function is an -approximation if for all , that is, are the multiplicative and additive approximation error, respectively. We speak of a stretch of in case of an -approximation. If the stretch is one, we call exact.

Definition 1.4 (Stateless Routing Scheme).

Every node of a graph needs to learn a label and a routing function (sometimes called “table”) where are adjacent nodes of in (whereas we formally set ). The functions must fulfill the following correctness condition. Let and recursively define . Then the routing functions must satisfy for some . Let be the path induced by the visited nodes . We call an -approximation if for all .

Definition 1.5 (Stateful Routing Scheme).

This is mostly defined as in the stateless case, with the difference that the routing function can additionally depend on the information gathered along the path that has already been visited by a packet (which would be stored in its header). Note that in this means that the routing path defined by such a function is not necessarily simple (i.e., might have loops).

Definition 1.6 (Randomized Graph Algorithms).

We say that an algorithm has success probability , if it succeeds with probability at least on every possible input graph (however, some of our results are restricted to unweighted graphs as input). Specifically, for our upper bounds we aim for success with high probability (w.h.p.), which means with success probability at least for any constant .

2. Upper Bounds

The first part of this paper is to derive algorithms that compute routing schemes and distance oracles in the model, which we consider as a warm-up and complementary to the subsequent section on lower bounds. We can draw on the techniques and fast algorithms for shortest paths problems from [AHK20, KS20, CHLP21a] (where most of the heavy lifting occurs) and show how to leverage these to obtain distance oracles and routing schemes efficiently in the model. We start with a quick introduction to the techniques we use.

2.1. Techniques

Skeleton graphs were first used by [UY91] and became one of the main tools used in the context of shortest path algorithms in the model (c.f., [AHK20, KS20, CHLP21a]). Simply speaking, a skeleton is a minor of a graph consisting of a (usually relatively small) set of nodes sampled with some probability and virtual edges formed between sampled nodes at most hops apart with weights such that distances in the skeleton graph correspond to those in w.h.p.

The usual approach is to solve a given shortest path problem on an appropriately sized skeleton graph by leveraging the global communication provided by the model and then extend that solution to the whole graph using local communication. While at this point it is not necessary to fully characterize skeleton graphs anymore (we use existing algorithms out of the box), we still have to use the subsequent property for a random sampling of nodes (from which all required properties of a skeleton graph are derived).

Assume each node joins some set independently and identically distributed (i.i.d.) with probability for some . The expected number of nodes joining is , and we also have w.h.p. if is sufficiently large (which a simple application of the Chernoff bound given in Lemma A.1 shows). Furthermore, there exists some such that for any there will be a sampled node on some shortest --path at least every hops for any w.h.p. This is formalized as follows (the proof can be found at the end of Appendix A).

Lemma 2.1 (c.f., [Ks20], [Ahk20]).

Let . Let each node join some set i.i.d. with probability . Then there is a constant , such that for any with , there is at least one shortest path from to , such that any sub-path of with at least nodes contains a node in w.h.p.

We are interested in the distances to the sampled nodes, which can be formalize as follows.

Definition 2.2 (Random Sources Shortest Paths (RSSP)).

Given a subset of nodes (sources) that were sampled i.i.d. with probability for some from an undirected, weighted graph . The RSSP problem is solved when every node in the network has learned its distance to each of the random source nodes.

We provide a rough overview how RSSP was solved (simplified for ) for readers unfamiliar with the topic. First, a skeleton graph of is constructed on the sampled nodes as in [AHK20]. Note that edges of that skeleton are at most hops apart, which means that one round of the model can be simulated on that skeleton graph in real rounds. Second, [KS20] showed that a round of the model191919In the model, in each round each node is allowed to send a (different) message to every node. can also be simulated in rounds on the skeleton graph using a routing protocol tailored to the model to efficiently communicate bit messages between pairs of senders and receivers.

Third, [CHLP21a] observed that skeleton nodes with a high degree in the skeleton graph can learn a lot of information by relying on the bandwidth of their neighbors in the skeleton. With this observation they use simulated and rounds (of real rounds each) to compute “tiered oracles” (not to be confused with distance oracles in this paper) meaning that each node with a degree in a certain “tier” (exponential degree class with ) learns the subgraph of the skeleton graph induced by nodes of degree in its own tier or below.

Iteratively, one can solve the all pairs shortest paths problem on the skeleton. Initially, the nodes of the highest tier know the whole skeleton graph and can send their distance to every node in one round. This information enables the nodes in the next lower tier to compute their distance to every node in the skeleton. Then the process repeats (for each of the tiers) until eventually all pairs shortest paths is solved on the skeleton. All other nodes in can learn their distance to each skeleton node from those within hops. The following lemma summarizes this.

Lemma 2.3 (c.f., [CHLP21a]202020For our applications, it is convenient to rephrase the result of [CHLP21a], which considers sampling probabilities for with running time . This corresponds to the variant given here via the substitution .).

There is an algorithm that solves the random sources shortest path problem for sampling probability for some exactly and w.h.p. in rounds.

This result is almost tight (up to factors) for (i.e., there are sources) due to a corresponding lower bound by [CHLP21a] which was slightly adapted for random sources from the lower bound for the -sources shortest path problem given in [KS20].

2.2. Base Algorithm

We combine the previous two techniques to compute exact distance oracles and routing schemes in the model. We will presume a subroutine explore() that floods all graph information for hops such that afterwards each node knows defined as the subgraph induced by the nodes within hops around . Furthermore we presume a subroutine solve-rssp that solves RSSP on the sampled nodes in accordance with Lemma 2.3.

Algorithm 1 gives an overview. The parameters and are tuning parameters which will be specified for the task at hand. Algorithm 1 consists of two parts: first all nodes collect the information required to compute distance oracles and routing schemes. Second, in the last three lines, the computation of the label , oracle function and routing function takes place (c.f., Definitions 1.3, 1.5). We will override these sub-procedures to adapt the algorithm for exact and approximate results and for the special case of unweighted graphs. The steps are described on a node-level.

joins with probability
explore() learns
solve-rssp with source nodes
create-label computation of ’s problem-specific label
create-oracle-function output as in Def. 1.3
create-routing-function output as in Def. 1.4
Algorithm 1 base-algorithm() not smaller as in Lem. 2.1
Lemma 2.4 ().

Given that the last three lines have constant running time, Algorithm 1 takes rounds.


The time consuming steps are explore(), i.e., the flooding of the graph for rounds and solving the RSSP with (c.f., Lemma 2.3). ∎

2.3. Exact Distance Oracles & Routing Schemes

First, create-label computes ’s label corresponding to the identifiers of all nodes in and the associated distances that are known from solving the RSSP problem. Second, for a given label of some destination create-oracle-function outputs the following function


Note that in the above equation we set and for . The -hop distances are known since knowns , the distances are known from solving the RSSP problem on and the distances between pairs are part of the label , thus can be computed by .

Exchanging the computed distance oracles between neighbors problem gives us sufficient information to solve the routing problem. Roughly speaking, the next node on a shortest path is given by a neighbor that minimizes the distance to the destination of the packet (a little bit of care has to be taken for proving this, though).

More precisely, the subroutine create-routing-function will first do a single round of communication so that each node learns the oracle function of each of its neighbors in the local network. Then we use this knowledge to pass the packet only to a neighbor whose distance oracle to the target decreases by the weight of that edge (pick an arbitrary one if there is more than one).


Note that additional knowledge of for is sufficient to compute . It remains to analyze the resulting algorithm and give the remaining correctness arguments, which we do in the proof of the following theorem. Note that here we obtain a trade off between label size and the running time, which we formalize with a parameter .

Theorem 2.5 ().

For any exact distance oracles and stateless routing schemes with labels of size bits can be computed in rounds in the model w.h.p.


Note that for the problem becomes trivial (any graph problem can be solved in rounds in ), so we assume . We choose and as in Lemma 2.1, then the runtime follows from Lemma 2.4. The number of sampled nodes is (a simple application of Lemma A.1). As the label contains information of size bits for each node (recall that distances are polynomial in ), requires bits. We can shift the factor from the label size into the runtime (where it is absorbed by the notation) with a substitution .

We already established in the algorithm description that the required information to compute , and is present at the node from executing explore() and solve-rssp. It remains to show that . If there is a shortest --path with at most hops, then the first argument of the outer function in Equation (1) corresponds to . If all shortest --paths have more than hops then there must be a node on one such path by Lemma 2.1, which means that the second argument of the outer function in Equation (1) corresponds to .

Regarding the routing function, we observe that is the next node on some shortest path from to if and only if , which is equivalent to as are exact distance oracles. Since is connected, there is always a neighbor of on some shortest path to so the set in Equation (2) is not empty. By always choosing the next node on some shortest path from the current node to (c.f., Equation (2)), we will naturally obtain a shortest --path overall. Note that the obtained routing scheme is oblivious to previous routing decisions. ∎

2.4. Approximate Solutions

Note that if we do not want to compromise on the running time the label size in Theorem 2.5 is . However, we can compromise on the stretch in order to significantly decrease the label size as we show in the following.

Subroutine create-label of computes the much smaller label , where corresponds to the identifier and distance of the closest node in .

Given some label then node outputs the following function in subroutine create-oracle-function, which is the shorter of the -hop distance to and the shortest --path that transits .


We start by showing that the oracle function from above gives a decent approximation (with proofs similar to those for approximations for the single source shortest paths problem in [AHK20]).

Lemma 2.6 ().

For it is w.h.p. (for from Eq. (3)).


If there is a shortest --path with at most hops, then we actually have (c.f., first argument of Equation (3)) analogous to the proof of Theorem 2.5. Else, all shortest --paths have more than hops. Then by Lemma 2.1 w.h.p. there must be a node such that

Let from the label . Then

Then, for the second argument of Equation (3) we get

c.f., Equation (3)
triangle ineq.
by ineq. (ii)

We can also express the approximation as additive error depending on largest weight on some --path and the hop distance between sampled nodes on that shortest path.

Lemma 2.7 ().

For let be the largest weight on some shortest --path. Then w.h.p. (for from Eq. (3)) where denotes the value from Lemma 2.1.


Fix a shortest --path . Let be the largest weight on . By Lemma 2.1 there is a sampled node on with w.h.p.212121Note for the union bound to work, Lemma 2.1 is phrased such that for each pair there is just one shortest --path (out of possibly exponentially many) which has a sampled node at last every hops. In fact in the proof we can fix one specific such path for each pair ourselves and the union bound still works. This implies . Let (from the label ). By definition of we have . Then we get

c.f., Equation (3)
triangle ineq.

Similar to Equation (2), we define as a node that is adjacent to such that the oracle function decreases by at least the weight of the corresponding edge, i.e., (we will show that there is always a neighbor of that fulfills these criteria and if several do, we choose one arbitrarily). Then subroutine create-routing-function outputs

Lemma 2.8 ().

For any the routing functions in Equation (3) induce a --path with w.h.p.


Assume a packet is forwarded along a path containing the nodes with (whereas we abbreviate and we have ) then we can upper bound with a telescoping sum

It remains to prove the existence of . For that we show that each node has a neighbor that fulfills the requirement . We have to unwrap the definition of to make this argument.

Case 1: if (first argument of the function in Equation (3)), then this means there is a -hop path from to that fulfills . Clearly, the next on is one hop closer to and also sees the sub-path within its ball so by Equation (3) ’s distance estimate must be at least as good: .

Case 2: if , then this means our distance estimation via is at least as good as the -hop distance to (c.f., second argument of in Equation (3)). Let be a path concatenated from two shortest paths from to and from to , respectively.

Note that , as otherwise there would be a node , on by Lemma 2.1, which would be closer to thus contradicting the definition in the label . This means that we can assume since otherwise we can apply case 1. Let be the next node on (which contains at least the 2 nodes and , but is possible). Then

The following Theorem gives a summary of the obtained approximation algorithms for which we utilize the previous lemmas.

Theorem 2.9 ().

Distance oracles and stateless routing schemes with label-size can be computed in w.h.p. and

  • stretch 3 in rounds on weighted graphs,

  • stretch for in