15 research outputs found
Super-Fast 3-Ruling Sets
A -ruling set of a graph is a vertex-subset
that is independent and satisfies the property that every vertex is
at a distance of at most from some vertex in . A \textit{maximal
independent set (MIS)} is a 1-ruling set. The problem of computing an MIS on a
network is a fundamental problem in distributed algorithms and the fastest
algorithm for this problem is the -round algorithm due to Luby
(SICOMP 1986) and Alon et al. (J. Algorithms 1986) from more than 25 years ago.
Since then the problem has resisted all efforts to yield to a sub-logarithmic
algorithm. There has been recent progress on this problem, most importantly an
-round algorithm on graphs with
vertices and maximum degree , due to Barenboim et al. (Barenboim,
Elkin, Pettie, and Schneider, April 2012, arxiv 1202.1983; to appear FOCS
2012).
We approach the MIS problem from a different angle and ask if O(1)-ruling
sets can be computed much more efficiently than an MIS? As an answer to this
question, we show how to compute a 2-ruling set of an -vertex graph in
rounds. We also show that the above result can be improved
for special classes of graphs such as graphs with high girth, trees, and graphs
of bounded arboricity.
Our main technique involves randomized sparsification that rapidly reduces
the graph degree while ensuring that every deleted vertex is close to some
vertex that remains. This technique may have further applications in other
contexts, e.g., in designing sub-logarithmic distributed approximation
algorithms. Our results raise intriguing questions about how quickly an MIS (or
1-ruling sets) can be computed, given that 2-ruling sets can be computed in
sub-logarithmic rounds
Symmetry Breaking in the Congest Model:Time- and Message-Efficient Algorithms for Ruling Sets
We study local symmetry breaking problems in the CONGEST model, focusing on
ruling set problems, which generalize the fundamental Maximal Independent Set
(MIS) problem. A -ruling set is an independent set such that every node
in the graph is at most hops from a node in the independent set. Our
work is motivated by the following central question: can we break the
time complexity barrier and the message complexity
barrier in the CONGEST model for MIS or closely-related symmetry breaking
problems? We present the following results:
- Time Complexity: We show that we can break the "barrier" for 2-
and 3-ruling sets. We compute 3-ruling sets in rounds with high probability (whp). More generally we show that
2-ruling sets can be computed in rounds for any , which is for a wide range of values (e.g., ). These are the first 2- and 3-ruling set
algorithms to improve over the -round complexity of Luby's algorithm
in the CONGEST model.
- Message Complexity: We show an lower bound on the message
complexity of computing an MIS (i.e., 1-ruling set) which holds also for
randomized algorithms and present a contrast to this by showing a randomized
algorithm for 2-ruling sets that, whp, uses only messages and
runs in rounds. This is the first message-efficient
algorithm known for ruling sets, which has message complexity nearly linear in
(which is optimal up to a polylogarithmic factor)
Distributed Reconfiguration of Maximal Independent Sets
In this paper, we investigate a distributed maximal independent set (MIS) reconfiguration problem, in which there are two maximal independent sets for which every node is given its membership status, and the nodes need to communicate with their neighbors in order to find a reconfiguration schedule that switches from the first MIS to the second. Such a schedule is a list of independent sets that is restricted by forbidding two neighbors to change their membership status at the same step. In addition, these independent sets should provide some covering guarantee.
We show that obtaining an actual MIS (and even a 3-dominating set) in each intermediate step is impossible. However, we provide efficient solutions when the intermediate sets are only required to be independent and 4-dominating, which is almost always possible, as we fully characterize.
Consequently, our goal is to pin down the tradeoff between the possible length of the schedule and the number of communication rounds. We prove that a constant length schedule can be found in O(MIS+R32) rounds, where MIS is the complexity of finding an MIS in a worst-case graph and R32 is the complexity of finding a (3,2)-ruling set. For bounded degree graphs, this is O(log^*n) rounds and we show that it is necessary. On the other extreme, we show that with a constant number of rounds we can find a linear length schedule
Sample-And-Gather: Fast Ruling Set Algorithms in the Low-Memory MPC Model
Motivated by recent progress on symmetry breaking problems such as maximal independent set (MIS) and maximal matching in the low-memory Massively Parallel Computation (MPC) model (e.g., Behnezhad et al. PODC 2019; Ghaffari-Uitto SODA 2019), we investigate the complexity of ruling set problems in this model. The MPC model has become very popular as a model for large-scale distributed computing and it comes with the constraint that the memory-per-machine is strongly sublinear in the input size. For graph problems, extremely fast MPC algorithms have been designed assuming ??(n) memory-per-machine, where n is the number of nodes in the graph (e.g., the O(log log n) MIS algorithm of Ghaffari et al., PODC 2018). However, it has proven much more difficult to design fast MPC algorithms for graph problems in the low-memory MPC model, where the memory-per-machine is restricted to being strongly sublinear in the number of nodes, i.e., O(n^?) for constant 0 < ? < 1.
In this paper, we present an algorithm for the 2-ruling set problem, running in O?(log^{1/6} ?) rounds whp, in the low-memory MPC model. Here ? is the maximum degree of the graph. We then extend this result to ?-ruling sets for any integer ? > 1. Specifically, we show that a ?-ruling set can be computed in the low-memory MPC model with O(n^?) memory-per-machine in O?(? ? log^{1/(2^{?+1}-2)} ?) rounds, whp. From this it immediately follows that a ?-ruling set for ? = ?(log log log ?)-ruling set can be computed in in just O(? log log n) rounds whp. The above results assume a total memory of O?(m + n^{1+?}). We also present algorithms for ?-ruling sets in the low-memory MPC model assuming that the total memory over all machines is restricted to O?(m). For ? > 1, these algorithms are all substantially faster than the Ghaffari-Uitto O?(?{log ?})-round MIS algorithm in the low-memory MPC model.
All our results follow from a Sample-and-Gather Simulation Theorem that shows how random-sampling-based Congest algorithms can be efficiently simulated in the low-memory MPC model. We expect this simulation theorem to be of independent interest beyond the ruling set algorithms derived here
The Complexity of Symmetry Breaking in Massive Graphs
The goal of this paper is to understand the complexity of symmetry breaking problems, specifically maximal independent set (MIS) and the closely related beta-ruling set problem, in two computational models suited for large-scale graph processing, namely the k-machine model and the graph streaming model. We present a number of results. For MIS in the k-machine model, we improve the O~(m/k^2 + Delta/k)-round upper bound of Klauck et al. (SODA 2015) by presenting an O~(m/k^2)-round algorithm. We also present an Omega~(n/k^2) round lower bound for MIS, the first lower bound for a symmetry breaking problem in the k-machine model. For beta-ruling sets, we use hierarchical sampling to obtain more efficient algorithms in the k-machine model and also in the graph streaming model. More specifically, we obtain a k-machine algorithm that runs in O~(beta n Delta^{1/beta}/k^2) rounds and, by using a similar hierarchical sampling technique, we obtain one-pass algorithms for both insertion-only and insertion-deletion streams that use O(beta * n^{1+1/2^{beta-1}}) space. The latter result establishes a clear separation between MIS, which is known to require Omega(n^2) space (Cormode et al., ICALP 2019), and beta-ruling sets, even for beta = 2. Finally, we present an even faster 2-ruling set algorithm in the k-machine model, one that runs in O~(n/k^{2-epsilon} + k^{1-epsilon}) rounds for any epsilon, 0 <=epsilon <=1. For a wide range of values of k this round complexity simplifies to O~(n/k^2) rounds, which we conjecture is optimal.
Our results use a variety of techniques. For our upper bounds, we prove and use simulation theorems for beeping algorithms, hierarchical sampling, and L_0-sampling, whereas for our lower bounds we use information-theoretic arguments and reductions to 2-party communication complexity problems