On the Power of Preprocessing in Decentralized Network Optimization

TL;DR

This paper investigates how preprocessing can enhance the efficiency of local algorithms in decentralized network optimization, revealing both significant speedups and fundamental limitations, with implications for scalable communication networks.

Contribution

It introduces a model for analyzing the benefits and limits of preprocessing in decentralized algorithms, providing approximation bounds and demonstrating asymptotic optimality of speedups.

Findings

Preprocessing enables significant speedups in network problems.

There are strict limitations on preprocessing benefits in certain scenarios.

Preprocessing can help bypass runtime barriers despite link failures.

Abstract

As communication networks are growing at a fast pace, the need for more scalable approaches to operate such networks is pressing. Decentralization and locality are key concepts to provide scalability. Existing models for which local algorithms are designed fail to model an important aspect of many modern communication networks such as software-defined networks: the possibility to precompute distributed network state. We take this as an opportunity to study the fundamental question of how and to what extent local algorithms can benefit from preprocessing. In particular, we show that preprocessing allows for significant speedups of various networking problems. A main benefit is the precomputation of structural primitives, where purely distributed algorithms have to start from scratch. Maybe surprisingly, we also show that there are strict limitations on how much preprocessing can help in different scenarios. To this end, we provide approximation bounds for the maximum independent set problem---which however show that our obtained speedups are asymptotically optimal. Even though we show that physical link failures in general hinder the power of preprocessing, we can still facilitate the precomputation of symmetry breaking processes to bypass various runtime barriers. We believe that our model and results are of interest beyond the scope of this paper and apply to other dynamic networks as well.

Figures

Equations

$$V=\bigl{\{}v_{x}:v\in V_{Q},x\in\{0,1\}\bigr{\}}$$

$$\begin{split}E(F)&=\bigl{\{}\{u_{x},v_{1-x}\}:\{u,v\}\in F,x\in\{0,1\}\bigr{\}}\cup{}\\ &\phantom{{}={}}\bigl{\{}\{u_{x},v_{x}\}:\{u,v\}\in E_{Q}\setminus F,x\in\{0,1\}\bigr{\}}.\end{split}$$

$$H=(V,E(\varnothing )\cup E(E_Q)),G_1=G(\varnothing ),G_2=G(E).$$

$$G_1^{\prime }$$

$$G_2^{\prime }$$

