On the Use of Randomness in Local Distributed Graph Algorithms

TL;DR

This paper investigates the role of randomness in local distributed graph algorithms, demonstrating that minimal randomness suffices for efficiency and that success probabilities can be significantly improved, approaching derandomization.

Contribution

It shows that efficient randomized algorithms can operate with very limited randomness and that their success probabilities can be greatly enhanced, advancing understanding of derandomization in distributed computing.

Findings

Polylogarithmic-time algorithms work with minimal randomness.

Success probabilities can be exponentially improved.

Certain derandomization results imply breakthroughs in deterministic algorithms.

Abstract

We attempt to better understand randomization in local distributed graph algorithms by exploring how randomness is used and what we can gain from it: - We first ask the question of how much randomness is needed to obtain efficient randomized algorithms. We show that for all locally checkable problems for which polylog $n$-time randomized algorithms exist, there are such algorithms even if either (I) there is a only a single (private) independent random bit in each polylog $n$-neighborhood of the graph, (II) the (private) bits of randomness of different nodes are only polylog $n$-wise independent, or (III) there are only polylog $n$ bits of global shared randomness (and no private randomness). - Second, we study how much we can improve the error probability of randomized algorithms. For all locally checkable problems for which polylog $n$-time randomized algorithms exist, we show that there are such algorithms that succeed with probability $1-n^{-2^{\varepsilon(\log\log n)^2}}$ and more generally $T$-round algorithms, for $T\geq$ polylog $n$, that succeed with probability $1-n^{-2^{\varepsilon\log^2T}}$. We also show that polylog $n$-time randomized algorithms with success probability $1-2^{-2^{\log^\varepsilon n}}$ for some $\varepsilon>0$ can be derandomized to polylog $n$-time deterministic algorithms. Both of the directions mentioned above, reducing the amount of randomness and improving the success probability, can be seen as partial derandomization of existing randomized algorithms. In all the above cases, we also show that any significant improvement of our results would lead to a major breakthrough, as it would imply significantly more efficient deterministic distributed algorithms for a wide class of problems.

Full text

• •

We first ask the question of how much randomness is needed to obtain efficient randomized algorithms. We show that for all locally checkable problems for which $\operatorname{poly}\log n$-time randomized algorithms exist, there are such algorithms even if either (I) there is a only a single (private) independent random bit in each $\operatorname{poly}\log n$-neighborhood of the graph, (II) the (private) bits of randomness of different nodes are only $\operatorname{poly}\log n$-wise independent, or (III) there are only $\operatorname{poly}\log n$ bits of global shared randomness (and no private randomness).

• •

Second, we study how much we can improve the error probability of randomized algorithms. For all locally checkable problems for which $\operatorname{poly}\log n$-time randomized algorithms exist, we show that there are such algorithms that succeed with probability $1-n^{-2^{\varepsilon(\log\log n)^{2}}}$ and more generally $T$-round algorithms, for $T\geq\operatorname{polylog}\ n$, that succeed with probability $1-n^{-2^{\varepsilon\log^{2}T}}$. We also show that $\operatorname{poly}\log n$-time randomized algorithms with success probability $1-2^{-2^{\log^{\varepsilon}n}}$ for some $\varepsilon>0$ can be derandomized to $\operatorname{poly}\log n$-time deterministic algorithms.

Both of the directions mentioned above, reducing the amount of randomness and improving the success probability, can be seen as partial derandomization of existing randomized algorithms. In all the above cases, we also show that any significant improvement of our results would lead to a major breakthrough, as it would imply significantly more efficient deterministic distributed algorithms for a wide class of problems.

1 Introduction

The gap between the complexity of randomized and deterministic distributed algorithms for local graph problems is one of the foundational, deep, and long-standing questions in distributed algorithms. A well-known special case is the question of Linial from 1987[Lin87, Lin92] about the Maximal Independent Set (MIS) problem: While we have known randomized MIS algorithms that work in $O(\log n)$ rounds of the $\mathsf{LOCAL}$ model—i.e., synchronous message passing rounds—since the celebrated work of Luby[Lub86] and Alon, Babai, and Itai[ABI86], Linial’s question for obtaining a deterministic algorithm that computes an MIS in $\operatorname{poly}(\log n)$ rounds still remains open. There is an abundance of similar questions about other concrete graph problems, several of which remain open. See e.g., the first five problems111Though, the last two of these are no longer open[FGK17, GHK18]. in the open problems chapter of the book by Barenboim and Elkin[BE13]. More generally, we can ask whether

$\mathsf{P}$-$\mathsf{LOCAL}\stackrel{{\scriptstyle\mathclap{\mbox{?}}}}{{=}}\mathsf{P}$-$\mathsf{RLOCAL}$

Here, $\mathsf{P}$-$\mathsf{LOCAL}$ denotes the family of locally checkable problems222To make the question more widely applicable, we use a relaxed version of local checkability, where the local checking radius can be up to polylogarithmic in $n$. For a precise definition, we refer to Section 2. that can be solved by deterministic algorithms in $\operatorname{poly}(\log n)$ rounds in $n$-node graphs and $\mathsf{P}$-$\mathsf{RLOCAL}$ denotes the family of locally checkable problems that can be solved by randomized algorithms in $\operatorname{poly}(\log n)$ rounds, with success probability $1-1/n$. Both of these are with respect to the $\mathsf{LOCAL}$ model. One may view the above question as an analog of the well known $\mathsf{P}$ vs. $\mathsf{BPP}$ question in centralized computational complexity, i.e., (deterministic) polynomial-time vs. bounded-error probabilistic polynomial-time [AB09, Chapter 7]. However, as we will see below, the questions are inherently very different.

In this paper, we try to shed more light on this fundamental question by taking a step back and asking “what is the randomness used in these randomized distributed graph algorithms?” That is, (A) how much randomness is needed, and (B) how strong are the probabilistic guarantees that randomized algorithms can provide? Both of these questions can be used as means for interpolating between randomized and deterministic algorithms: Randomized algorithms, under the standard definition, can use an unbounded number of independent random bits at different nodes and they guarantee success with probability $1-1/n$. Deterministic algorithms use no randomness and they always guarantee success (which is at least as strong as guaranteeing success with probability $1$).

Before delving into our answers to these questions, let us review some of the recent work centered on the gap between deterministic and randomized algorithms.

1.1 An Overview of the Recent Developments on DET vs. RAND

Over the past decade, there has been a number of beautiful developments, which are related to the aforementioned deterministic versus randomized question. We give a brief overview here.333This is certainly not exhaustive and it probably does not do justice to all the recent progress. We discuss only the cases that are most directly related to the current paper, in our understanding.

Shattering Method and its Necessity:

One of the influential developments of the past decade in distributed algorithms for local graph problems was the introduction and wide usage of the shattering method. The method, which is inspired by Beck’s algorithmic version of the Lovász Local Lemma[Bec91], was first introduced in the distributed setting by Barenboim et al. [BEPS16]. In a rough sense, the method leads to randomized algorithms with two phases: a first efficient randomized phase that typically works in time that only depends on local graph parameters such as the maximum degree $\Delta$ and leaves a graph made of only small components, e.g., each of $\operatorname{poly}(\log n)$ size; and a second phase that solves each of these connected components separately, all in parallel, using deterministic algorithms. Hence, the dependency on the network size $n$ in randomized algorithms is brought down to the deterministic complexity for networks of size $N=\operatorname{poly}(\log n)$. For instance, for MIS, we know an $O(\log\Delta)+2^{O(\sqrt{\log\log n})}$-round randomized algorithm with success probability $1-1/n$[Gha16], and the second complexity term here mirrors the $2^{O(\sqrt{\log n})}$ complexity of the best known deterministic MIS algorithm [PS92]. We run deterministic algorithms in the second phase, because the usual error probability bound of randomized algorithms, which is $1/\operatorname{poly}(N)$ for $N$-node instances, is not enough for a union bound over all components. Here, the deterministic vs. randomized question is more about the success probability, rather than the bits of randomness.

More surprisingly, Chang et al.[CKP16] showed that the randomized complexity of any locally checkable problem on $n$-node networks (with success probability $1-1/n$) is at least its deterministic complexity on graphs with $\sqrt{\log n}$ nodes. Thus, if one improves the $n$-dependency of the randomized algorithms compared to the shattering-based results above, that improves also the deterministic complexity. This underlines the importance of understanding the complexity of deterministic algorithms, even if eventually we only care about randomized algorithms.

Exponential Separations in the Landscape of Lower Complexities:

Another significant recent development was the emergence of provable exponential separations between randomized and deterministic algorithms, though in a complexity regime below $O(\log n)$. Brandt et al.[BFH*+*16] showed a lower bound of $\Omega(\log\log n)$ on the round complexity of computing a sinkless orientation in constant-degree graphs, which also implied a similar lower bound for $\Delta$-coloring trees of degree $\Delta=O(1)$. Chang et al.[CKP16] extended these to $\Omega(\log n)$ lower bounds for deterministic algorithms. They also exhibited an $O(\log\log n)$ round randomized algorithm and an $O(\log n)$ round deterministic algorithm for $\Delta$-coloring trees, hence proving that these complexities are tight and they have an exponential separation. Ghaffari and Su [GS17] later showed that the original problem of sinkless orientation (which is a special case of the Lovász Local Lemma) also exhibits the same exponential separation, by providing a $\Theta(\log\log n)$-round randomized and a $\Theta(\log n)$-round deterministic algorithm for it. We emphasize that this exponential separation is between complexities that are in $O(\log n)$. To the best of our understanding, this separation has no bearing on the $\mathsf{P}$-$\mathsf{LOCAL}$ vs. $\mathsf{P}$-$\mathsf{RLOCAL}$ question or particular cases of it such as Linial’s MIS question.

A Complexity-Theoretic Study and Derandomization:

