18 research outputs found
Distributed Binary Labeling Problems in High-Degree Graphs
Balliu et al. (DISC 2020) classified the hardness of solving binary labeling
problems with distributed graph algorithms; in these problems the task is to
select a subset of edges in a -colored tree in which white nodes of degree
and black nodes of degree have constraints on the number of
selected incident edges. They showed that the deterministic round complexity of
any such problem is , , or
, or the problem is unsolvable. However, their
classification only addresses complexity as a function of ; here
hides constants that may depend on parameters and .
In this work we study the complexity of binary labeling problems as a
function of all three parameters: , , and . To this end, we
introduce the family of structurally simple problems, which includes, among
others, all binary labeling problems in which cardinality constraints can be
represented with a context-free grammar. We classify possible complexities of
structurally simple problems. As our main result, we show that if the
complexity of a problem falls in the broad class of , then the complexity for each and is always either
, , or .
To prove our upper bounds, we introduce a new, more aggressive version of the
rake-and-compress technique that benefits from high-degree nodes
Local Conflict Coloring Revisited: Linial for Lists
Linial's famous color reduction algorithm reduces a given -coloring of a
graph with maximum degree to a -coloring, in a
single round in the LOCAL model. We show a similar result when nodes are
restricted to choose their color from a list of allowed colors: given an
-coloring in a directed graph of maximum outdegree , if every node
has a list of size from a color space then they can select a color
in two rounds in the LOCAL model. Moreover, the communication of a node
essentially consists of sending its list to the neighbors. This is obtained as
part of a framework that also contains Linial's color reduction (with an
alternative proof) as a special case. Our result also leads to a defective list
coloring algorithm. As a corollary, we improve the state-of-the-art truly local
-list coloring algorithm from Barenboim et al. [PODC'18] by slightly
reducing the runtime to and significantly
reducing the message size (from huge to roughly ). Our techniques are
inspired by the local conflict coloring framework of Fraigniaud et al.
[FOCS'16].Comment: to appear at DISC 202
Locality in Online, Dynamic, Sequential, and Distributed Graph Algorithms
In this work, we give a unifying view of locality in four settings: distributed algorithms, sequential greedy algorithms, dynamic algorithms, and online algorithms. We introduce a new model of computing, called the online-LOCAL model: the adversary presents the nodes of the input graph one by one, in the same way as in classical online algorithms, but for each node we get to see its radius-T neighborhood before choosing the output. Instead of looking ahead in time, we have the power of looking around in space.
We compare the online-LOCAL model with three other models: the LOCAL model of distributed computing, where each node produces its output based on its radius-T neighborhood, the SLOCAL model, which is the sequential counterpart of LOCAL, and the dynamic-LOCAL model, where changes in the dynamic input graph only influence the radius-T neighborhood of the point of change.
The SLOCAL and dynamic-LOCAL models are sandwiched between the LOCAL and online-LOCAL models. In general, all four models are distinct, but we study in particular locally checkable labeling problems (LCLs), which is a family of graph problems extensively studied in the context of distributed graph algorithms. We prove that for LCL problems in paths, cycles, and rooted trees, all four models are roughly equivalent: the locality of any LCL problem falls in the same broad class - O(log* n), ?(log n), or n^?(1) - in all four models. In particular, this result enables one to generalize prior lower-bound results from the LOCAL model to all four models, and it also allows one to simulate e.g. dynamic-LOCAL algorithms efficiently in the LOCAL model.
We also show that this equivalence does not hold in two-dimensional grids or general bipartite graphs. We provide an online-LOCAL algorithm with locality O(log n) for the 3-coloring problem in bipartite graphs - this is a problem with locality ?(n^{1/2}) in the LOCAL model and ?(n^{1/10}) in the SLOCAL model
Efficient Classification of Locally Checkable Problems in Regular Trees
We give practical, efficient algorithms that automatically determine the asymptotic distributed round complexity of a given locally checkable graph problem in the [?(log n), ?(n)] region, in two settings. We present one algorithm for unrooted regular trees and another algorithm for rooted regular trees. The algorithms take the description of a locally checkable labeling problem as input, and the running time is polynomial in the size of the problem description. The algorithms decide if the problem is solvable in O(log n) rounds. If not, it is known that the complexity has to be ?(n^{1/k}) for some k = 1, 2, ..., and in this case the algorithms also output the right value of the exponent k.
In rooted trees in the O(log n) case we can then further determine the exact complexity class by using algorithms from prior work; for unrooted trees the more fine-grained classification in the O(log n) region remains an open question
Exponential Speedup over Locality in MPC with Optimal Memory
Locally Checkable Labeling (LCL) problems are graph problems in which a solution is correct if it satisfies some given constraints in the local neighborhood of each node. Example problems in this class include maximal matching, maximal independent set, and coloring problems. A successful line of research has been studying the complexities of LCL problems on paths/cycles, trees, and general graphs, providing many interesting results for the LOCAL model of distributed computing. In this work, we initiate the study of LCL problems in the low-space Massively Parallel Computation (MPC) model. In particular, on forests, we provide a method that, given the complexity of an LCL problem in the LOCAL model, automatically provides an exponentially faster algorithm for the low-space MPC setting that uses optimal global memory, that is, truly linear.
While restricting to forests may seem to weaken the result, we emphasize that all known (conditional) lower bounds for the MPC setting are obtained by lifting lower bounds obtained in the distributed setting in tree-like networks (either forests or high girth graphs), and hence the problems that we study are challenging already on forests. Moreover, the most important technical feature of our algorithms is that they use optimal global memory, that is, memory linear in the number of edges of the graph. In contrast, most of the state-of-the-art algorithms use more than linear global memory. Further, they typically start with a dense graph, sparsify it, and then solve the problem on the residual graph, exploiting the relative increase in global memory. On forests, this is not possible, because the given graph is already as sparse as it can be, and using optimal memory requires new solutions
Distributed graph problems through an automata-theoretic lens
The locality of a graph problem is the smallest distance such that each
node can choose its own part of the solution based on its radius-
neighborhood. In many settings, a graph problem can be solved efficiently with
a distributed or parallel algorithm if and only if it has a small locality.
In this work we seek to automate the study of solvability and locality: given
the description of a graph problem , we would like to determine if
is solvable and what is the asymptotic locality of as a function of the
size of the graph. Put otherwise, we seek to automatically synthesize efficient
distributed and parallel algorithms for solving .
We focus on locally checkable graph problems; these are problems in which a
solution is globally feasible if it looks feasible in all constant-radius
neighborhoods. Prior work on such problems has brought primarily bad news:
questions related to locality are undecidable in general, and even if we focus
on the case of labeled paths and cycles, determining locality is
-hard (Balliu et al., PODC 2019).
We complement prior negative results with efficient algorithms for the cases
of unlabeled paths and cycles and, as an extension, for rooted trees. We
introduce a new automata-theoretic perspective for studying locally checkable
graph problems. We represent a locally checkable problem as a
nondeterministic finite automaton over a unary alphabet. We
identify polynomial-time-computable properties of the automaton
that near-completely capture the solvability and locality of in cycles
and paths, with the exception of one specific case that is
\mbox{co-\mathsf{NP}}-complete
Distributed Lower Bounds for Ruling Sets
Given a graph , an -ruling set is a subset such that the distance between any two vertices in is at least
, and the distance between any vertex in and the closest vertex in
is at most . We present lower bounds for distributedly computing
ruling sets.
More precisely, for the problem of computing a -ruling set in the
LOCAL model, we show the following, where denotes the number of vertices,
the maximum degree, and is some universal constant independent of
and .
Any deterministic algorithm requires
rounds, for all . By optimizing , this implies a
deterministic lower bound of for all .
Any randomized algorithm requires rounds, for all . By optimizing
, this implies a randomized lower bound of
for all
.
For , this improves on the previously best lower bound of
rounds that follows from the 30-year-old bounds of Linial
[FOCS'87] and Naor [J.Disc.Math.'91]. For , i.e., for the problem of
computing a maximal independent set, our results improve on the previously best
lower bound of on trees, as our bounds already hold on
trees