$${\varphi }_i(v_x)=\{\begin{array}{ll}{v}_x& \text{if }{C}_i(v)=0,\\ v_{1-x}& \text{if }{C}_i(v)=1.\end{array}$$

$$E(F_1)$$

$$E(F_2)$$

Full text

• On the Power of Preprocessing in Decentralized Network Optimization

Klaus-Tycho Foerster  $\cdot$  University of Vienna, Austria

Juho Hirvonen  $\cdot$  Aalto University, Finland

Stefan Schmid  $\cdot$  University of Vienna, Austria

Jukka Suomela  $\cdot$  Aalto University, Finland

• Abstract. As communication networks are growing at a fast pace, the need for more scalable approaches to operate such networks is pressing. Decentralization and locality are key concepts to provide scalability. Existing models for which local algorithms are designed fail to model an important aspect of many modern communication networks such as software-defined networks: the possibility to precompute distributed network state. We take this as an opportunity to study the fundamental question of how and to what extent local algorithms can benefit from preprocessing. In particular, we show that preprocessing allows for significant speedups of various networking problems. A main benefit is the precomputation of structural primitives, where purely distributed algorithms have to start from scratch. Maybe surprisingly, we also show that there are strict limitations on how much preprocessing can help in different scenarios. To this end, we provide approximation bounds for the maximum independent set problem—which however show that our obtained speedups are asymptotically optimal. Even though we show that physical link failures in general hinder the power of preprocessing, we can still facilitate the precomputation of symmetry breaking processes to bypass various runtime barriers. We believe that our model and results are of interest beyond the scope of this paper and apply to other dynamic networks as well.

• © 2018 IEEE. This is the authors’ version of a paper that will appear in the Proceedings of the IEEE International Conference on Computer Communications (INFOCOM 2019).

1 Introduction

1.1 Context: Decentralization for Scalability

Locality, the idea of avoiding global collection of distributed network state and decentralizing the operation of networked systems, is a fundamental design principle for scalability. A more local operation cannot only reduce communication overheads but also allow to react faster to local events—an important aspect given the increasingly stringent latency and dependability requirements in future communication networks. Given the quickly increasing scale of communication networks, also due to the advent of new applications such as the Internet-of-Things, the importance of local approaches to networking is likely to increase.

Designing local (i.e., decentralized) algorithms however can be challenging and face a tradeoff: while a more local network operation requires less coordination (and less overhead) between neighboring domains, hence improving scalability, a more limited local view may lead to suboptimal decision making: compared to a global approach to network optimization, a decentralized architecture may be subject to a “price of locality”.

Local algorithms have been studied intensively over the last decades, and today, we have a fairly good understanding of their opportunities and limitations [30, 36, 6]. Highly efficient distributed algorithms are known for many network optimization problems, sometimes even achieving an “ideal scalability”: their performance, i.e., runtime, is constant, independently of the network size (which could even be infinite) [36]. However, it is also known that for many fundamental network optimization problems, e.g., related to spanning tree [31] or shortest path [19] computations, or minimizing congestion [10], designing good decentralized optimization algorithms is impossible [22]: in order to achieve non-trivial approximations of the global optimum, non-local coordination is required.

1.2 Motivation: Improving Scalability with Preprocessing

Our work is motivated by the observation that existing models for the design of distributed network algorithms, originally developed for ad-hoc and sensor networks, do not account for a key aspect of modern, large wired communication networks: the possibility to preprocess distributed network state. In ad-hoc networks, the network topology is typically assumed to be unknown in the beginning, and depend, e.g., on the (unknown) node locations and wireless communication channels. The network topology hence needs to be discovered in addition to performing optimizations. In contrast, most wired networks today have a fairly static and known (to the operator) network topology, which can hence be assumed to be given. Network optimization algorithms here are mainly concerned with the fast reaction to new events, e.g., finding optimal routes based on the current traffic patterns. While the topology of wired networks may change as well, especially link additions but also link failures happen less frequently and at different time scales.

This introduces an opportunity for preprocessing and calls for a radically new model: decentralized and local algorithms reacting to changes of the demand, network flows, or even failures, may rely on certain knowledge of the physical network topology, based on which distributed network state can be precomputed: this information can later “support” local algorithms during their local optimizations.

Indeed, enhancing classic, most basic local coordination problems with preprocessing appears to be a game changer: distributed algorithms in traditional models often require symmetry breaking mechanisms whose complexity alone is in the same order as solving the entire optimization problem [33]. With preprocessing, such symmetries can trivially be broken ahead of time.

1.3 Case Study: Scalable SDNs

As an example and case study, let us consider emerging Software-Defined Networks (SDNs). While there is now a wide consensus on the benefits of moving toward more software-defined communication networks, which are increasingly adopted not only in datacenters [35] but also in wide-area networks [20, 38], one question becomes increasingly pressing [13]: how to deploy SDNs at scale? In the near future, large-scale SDNs may carry millions of flows and span thousands of switches and routers distributed across a large geographic area.

A canonical solution to support large-scale deployments while ensuring fast control plane reaction to dataplane events (close to their origin), is to partition the control plane [13] and leverage locality: different controller instances are made responsible for a separate portion of the topology. These controllers may then exchange e.g. routing information with each other to ensure consistent decisions. However, SDN controllers face more general problems than just routing, as they also need to support advanced controller applications, including involving distributed state management.

Clearly, SDNs are very different from the models usually studied in the context of ad-hoc networks: an operator usually has full knowledge of the physical connectivity of its networks, but needs clever algorithms that allow distributed controllers to locally react to new demands. In principle, these distributed controllers can leverage such additional knowledge on the topology and precompute distributed network state.

1.4 Contributions

Our work is motivated by the observation that existing algorithmic locality models in the literature are not a good fit for modern large-scale wired networks such as SDNs whose distributed control plane may leverage precomputed network state. Accordingly, we investigate a novel model in which distributed decision making can be supported by centralized preprocessing, present and discuss different algorithmic techniques, and derive lower bounds.

Indeed, we find several most fundamental problems where significantly faster and hence more scalable network algorithms can be devised than in traditional models. In particular, we show that preprocessing allows us to run many centralized algorithms efficiently in a distributed setting: e.g., compared to existing work, we can achieve an almost exponential speedup for problems such as maximal independent set, as well as for approximation schemes of its optimization variant. Furthermore, we can show that for locally checkable labellings, all symmetry breaking problems collapse to constant time complexity.

However, surprisingly, we also identify inherent limitations of the usefulness of precomputations; even seemingly simple problems still require linear runtimes. Moreover, we also prove that our provided approximation schemes are essentially the best one can hope for: faster algorithms come at the price of worse approximation ratios.

Last in this list, we study the impact of physical link failures on the power of preprocessing. Unlike prior work, we assume that the link failures can be arbitrary, i.e., only a small part of the resulting physical topology could remain, possibly in many disconnected parts. While we formally prove that this model inherently limits the general power of precomputation, we can still speed up various distributed algorithms for restricted graph classes respectively bounded node degrees.

1.5 Organization

The remainder of this paper is organized as follows. In Section 2, we begin our investigation by providing a formal model that captures the capabilities of preprocessing, along with defining some key notation. Section 3 then provides two introductory examples to outline the power respectively limitations of preprocessing. We next show in Section 4 how a recently introduced problem class of central computation can be turned distributed with small overhead, by leveraging preprocessing. Section 5 investigates the power of preprocessing in an important class of locally verifiable problems, and Section 6 studies approximation of maximum independent sets. We further prove lower bounds in Section 7, providing matching bounds for the algorithmic results of the previous section. Related work is discussed in Section 9, followed by concluding remarks in Section 10.

2 Model

Let us first revisit the $\mathsf{LOCAL}$ model which is used predominantly today to design and analyze distributed network algorithms [30]. In the $\mathsf{LOCAL}$ model the communication structure is given by an undirected graph $G=(V,E)$, where each node $v\in V$ is a computer with a unique identifier. The nodes can exchange messages between neighbors across edges in each communication round, where in parallel each node can send and receive a message to/from each neighbor, and afterward update its local state. Before the first communication round, each node is provided with an input that defines the problem instance. The running time of an algorithm is the number of rounds needed until all nodes stopped, i.e., they announce a final output and no longer communicate.

In this paper, we are interested in the benefits of extending the $\mathsf{LOCAL}$ model with an opportunity of preprocessing the network topology. We will refer to our model as the $\mathsf{SUPPORTED}$ model [33]. In the $\mathsf{SUPPORTED}$ model the communication structure is given by an undirected connected graph $H=(V(H),E(H))$ (the support graph), where again each node111In the context of SDNs (Section 1.3), each node in the $\mathsf{SUPPORTED}$ model could correspond to a controller domain. is a computer with a unique identifier. However, the problem instance (the logical state) is defined on a subgraph $G\subseteq H$, where $G$ is called the input graph $G=(V,E)$ and inherits the node identifiers of $H$. Computation in the $\mathsf{SUPPORTED}$ model now proceeds in two steps: $(1)$ As a preprocessing phase, the nodes may compute any function depending on $H$ and store their output in local memory. Next, $(2)$ the nodes are tasked to solve a problem on the input graph $G$ in the $\mathsf{LOCAL}$ model, where additionally the preprocessing from $(1)$ and the communication infrastructure of $H$ may be used. The running time $t$ of an algorithm in the $\mathsf{SUPPORTED}$ model is measured in the number of rounds needed in step $(2)$, also denoted as $\mathsf{SUPPORTED}(t)$. We will use analogous notation also for other models, e.g., $\mathsf{LOCAL}(t)$.

3 Potential and Limitations

To provide intuition, we first present an example that shows the potential of the $\mathsf{SUPPORTED}$ model to overcome inherent limitations of the $\mathsf{LOCAL}$ model.

Fast symmetry breaking.

One of the most important problems [30] in the $\mathsf{LOCAL}$ model is coloring, i.e., providing each node with a color different to its neighbors’, with the goal of using a small color palette.222For a fast (inefficient) coloring solution, each node could assign its unique identifier, e.g., its MAC-address, as its color, requiring $n$ colors in total. Such symmetry breaking is often the first step for more advanced problems, but also has direct applications, such as, e.g., in scheduling. Even in very simple topologies such as a ring, computing a 3-coloring in the $\mathsf{LOCAL}$ model takes non-constant time [23], and 2-coloring even requires $\Omega(n)$ rounds. By using the power of precomputation, we can assign an efficient coloring based on the support graph ahead of time, which is then still valid on the input graph. As such, the $\mathsf{SUPPORTED}$ model can significantly speed up the computation of many $\mathsf{LOCAL}$ algorithms if the support graph allows for a coloring with few colors. We note that this is just an introductory example, we cover more complex cases starting in the following Section 4.

Not everything can be precomputed.

However, there are also inherent limitations. For example in leader election, the task is to provide each connected component with a single coordinator. In the $\mathsf{LOCAL}$ model, a leader can be elected in time equivalent to the diameter of such a component, assuming identifiers are present [5]. From a theoretical point of view, the $\mathsf{SUPPORTED}$ model cannot improve this time bound: as the input graph can be any subgraph of the support graph, nodes must first discover their connected component. If no leader exists, a new one must be elected, and if multiple leaders exist, they must coordinate with each other to declare a unique leader, possibly over long distances. For an extreme example, consider a line as a support topology, where the input graph can consist of many disconnected components of large sizes.

4 Exploiting the Locality of Global Problems

The $\mathsf{SLOCAL}$ model.

Many networking problems are slow to solve from scratch in a distributed setting. For example, the best known algorithm for maximal independent set requires $2^{O(\sqrt{\log n})}$ rounds in the $\mathsf{LOCAL}$ model [29], but the problem is rather trivial in a centralized setting: go through the nodes sequentially, adding them to the independent set if none of their neighbors are in it.

The maximal independent set problem has a low locality (just the node’s directed neighbors are important), but still defies fast distributed algorithms. Recent work formalized this notion of locality from a globalized point of view, coined the $\mathsf{SLOCAL}$ model [16]. In the $\mathsf{SLOCAL}$ model, the locality $t$ is defined as the radius $t$-neighborhood a node may use to compute its output—where the nodes are processed sequentially in an arbitrary order. For example, the maximal independent set problem is therefore in $\mathsf{SLOCAL}$ with locality $t=1$.

An $\mathsf{SLOCAL}$ simulation.

Ghaffari et al. [16] provided an approach to transforming any algorithm from the $\mathsf{SLOCAL}$ model into a purely distributed algorithm by simulating it in the $\mathsf{LOCAL}$ model. This is done by computing a locally simulatable execution order for the $\mathsf{SLOCAL}$ algorithm: each node $v$ must know on what other nodes’ output does $v$ need to wait on before computing its output?

We can adapt their techniques to also apply to the $\mathsf{SUPPORTED}$ model:

Theorem 1**.**

An $\mathsf{SLOCAL}$ algorithm with locality $t$ can be simulated in the $\mathsf{SUPPORTED}$ model in time $O(t\cdot\operatorname{poly}\log n)$.

Proof.

Ghaffari et al. [16] show how network decompositions can be leveraged to compute dependencies of bounded depth: as some graphs, e.g., the complete graph, require dependency chains of length $\Omega(n)$, it can be useful to also incorporate communication between the nodes. The idea is that the nodes learn all their nearby dependency chains. For example, in the complete graph, one round suffices to gather all information. With this modification, every graph has an ordering of depth $O(\operatorname{poly}\log n)$, if the nodes are allowed to communicate within a distance of $O(\operatorname{poly}\log n)$ [16].

We start with the case of $G=H$. After providing such an ordering, every $\mathsf{SLOCAL}$ algorithm with locality $t$ can be run in time $O(t\cdot\operatorname{poly}\log n)$ in the $\mathsf{LOCAL}$ model, by simulating executions of lower priority in polylogarithmic distance. We can provide the ordering in the $\mathsf{SUPPORTED}$ model in the precomputation phase, finishing the case of $G=H$.

We next cover the remaining case of $G\neq H$. Observe that a dependency chain is still valid even if edges are deleted, as nodes just need to respect the computation of all neighbors of lower priority — but under edge deletions, a node might need longer to learn about previously nearby dependency chains. However, in the $\mathsf{SUPPORTED}$ model, the edges are not physically deleted333We study this model variant in §8, coined passive $\mathsf{SUPPORTED}$ model., but rather just not part of the problem graph anymore, still available for communication purposes. The simulation approach therefore still holds for $G\neq H$. ∎

Hence, we can obtain a maximum independent set in time $O(\operatorname{poly}\log n)$ in the $\mathsf{SUPPORTED}$ model, as it had an $\mathsf{SLOCAL}$ locality of $1$. Ghaffari et al. [16] define the class $\mathsf{PSLOCAL}$ as $\mathsf{SLOCAL}$($\operatorname{poly}\log n$). We obtain the following corollary:

Corollary 2**.**

$\mathsf{PSLOCAL}{}\subseteq\mathsf{SUPPORTED}(\operatorname{poly}\log n)$.

Separation of $\mathsf{SLOCAL}$ and $\mathsf{SUPPORTED}$ model.

As we have seen, the $\mathsf{SLOCAL}$ model can be simulated in the $\mathsf{SUPPORTED}$ model with polylogarithmic overhead. Under some additional assumptions, the converse it not true:

• •

Degree/colorability restrictions of the support graph $H$:

If we restrict the support graph $H$ to be 2-colorable (or to be of maximum degree 2), then we can precompute a 2-coloring which is also valid for any subgraph $G\subseteq H$. Computing a 2-coloring on $G$ in the $\mathsf{SLOCAL}$ model however has a locality of $\Omega(n)$.

• •

Unknown range of IDs / network size: Computing an upper bound on the network size requires a locality of $\Omega(n)$ in the $\mathsf{SLOCAL}$ model, but is trivial with preprocessing.

• •

Inputs already known in the preprocessing phase:

Similarly, if some problem inputs are already known ahead of time in the $\mathsf{SUPPORTED}$ model, large speedups can be obtained in comparison to the $\mathsf{SLOCAL}$ model.

However, we leave it as an open question if there is a strict (e.g., beyond polylogarithmic) separation between the $\mathsf{SLOCAL}$ and $\mathsf{SUPPORTED}$ model without the above assumptions.

5 Locally Checkable Labellings

Locally checkable labellings, first introduced by Naor and Stockmeyer [26], are a family of problems that can be efficiently verified in a distributed setting. They include fundamental problems like maximal independent set, maximal matching, $(\Delta+1)$-coloring, and $(2\Delta-1)$-edge coloring.

More formally, let $\Sigma$ and $\Gamma$ denote a finite sets of input and output labels, respectively. A graph problem consists of a set of labelled graphs with some constant maximum degree $\Delta$. A problem $\Pi$ is locally checkable if there exists a constant $r$ and a distributed algorithm $A$ with running time $r$ such that given a labelling $\lambda\colon V(G)\rightarrow(\Sigma\times\Gamma)$, we have that $A$ outputs yes at every node if and only if $(G,\lambda)\in\Pi$. In particular, if $(G,\lambda)\notin\Pi$, at least one node outputs no.

Theorem 3**.**

Every $\mathsf{LCL}$ in $\mathsf{LOCAL}(o(\log n))$ can be solved in time $O(1)$ in the $\mathsf{SUPPORTED}$ model.

The proof follows the idea of Chang et al. [11]: nodes compute a coloring that locally looks like a unique identifier assignment, but from a smaller space. Then we simulate a $\mathsf{LOCAL}$ algorithm on this identifier setting and it must terminate fast.

Proof.

Let $A$ be an algorithm for an $\mathsf{LCL}{}$ $P$ with running time $T(n)=o(\log_{\Delta(G)}n)$ in the $\mathsf{LOCAL}$ model (here $T(n)$ might include functions of $\Delta(G)$, i.e., of the maximum degree of the input graph, but these are constants). Without loss of generality we assume that $P$ can be checked with radius 1 (this is a standard transformation—nodes encode also the outputs of their neighborhood as necessary).

Given an input graph $G$ with maximum degree $\Delta=\Delta(G)$, the ball of radius $t$ around each node holds at most $1+\Delta(\Delta-1)^{t-1}$ nodes. We want to find the smallest $n_{0}$ such that any nodes of $G$ at distance at most $2T(n_{0})+2$ can be colored with different colors from $[n_{0}]$. By definition of $T(n)$ we can find a constant $n_{0}$ such that $\Delta^{2T(n_{0})+2}+1\leq n_{0}$, that is, we can greedily color nodes with locally unique colors.

Given a support $H$ of size $N$, compute an $n_{0}$-coloring $\phi$ of distance $(2T(n_{0})+1)$ of $H$. This can be done without communication given the support. Now we apply $A$ with the coloring $\phi$ on the input graph $G$. This can be done in time $T(n_{0})=O(1)$. As $G$ is a subgraph of $H$, the coloring $\phi$ is still a proper distance $2T(n_{0})+2$-coloring of $G$. Since each node sees only values from $[n_{0}]$ inside its $T(n_{0})$-neighborhood and each value is unique, the algorithm is well defined on $G$ with $\phi$ representing the identifiers of the nodes. Finally, since locally in each 1-neighborhood the output of the nodes looks identical to some execution in a graph of size $n_{0}$, the output must be consistent with the legal outputs of $P$. Since $P$ is an $\mathsf{LCL}$, an output that is correct everywhere locally is correct also globally. ∎

In the standard $\mathsf{LOCAL}$ model locally checkable labellings can have three types of complexities: trivial problems solvable in constant time, symmetry breaking problems with complexity $\Theta(\log^{*}n)$, and problems with complexity $\Omega(\log n)$. Theorem 3 implies that all symmetry breaking problems collapse to constant time in the $\mathsf{SUPPORTED}$ model.

We are unable to establish the existence of “intermediate” $\mathsf{LCL}$ problems for the $\mathsf{SUPPORTED}$ model [8, 11, 15], in particular a lower bound of $\Omega(\log n)$ for an $\mathsf{LCL}$ in $\mathsf{LOCAL}(\operatorname{poly}\log n)$. We do show that there are problems that are hard despite the power of the support.

Consider the problem of sinkless orientation: each edge must be oriented so that every node has an outgoing edge. Usually this problem is defined so that nodes with degree 2 or less can be sinks. We consider the variant where every node with degree at least 2 must not be a sink.

Theorem 4**.**

Finding a sinkless orientation requires $\Omega(n)$ time in the $\mathsf{SUPPORTED}$ model.

Proof.

Consider the following support $H$ on $N=6n$ nodes. Let $P_{i}=(v_{i,1},v_{i,2},\dots,v_{i,n})$, for $i\in\{1,2,\dots,6\}$, denote six paths of length $n$. Add edges $\{v_{1,1},v_{2,1}\},\{v_{1,1},v_{3,1}\},\{v_{1,n},v_{4,1}\},\{v_{1,n},v_{5,1}\}$ and edges $\{v_{6,1},v_{2,n}\},\{v_{6,1},v_{3,n}\},\{v_{6,n},v_{4,n}\},\{v_{6,n},v_{5,n}\}$ between these paths.

Observe that on a cycle a sinkless orientation is a consistent orientation: each node must have exactly one incoming and one outgoing edge.

Now consider the cycles $C_{1}=(v_{1,1},P_{2},v_{6,1},P_{3})$ and $C_{2}=(v_{1,n},P_{4},v_{6,n},P_{4})$ and assume that these are maximal connected components of $G$. Now both cycles must be oriented consistently in any valid solution. Without loss of generality assume that an algorithm $A$ orients path $P_{2}$ from $v_{1,1}$ to $v_{6,1}$, path $P_{3}$ from $v_{6,1}$ to $v_{1,1}$, path $P_{4}$ from $v_{1,n}$ to $v_{6,n}$, and path $P_{5}$ from $v_{6,n}$ to $v_{1,n}$.

Now consider a graph $G^{\prime}$ where the cycle $(P_{2},P_{1},P_{4},P_{6})$ forms a maximal connected component. If paths $P_{2}$ and $P_{4}$ are oriented as in $G$, then the solution cannot form a consistent orientation. Therefore either node $v_{2,\lceil n/2\rceil}$ or node $v_{4,\lceil n/2\rceil}$ must change its output between $G$ and $G^{\prime}$. Since distinguishing between $G$ and $G^{\prime}$ requires $\lceil n/2\rceil$ rounds for these nodes, we conclude that solving sinkless orientation in the $\mathsf{SUPPORTED}$ model requires $\Omega(n)$ rounds. ∎

6 Maximum Independent Set

We show how to find large independent sets in logarithmic time in the $\mathsf{SUPPORTED}$ model. This leads to an approximation scheme in graphs that have independent sets of linear size.

Let $\alpha(G)$ denote the fraction of nodes in the maximum independent set of graph $G$.

Theorem 5**.**

There is an algorithm that finds an independent set of size $(\alpha(G)-\epsilon)n$, for any $\epsilon>0$, in time $O(\log_{1+\varepsilon}n)$ in the $\mathsf{SUPPORTED}$ model.

Proof.

To prove this we use a standard ball growing argument [24, 16] which essentially states that a graph can only expand for a logarithmic number of hops. We denote by $B_{t}(v)$ the $t$-hop neighborhood of node $v$. Let $H$ be a graph: for any $\varepsilon>0$ and each node $v\in V(H)$, there exists a radius $r\leq\log_{1+\varepsilon}n$ such that $|B_{r+1}(v)|<(1+\varepsilon)|B_{r}(v)|$. To see this, assume the contrary: since $|B_{i+1}(v)|\geq(1+\varepsilon)|B_{i}(v)|$, for $i$ up to $r>\log_{1+\varepsilon}n$, we have that $|B_{r}(v)|\geq(1+\varepsilon)^{r}>(1+\varepsilon)^{\log_{1+\varepsilon}n}=n$, a contradiction.

In the preprocessing phase we decompose the graph into parts that have logarithmic diameter and a small boundary. Then the problem can be solved optimally in each such component and fixed on the boundaries.

Consider an arbitrary node $v_{1}\in V(H)$ and find the smallest radius $r_{1}$ such that $|B_{r+1}(v_{1})|<(1+\varepsilon)|B_{r}(v_{1})|$ as observed previously. Define $C_{1}=B_{r+1}(v_{1})$ and remove $C_{1}$ from $H$. By definition, at most a fraction of $\varepsilon^{\prime}=\varepsilon/(1+\varepsilon)$ nodes in $B_{r+1}(v_{1})$ are connected to $G\setminus B_{r+1}(v_{1})$. Continue by selecting another node $v_{2}$ and finding the smallest $r_{2}$ such that the boundary of $B_{r+1}(v_{2})$ has an $\varepsilon^{\prime}$-fraction of the nodes. Again put these nodes into cluster $C_{2}$ and remove them from $H\setminus C_{1}$. Proceed in this fashion until all nodes (neighborhoods) have been allocated to a cluster.

Since at each step each cluster has an $\varepsilon^{\prime}$-fraction of nodes on the boundary (in $B_{r+1}(v)\setminus B_{r}(v)$), we have at least a $(1-\varepsilon^{\prime})$-fraction of nodes strictly inside the clusters (that is, not on the boundary). Denote by $\bar{C_{i}}$ the inner nodes of cluster $C_{i}$.

Now given the input graph $G$, each node $v$ in cluster $C_{i}$ gathers the subgraph of $G$ induced by $C_{i}$. Then all nodes use the same algorithm to find an optimal maximum independent set of $C_{i}$, and put themselves in the (independent) set $I$ if they are included in this solution. This can be done using local computation, since the subgraph is known to all nodes.

Finally, there are at most $\varepsilon^{\prime}n$ nodes that are connected to two clusters. In the worst case all of these are adjacent to another node in the chosen set $I$. By removing each such node that has a neighbor in $I$ with a smaller identifier we make $I$ independent. Let $I^{*}$ denote a maximum independent set of $G$ and $I[S]$ a set $I$ restricted to a subgraph $S$. Since $I^{*}[C_{i}]$ is an independent set of $C_{i}$, we have that $|I[C_{i}]|\geq|I^{*}[C_{i}]|$ for all $C_{i}$. Therefore $I$ has size at least $|I^{*}|-\varepsilon^{\prime}n$. ∎

Now if the family of graphs from which the support is drawn has a linear lower bound on the size of the maximum independent set, the solution $I$ constitutes a $(1+\varepsilon)$-approximation of $I^{*}$.

Corollary 6**.**

Maximum independent set can be approximated to within factor $(1+\epsilon)$, for any $\epsilon>0$, on graphs of constant maximum degree in time $O(\log_{1+\varepsilon}n)$ in the $\mathsf{SUPPORTED}$ model.

Note that the proof generalizes to a larger family of optimization problems: essentially we required that the global score of a solution is a sum of local scores, and that the nodes of the boundary constitute only a small fraction of the weight of the full solution. As an example, maximum cut and maximum matching are not problems of this type, as the input graph could only contain edges on the boundaries of the clusters, making the precomputation unhelpful.

The above results have the best possible running time as a function of $n$: finding an independent set of size $\omega(\frac{n\log\Delta}{\Delta})$ requires logarithmic time, as will be shown in Section 7. Ghaffari et al. [16] used the same ball growing idea to give $\mathsf{SLOCAL}$ algorithms for computing $(1+\varepsilon)$-approximations of covering and packing ILPs in time $O(\log n/\varepsilon)$. Their algorithm can be simulated via Theorem 1 in time $O(\operatorname{poly}\log n)$.

Note that we are abusing the unlimited computational power of the $\mathsf{SUPPORTED}$ model: solving each cluster optimally is an NP-hard problem.

7 Lower Bounds

In the previous section, we saw that maximum independent sets can be approximated well in the $\mathsf{SUPPORTED}$ model in logarithmic time. To complement this result, we now give a lower bound that shows that any sublogarithmic-time algorithm in the $\mathsf{SUPPORTED}$ model necessarily results in a poor approximation ratio:

Theorem 7**.**

Maximum independent set cannot be approximated by a factor $o(\Delta/\log\Delta)$ in time $o(\log_{\Delta}n)$ in the $\mathsf{SUPPORTED}$ model.

This bound is tight in the sense that it can be matched in triangle-free regular graphs: Shearer [34] noted that the randomized greedy algorithm finds an independent set of size $O(\frac{\ln d}{d}n)$, and this can be approximated with a small loss in randomized constant time in the $\mathsf{LOCAL}$ model, for example using the method of random priorities due to Nguyen and Onak [27].

More precisely, we analyze the expected approximation ratio here. To prove the result, assume that there is a family of (randomized) algorithms $\mathcal{A}_{d}$ such that for each even $d$ algorithm $\mathcal{A}_{d}$ finds a factor $\alpha_{d}$ approximation of a maximum independent set in any graph for which we have a $d$-regular support. Furthermore, assume that $\mathcal{A}_{d}$ runs in time $T(n,d)=o(\log_{d}n)$ in the $\mathsf{SUPPORTED}$ model. To reach a contradiction, assume that $\alpha_{d}=o(d/\log d)$.

Fix a $d=2k$. Using the probabilistic method, we can find a sufficiently large $n_{Q}$ such that there exists a $k$-regular graph $Q=(V_{Q},E_{Q})$ with $n_{Q}$ nodes with the following properties [14, 39, 1]:

the girth of $Q$ is larger than $2T(2n_{Q},d)+1$, 2. 2.

there is no independent set with at least $n_{Q}/(2\alpha_{d})$ nodes.

We will consider graphs with $n=2n_{Q}$ nodes: for each original node $v\in V_{Q}$, we will have two copies $v_{0}$ and $v_{1}$. Let

[TABLE]

be the set of all copies. For each $F\subseteq E_{Q}$ we define

[TABLE]

For each $F$, the graph $G(F)=(V,E(F))$ is a double cover of $Q$; intuitively, $F$ tells which pair of edges goes “straight” and which goes “across”. In particular, we are interested in the following graphs (see Figure 1):

[TABLE]

Here graph $G_{1}\cong 2Q$ consists of two copies of $Q$ and graph $G_{2}\cong Q\times K_{2}$ is the bipartite double cover of $Q$. By construction, there is no maximum independent set in $G_{1}$ with at least $n/(2\alpha_{d})=n_{Q}/\alpha_{d}$ nodes. However, the largest independent set of $G_{2}$ has at least $n/2=n_{Q}$ nodes, as $\{v_{0}:v\in V_{Q}\}$ is an independent set.

Now we will construct random graphs $G_{1}^{\prime}$ and $G_{2}^{\prime}$ as follows (see Figure 1). For each $i\in\{1,2\}$ and $v\in V_{Q}$, choose a label $C_{i}(v)\in\{0,1\}$ uniformly at random. Then let $X_{i}\subseteq E_{Q}$ be the set of edge $\{u,v\}\in E_{Q}$ with $C_{i}(u)\neq C_{i}(v)$. That is, $C_{i}$ is a uniform random cut of $Q$, and $X_{i}$ is the set of cut edges w.r.t. $C_{i}$. Define

[TABLE]

First, we will argue that from a global perspective, graphs $G_{1}^{\prime}$ and $G_{2}^{\prime}$ are different.

Lemma 8**.**

Graph $G_{1}^{\prime}$ is isomorphic to $G_{1}$ and graph $G_{2}^{\prime}$ is isomorphic to $G_{2}$.

Proof.

For each cut $C_{i}$ of graph $Q$, define the bijection $\phi_{i}\colon V\to V$ as follows:

[TABLE]

That is, $\phi_{i}$ exchanges the labels of the copies of $v\in V$ whenever $C_{i}(v)=1$. In particular, $\phi_{i}$ exchanges labels at exactly one endpoint of $e\in E_{Q}$ iff $e$ is a cut edge w.r.t. $C_{i}$. By construction, we have

[TABLE]

That is, $\phi_{1}$ is a graph isomorphism from $G_{1}$ to $G_{1}^{\prime}$, and similarly $\phi_{2}$ is a graph isomorphism from $G_{2}$ to $G_{2}^{\prime}$. ∎

Corollary 9**.**

The maximum independent set of $G_{1}^{\prime}$ has fewer than $n_{Q}/\alpha_{d}$ nodes and the maximum independent set of $G_{2}^{\prime}$ has at least $n_{Q}$ nodes.

However, while the random graphs $G_{1}^{\prime}$ and $G_{2}^{\prime}$ are globally very different, we will argue that they are locally indistinguishable from the perspective of $\mathsf{SUPPORTED}$ algorithms, if we use the same support $H$.

Let $T=T(2n_{Q},d)=T(n,d)$ be the running time of algorithm $\mathcal{A}_{d}$ when we run it in the random graph $G_{i}^{\prime}$ with support $H$. Consider a node $u\in V_{Q}$ and one of its copies, say, $u_{0}\in V$.

As $Q$ is a graph of girth larger than $2T+1$, the radius-$T$ neighborhood of $u$ is a regular tree. Let $V^{T}_{Q}\subseteq V_{Q}$ be the set of nodes in the tree. Let $H^{T}$ be the radius-$T$ neighborhood of $u_{0}$ in the support $H$. Note that $H^{T}$ is the subgraph of $H$ induced by the copies of the nodes in $V^{T}_{Q}$. As the running time of $\mathcal{A}_{d}$ is $T$, the probability distribution of the output of node $u$ only depends on the input within $H^{T}$.

Construct a labelling $D\colon V^{T}_{Q}\to\{0,1\}$ that labels the nodes of the tree by their distance from $u$ modulo $2$, and define a bijection $f\colon C_{1}\mapsto C_{2}$ between labellings $C_{1}$ and $C_{2}$ as follows. Given any labelling $C_{1}\colon V_{Q}\to\{0,1\}$, define a labelling $C_{2}\colon V_{Q}\to\{0,1\}$ by setting $C_{2}(v)=C_{1}(v)+D(v)\bmod 2$ for each $v\in V^{T}_{Q}$ close to $u$, and let $C_{2}(v)=C_{1}(v)$ for each $v\notin V^{T}_{Q}$ far from $u$.

This is clearly a bijection. In particular, the following random processes are indistinguishable: (1) pick $C_{2}$ uniformly at random; (2) pick $C_{1}$ uniformly at random and let $C_{2}=f(C_{1})$.

Recall that we used $C_{1}$ to construct graph $G_{1}^{\prime}$ and $C_{2}$ to construct graph $G_{2}^{\prime}$. The key observation is this: if we set $C_{2}=f(C_{1})$, then the structure of $G_{1}^{\prime}$ restricted to $H^{T}$ is isomorphic to the structure of $G_{2}^{\prime}$ restricted to $H^{T}$. In particular, the probability that $u_{0}$ joins the independent set in $G_{1}^{\prime}$ is the same as the probability that $u_{0}$ joins the independent set in $G_{2}^{\prime}$.

Summing over all choices of $C_{1}$ (and hence summing over all choices of $C_{2}=f(C_{1})$), we conclude that the probability that $u_{0}$ joins the independent set is the same in random graphs $G_{1}^{\prime}$ and $G_{2}^{\prime}$. Summing over all choices of $u_{0}$ (and similarly $u_{1}$), we see that the expected size of the independent set produced by $\mathcal{A}_{d}$ is the same in $G_{1}^{\prime}$ and $G_{2}^{\prime}$.

By Corollary 9, we see that the expected size of the independent set produced by $\mathcal{A}_{d}$ in any $G_{1}^{\prime}$ has to be less than $n_{Q}/\alpha_{d}$, and hence it fails to find an $\alpha_{d}$-approximation in expectation in some $G_{2}^{\prime}$. This concludes the proof of Theorem 7.

We point out that similar ideas can be used to prove a lower bound for the maximum cut problem. For example, in $d$-regular triangle-free graphs, it is possible to find a factor $1/(1/2+1/O(\sqrt{d}))$ approximation of the maximum cut in constant time with randomized $\mathsf{LOCAL}$ model algorithms [18]. We can show that switching to the $\mathsf{SUPPORTED}$ model does not help: it is not possible to find a factor $1/(1/2+1/o(\sqrt{d}))$ approximation of the maximum cut in sublogarithmic time with randomized $\mathsf{SUPPORTED}$ algorithms.

8 Link failures: The Passive $\mathsf{SUPPORTED}$ Model

So far we assumed that all edges in the support topology $H$ can be used for communication, no matter the input subgraph $G\subseteq H$. However, if edges physically fail, then this assumption is no longer viable. We thus introduce the passive $\mathsf{SUPPORTED}$ model, where after the precomputation phase, communication is restricted to the input graph $G$.

For simplicity of presentation, we only consider edge failures444A node failure can be simulated by failing all incident edges. and assume the communication graph is $G=(V,E)$. Note that unlike most prior work, we do not restrict ourselves to a few failures, but allow any subgraph $G$ of $H$. We next provide a brief overview of our results for the passive model.

General graphs are problematic.

From a very general point of view, precomputation on general graphs does not help much in the passive $\mathsf{SUPPORTED}$ model. For example, if $H$ is a complete support graph, then it seems that only few meaningful information can be prepared against adversarial failures, such as an upper bound on the network size respectively obtaining a superset of the ID-space; no meaningful topological information about the structure of $G$ is known ahead of time. We will formalize this intuition in Section 8.1.

Restricted graph families are useful.

This unsatisfying situation changes when we consider graph properties that are retained under edge deletions. To give a prominent example, a planar graph remains planar, no matter what subgraph $G$ is selected. Similarly, the genus or chromatic number of a graph only becomes smaller. We will show in Section 8.2 how to speed up the runtime of some algorithms in these restricted graph families, beginning with planar graphs.

Weaker $\mathsf{SLOCAL}$ simulations.

Due to the possible physical edge failures, our $\mathsf{SLOCAL}$-simulation from Section 4 can no longer be applied. In particular on dense graphs, it relied extensively on support edges not contained in the input graph, but those edges are no longer available for communication purposes. Notwithstanding, we can still provide a weaker simulation of the $\mathsf{SLOCAL}$ model in Section 8.3.

8.1 Simulation in the $\mathsf{LOCAL}$ Model

We begin by showing that, under certain assumptions, the passive $\mathsf{SUPPORTED}$ model can be simulated in the deterministic $\mathsf{LOCAL}$ model. When a passive $\mathsf{SUPPORTED}$ algorithm runs in polylogarithmic time, the overhead is only a constant factor in the number of rounds, illustrating that in general the power of preprocessing in the passive case is rather limited.

Theorem 10**.**

Consider the $\mathsf{LOCAL}$ model with identifiers in $\{1,2,\dots,n\}$. Let $\Pi$ be a graph problem such that a feasible solution for each connected component is a feasible solution for the whole graph. Let $A$ be $T(n)$-time algorithm for $\Pi$ in the passive $\mathsf{SUPPORTED}$ model that works for a support with maximum degree $\Delta=O(n^{1/k})$. Then $A$ can be simulated in time $O(T(n^{k}))$ in the $\mathsf{LOCAL}$ model.

Proof.

Let $A$ be a $T(n)$-time algorithm for a problem $\Pi$. The nodes of $G$ agree on a virtual support $H$ as follows: $H$ consists of a clique $K_{n}$ on the real vertices in $V(G)$, and of $n^{k}-n$ virtual nodes. Each real node is connected to one virtual node, and the remaining virtual nodes form a connected graph of maximum degree $\Delta(H)=n$. Since all real nodes $v$ also have $\deg_{H}(v)=n$, we have that $\Delta(H)=n=|V(H)|^{1/k}$.

Next nodes start simulating $A$ as if it was run on $H$, with the edges failing in a way that produces the observed input graph $G$. In particular, the edges between the real and the virtual nodes are assumed to have failed. Since $H$ contains the complete graph $K_{n}$ as its subgraph, all observable graphs $G$ can be formed from the support $H$ by edge deletions.

Since the support $H$ has size $n^{k}$, we have that $A$ runs on $H$ (and thus $G$) in time $T(n^{k})$. If $T(n)=O(\operatorname{poly}\log n)$, then $T(n^{k})=O(\operatorname{poly}\log n)$. Since $A$ produces a feasible output on $H$, it produces a feasible output on $H$ restricted to $G$. By assumption this is a feasible output on $G$. ∎

Note that the above result covers in particular the class of locally checkable labelling problems. The assumption that the nodes have names from $\{1,2,\dots,n\}$ is not usually useful for algorithm design in the $\mathsf{LOCAL}$ model.

We can also consider optimization problems. We consider problems for which the size of the solution is the sum of the sizes over all connected components.

Corollary 11**.**

Let $A$ be a $T(n)$-time algorithm for an optimization problem $\Pi$ in the passive $\mathsf{SUPPORTED}$ model that produces a solution of size at least $\alpha n$ when $\Delta(H)=O(n^{1/k})$. Then there exists a $\mathsf{LOCAL}$ algorithm that produces a solution of size $\alpha n$ in time $T(n^{k})$.

Proof.

Without loss of generality we consider a problem where we want to maximize the target function $f$. Let $N=n^{k}$. Let $G_{0}$ be the input graph on $n$ nodes in the $\mathsf{LOCAL}$ model, and let $H$ denote the (virtual) support that consists of $N$ cliques of size $n$, denoted by $H_{0},H_{1},H_{2},\dots,H_{N-1}$, connected by some subset of edges, at most one per node.

We construct the input graph $G$ as follows, shuffling the identifiers of the graph as we go. First, remove all edges between two different cliques $H_{i}$ and $H_{j}$. Then, let $G_{1}$ equal the subgraph of $H_{1}$ and $\varphi_{1}$ the identifier setting from $[N]$ to $V(G_{1})$ such that the value $f(G_{1})$ is minimized over all subgraphs and all identifier settings, when $A$ is run on $G_{1}$. Let $\varphi(G_{1})$ denote the set of identifiers used on $G_{1}$. Again, let $G_{2}$ be the subgraph of $H_{2}$ with the identifier setting $\varphi_{2}$ from $[N]\setminus\varphi(H_{1})$ that minimizes $f(H_{2})$ over all subgraphs and all identifier settings. We proceed in this manner until all $H_{i}$ have been dealt with, except for $H_{0}$.

There is a subset $S=\{s_{1},s_{2},\dots,s_{n}\}\subseteq[N]$ of identifiers left. We choose the mapping $\varphi_{0}:i\mapsto s_{i}$ for the identifiers of $G_{0}$. This can be done consistently by all nodes of $G_{0}$ since the graphs $H_{1},H_{2},\dots,H_{N-1}$ can be constructed with the knowledge of $N$ and $A$. Now, since regardless of the topology of $G_{0}$, it is a subgraph of each $H_{i}$ and the set $S$ was under consideration when assigning each $\varphi_{i}$, we must have that $f(G_{0})\geq f(G_{N-1})\geq f(G_{N-2})\geq\cdots\geq f(G_{1})$. In addition, since we have by assumption that $\sum_{i=0}^{N-1}f(G_{i})\geq\alpha N$, we must have that $f(G_{0})\geq\alpha n$. ∎

8.2 Breaking Locality Lower Bounds

Planar graphs.

Maximum independent set, maximum matching, and minimum dominating set are considered to be classic networking problems. Already on planar graphs, a $(1+\delta)$-approximation is impossible to compute in constant time for any of the three problems [12]. However, we can adapt the algorithms of Czygrinow et al. [12] to break these locality lower bounds in the passive $\mathsf{SUPPORTED}$ model:

Theorem 12**.**

Let $H$ be a planar support graph and fix any $\delta>0$. In the passive $\mathsf{SUPPORTED}$ model, a $(1+\delta)$-approximation can be computed in constant time on any input graph $G\subseteq H$ for the following three problems: $1)$ maximum independent set, $2)$ maximum matching, and $3)$ minimum dominating set.