As a step toward studying deterministic versus randomized complexities, Ghaffari et al.[GKM17] introduced the sequential local model $\mathsf{SLOCAL}$: here a sequential algorithm processes vertices in an arbitrary order $v_{1},v_{2},\dots,v_{n}$, each time deciding about the output of the vertex $v_{i}$ that is being processed—e.g., its color in the coloring problem—by reading the current information available within a small $r$-hop neighborhood of $v_{i}$, including the related topology, and then recording the result (and potentially the gathered information) in the node $v_{i}$. See [GKM17] for the precise definitions. The parameter $r$ is the locality of such an $\mathsf{SLOCAL}$ algorithm. The model provides a generalization of sequential greedy processes for problems such as MIS and $\Delta+1$ coloring, which both can be solved with locality $1$ in the $\mathsf{SLOCAL}$ model. The model may seem too powerful at first sight, given that it allows sequential processing, but it is no more powerful than adding randomization to the $\mathsf{LOCAL}$ model: It was shown in [GKM17] that any (randomized or deterministic) $\mathsf{SLOCAL}$ algorithm with locality $\operatorname{poly}(\log n)$ for any locally checkable problem can be transformed to a $\operatorname{poly}(\log n)$-round randomized $\mathsf{LOCAL}$ algorithm. Given this, Ghaffari et al.[GKM17] studied the question of $\mathsf{P}$-$\mathsf{SLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$: whether any locally checkable problem that admits a deterministic $\mathsf{SLOCAL}$ algorithm with locality $\operatorname{poly}(\log n)$ can be solved using a $\operatorname{poly}(\log n)$-round deterministic $\mathsf{LOCAL}$ algorithm. A number of problems were shown to be complete with respect to $\mathsf{P}$-$\mathsf{SLOCAL}$[GKM17, GHK18], in the following sense: they admit deterministic $\mathsf{SLOCAL}$ algorithms with locality $\operatorname{poly}(\log n)$ and if one can provide a $\operatorname{poly}(\log n)$-round deterministic $\mathsf{LOCAL}$ for any of them, one has proven that $\mathsf{P}$-$\mathsf{SLOCAL}=\mathsf{P}$-$\mathsf{LOCAL}$. Example complete problems include network decompositions, splitting[GKM17], and certain locally verifiable versions of approximating dominating set or set cover[GHK18].

The work of [GKM17] investigated a part of the question of randomized vs. deterministic by examining $\mathsf{P}$-$\mathsf{SLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$. A different work of Ghaffari et al.[GHK18] showed that this actually fully captures the issue, by proving that $\mathsf{P}$-$\mathsf{RLOCAL}=\mathsf{P}$-$\mathsf{SLOCAL}$. That is, any $\operatorname{poly}(\log n)$-round randomized $\mathsf{LOCAL}$ algorithm that solves a locally checkable problem with high probability can be derandomized into a deterministic $\mathsf{SLOCAL}$ algorithm for the same problem with locality $\operatorname{poly}(\log n)$. Hence, the question $\mathsf{P}$-$\mathsf{SLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$ is equivalent to $\mathsf{P}$-$\mathsf{RLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$ and the aforementioned problems are complete also with respect to $\mathsf{P}$-$\mathsf{RLOCAL}$. All of those problems admit $\operatorname{poly}(\log n)$-round randomized $\mathsf{LOCAL}$ algorithms, and any $\operatorname{poly}(\log n)$-round deterministic $\mathsf{LOCAL}$ algorithm for any of them would imply that $\mathsf{P}$-$\mathsf{RLOCAL}=\mathsf{P}$-$\mathsf{LOCAL}.$ Given what is known about these complete problems, and particularly network decomposition [PS92], the best known derandomization is that any $\operatorname{poly}(\log n)$-round randomized algorithm for any locally checkable problem can be derandomized to a $2^{O(\sqrt{\log n})}$-round deterministic algorithm [GHK18].

As a side remark, it is worth noting that the complexity-theoretic view mentioned above and some of the algorithmic and derandomization tools developed around it have already had concrete algorithmic applications: In particular, [FGK17, GHK18] resolved a couple of the open questions regarding deterministic vs. randomized distributed algorithm for particular graph problems, including Open Problems 11.4, 11.5 and 11.10 of the book of Barenboim and Elkin[BE13].

1.2 Our Contribution

As mentioned above, we try to shed more light on the $\mathsf{P}$-$\mathsf{RLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$ problem by asking two questions about randomized distributed graph algorithms: (A) “how much” randomness do they need for their efficiency, to solve in particular the above complete problems—e.g., network decompositions with $\operatorname{poly}(\log n)$ parameters—in $\operatorname{poly}(\log n)$-rounds? (B) And what kind of a bound can we prove on their error probability, given some limit on the time complexity. In each direction, we provide results that are in some sense the strongest that we one can achieve, barring a major breakthrough. More concretely, if one achieves a considerably stronger result, that would either prove $\mathsf{P}$-$\mathsf{SLOCAL}=\mathsf{P}$-$\mathsf{LOCAL}$ or at least provide a much faster deterministic algorithm for all problems in $\mathsf{P}$-$\mathsf{RLOCAL}$, including MIS, $(\Delta+1)$-coloring, and network decomposition with $\operatorname{poly}(\log n)$ parameters.

Before diving to the answers, let us make something concrete. In much of the discussions in this paper, instead of talking about all possible randomized algorithms for all problems, we will focus directly on problems that are now known to be complete with respect to the $\mathsf{P}$-$\mathsf{RLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$ question, in the sense mentioned above. In particular, much of our focus will be on network decompositions as introduced in [AGLP89]. A network decomposition of $G=(V,E)$ with $\alpha$ colors and diameter $\beta$—often abbreviated as an $(\alpha,\beta)$ network decomposition—is a partitionong of $V$ into $\alpha$ disjoint sets $V_{1},\dots,V_{\alpha}$ such that for each $i\in\left\{1,\dots,\alpha\right\}$, each connected component of the induced subgraph $G[V_{i}]$ has diameter at most $\beta$ (see Section 2 for a formal definition). In the following, when referring to a network decomposition with $\operatorname{poly}(\log n)$ parameters, we mean that $\alpha=\operatorname{poly}(\log n)$ and $\beta=\operatorname{poly}(\log n)$. It is known that every $n$-node network admits an $(O(\log n),O(\log n))$ network decomposition and that such a decomposition can be computed in $O(\log^{2}n)$ rounds of the $\mathsf{LOCAL}$ model using randomized algorithms, with success probability $1-1/n$ [LS93]. The best known deterministic algorithm to compute a network decomposition with $\operatorname{poly}(\log n)$ (or even weaker) parameters is exponentially slower and requires $2^{O(\sqrt{\log n})}$ rounds[ABCP96, PS92]. We ask how much randomness is needed to compute network decompositions with $\operatorname{poly}(\log n)$ parameters (or some other related questions such as splitting) or what kind of a probabilistic guarantees can randomized algorithms provide in a given amount of time, for these problems. Given the aformentioned completeness results, we know that these concrete questions capture the role of randomness for all locally checkable problems: For instance, if we can construct a network decomposition with $\operatorname{poly}(\log n)$ parameters in $\operatorname{poly}(\log n)$ time using a certain “amount of randomness”, then the same is true for any problem in $\mathsf{P}$-$\mathsf{RLOCAL}$ (using the same amount of randomness).

1.2.1 Direction 1 — How much randomness is needed?

We formalize the question about the amount of randomness, in three different ways: (A) the number of bits in each “local neighborhood”, (B) the independence of the bits in different nodes, and (C) the number of bits shared in the whole network. We next discuss these cases, separately.

(A) First, we note that the standard definition for randomized algorithms allows each node to have unbounded amount of randomness. Usual algorithms need less than this and use only $\operatorname{poly}(\log n)$ bits per node [LS93]. We show in Theorems 3.1 and 3.7 that even much less than that suffices: even if for each node there is just one bit of randomness somewhere within its $\operatorname{poly}(\log n)$ hops, and these bits are independent of each other, then we can still compute all $\mathsf{P}$-$\mathsf{RLOCAL}$ problems in $\operatorname{poly}(\log n)$. We also give an algorithm that, in such a setting, builds a network decomposition with $\operatorname{poly}(\log n)$ parameters, in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{CONGEST}$ model, with probability $1-1/\operatorname{poly}(n)$. Recall that the $\mathsf{CONGEST}$ model is a variant of the $\mathsf{LOCAL}$ model where the message sizes are limited to $O(\log n)$ bits, in contrast to the $\mathsf{LOCAL}$ model which allows unbounded message sizes.

Two comments are in order. First, this one bit per $\operatorname{poly}(\log n)$-hop neighborhood is in some sense the least that we need to assume. Otherwise, there can be large $\operatorname{poly}(\log n)$-hop neighborhoods where there is no randomness, and hence $\operatorname{poly}(\log n)$-time algorithms that work in those areas are actually providing a deterministic algorithm. Second, our theoretical result might have some message for practical settings when thinking outside the realm of the worst-case analysis. Probably, in many networking settings, it is reasonable to assume that one can “extract” one bit of randomness out of various network properties (topology, identifiers, etc.) in each $\operatorname{poly}(\log n)$ neighborhood. In a very informal sense, our result implies that there are probably reasonable ways of building efficient “deterministic” algorithms (with only $1$ bit of pseudo-randomness per $\operatorname{poly}(\log n)$-hop neighborhood), such that breaking these algorithms requires very carefully built input networks444There is much to be investigated here. What kind of randomness extraction is possible, under different network assumptions? Also, can we formalize the sufficiency of such randomness against a computationally bounded adversary who builds the input graph, perhaps using some cryptographic assumptions?.

(B) Second, we investigate the independence between the random bits. Standard algorithms assume the bits of different nodes to be fully independent. In Theorem 3.5, we show that $\operatorname{poly}(\log n)$-wise independence suffices for computing a network decomposition with $\operatorname{poly}(\log n)$ parameters in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model. Hence, any problem in $\mathsf{P}$-$\mathsf{RLOCAL}$ can be solved in $\operatorname{poly}(\log n)$ rounds, even if the random bits of different nodes are $\operatorname{poly}(\log n)$-wise independent.

(C) Third, as a result of (B), we can also bound the total number of random bits required in the whole network. Standard models of randomized algorithms implicitly assume a total of at least $\Omega(n)$ bits, i.e., at least one bit per node. We show that just $\operatorname{poly}(\log n)$ shared random bits suffice. For the local splitting problem shown to be complete in [GKM17], we prove in Lemma 3.4 that just $O(\log n)$ bits of shared randomness suffices. This concretely shows that the $\mathsf{P}$-$\mathsf{RLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$ question is very different from its well-known centralized $\mathsf{P}$ vs. $\mathsf{BPP}$ analog (polynomial-time vs. bounded-error probabilistic polynomial time)[Sip06, AB09]. Note that for this centralized question, any probabilistic algorithm with $O(\log n)$ bits of randomness can be derandomized trivially in polynomial time, by checking all the $2^{O(\log n)}=n^{O(1)}$ possibilities for the $O(\log n)$ bits of randomness. Our result about splitting shows that even problems that are solvable efficiently with $O(\log n)$ bits of randomness can be hard with respect to $\mathsf{P}$-$\mathsf{RLOCAL}$ vs. $\mathsf{P}$-$\mathsf{LOCAL}$. Furthermore, we note that this bound of $O(\log n)$ bits is asymptotically the least that we can assume, unless we come up with a deterministic algorithm555An algorithm with $b<\log n$ bits of randomness is a uniformly random choice among $2^{b}<n$ possible deterministic algorithms. Each deterministic algorithm either succeeds or fails. Hence, the highest probability that is not $1$ would be at most $1-1/2^{b}<1-1/n$. Thus, if the probability is at least $1-1/n$, it is equal to $1$..

Perhaps as more interesting end results, we also show that something similar can be said about more standard graph problems, for instance network decomposition. The result of the item (B) discussed above, combined with standard constructions for $k$-wise independent bits[AS04], shows that $\operatorname{poly}(\log n)$ bits of shared randomness build network decompositions with $\operatorname{poly}(\log n)$ parameters, in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model. We show such a result also for the much more stringent $\mathsf{CONGEST}$ model, using a very different method: In Theorem 3.6, we show that we can build network decompositions with $\operatorname{poly}(\log n)$ parameters, in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{CONGEST}$ model, using only $\operatorname{poly}(\log n)$ bits of shared randomness (and no private randomness).

1.2.2 Direction 2 — Error probability vs Round Complexity

Usually, the study of distributed graph algorithms has focused only on two regimes of error probabilities: an error probability of [math], for deterministic algorithms, and an error probability of $1/\operatorname{poly}(n)$, for randomized algorithms. In a number of places where we need deterministic algorithms, the main property that we require from the algorithms is that the error probability is [math] or close to [math] and not how many random bits we use. Our second direction is to explore the trade-off between error probability and running time. Concretely, how small can we make the error probability in a certain time budget? Moreover, at what point is the error probability small enough so that we can derandomize the algorithm completely?

For any $T\geq\log^{c}n$, where $c$ is a sufficiently large constant, we give a randomized algorithm that succeeds with probability at least $1-2^{-2^{\varepsilon\log^{2}T}}=1-n^{-2^{\varepsilon\log^{2}T}}$ for some constant $\varepsilon>0$ and that computes a network decomposition with cluster diameter $T$ and $T$ cluster colors in $T$ rounds of the $\mathsf{CONGEST}$ model (see Theorem 4.2). For instance, for $T=\operatorname{polylog}n$, this results in an error probability of $n^{-2^{\varepsilon\log^{2}\log n}}$, which is much stronger than the $n^{-\Theta(1)}$ error probability bound of standard randomized algorithms. In Theorem 4.3, we also show that the result of Theorem 4.2 is nearly the best error probability that one can guarantee, unless we improve the deterministic complexity of network decompositions. Concretely, any randomized algorithm with round complexity $T$—even in the $\mathsf{LOCAL}$-model—that has success probability at least $1-2^{2^{\varepsilon\log^{\beta}}T}$ for any constant $\varepsilon>0$ and any constant $\beta>2$ would imply a deterministic network decomposition with $\operatorname{poly}(\log n)$ parameters in $2^{O(\log^{1/\beta}n)}\ll 2^{O(\sqrt{\log n})}$ rounds, thus significantly improving on the long-standing bounds of Panconesi and Srinivasan[PS92]. Similarly, in Theorem 4.6, we show that any randomized $\operatorname{poly}(\log n)$-round algorithm with success probability better than $1-2^{-2^{\log^{\varepsilon}n}}$, for an arbitrary constant $\varepsilon>0$, would imply a $\operatorname{poly}(\log n)$-round network decomposition with $\operatorname{poly}(\log n)$ parameters, thus proving that $\mathsf{P}$-$\mathsf{RLOCAL}=\mathsf{P}$-$\mathsf{LOCAL}.$ Previously, the best known such derandomization result was that any randomized algorithms with a much stronger success probability of $1-2^{-\Theta(n^{2})}$ can be derandomized (via a union bound over all $2^{\Theta(n^{2})}$ many possibilities for $n$-node graphs). This was implicit in Theorem 3 of [CKP16].

2 Model and Preliminaries

Communication Model: We work with two closely related models of distributed computing, $\mathsf{LOCAL}$ and $\mathsf{CONGEST}$: The communication network is abstracted as an $n$-node graph $G=(V,E)$, with one processor on each node $v\in V$ which has a unique identifier. We typically assume that the identifiers are represented by $\Theta(\log n)$ bits. Communication happens in synchronous rounds, where per round each node can send one message to each neighbor. In the $\mathsf{LOCAL}$ model, message sizes can be unbounded. In the $\mathsf{CONGEST}$ model, each message can have $O(\log n)$ bits. At the beginning, the processors/nodes do not know the topology of the network, except for potentially knowing some global parameters (as we shall discuss next). At the end, each processor should know its own part of the output, e.g., its color in the vertex coloring problem.

Uniform and Non-Uniform Algorithms:

In most cases, we assume that the nodes of a distributed algorithm initially know the number of nodes $n$ or an upper bound on $n$.x We call such an algorithm a non-uniform distributed algorithm and we call an algorithm where the nodes initially do not know anything about $n$ a uniform algorithm. We formally model the knowledge of $n$ as follows. In a non-uniform distributed algorithm, all nodes are given $n$ as input. We say that a non-uniform algorithm $\mathcal{A}$ solves a distributed graph problem $\mathcal{P}$ in time $T(n)$ if $\mathcal{A}$ solves $\mathcal{P}$ in time at most $T(n)$ on all graph with at most $n$ nodes. If the correctness of a solution to a graph problem $\mathcal{P}$ depends on the number of nodes $n$, we use the notation $\mathcal{P}(n)$ to make this clear. A solution to problem $\mathcal{P}(n)$ that satisfies the requirements for graphs with at most $n$ nodes. If we for example compute an $(O(\log n),O(\log n))$-decomposition of a graph $G=(V,E)$ with at most $n$ nodes, the cluster diameter and number of cluster colors can depend logarithmically on $n$ rather than just on the actual number of nodes $|V|$. The error probability of a non-uniform algorithm is defined as follows.

Definition 2.1** (Error Probability).**

We say that a (non-uniform) distributed algorithm $\mathcal{A}$ solves a given distributed graph problem $\mathcal{P}$ on $n$-node graphs with error probability $\delta(n)$ in time $T(n)$ if the following holds. When given $n$ as an input, $\mathcal{A}$ computes a correct solution to $\mathcal{P}$ with probability at least $1-\delta(n)$ on all graphs $G$ with at most $n$ nodes.

The definition implies that a randomized algorithm has to succeed with probability $1-\delta(n)$ even if the actual graph has fewer than $n$ nodes. If $\delta(n)\leq 1/n^{c}$ for a constant $c>1$ that can be chosen sufficiently large, we say that algorithm $\mathcal{A}$ solves the problem $\mathcal{P}$ with high probability (w.h.p.).

Local Checkability:

As mentioned in the introduction, we study distributed graph problems where the validity of a solution is locally checkable [FKP13]. Roughly, a graph problem $\mathcal{P}$ is said to be $d$-locally checkable if given a solution to $\mathcal{P}$, there exists a deterministic $d$-round algorithm $\mathcal{A}_{C}$ in the $\mathsf{LOCAL}$ model such that every node outputs “yes” if and only if the given solution is a valid solution to $\mathcal{P}$. The class of problems we consider contains the well-known class of locally checkable labeling (LCL) problems666LCL problems are graph problems where the output of each node is a label from a constant-size alphabet and where the correctness of a solution can be checked with a constant-time $\mathsf{LOCAL}$ algorithm [NS95]., however, we use a much looser definition of local checkability, where in particular the checking radius can depend on $n$ and which is formally defined as follows.

Definition 2.2** (Local Checkability).**

Let $\mathcal{P}$ be a distributed graph problem. We say that $\mathcal{P}$ is $d(n)$-locally checkable for a function $d(n)$ if there exists a deterministic non-uniform distributed algorithm $\mathcal{A}_{C}$, which is given $n$ as input an which has the following properties. Given a graph $G=(V,E)$ of size $|V|\leq n$ and values $x_{v}$ for $v\in V$, $\mathcal{A}_{C}$ has round complexity at most $d(n)$ and it checks whether $\left\{x_{v}:v\in V\right\}$ is a correct solution for $\mathcal{P}$. After running $\mathcal{A}_{C}$, each node outputs “yes” or “no” such that all nodes output “yes” if and only if $\left\{x_{v}:v\in V\right\}$ is a correct solution for $\mathcal{P}$. We say that $\mathcal{P}$ is strictly $d(n)$-locally checkable if the round complexity is $d(|V|)$, i.e., if the checking radius only depends on the actual number of nodes and not on the upper bound $n$.

Note that any LCL problem and more generally any problem that is $d$-locally checkable for a constant $d\geq 0$ is also strictly locally checkable.

Network Decomposition:

As discussed, the complexity of computing a network decomposition is at the core of understanding the role of randomization in local distributed graph algorithms: Given a network decomposition with $\operatorname{poly}(\log n)$ parameters for a sufficiently large (polylogarithmic) power $G^{r}$ of the network graph $G$, any randomized $\operatorname{poly}(\log n)$-time algorithm for a $\operatorname{poly}(\log n$)-locally checkable problem can be derandomized to a deterministic $\operatorname{poly}(\log n)$-time algorithm [GKM17, GHK18]. We slightly adapt the definition of a network decomposition from the one introduced in [AGLP89, LS93] to make it more directly useful in the $\mathsf{CONGEST}$ model. Given a graph $G=(V,E)$, a strong $(d(n),c(n))$-decomposition of $G$ is partition of $V$ into clusters $C_{1},\dots,C_{p}$ together with a subtree $T_{i}$ of $G$ and a color $\gamma_{i}\in\left\{1,\dots,c(n)\right\}$ for each cluster $C_{i}$. The tree $T_{i}$ of cluster $C_{i}$ contains all nodes of $C_{i}$ (i.e., $T_{i}$ spans the cluster $C_{i}$). Each tree $T_{i}$ has diameter at most $d(n)$ (which implies that each cluster has weak diameter at most $d(n)$) and the colors of the clusters are chosen such that clusters that are connected by an edge of $G$ are assigned different colors. We say that a decomposition has congestion $\kappa\geq 1$ if each node is containted in at most $\kappa$ clusters of each color.777For efficient usage in $\mathsf{CONGEST}$, one could require that each edge is only used by a few clusters per color. Usually, in the literature, the trees spanning the clusters are not given as part of the definition and instead of explicitly specifying the congestion of a decomposition, the literature distinguishes between strong and weak diameter decompositions. The decompositions of the above definition have weak diameter $d(n)$. In a strong diameter decomposition, the tree $T_{i}$ of each cluster $C_{i}$ consists exactly of the nodes in $C_{i}$ such that each node participates only in the tree of its cluster. A strong diameter decomposition is therefore a special case of a decompositions with congestion $1$.

3 Viewing Randomness as a Scarce Resource

In this section, we view randomness as a resource and use this perspective to interpolate between standard randomized algorithms and deterministic algorithms. Deterministic distributed algorithms do not use any randomness. Randomized distributed algorithms, in the standard definitions, can use an unbounded number of bits of randomness in each node of the network, where all the bits (in the same node and also across the whole network) are assumed to be independent of each other. As mentioned before, for many of the classic problems in distributed graph algorithms, the known randomized algorithms are considerably more time-efficient compared to their deterministic counterparts. Our goal in this section is to investigate this gap, by viewing the bits of randomness as a scarce resource and asking “how much” of it is really needed for “efficiency”. We next discuss how we make these two phrases of how much and efficiency more concrete.

Regarding “efficiency”, our concrete objective is to be able to solve the classic local problems in distributed graph algorithms (e.g., network decompositions, maximal independent set, and $\Delta+1$ coloring) in time polylogarithmic in $n$, given the limited randomness that we have. Recall that this polylogarithmic time is usually construed as a first-order definition of efficiency [Bar12] and it is achievable using randomized algorithms with unbounded randomness per node. Regarding “how much” randomness, we formalize the question and study it in three different ways:

• (A)

What if instead of each node having access to its own (unbounded) source of random bits, we only have some few bits of randomness in the whole network but such that each node can reach at least one of them? Concretely, we assume that some nodes $S\subseteq V$ of the network hold some bits of randomness (which are independent of each other), each holding just a single bit, and for each node $v\in V$, there is at least one node $s\in S$ within distance $h$ hops of $v$. In order so that just accessing this bit of randomness is time-efficient, we will assume that $h=\operatorname{poly}(\log n)$.

• (B)

What if the bits of the randomness in the network are correlated and have only some limited independence, e.g., they that $k$-wise independent for $k=\operatorname{poly}(\log n)$?

• (C)

What if instead of each node having its own independent bits, which amounts to $\Omega(n)$ bits in the whole network, we have only $k$ bits of global shared randomness?

We discuss these directions separately, (A) in Section 3.1 and (B) and (C) in Section 3.2.

3.1 One Bit of Private Randomness Per $\operatorname{poly}(\log n)$ Hops

In this subsection, we work under the assumption that there is one bit of randomness within $\operatorname{poly}(\log n)$ distance of each node, and we show that this amount suffices for building network decompositions with $\operatorname{poly}(\log n)$ colors and radius. Therefore, this amount of randomness suffices to have a $\operatorname{poly}(\log n)$-round $\mathsf{LOCAL}$ model algorithm for any (locally checkable) problem that can be solved in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model using unbounded randomness. We provide a construction of network decomposition in the $\mathsf{CONGEST}$ model, with the hope that this construction can be useful also in settings where we care about having small messages.

Theorem 3.1**.**

Suppose that nodes $S\subseteq V$ of the network hold some independent bits of randomness, each holding just a single bit, and for each node $v\in V$, there is at least one node $s\in S$ within distance $h$ hops of $v$, where $h=\operatorname{poly}(\log n)$. Then, there is a $\operatorname{poly}(\log n)$-time distributed algorithm in the $\mathsf{CONGEST}$ model that, using only these bits as its source of randomness, constructs a $(O(\log n),h\operatorname{poly}(\log n))$-network decomposition of the the graph with congestion $1$.

Proof.

The proof of Theorem 3.1 consists of two parts, which we next present as Lemmas 3.2 and 3.3. In Lemma 3.2, we use a certain ruling set construction to cluster nodes into low-diameter clusters, each each cluster has some $\operatorname{poly}(\log n)$ bits of randomness, unless the cluster is a connected component on its own. Then, in Lemma 3.3, we use this randomness to build the desired network decomposition. Theorem 3.1 directly follows from the statements of Lemmas 3.2 and 3.3. ∎

Note that an undesirable property of Theorem 3.1 is that $h$ appears in the diameter of the network decomposition. In Theorem 3.7, we explain how to fix that issue, using some of the methods that we will discuss in the next subsection. Before stating the two lemmas to prove Theorem 3.1, we first recall the notion of ruling sets and the known deterministic algorithms for them.

Ruling Sets:

We need the notion of ruling sets as introduced in [AGLP89] in some of our algorithms. Given a graph $G=(V,E)$, a subset $U\subseteq V$ of the nodes of $G$, and two parameters $\alpha,\beta\geq 1$, a $(\alpha,\beta)$-ruling set of $G$ w.r.t. $U$ is a subset $S\subseteq U$ of the nodes in $U$ such that for all $x,y\in S$, $d_{G}(x,y)\geq\alpha$ and for all $x\in U$, there exists a $y\in S$ such that $d_{G}(x,y)\leq\beta$. For any $\alpha\geq 2$, a $(\alpha,\alpha\log n)$-ruling set of $G$ w.r.t. $S$ can be computed deterministically in time $O(\alpha\cdot\log n)$ in time $O(\alpha\cdot\log n)$ in the $\mathsf{CONGEST}$ model [AGLP89, HKN16].

Now, we are ready to provide the lemmas that prove Theorem 3.1.

Lemma 3.2**.**

Suppose that nodes $S\subseteq V$ of the network hold some independent bits of randomness, each holding just a single bit, and for each node $v\in V$, there is at least one node $s\in S$ within distance $h$ hops of $v$, where $h=\operatorname{poly}(\log n)$. Then, there is an $O(hk\log n)$-round deterministic algorithm in the $\mathsf{CONGEST}$ model that partitions the nodes into disjoint clusters, each inducing a connected subgraph with diameter $O(kh\log n)$, with the following property: Each cluster is either (A) isolated — meaning that it has no neighboring cluster — or (B) its center holds $k$ bits of randomness, which are independent of each other and independent of the bits held by other cluster centers.

Proof of Lemma 3.2.

First, we compute a certain $(h^{\prime},h^{\prime}\log n)$-ruling sets $R$, for $h^{\prime}=10kh$. That is, any two nodes of $R$ have distance at least $h^{\prime}$ from each other and moreover, for each node $v\in V$, there is at least one node of $R$ within its distance $h^{\prime}\log n$. This can be computed directly in the $\mathsf{CONGEST}$ using the ruling set algorithm of Awerbuch et al.[AGLP89], as we remarked in Section 2. Now, define clusters in the graph, one centered at each node in $R$, where each node $v\in V$ joins the cluster of the nearest $R$ node. Notice that this is doable in $h^{\prime}\log n$ rounds, using a simple flooding of the name of nodes in $R$, where only the first name is propagated. Then, each node $v\in V$ knows its cluster center in $R$. Let us focus on one cluster $\mathcal{C}$ centered at node $r\in R$. There are two possibilities:

In the easier case of singularity where the cluster has no neighboring cluster, we leave these clusters on their own; these satisfy property (A) in the lemma statement, and later, when it comes to building a network decomposition, we will color these clusters easily with color $1$, as one of the clusters of our network decomposition.

In the less trivial case, suppose that $\mathcal{C}$ has at least one neighboring cluster $\mathcal{C}^{\prime}$ centered at $r^{\prime}\in R$. Then, on the shortest path $\mathcal{P}$ connecting $r$ to $r^{\prime}$, the first $h^{\prime}/3$ nodes $F\subset\mathcal{P}$ belong to $\mathcal{C}$ (they cannot belong to any other cluster, as that would be in contradiction with $R$ being $h^{\prime}$ independent). In fact, for each node $w\in F$, even the whole $h^{\prime}/6$-hop neighborhood of $w$ belongs to $\mathcal{C}$, for the same reason. Now, we can choose $h^{\prime}/(10h)>k$ nodes $F^{\prime}\subset F$ such that any two nodes of $F^{\prime}$ have distance at least $3h$ from each other. For each node $w\in F^{\prime}$, there is some node $s_{w}\in S$ within $h$ hops of $w$ that holds a random bit. Moreover, these source nods $s_{w}$ are distinct for any different nodes $w,w^{\prime}\in F^{\prime}$, because any two nodes of $F^{\prime}$ have distance at least $3h$. Since $h^{\prime}/6$-hop neighborhood of any node in $F$ is in $\mathcal{C}$, and given that $h\gg h^{\prime}/6$, all nodes $s_{w}$ for all $w\in F^{\prime}$ are also in $\mathcal{C}$. Therefore, cluster $\mathcal{C}$ contains at least $h^{\prime}/(10h)>k$ bits of randomness. We can propagate this amount of randomness to the cluster center $r$, by a simple upcast on the tree connecting $r$ to the nodes of $\mathcal{C}$, in $O(h^{\prime}\log n+k)=O(h^{\prime}\log n)=O(kh\log n)$ rounds. ∎

Lemma 3.3**.**

Suppose that we are given a partitioning of the nodes into disjoint clusters, each inducing a connected subgraph with diameter $O(h\log^{3}n)$, with the following property: Each cluster is either (A) isolated — meaning that it has no neighboring cluster — or (B) its center holds $C\log^{2}n$ bits of randomness, which are independent of each other and independent of the bits held by other cluster centers. Then, there is a $h\cdot\operatorname{poly}(\log n)$-time distributed algorithm in the $\mathsf{CONGEST}$ model that, using only these bits as its source of randomness, constructs a $(O(\log n),h\operatorname{poly}(\log n))$-network decomposition of the the graph with congestion $1$.

Proof of Lemma 3.3.

On a high-level, our network decomposition is obtained by running the randomized algorithm of Elkin and Neiman[EN16], itself inspired by Blelloch et al.[BGK*+*14] and Miller et al.[MPX13], on top a logical network where we virtually contract each cluster to be a single node. This logical cluster graph $\mathcal{CG}$ is obtained by viewing each cluster as one node and connecting two clusters if they include nodes that are adjacent, in the base graph. Each round of communication between two neighboring clusters can be performed in $O(h^{\prime}\log n)$ rounds, given that the centers are within $O(h^{\prime}\log n)$ hops of each other. One has to be careful with one subtlety: we cannot simulate a full-fledged $\mathsf{CONGEST}$ model on this cluster graph, e.g., if a cluster has to receive many different messages from many different neighboring clusters, we might not be able to deliver all of these messages to the center of the cluster, in time proportional to the cluster radius. However, in order to run the construction of Elkin and Neiman[EN16], it will suffice for us to deliver an aggregate function of the messages sent by neighboring clusters to the cluster center, e.g., the minimum value in these messages.

Construction:

We next give a brief overview of the algorithm of [EN16]. Our description is phrased as running on top of our clusters. The construction has $10\log n$ phases, where in each phase $i$ we gradually color some non-adjacent set of the clusters with color $i$ and remove them from the graph. Let each center $v$ of a cluster $\mathcal{C}$ pick a random value $r_{v}$ from a geometric distribution888Elkin and Neiman[EN16] wrote their description by choosing random variables $r_{v}$ from an exponential distribution, which can assume continuous values. We would like to explicitly talk about the number of random bits and for that, the geometric distribution is more convenient. The arguments of Elkin and Neiman[EN16] about the exponential distributed extends to its discrete analog, the geometric distribution; the core property of being a memoryless distribution which holds for both distributions., where $Pr[r_{v}=k]=2^{-k}$. Then, each cluster $\mathcal{C}^{\prime}$ centered at node $u$ considers the maximum two clusters according to the measure $r_{v}-dist_{\mathcal{CG}}(v,u)$, where $dist_{\mathcal{CG}}(v,u)$ is the distance between the clusters centered at $v$ and $u$ in the cluster graph $\mathcal{CG}$. Let $m_{1}$ and $m_{2}$ be the two maximum measures. If $m_{1}-m_{2}>1$, then the cluster $\mathcal{C}^{\prime}$ centered at $u$ gets colored in this phase with color $i$. If $m_{1}-m_{2}\in\{0,1\}$, then cluster $\mathcal{C}^{\prime}$ remains for the next phase. Each phase runs in $O(\log n)$ rounds on top of the cluster graph $\mathcal{CG}$. This can be performed in $O(h\log^{2}n)$ rounds on the base graph $G$, because each cluster $\mathcal{C}^{\prime}$ centered at a node $u$ needs to pass to each of its neighbors only the top two cluster names $\mathcal{C}$ centered at node $v$ and radii $r_{v}$ according to measure $r_{v}-dist_{\mathcal{CG}}(v,u)$. Over all the $10\log n$ phases, this translates to a round complexity of $O(h\log^{3}n)$.

Randomness:

We argue that the randomness that we have in clusters suffices for the construction. To choose the random value $r_{v}$ for each phase, having $10\log n$ bits suffices, with high probability: To generate $r_{v}$, think about the process of flipping coins one by one until the first tail coin shows up. The iteration of the first tail is the value $r_{v}$. With probability $1-1/n^{10}$, we toss at most $10\log n$ coins, before the first tail. Hence, to run all the $10\log n$ phases, $100\log^{2}n$ bits suffice999In fact, $O(\log n)$ bits suffice for all phases as the number of coins until one sees $\Theta(\log n)$ tails is, w.h.p., $O(\log^{2}n)$..

Properties of network decomposition:

We give only a sketch; the proof details can be found in [EN16]. First, as another corollary of the above, we also see that with high probability, we have $\max\{r_{v}\}=O(\log n)$. Thus, each cluster $\mathcal{C}^{\prime}$ that gets color $i$ is at most $O(\log n)$ hops away from its central cluster $\mathcal{C}$, in the cluster graph $\mathcal{CG}$. Moreover, as argued in [EN16, Lemma 4], due the way of tie breaking by measure $r_{v}-dist_{\mathcal{CG}}(v,u)$, we can see that (I) any two neighboring clusters that get color $i$ must have the same central cluster $\mathcal{C}$, and (2) all clusters on the shortest path in $\mathcal{CG}$ from $\mathcal{C}$ to $\mathcal{C}^{\prime}$ are also colored with color $i$. Hence, they induce a connected subgraph with radius $O(\log n)$ in the cluster graph $\mathcal{CG}$ and thus also a connected subgraph with radius $O(h\log^{3}n)$ in the base graph $G$. Finally, the probability of a cluster remaining uncolored in one phase is $1/2$[EN16, Claim 6]. Hence, after $10\log n$ phases, with high probability, all clusters are colored. Hence, we get a strong-diameter network decomposition with $10\log n$ colors and diameter $O(h\log^{3}n)$, i.e., an $((10\log n),O(h\log^{3}n))$-network decomposition with congestion $1$. ∎

3.2 Shared Randomness, and Private Randomness with Limited Independece

We now ask how many bits of globally shared randomness are sufficient for efficiency (when there is no private randomness). Another way of viewing the question is asking how much randomness is needed, in total, over the whole network. Standard randomized algorithms use $\Omega(n)$ bits, e.g., at least one bit per node. The arguments of the previous section can be used to lower this somewhat but it might still be $\tilde{\Omega}(n)$ bits in some networks. But in fact, much less suffices, merely $\operatorname{poly}(\log n)$ bits. Incidentally, when showing this, we will also prove that in the standard model where each node has some private randomness, say e.g., $\operatorname{poly}(\log n)$ bits, we do not need these bits to be fully independent and it suffices if the bits in the whole network are only $\operatorname{poly}(\log n)$-wise independent.

First, we investigate these questions in the $\mathsf{LOCAL}$ model. We explain that with just $O(\log n)$ bits of shared randomness, we can solve the splitting problem introduced by Ghaffari et al.[GKM17]. This is a problem that nicely captures the power of randomness as it can be solved using randomized algorithms in zero rounds, and it was shown[GKM17] that if one can solve it in $\operatorname{poly}(\log n)$ rounds deterministically, then we can derandomize all $\operatorname{poly}(\log n)$-round randomized algorithms for any locally checkable problem. In particular, [GKM17] gives a reduction that solves network decomposition using $\operatorname{poly}(\log n)$ iterations of splitting, and this implies $\operatorname{poly}(\log n)$ bits of shared randomness suffice for network decomposition, in the $\mathsf{LOCAL}$ model. Then, we also show that similar ideas can be used to prove that $\operatorname{poly}(\log n)$-wise independence among the private bits of randomness in the network suffices for network decomposition in the $\mathsf{CONGEST}$ model. Finally, we turn our attention to the $\mathsf{CONGEST}$ model and show a more explicit algorithm (instead of reductions) that builds network decompositions in $\operatorname{poly}(\log n)$ rounds using $\operatorname{poly}(\log n)$ bits of shared randomness.

Splitting in zero rounds, using $O(\log n)$ bits of shared randomness:

Ghaffari et al.[GKM17] defined a certain problem called splitting, which can be solved using randomized algorithms in zero rounds with high probability, and showed that if one can solve this problem in $\operatorname{poly}(\log n)$ rounds deterministically, then one can derandomize all $\operatorname{poly}(\log n)$-round randomized algorithms for any locally checkable problem. We show that $O(\log n)$ bits of shared randomness suffice for solving this problem in zero rounds, with high probability. In the splitting problem, we are given a bipartite graph $H=(U,V,E)$ where each node in $U$ has at least $\Omega(\log^{c}n)$ neighbors in $V$ and we should color each node of $V$ red or blue so that each node of $U$ has at least one neighbor in each color. Here, $c$ can be set to be a desirably large constant $c\geq 1$.

Lemma 3.4**.**

There is a randomized algorithm that using $O(\log n)$ bits of shared randomness solves the splitting problem, in zero rounds, with probability at least $1-1/n$.

Proof.

Notice that coloring each node of $U$ randomly red or blue satisfies this constraint, with high probability (by applying a Chernoff bound on the neighborhood of each node in $U$ and then a union bound over all nodes in $U$).

There are two well-known arguments for showing that a small amount of shared randomness suffices for this problem. First, thanks to the variant of Chernoff that holds for $p$-wise independent random variables [SSS95], we can see that $O(\log n)$-wise independence suffices for this argument. Moreover, we can build $\operatorname{poly}(n)$ bits that are $p$-wise independent, by using merely $O(p\log n)$ bits that are fully independent, using standard constructions, see e.g., [AS04]. This means $O(p\log n)=O(\log^{2}n)$ bits of shared randomness suffice for splitting. Second, a result of Naor and Naor[NN93] can be used to show that even $O(\log n)$ bits suffice. They give a construction of $p$-wise $\varepsilon$-bias spaces. Very roughly speaking, these are spaces that are approximately $k$-wise independent; see their paper for the definition, and also for the concentration inequalities that can be derived for such random variables. In their section 6.1, they show that a sample space of size $n^{O(1)}$ suffices for getting a coloring where each node has at least one neighbors in each color101010Their phrasing is different. They talk about a problem called set balancing, in the context of discrepancy theory. But the problems are the same and when we assume that the minimum degree is at least $d$, their construction in section 6.1 suffices to get a discrepancy of $O(d^{1/2+\delta}\cdot\sqrt{\log n})$ between the two colors, for any constant $\delta>0$. Setting $\delta=0.1$ and $c\geq 1+4\delta=1.4$ in the definition of the splitting problem ensures that $d^{1/2+\delta}\cdot\sqrt{\log n}=o(d)$.. This $n^{O(1)}$ size space means $O(\log n)$ bits of shared randomness suffice to sample from this space. ∎

Network decomposition in $\mathsf{LOCAL}$ using $\operatorname{poly}(\log n)$-wise independent bits:

There are known randomized construction of network decomposition with $\operatorname{poly}(\log n)$ parameters in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model[LS93, EN16]. These all assume that the random bits of different nodes are fully independent of each other. We show that limited independence suffices. Concretely, it is enough if each node has $\operatorname{poly}(\log n)$ bits of randomness and over the whole network these bits are $\operatorname{poly}(\log n)$-wise independent. Notice that this also allows us to say that we can build such a network decomposition with only $\operatorname{poly}(\log n)$ bits of shared randomness. The reason is that by standard constructions of $k$-wise independent random bits[AS04], we need only $O(k\log n)$ fully independent random bits to be able to produce $\operatorname{poly}(n)$ random bits that are $k$-wise independent. Hence, if there are $\operatorname{poly}(\log n)$ bits of shared randomness, we can construct $\operatorname{poly}(n)$ many bits of randomness out of them which are $\operatorname{poly}(\log n)$-wise independent, using a deterministic procedure. These bits can be shared among the nodes, e.g., just by identifiers. Hence, we then have a setting where each node $\operatorname{poly}(n)$ bits of randomness and the bits over the whole network are $\operatorname{poly}(\log n)$-wise independent. By what we will show below, this allows us to build a network decomposition with $\operatorname{poly}(\log n)$ parameters in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model.

Theorem 3.5**.**

There is a distributed algorithm that builds a network decomposition with $\operatorname{poly}(\log n)$ parameters in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{LOCAL}$ model, assuming each node has $\operatorname{poly}(\log n)$ bits of randomness and over the whole network these bits are $\operatorname{poly}(\log n)$-wise independent.

Proof.

To construct a network decomposition with $\operatorname{poly}(\log n)$ parameters, we instead give a $\operatorname{poly}(\log n)$-round algorithm for a different problem called conflict-free hypergraph multi-coloring. In [GKM17], it is shown that network decomposition can be formulated as an instance of conflict-free hypergraph multi-coloring. Hence, our solution for the latter problem immediately implies a construction for network decomposition.

In the conflict-free hypergraph multi-coloring, we are given a hypergraph with $\operatorname{poly}(n)$ hyperedges, on the $n$ nodes of our graph. Moreover, hyperedges are grouped in $\log n$ classes, where all hyperedges of the $i^{th}$ class contain a number of vertices in $[2^{i-1},2^{i})$. The objective is to multi-color the vertices with $\operatorname{poly}(\log n)$ colors — multi-coloring means a node is allowed to have many colors — such that for each hyperedge, there is one color such that exactly one node of this hyperedge has that color. Ghaffari et al.[GKM17] also gave a $\operatorname{poly}(\log n)$-round deterministic algorithm for conflict-free hypergraph multi-coloring, whenever all hyperedges have size at most $\operatorname{poly}(\log n)$. We explain that a source of $\Theta(\log^{2}n)$-wise independent random bits allows us to reduce the general case to this special case where all hyperedges have size at most $\operatorname{poly}(\log n)$, which can be solved then deterministically by the algorithm of [GKM17].

We use different colorings for the $\log n$-different hyperedge size classes. Our focus is now to get a conflict-free multi-coloring with $\operatorname{poly}(\log n)$ colors, for each hyperedge size class. Let us focus on one class: For hyperedges with size in $[2^{i-1},2^{i})$, if $2^{i}\leq\operatorname{poly}(\log n)$, we do not need to do anything as the deterministic algorithm of [GKM17] is directly applicable. Otherwise, mark each node randomly with probability $p=\frac{\Theta(\log n)}{2^{i}}$. Notice that each node can do this using $\log n$ bits of randomness. Moreover, if these bits are $(k\log n)$-wise independent, then any set of at most $k$ nodes are marked independently of each other. That is, whether nodes are marked or not are $k$-wise independent, which means for any set $S$ of nodes with $|S|\leq k$, the probability that all nodes of $S$ are marked is $p^{k}$. We set $k=\Theta(\log n)$. Hence, by an application of the extension of Chernoff bound to $k$-wise independent random variables[SSS95], we can infer that in each hyperedge of size $[2^{i-1},2^{i})$, we have $\Theta(\log n)$ marked nodes, with probability $1-1/\operatorname{poly}(\log n)$. Now, we apply the deterministic algorithm of [GKM17] on these hyperedges, which consist of only marked nodes, hence getting a conflict-free multi-coloring of it with $\operatorname{poly}(\log n)$ colors, in $\operatorname{poly}(\log n)$ rounds. Finally, we recall that we use $\log n$ different collections of colors, for different hyperedge size classes, where each collection has $\operatorname{poly}(\log n)$ colors. Hence, we get a conflict-free multi-coloring of the whole hypergraph. ∎

An idea similar to above can be used to show that $\operatorname{poly}(\log n)$ bits of shared randomness suffice for network decomposition, thanks to standard constructions of $k$-wise independent random bits. The following theorem given an even stronger result, by showing that such a construction can be performed even in the $\mathsf{CONGEST}$ model (using a very different method, and by making use of a randomized construction of Elkin and Neiman[EN16].)

Theorem 3.6**.**

There is a distributed algorithm that builds a $(O(\log n),O(\log^{2}n))$-network decomposition with congestion $1$, in $\operatorname{poly}(\log n)$ rounds in the $\mathsf{CONGEST}$ model, using only $\operatorname{poly}(\log n)$ bits of shared randomness (and no private randomness).

Proof.

The construction works in $O(\log n)$ phases, where per phase each node gets clustered with at least a constant probability, and remains for the next phases otherwise. We describe the process for one phase, which will define non-adjacent clusters, each with radius $O(\log^{2}n)$, such that each node is clustered with at least a constant probability. Repeating this process for $O(\log n)$ phases gives us the desired network decomposition, with high probability. The point for us is to describe how we perform one phase in $\operatorname{poly}(\log n)$ rounds of the $\mathsf{CONGEST}$ model and using only $\operatorname{poly}(\log n)$ bits of shared randomness. We first describe a construction assuming fully independent random bits and then argue why it can be performed using only $\operatorname{poly}(\log n)$ bits.

Construction for One Phase:

The construction for one phase consists of $p=\Theta(\log n)$ epoch, indexed by $i=1,2,...,p$. For epoch $i$, we define a base radius $R_{i}:=(p-i)\cdot c\log n$ for a sufficiently large constant $c\geq 10$. At the beginning of an epoch, each node that is still available decides to be a center with probability $O(2^{i}\cdot\log n)/n$. Each node $u$ that decides to be a center then chooses a random variable $X_{u}$ according to a geometric distribution with parameter $1/2$. That is, $Pr[X_{u}=Z]=2^{-Z}$ for any integer $Z\geq 1$. Notice that with high probability, for each center $u$, we have $X_{u}\leq c\log n$. The intuitive way of interpreting these random variables is that the cluster of center $u$ will grow up to a distance of at most $R_{i}+X_{u}$, from its center $u$. We say the cluster of $u$ can reach node $v$ if $(R_{i}+X_{u})\geq d_{G}(u,v)$. The actual clusters are defined as follows: Each node $v$ selects a center $u$ for which $(R_{i}+X_{u})-d_{G}(u,v)\geq 0$ and who maximizes $(R_{i}+X_{u})-d_{G}(u,v)$. For $v$, let $m_{1}$ and $m_{2}$ be the the two largest values $R_{i}-(X_{u}+d_{G}(u,v))$ among cluster center whose cluster reaches $v$. If there is no second cluster, define $m_{2}=0$. If $v$ received from at least one cluster center, then $v$ will be removed in this phase, and either clustered or set aside, according to the following criterion: If $m_{1}-m_{2}>1$, then $v$ joins the cluster of its center $u$; otherwise, it is set aside and it remains unclustered for the whole duration of this phase (it will be brought back in the next phases, to get clustered then). If no cluster reaches $v$ in this epoch, then $v$ continues to the next epoch.

Correctness:

The fact that the carved clusters are non-adjacent and each has strong diameter at most $O(\log^{2}n)$ are similar to the case discussed before, for the construction in Lemma 3.3; the argument is the same as [EN16, Lemma 4]. We can also show that each node $v$ has probability $1/2$ to be clustered, in each phase. Consider the first epoch in which node $v$ is reached by some cluster. Similar to Lemma 3.3, and as shown in [EN16, Claim 6], we see that conditioned on $v$ being reached by some cluster, the probability that it has $m_{1}-m_{2}>1$ is at least a constant. If $v$ is reached in this epoch but it has $m_{1}-m_{2}\in\{1,0\}$, then it is set aside and it remains for the next phases. Given the fact that the probability of being chosen as a centered grows as $\frac{2^{i}\log n}{n}$ with epoch number $i$, in some epoch, some center’s cluster reaches $v$; because at the very latest, in the last epoch, $v$ itself (if remaining) becomes a center with probability $1$ and its ball reaches itself. Thus, in each phase, $v$ gets clustered with at least a constant probability. Therefore, in $O(\log n)$ phases, node $v$ gets clustered with high probability.

Randomness:

We now discuss how to use a limited amount of randomness for the above algorithm. We use a source of $\Theta(\log^{2}n)$-wise independent random bits for nodes deciding whether they are sampled or not, for each epoch. Randomness in different epochs and different phases are independent. Moreover, we use another (independent) source of $\Theta(\log^{2}n)$-wise independent random bits for each sampled center $u$ determining their random radii $X_{u}$. We next argue why this suffices.

Notice that the radius $R_{i}$ decreases by $c\log n$ in each epoch, and the random values $X_{u}$ for the centers are always upper bounded by $c\log n$, with high probability. We can use this to conclude that in each epoch, w.h.p., each node $v$ can only be reached by at most $O(\log n)$ different centers. The reason is as follows: If there are more than $C\log n$ centers that can reach $v$ in the current epoch $i$, for a sufficiently large $C$, it means that the number of nodes in distance $R_{i-1}$ of $v$ is at least $\frac{Cn}{2\cdot 2^{i}}$, with high probability (using Chernoff for sum of variables that are $(\log n)-$wise independent). That means, in epoch $i-1$ where the sampling probability was $\frac{\log n\cdot 2^{i-1}}{n}$, with high probability, at least one of these nodes should have been sampled to be a center (again, using Chernoff for sum of variables that are $(\log n)-$wise independent). That means, at least one center would have reached $v$ in the previous epoch, which means $v$ would have been removed for this epoch. Thus, we conclude that in each epoch, at most $O(\log n)$ sampled centers can reach $v$.

Now, we come to analyzing the random radii, and the probability of a node $v$ being clustered in the the first epoch in which a cluster reaches it. Notice that thanks to the property discussed above, there are only $O(\log n)$ sampled centers that can reach $v$. Hence, the event of whether $v$ is clustered or not depends only on the random radii of these $O(\log n)$ cluster centers. But that is an event that is determined by $O(\log^{2}n)$ bits of randomness, $O(\log n)$-bits per cluster center. Given $\Theta(\log^{2}n)$-wise independence of the bits used for defining radii, this space is the same as when the randomness is fully independent. Hence, the analysis explained above applies and shows that $v$ is clustered in this epoch with probability at least a constant. Since different phases have independent randomness, we can conclude that $v$ gets clustered in some phase, with high probability. ∎

Theorem 3.7**.**

Suppose that nodes $S\subseteq V$ of the network hold some independent bits of randomness, each holding just a single bit, and for each node $v\in V$, there is at least one node $s\in S$ within distance $h$ hops of $v$, where $h=\operatorname{poly}(\log n)$. There is a distributed algorithm that works in $h\operatorname{poly}(\log n)$ rounds of the $\mathsf{CONGEST}$ model and constructs a strong-diameter network decomposition with $O(\log n)$ colors and $O(\log^{2}n)$ radius.

Proof Sketch of Theorem 3.7.

We perform the bit gathering of Lemma Lemma 3.2 so that each cluster center has $O(\log^{4}n)$ bits. Then, we share this randomness to all the nodes of the cluster. We then apply the network decomposition explained in the previous section, using these $O(\log^{4}n)$ bits. Notice that in each cluster, the bits of randomness are independent and they can be viewed as shared randomness. In different clusters, we have bits that are fully independent of each other. This allows us to run the construction of Section 3.2, in a direct way, and obtain a strong-diameter network decomposition with $O(\log n)$ colors and $O(\log^{2}n)$ radius. ∎

4 Time vs. Error Probability Trade-Offs

In this second part, we investigate the success probability randomized local distributed graph algorithms. In particular, we are interested in understanding the trade-off between the time complexity of a randomized algorithm and its success probability. Given a time budget, what is the best achievable error probability and at what point is it even possible to completely derandomize and obtain a deterministic algorithm? We first state a basic (and known) such derandomization lemma.

Lemma 4.1** (Implicit in [CKP16]).**

Assume that we are given a non-uniform randomized distributed algorithm $\mathcal{A}$ that is given $n$ as input and solves a given distributed graph problem $\mathcal{P}$ on node graphs of size at most $n$ with probability at least $1-2^{-n^{2}}$ in time $T(n)$. Then, there also exists a deterministic algorithm $\mathcal{A}^{\prime}$ that solves $\mathcal{P}$ on graphs of size at most $n$ in time $T(n)$. If $\mathcal{A}$ works in the $\mathsf{CONGEST}$ model, $\mathcal{A}^{\prime}$ also works in the $\mathsf{CONGEST}$ model.

Proof.

We only sketch a proof of this lemma here. A more detailed proof for example appears as part of Theorem 3 in [CKP16].

In a randomized algorithm, we can w.l.o.g. assume that each node $v\in V$ first chooses a sequence of random bits $X_{v}$ and that afterwards, the algorithm is run deterministically. We can think of this initial randomness as a random function $\phi(i)$ that assigns a random bit string to every possible node ID $i$. Assume that node IDs are from the range $\left\{1,\dots,n^{c}\right\}$ and let $\mathcal{G}_{n}$ be the family of graphs with at most $n$ nodes, where each node has a unique label from $\left\{1,\dots,n^{c}\right\}$. The number of such graph is $|\mathcal{G}_{n}|\leq n\cdot 2^{{n\choose 2}}\cdot n^{cn}<2^{n^{2}}$ for sufficiently large $n$. If each of the possible assignments of random bits fails on at least one of the graphs in $\mathcal{G}_{n}$, the success probability of the algorithm cannot be better than $1-1/|\mathcal{G}_{n}|<1-2^{-n^{2}}$. There therefore needs to be at least one possible assignment of the random bits for each node ID such that the algorithm works for every graph in $\mathcal{G}_{n}$. We can run $\mathcal{A}$ with this assignment of random bits and obtain a deterministic algorithm $\mathcal{A}^{\prime}$ with the same running time. The maximum messages size of $\mathcal{A}^{\prime}$ is at most as large as the maximum message size of $\mathcal{A}$ and $\mathcal{A}^{\prime}$ therefore works in the $\mathsf{CONGEST}$ model if $\mathcal{A}$ works in the $\mathsf{CONGEST}$ model. ∎

We are usually interested in success probabilities of the form $1-1/n^{c}$ for some constant $c$. By increasing the running time by a factor $\tau>1$, one can often improve the error probability by a factor that is exponentially small in $\tau$. This leads to error probabilities that are at best exponentially small in the running time. As a first contribution of this section, the following theorem shows that by using the graph shattering technique (cf. the respective discussion in Section 1), we can boost the success probability when computing a network decomposition significantly beyond this. By the reductions in [GKM17, GHK18], we then also immediately get the same improvement in the success probability for all $\operatorname{poly}(\log n)$-locally checkable graph problems that have $\operatorname{poly}(\log n)$-time randomized distributed algorithms with only polynomially small error probability.

Theorem 4.2**.**

Let $T(n)\geq\log^{c}n$ for a sufficiently large constant $c>0$. There is a randomized $\mathsf{CONGEST}$ model algorithm that computes a \big{(}T(n),T(n)\big{)}-decomposition with congestion $1$ and a randomized $\mathsf{LOCAL}$ algorithm to compute a strong diameter \big{(}O(\log n),O(\log n)\big{)}-decomposition in time $T(n)$ with success probability at least $1-n^{-2^{\varepsilon\cdot\log^{2}T(n)}}$ for some constant $\varepsilon>0$.

Proof.

For convenience, we only prove that the time complexities of the resulting $\mathsf{CONGEST}$ and $\mathsf{LOCAL}$ algorithms is $T(n)\cdot\operatorname{poly}\log n$. Note that by applying this weaker statement for an appropriately chosen smaller value of $T(n)$ and by choosing the constants $c$ and $\varepsilon$ appropriately, the claim of the theorem then follows.

The algorithm consists of 2 main steps. First, we apply a standard randomized polylog-time network decomposition algorithm $\mathcal{A}$ that succeeds w.h.p. The success probability of $\mathcal{A}$ is not as high as we need it to be, however, we show that after running $\mathcal{A}$, the number of sufficiently separated remaining nodes is small with the “right” success probability. This allows to compute a decomposition on the remaining nodes by using adeterministic network decomposition algorithm.

For the first step, we apply the randomized decomposition algorithm of Elkin and Neiman [EN16], which computes a strong diameter \big{(}O(\log n),O(\log n)\big{)}-decomposition in time $O(\log^{2}n)$ in the $\mathsf{CONGEST}$ model (and thus in particular a decomposition with congestion $1$). The parameters in the algorithm of [EN16] such that it succeeds with probability at least $1-1/n^{2}$. In the following, assume that the algorithm is run in this way. In particular, this also implies that for every node $v\in V$, the probability at $v$ is in a cluster after running the algorithm is at leat $1-1/n^{2}$.

For a subset $S\subseteq V$, we say that $S$ is $d$-separated if any two nodes in $S$ are at distance at least $d$ in $G$. Let $t(n)=O(\log^{2}n$) be the running time of the algorithm of [EN16]. Further, let $\bar{V}\subseteq V$ be the set of nodes that are not inside a cluster after running the algorithm. Note that the output of a node $u\in V$ can only depend on the random bits of nodes within distance at most $t(n)$ of $u$. Hence, the outputs of a set $S$ of nodes at pairwise distance at least $2t(n)+1$ are independent. In particular, the events that the nodes in $S$ are in $\bar{V}$ are independent. Let $S\subseteq V$ therefore be such a $(2t(n)+1)$-separated set of nodes. The probability that all nodes in $S$ are in $\bar{V}$ is at most $1/n^{2|S|}$. For any $K\geq 1$, the probability that $\bar{V}$ contains a $(2t(n)+1)$-separated set $S$ of size at least $K$ is thus at most ${n\choose K}\cdot 1/n^{2K}\leq 1/n^{K}$. We choose the value $K$ such that this probability is upper bounded by the failure probability required by the lemma statement, i.e., we choose $K$ such that $n^{K}\geq n^{2^{\varepsilon\cdot\log^{2}T(n)}}$ and we can thus choose $K=2^{\varepsilon\cdot\log^{2}T(n)}$ for an appropriate constant $\varepsilon>0$.

Our goal is to reduce the remaining problem to deterministically computing a network decomposition on a graph of size at most $K$. As a first step, we compute a $(2t(n)+1)$-separated subset $S\subseteq\bar{V}$ of remaining nodes. This can be done by computing a \big{(}2t(n)+1,O(t(n)\log n)\big{)}-ruling set $S$ w.r.t. $\bar{V}$. Note that because $S$ is a $(2t(n)+1)$-separated set of nodes, with probability at least $1-1/n^{K}$, its size is at most $K$. For the rest of the proof, we therefore assume that $S$ is of size at most $K$. Because $S$ is a \big{(}2t(n)+1,O(t(n)\log n)\big{)}-ruling set w.r.t. $\bar{V}$, each remaining node $u\in\bar{V}$ has at least one node in $S$ within distance $O(t(n)\log n)$ in $G$. By starting parallel BFS explorations from each node $v\in S$, we can therefore build a cluster $C_{v}$ of radius at most $O(t(n)\log n)$ around each node $v\in S$ such that each node $u\in\bar{V}$ is contained in the cluster of its closest node in $S$ (ties broken arbitrarily). For each cluster $C_{v}$, we obtain a spanning tree of depth $O(t(n)\log n)$ and the trees of different clusters are vertex-disjoint. We note that the trees might contain nodes of $V\setminus\bar{V}$. We define the cluster graph $G_{C}$ as the graph defined on the set of clusters $C_{v}$ for $v\in S$, where two clusters $C_{u}$ and $C_{v}$ are neighbors whenever there are nodes $x\in C_{u}\cap\bar{V}$ and $y\in C_{v}\cap\bar{V}$ that are neighbors in $G$. In [Gha19], it is possible to compute a strong-diameter \big{(}2^{O(\sqrt{\log K})},2^{O(\sqrt{\log K})}\big{)}-decomposition of such a cluster graph in time $2^{O(\sqrt{\log K})}$ times the maximum cluster radius. Note that since the clusters a vertex-disjoint, a strong-diameter decomposition of $G_{C}$ leads to a decomposition with congestion $1$ for the remaining nodes $\bar{V}$ on $G$. By our choice of $K=2^{\varepsilon\cdot\log^{2}T(n)}$, we have $2^{c\sqrt{\log K}}=T^{\sqrt{\varepsilon}\cdot c}$ and the $\mathsf{CONGEST}$ model part of the claim of the lemma thus follows by choosing the constant $\varepsilon>0$ sufficiently small. The claim about the $\mathsf{LOCAL}$ model then follows in the $\mathsf{LOCAL}$ model any $(d(n),c(n))$-decomposition can be turned into an $(O(\log n),O(\log n))$-decomposition in time $O(d(n)\cdot c(n)\cdot\log^{2}n)$ [ABCP96, GKM17]. ∎

The following theorem shows that the error probability bound of Theorem 4.2 is essentially tight, in the following sense. A stronger bound would be a major breakthrough and directly imply a significant improvement over the 25-year old and currently best deterministic network decomposition algorithm [PS95], which has a time complexity of $2^{O(\sqrt{\log n})}$. The following theorem also shows that the approach of the above algorithm is best possible. A better deterministic network decomposition algorithm resulting from a better error probability bound would directly also allow to improve the above algorithm to achieve this same error probability bound. In order to work for general locally checkable problems (such that in particular network decomposition is included), the following theorem is stated in an rather technical way. We discuss what it means for specific problems below.

Theorem 4.3**.**

Let $\mathcal{P}(n)$ be a distributed graph problem, where the solution might depend on $n$. Assume that there is non-uniform randomized distributed algorithm that given $n$ as input solves $\mathcal{P}(n)$ in time $T(n)$ with probability at least $1-2^{2^{\varepsilon\log^{\beta}T(n)}}$ for some constant $\varepsilon>0$ and some $\beta>2$. Then, there is a deterministic distributed algorithm that solves $\mathcal{P}(N)$ in time $2^{O(\log^{1/\beta}n)}$, where $N$ is chosen such that $T(N)=2^{c\cdot\log^{1/\beta}n}$ for some constant $c>0$.

If the problem $\mathcal{P}(n)$ is strictly $d(n)$-locally checkable for some function $d(n)$, the deterministic algorithm solves $\mathcal{P}(n)$ rather than $\mathcal{P}(N)$. Further, if the randomized algorithm works in the $\mathsf{CONGEST}$ model, the deterministic algorithm also works in the $\mathsf{CONGEST}$ model.

Proof.

We apply a technique that was first used by Chang, Kopelowitz, and Pettie in [CKP16]. The basic idea is to “lie” to the algorithm about the number of nodes and pretend that the graph has size $N\gg n$ rather than $n$ in order to boost the success probability of the algorithm to value that is sufficiently clost to $1$ in order to apply Lemma 4.1.

Assume that we are given a graph $G$ with $n$ nodes on which we have to solve $\mathcal{P}(n)$. The nodes of $G$ cannot distinguish the graph $G$ from a graph $G^{\prime}$ with $N$ nodes, which contains $G$ as one of its connected components. A randomized algorithm that is given $n$ as input and solves $\mathcal{P}(n)$ on $G$ in time $T(n)$ with probability at least $1-\delta(n)$ can therefore also be used to solve $\mathcal{P}(N)$ on $G^{\prime}$ (and thus also on $G$) in time $T(N)$ with probability at least $1-\delta(N)$. If we choose $N$ such that $\delta(N)\leq 2^{-n^{2}}$ by Lemma 4.1, the resulting algorithm can be derandomized when applied on $G$.

We thus have to choose the size $N$ of the “virtual” graph $G^{\prime}$ such that $2^{\varepsilon\log^{\beta}T(N)}\geq n^{2}$. This implies that \log T(N)\geq\big{(}\frac{2}{\varepsilon}\big{)}^{1/\beta}\log^{1/\beta}n, which is satisfied for $T(N)=2^{c\cdot\log^{1/\beta}n}$ for some constant $c>0$. We therefore get a deterministic algorithm for $\mathcal{P}(N)$ with time complexity $2^{O(\log^{1/\beta}n)}$, where $N$ is chosen such that $T(N)=2^{c\cdot\log^{1/\beta}N}$. If the randomized algorithm works in the $\mathsf{CONGEST}$ model, the deterministic algorithms also works in the $\mathsf{CONGEST}$ model.

If the problem $\mathcal{P}(n)$ is strictly $d(n)$-locally checkable for some function $d(n)$, the checking algorithm cannot distinguish between the graphs $G$ and the component isomorphic to $G$ in $G^{\prime}$. A valid solution to $\mathcal{P}(N)$ on a graph of size $N$ is therefore also a valid solution to $\mathcal{P}(n^{\prime})$ for each connected component of $G$ of size $n^{\prime}$. ∎

As the above theorem is stated for general graph problems $\mathcal{P}(n)$ and general time complexities $T(n)$ (which both can depend on $n$ in various ways), it is interesting to discuss what the theorem implies for specific choices of $T(n)$ and for concrete graph problems. We first consider the case of randomized algorithms that have running times that are between $\operatorname{poly}(\log n)$ and $2^{O(\sqrt{\log n})}$. That is, we consider running times that are between the best randomized (in the classic sense) and deterministic time complexities for network decomposition and many other important problems. The following corollary follows immediately from Theorem 4.3.

Corollary 4.4**.**

Let $\alpha>\beta>2$ be two constants, let $\mathcal{P}(n)$ be a distributed graph problem, and assume that there is non-uniform randomized distributed algorithm that given $n$ as input solves $\mathcal{P}(n)$ in time $2^{O(\log^{1/\alpha}n)}$ with probability at least $1-2^{2^{\varepsilon\log^{\beta/\alpha}n}}$ for some constant $\varepsilon>0$. Then, there is a deterministic distributed algorithm that solves $\mathcal{P}(N)$ in time $2^{O(\log^{1/\beta}n)}$, where $N$ is chosen such that $\log N=\Theta(\log^{\alpha/\beta}n)$ for some constant $c>0$.

If the problem $\mathcal{P}(n)$ is strictly $d(n)$-locally checkable for some function $d(n)$, the deterministic algorithm solves $\mathcal{P}(n)$ rather than $\mathcal{P}(N)$. Further, if the randomized algorithm works in the $\mathsf{CONGEST}$ model, the deterministic algorithm also works in the $\mathsf{CONGEST}$ model.

Note that if the parameters $\mathcal{P}(n)$ only depend polylogarithmically on $n$, the parameters of $\mathcal{P}(N)$ also depend polylogarithmically on $n$. For example if $\mathcal{P}(n)$ is the problem of computing an \big{(}O(\log n),O(\log n)\big{)}-network decomposition, then $\mathcal{P}(N)$ refers to the problem of computing an \big{(}O(\log^{\alpha/\beta}n),O(\log^{\alpha/\beta}n)\big{)}-network decomposition. Further, if $\mathcal{P}$ is an LCL problem (e.g., MIS or $(\Delta+1)$-coloring), $\mathcal{P}$ is strictly $O(1)$-locally checkable. Hence, for this important and widely studied class of problems, the stronger versions of Theorem 4.3 and Corollary 4.4 hold, i.e., in both cases we get a deterministic $2^{O(\log^{1/\beta}n)}$-time algorithm that solves $\mathcal{P}$ in its original form. The following corollary shows that the same (and actually something slightly stronger) also holds for the network decomposition problem in the $\mathsf{LOCAL}$ model.

Corollary 4.5**.**

Assume that there is non-uniform randomized distributed algorithm that given $n$ as input computes a $(T(n),T(n))$-decomposition in time $T(n)$ with probability at least $1-2^{2^{\varepsilon\log^{\beta}T(n)}}$ for some constant $\varepsilon>0$ and some $\beta>2$. Then, there exists a deterministic $2^{O(\log^{1/\beta}n)}$-round algorithm to compute a \big{(}O(\log n),O(\log n)\big{)}-decomposition in the $\mathsf{LOCAL}$ model.

Proof.

Theorem 4.3 directly implies that there exists a deterministic $T(N)$-round algorithm to compute a $(T(N),T(N))$-decompostion, where $T(N)=2^{O(\log^{1/\beta}n)}$. In [ABCP96], it is shown that given such a decomposition, one can compute a strong diameter \big{(}O(\log n),O(\log n)\big{)}-decomposition in time $2^{O(\log^{1/\beta}n)}$ deterministically in the $\mathsf{LOCAL}$ model. ∎

The next theorem bounds the error probability that is needed to derandomize a polylogarithmic-time randomized algorithm to a polylogarithmic-time deterministic algorithm. As this result is most interesting for strictly locally checkable graph problems, we only state it for this case.

Theorem 4.6**.**

Let $\mathcal{P}$ be a strictly $d(n)$-locally checkable graph problem for some function $d(n)$ or let $\mathcal{P}$ be the problem of computing a network decomposition with $\operatorname{poly}(\log n)$ parameters. Further assume that there is randomized non-uniform distributed algorithm that solves $\mathcal{P}$ in $\operatorname{poly}(\log n)$ time with probability at least $1-2^{-2^{\log^{\varepsilon}n}}$ for some constants $\varepsilon>0$. Then, there is a deterministic distributed $\operatorname{poly}\log n$-time algorithm for $\mathcal{P}$.

Proof.

We use the same basic technique as in the proof of Theorem 4.3. We again lie to the randomized algorithm about the number of nodes and pretend that the number of nodes is $N\gg n$. We choose $N$ such that $2^{\log^{\varepsilon}N}\geq n^{2}$ and thus $\log N\geq(2\log n)^{1/\varepsilon}$. A running time that is polylogarithmic in $N$ is therefore also polylogarithmic in $n$, which proves the theorem. The result for network decompositions follows in the same way as in Corollary 4.5. ∎

Remark:

One could of course get similar results for other time complexity bounds. In the same way as in Theorem 4.6, it can for example be shown that if we have a randomized quasi-polylogarithmic time algorithm with success probability $1-2^{-2^{2^{(\log\log n)^{\varepsilon}}}}$ for some constant $\varepsilon>0$, we can derandomize it to a quasi-polylogarithmic deterministic algorithm for the same problem. By quasi-polylogarithmic running time, we mean a running time of the form $2^{(\log\log n)^{c}}$ for some constant $c>0$.