181 research outputs found
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
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
A Time Hierarchy Theorem for the LOCAL Model
The celebrated Time Hierarchy Theorem for Turing machines states, informally,
that more problems can be solved given more time. The extent to which a time
hierarchy-type theorem holds in the distributed LOCAL model has been open for
many years. It is consistent with previous results that all natural problems in
the LOCAL model can be classified according to a small constant number of
complexities, such as , etc.
In this paper we establish the first time hierarchy theorem for the LOCAL
model and prove that several gaps exist in the LOCAL time hierarchy.
1. We define an infinite set of simple coloring problems called Hierarchical
-Coloring}. A correctly colored graph can be confirmed by simply
checking the neighborhood of each vertex, so this problem fits into the class
of locally checkable labeling (LCL) problems. However, the complexity of the
-level Hierarchical -Coloring problem is ,
for . The upper and lower bounds hold for both general graphs
and trees, and for both randomized and deterministic algorithms.
2. Consider any LCL problem on bounded degree trees. We prove an
automatic-speedup theorem that states that any randomized -time
algorithm solving the LCL can be transformed into a deterministic -time algorithm. Together with a previous result, this establishes that on
trees, there are no natural deterministic complexities in the ranges
--- or ---.
3. We expose a gap in the randomized time hierarchy on general graphs. Any
randomized algorithm that solves an LCL problem in sublogarithmic time can be
sped up to run in time, which is the complexity of the distributed
Lovasz local lemma problem, currently known to be and
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 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 rounds. If not, it is known that the complexity has to
be for some , and in this case the
algorithms also output the right value of the exponent .
In rooted trees in the 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 region remains an open
question
Deciding and verifying network properties locally with few output bits
International audienceGiven a boolean predicate on labeled networks (e.g., the network is acyclic, or the network is properly colored, etc.), deciding in a distributed manner whether a given labeled network satisfies that predicate typically consists, in the standard setting, of every node inspecting its close neighborhood, and outputting a boolean verdict, such that the network satisfies the predicate if and only if all nodes output true. In this paper, we investigate a more general notion of distributed decision in which every node is allowed to output a constant number of bits, which are gathered by a central authority emitting a global boolean verdict based on these outputs, such that the network satisfies the predicate if and only if this global verdict equals true. We analyze the power and limitations of this extended notion of distributed decision
Towards a complexity theory for the congested clique
The congested clique model of distributed computing has been receiving
attention as a model for densely connected distributed systems. While there has
been significant progress on the side of upper bounds, we have very little in
terms of lower bounds for the congested clique; indeed, it is now know that
proving explicit congested clique lower bounds is as difficult as proving
circuit lower bounds.
In this work, we use various more traditional complexity-theoretic tools to
build a clearer picture of the complexity landscape of the congested clique:
-- Nondeterminism and beyond: We introduce the nondeterministic congested
clique model (analogous to NP) and show that there is a natural canonical
problem family that captures all problems solvable in constant time with
nondeterministic algorithms. We further generalise these notions by introducing
the constant-round decision hierarchy (analogous to the polynomial hierarchy).
-- Non-constructive lower bounds: We lift the prior non-uniform counting
arguments to a general technique for proving non-constructive uniform lower
bounds for the congested clique. In particular, we prove a time hierarchy
theorem for the congested clique, showing that there are decision problems of
essentially all complexities, both in the deterministic and nondeterministic
settings.
-- Fine-grained complexity: We map out relationships between various natural
problems in the congested clique model, arguing that a reduction-based
complexity theory currently gives us a fairly good picture of the complexity
landscape of the congested clique
Introduction to local certification
A distributed graph algorithm is basically an algorithm where every node of a
graph can look at its neighborhood at some distance in the graph and chose its
output. As distributed environment are subject to faults, an important issue is
to be able to check that the output is correct, or in general that the network
is in proper configuration with respect to some predicate. One would like this
checking to be very local, to avoid using too much resources. Unfortunately
most predicates cannot be checked this way, and that is where certification
comes into play. Local certification (also known as proof-labeling schemes,
locally checkable proofs or distributed verification) consists in assigning
labels to the nodes, that certify that the configuration is correct. There are
several point of view on this topic: it can be seen as a part of
self-stabilizing algorithms, as labeling problem, or as a non-deterministic
distributed decision.
This paper is an introduction to the domain of local certification, giving an
overview of the history, the techniques and the current research directions.Comment: Last update: minor editin
- âŠ