Proof.

We study the algorithm construction Czygrinow et al. [12], which solves the three problems in non-constant time, and show how it can be adapted to the passive $\mathsf{SUPPORTED}$ model. It is based on finding a weight-appropriate pseudo-forest555A directed graph with maximum out-degree of one. in constant time, which in turn is 3-colored. The coloring allows to find so-called heavy stars in constant time, which are used as the base of a constant time clustering algorithm. Due to the heavy stars having a constant diameter, the approximation in [12] also runs in constant time.

Hence, the only non-constant time component is to find a 3-coloring of the pseudo-forest. As planar graphs have a chromatic number of 4, we can precompute such a 4-coloring in the passive $\mathsf{SUPPORTED}$ model, i.e., it remains to go from 4 to 3 colors in constant time. To this end, we can make use of [37, Algorithm DPGreedy], which in pseudo-forests reduces an $x$-coloring to an $x-1$-coloring in two rounds, assuming that $x\geq 4$, which concludes the proof construction. ∎

Extensions to bounded genus graphs.

Amiri et al. [3, 2, 4] show how to adapt the technique of Czygrinow et al. [12] to graphs of bounded genus666Graphs of genus [math] are the class of planar graphs. $g\in O(1)$ for the minimum dominating set problem. By careful analysis of their work, as in the proof of Theorem 12, it only remains to provide a 3-coloring of the resulting pseudo-forests in constant time. As a genus $g$ graph can be colored with $O(\sqrt{g})$ colors [32], we can obtain such a 3-coloring in $O(\sqrt{g})$ time as well.

