633 research outputs found
Distributed -Coloring in Sublogarithmic Rounds
We give a new randomized distributed algorithm for -coloring in
the LOCAL model, running in
rounds in a graph of maximum degree~. This implies that the
-coloring problem is easier than the maximal independent set
problem and the maximal matching problem, due to their lower bounds of by Kuhn, Moscibroda, and Wattenhofer [PODC'04].
Our algorithm also extends to list-coloring where the palette of each node
contains colors. We extend the set of distributed symmetry-breaking
techniques by performing a decomposition of graphs into dense and sparse parts
Distributed Deterministic Edge Coloring using Bounded Neighborhood Independence
We study the {edge-coloring} problem in the message-passing model of
distributed computing. This is one of the most fundamental and well-studied
problems in this area. Currently, the best-known deterministic algorithms for
(2Delta -1)-edge-coloring requires O(Delta) + log-star n time \cite{PR01},
where Delta is the maximum degree of the input graph. Also, recent results of
\cite{BE10} for vertex-coloring imply that one can get an
O(Delta)-edge-coloring in O(Delta^{epsilon} \cdot \log n) time, and an
O(Delta^{1 + epsilon})-edge-coloring in O(log Delta log n) time, for an
arbitrarily small constant epsilon > 0.
In this paper we devise a drastically faster deterministic edge-coloring
algorithm. Specifically, our algorithm computes an O(Delta)-edge-coloring in
O(Delta^{epsilon}) + log-star n time, and an O(Delta^{1 +
epsilon})-edge-coloring in O(log Delta) + log-star n time. This result improves
the previous state-of-the-art {exponentially} in a wide range of Delta,
specifically, for 2^{Omega(\log-star n)} \leq Delta \leq polylog(n). In
addition, for small values of Delta our deterministic algorithm outperforms all
the existing {randomized} algorithms for this problem.
On our way to these results we study the {vertex-coloring} problem on the
family of graphs with bounded {neighborhood independence}. This is a large
family, which strictly includes line graphs of r-hypergraphs for any r = O(1),
and graphs of bounded growth. We devise a very fast deterministic algorithm for
vertex-coloring graphs with bounded neighborhood independence. This algorithm
directly gives rise to our edge-coloring algorithms, which apply to {general}
graphs.
Our main technical contribution is a subroutine that computes an
O(Delta/p)-defective p-vertex coloring of graphs with bounded neighborhood
independence in O(p^2) + \log-star n time, for a parameter p, 1 \leq p \leq
Delta
Asymptotic Error Free Partitioning over Noisy Boolean Multiaccess Channels
In this paper, we consider the problem of partitioning active users in a
manner that facilitates multi-access without collision. The setting is of a
noisy, synchronous, Boolean, multi-access channel where active users (out
of a total of users) seek to access. A solution to the partition problem
places each of the users in one of groups (or blocks) such that no two
active nodes are in the same block. We consider a simple, but non-trivial and
illustrative case of active users and study the number of steps used
to solve the partition problem. By random coding and a suboptimal decoding
scheme, we show that for any , where and
are positive constants (independent of ), and can be
arbitrary small, the partition problem can be solved with error probability
, for large . Under the same scheme, we also bound from
the other direction, establishing that, for any ,
the error probability for large ; again and
are constants and can be arbitrarily small. These bounds on the number
of steps are lower than the tight achievable lower-bound in terms of for group testing (in which all active users are identified,
rather than just partitioned). Thus, partitioning may prove to be a more
efficient approach for multi-access than group testing.Comment: This paper was submitted in June 2014 to IEEE Transactions on
Information Theory, and is under review no
The Complexity of Distributed Edge Coloring with Small Palettes
The complexity of distributed edge coloring depends heavily on the palette
size as a function of the maximum degree . In this paper we explore the
complexity of edge coloring in the LOCAL model in different palette size
regimes.
1. We simplify the \emph{round elimination} technique of Brandt et al. and
prove that -edge coloring requires
time w.h.p. and time deterministically, even on trees.
The simplified technique is based on two ideas: the notion of an irregular
running time and some general observations that transform weak lower bounds
into stronger ones.
2. We give a randomized edge coloring algorithm that can use palette sizes as
small as , which is a natural barrier for
randomized approaches. The running time of the algorithm is at most
, where is the complexity of a
permissive version of the constructive Lovasz local lemma.
3. We develop a new distributed Lovasz local lemma algorithm for
tree-structured dependency graphs, which leads to a -edge
coloring algorithm for trees running in time. This algorithm
arises from two new results: a deterministic -time LLL algorithm for
tree-structured instances, and a randomized -time graph
shattering method for breaking the dependency graph into independent -size LLL instances.
4. A natural approach to computing -edge colorings (Vizing's
theorem) is to extend partial colorings by iteratively re-coloring parts of the
graph. We prove that this approach may be viable, but in the worst case
requires recoloring subgraphs of diameter . This stands
in contrast to distributed algorithms for Brooks' theorem, which exploit the
existence of -length augmenting paths
- …