Shared Randomness Helps with Local Distributed Problems

TL;DR

This work presents a locally checkable labeling problem \Pi that provably separates the roles of shared versus private randomness in distributed graph algorithms. By constructing hard instances built from a vertical grid atop tree-like columns and layering a second problem \Pi^{\mathsf{badGraph}}, the authors show an Omega(\sqrt{n}) lower bound for private randomness, yet an O(\log n) upper bound when shared randomness is available. The separation leads to corollaries including a distributed quantum computing advantage under a shared state and a distinction between finitely dependent and non-signaling distributions, revealing new facets of the distributed computation landscape. The results significantly advance our understanding of how global coordination via shared randomness fundamentally changes the complexity landscape for LCLs, with implications for algorithm design and model hierarchies in distributed computing.

Abstract

By prior work, we have many results related to distributed graph algorithms for problems that can be defined with local constraints; the formal framework used in prior work is locally checkable labeling problems (LCLs), introduced by Naor and Stockmeyer in the 1990s. It is known, for example, that if we have a deterministic algorithm that solves an LCL in $o(\log n)$ rounds, we can speed it up to $O(\log^*n)$ rounds, and if we have a randomized $O(\log^*n)$ rounds algorithm, we can derandomize it for free. It is also known that randomness helps with some LCL problems: there are LCL problems with randomized complexity $Θ(\log\log n)$ and deterministic complexity $Θ(\log n)$. However, so far there have not been any LCL problems in which the use of shared randomness has been necessary; in all prior algorithms it has been enough that the nodes have access to their own private sources of randomness. Could it be the case that shared randomness never helps with LCLs? Could we have a general technique that takes any distributed graph algorithm for any LCL that uses shared randomness, and turns it into an equally fast algorithm where private randomness is enough? In this work we show that the answer is no. We present an LCL problem $Π$ such that the round complexity of $Π$ is $Ω(\sqrt n)$ in the usual randomized \local model with private randomness, but if the nodes have access to a source of shared randomness, then the complexity drops to $O(\log n)$. As corollaries, we also resolve several other open questions related to the landscape of distributed computing in the context of LCL problems. In particular, problem $Π$ demonstrates that distributed quantum algorithms for LCL problems strictly benefit from a shared quantum state. Problem $Π$ also gives a separation between finitely dependent distributions and non-signaling distributions.

Figures (6)

• Figure 1: Landscape of models and the new separations between them. The general structure of the landscape is from akbari24_online_arxiv. In this work we present a new LCL problem $\Pi$ that is easy in the blue-shaded region (models in which we have access to shared randomness), but hard in the red-shaded region (all other models), and we will get separations for all pairs of models that cross the cut. To prove these results, we give an upper bound in with shared randomness (\ref{['thm:ub-shared-rand']}), and all upper bounds in the blue region follow, and we give lower bounds in randomized (\ref{['thm:lb-slocal']}), (\ref{['thm:lb-detolcl']}), and the (\ref{['thm:lb-boundep']}), and all lower bounds in the red region follow.
• Figure 2: An example of a hard instance. The grid is composed of blue edges, purple edges, and purple nodes. Each connected component induced by orange nodes, orange edges, purple edges, and purple nodes connected to the orange edges is a tree-like structure.
• Figure 3: An example of a solution for $\Pi^{\mathsf {hard}}$. Black bits represent the inputs of the nodes of the last column. The inputs of the other nodes do not affect the solution and are omitted. Labels in red represent the outputs, where the label $y$ represents a happy node, and the label $n$ represents an unhappy node. All nodes that are not labeled either $y$ or $n$ output $y$, which is omitted in the figure.
• Figure 4: An example of a properly labeled tree-like structure. The labels $\mathsf {L}$, $\mathsf {R}$, $\mathsf {P}$, $\mathsf {Ch_L}$, and $\mathsf {Ch_R}$, stand, respectively, for left, right, parent, left child, and right child.
• Figure 5: An example of a properly labeled grid structure. The labels $\mathsf {L}$, $\mathsf {R}$, $\mathsf {U}$, and $\mathsf {D}$ stand, respectively, for left, right, up, and down.

Theorems & Definitions (41)

• definition 1: Labeled graph
• definition 2: Labeled graph satisfying some constraints
• definition 3: Locally checkable labeleling (LCL) problem
• definition 4: Tree-like structure
• lemma 1: congest-lcls
• lemma 2: congest-lcls
• lemma 3
• proof
• lemma 4: Lemma 6.10 in the arXiv version of congest-lcls, rephrased
• definition 5: Grid structure