Corollary 13**.**

Let $H$ be a support graph of constant genus $g$ and fix any $\delta>0$. In the passive $\mathsf{SUPPORTED}$ model, a $(1+\delta)$-approximation can be computed in constant time on any input graph $G\subseteq H$ for the minimum dominating set problem.

Locally checkable labellings.

We briefly re-visit graphs with some constant maximum degree $\Delta$, to investigate $\mathsf{LCL}$s in the passive $\mathsf{SUPPORTED}$ model. The bounded degree property allows us to efficiently precompute colorings, which we will also investigate in the next Section 8.3. In fact, when we check the proof of our $\mathsf{LCL}$-Theorem 3, we just made use of the precomputed coloring, not of the (now failed) additional support edges. As thus, symmetry breaking problems also collapse to constant time in the passive $\mathsf{SUPPORTED}$ model:

Corollary 14**.**

Every $\mathsf{LCL}$ in $\mathsf{LOCAL}(o(\log n))$ can be solved in time $O(1)$ in the passive $\mathsf{SUPPORTED}$ model.

8.3 An $\mathsf{SLOCAL}$ Simulation in the Passive $\mathsf{SUPPORTED}$ Model

As described earlier in this section, we can no longer rely on our efficient $\mathsf{SLOCAL}$ simulation from Section 4 in the passive $\mathsf{SUPPORTED}$ model. Still, we can create another kind of dependency chain which also works in the passive model.

Theorem 15**.**

An $\mathsf{SLOCAL}$ algorithm with locality $t$ can be simulated in the passive $\mathsf{SUPPORTED}$ model in time $\Delta^{O(t)}$.

Proof.

The following proof is conceptually similar to the proof of Theorem 1, but will rely on a dependency chain that is given by a coloring hierarchy, i.e., in the simulation, nodes of color 1 execute first, then color 2 etc. When creating the coloring, we need to ensure that the resulting execution performs as a global $\mathsf{SLOCAL}$ one. To this end, for every $t$-neighborhood, it must hold that at most one node executes its actions at the same time: then, as the locality $t$ is known, the executing nodes can gather the states of all nodes of smaller colors according to the given locality. In other words, any two nodes within distance $2t$ of each other need to have distinct colors, which is satisfied by a distance-$(2+1)$ coloring. As the maximum degree of the support graph being $\Delta$, such a coloring can be performed with $\Delta^{O(t)}$ colors. The execution time for a single color class is $O(t)$, resulting in $O(t)\Delta^{O(t)}$ rounds, which can be simplified to $\Delta^{O(t)}$ in the big-O notation for $\Delta>1$. ∎

9 Related Work

Decentralized and local network algorithms have been studied for almost three decades already [26], often with applications in ad-hoc networks in mind. More recently, decentralized approaches are also discussed intensively in the context of software-defined networks [28, 7, 40, 17, 9], which serve us as a case study in this paper, and also motivated Schmid and Suomela [33] to consider the $\mathsf{SUPPORTED}$ model.

To the best of our knowledge, this paper is the first to systematically explore the novel opportunities and limitations introduced by enhancing scalable network algorithms with preprocessing. That said, there are several interesting results which are relevant in this context as well.

The congested clique [25] can be considered a special case of the $\mathsf{SUPPORTED}$ model, where the support graph $H$ is the complete graph $K_{n}$. However, only speedup without preprocessing is investigated, and communication is restricted to messages of logarithmic size, i.e., the so-called $\mathsf{CONGEST}$ [30] model. Korhonen et al. [21, §7] investigate the $\mathsf{SUPPORTED}$ $\mathsf{CONGEST}$ model (with support graphs of bounded degeneracy) and show how preprocessing can be leveraged for faster subgraph detection in sparse graphs.

10 Conclusion

Scalability is a key challenge faced by the quickly growing communication networks. In this paper, we initiated the study of how enhancing local and decentralized algorithms with preprocessing (as it is often easily possible in modern networks) can help to further improve efficiency and scalability of such networks. We presented several positive results on how preprocessing can indeed be exploited, but also pointed out limitations.

We understand our work as a first step and believe that it opens many interesting questions for future research. In particular, there exist several fundamental algorithmic problems for which the usefulness of preprocessing still needs to be explored. Furthermore, it will also be interesting to better understand the relationship between the opportunities introduced by supported models and the opportunities introduced by randomization.

Acknowledgements

This work was supported in part by the Academy of Finland, Grant 285721, and the Ulla Tuominen Foundation. Part of the work was conducted while JH was affiliated with the Institut de Recherche en Informatique Fondamentale and the University of Freiburg.