Locally-iterative Distributed (Δ + 1)-coloring and Applications

2022 ◽  
Vol 69 (1) ◽  
pp. 1-26
Author(s):  
Leonid Barenboim ◽  
Michael Elkin ◽  
Uri Goldenberg

We consider graph coloring and related problems in the distributed message-passing model. Locally-iterative algorithms are especially important in this setting. These are algorithms in which each vertex decides about its next color only as a function of the current colors in its 1-hop-neighborhood . In STOC’93 Szegedy and Vishwanathan showed that any locally-iterative Δ + 1-coloring algorithm requires Ω (Δ log Δ + log * n ) rounds, unless there exists “a very special type of coloring that can be very efficiently reduced” [ 44 ]. No such special coloring has been found since then. This led researchers to believe that Szegedy-Vishwanathan barrier is an inherent limitation for locally-iterative algorithms and to explore other approaches to the coloring problem [ 2 , 3 , 19 , 32 ]. The latter gave rise to faster algorithms, but their heavy machinery that is of non-locally-iterative nature made them far less suitable to various settings. In this article, we obtain the aforementioned special type of coloring. Specifically, we devise a locally-iterative Δ + 1-coloring algorithm with running time O (Δ + log * n ), i.e., below Szegedy-Vishwanathan barrier. This demonstrates that this barrier is not an inherent limitation for locally-iterative algorithms. As a result, we also achieve significant improvements for dynamic, self-stabilizing, and bandwidth-restricted settings. This includes the following results: We obtain self-stabilizing distributed algorithms for Δ + 1-vertex-coloring, (2Δ - 1)-edge-coloring, maximal independent set, and maximal matching with O (Δ + log * n ) time. This significantly improves previously known results that have O(n) or larger running times [ 23 ]. We devise a (2Δ - 1)-edge-coloring algorithm in the CONGEST model with O (Δ + log * n ) time and O (Δ)-edge-coloring in the Bit-Round model with O (Δ + log n ) time. The factors of log * n and log n are unavoidable in the CONGEST and Bit-Round models, respectively. Previously known algorithms had superlinear dependency on Δ for (2Δ - 1)-edge-coloring in these models. We obtain an arbdefective coloring algorithm with running time O (√ Δ + log * n ). Such a coloring is not necessarily proper, but has certain helpful properties. We employ it to compute a proper (1 + ε)Δ-coloring within O (√ Δ + log * n ) time and Δ + 1-coloring within O (√ Δ log Δ log * Δ + log * n ) time. This improves the recent state-of-the-art bounds of Barenboim from PODC’15 [ 2 ] and Fraigniaud et al. from FOCS’16 [ 19 ] by polylogarithmic factors. Our algorithms are applicable to the SET-LOCAL model [ 25 ] (also known as the weak LOCAL model). In this model a relatively strong lower bound of Ω (Δ 1/3 ) is known for Δ + 1-coloring. However, most of the coloring algorithms do not work in this model. (In Reference [ 25 ] only Linial’s O (Δ 2 )-time algorithm and Kuhn-Wattenhofer O (Δ log Δ)-time algorithms are shown to work in it.) We obtain the first linear-in-Δ Δ + 1-coloring algorithms that work also in this model.

2020 ◽  
Vol 354 ◽  
pp. 75-89
Author(s):  
Cristina López-Ramírez ◽  
Jorge Eduardo Gutiérrez Gómez ◽  
Guillermo De Ita Luna

2016 ◽  
Vol 26 (01) ◽  
pp. 1650004 ◽  
Author(s):  
Benny Applebaum ◽  
Dariusz R. Kowalski ◽  
Boaz Patt-Shamir ◽  
Adi Rosén

We consider a message passing model with n nodes, each connected to all other nodes by a link that can deliver a message of B bits in a time unit (typically, B = O(log n)). We assume that each node has an input of size L bits (typically, L = O(n log n)) and the nodes cooperate in order to compute some function (i.e., perform a distributed task). We are interested in the number of rounds required to compute the function. We give two results regarding this model. First, we show that most boolean functions require ‸ L/B ‹ − 1 rounds to compute deterministically, and that even if we consider randomized protocols that are allowed to err, the expected running time remains [Formula: see text] for most boolean function. Second, trying to find explicit functions that require superconstant time, we consider the pointer chasing problem. In this problem, each node i is given an array Ai of length n whose entries are in [n], and the task is to find, for any [Formula: see text], the value of [Formula: see text]. We give a deterministic O(log n/ log log n) round protocol for this function using message size B = O(log n), a slight but non-trivial improvement over the O(log n) bound provided by standard “pointer doubling.” The question of an explicit function (or functionality) that requires super constant number of rounds in this setting remains, however, open.


2019 ◽  
Vol 5 (2) ◽  
pp. 1-27
Author(s):  
Martin Burtscher ◽  
Sindhu Devale ◽  
Sahar Azimi ◽  
Jayadharini Jaiganesh ◽  
Evan Powers

2021 ◽  
Author(s):  
Van-Vi Vo ◽  
Tien-Dung Nguyen ◽  
Duc-Tai Le ◽  
Moonseong Kim ◽  
Hyunseung Choo

<div>Over the past few years, the use of wireless sensor networks in a range of Internet of Things (IoT) scenarios has grown in popularity. Since IoT sensor devices have restricted battery power, a proper IoT data aggregation approach is crucial to prolong the network lifetime. To this end, current approaches typically form a virtual aggregation backbone based on a connected dominating set or maximal independent set to utilize independent transmissions of dominators. However, they usually have a fairly long aggregation delay because the dominators become bottlenecks for receiving data from all dominatees. The problem of time-efficient data aggregation in multichannel duty-cycled IoT sensor networks is analyzed in this paper. We propose a novel aggregation approach, named LInk-delay-aware REinforcement (LIRE), leveraging active slots of sensors to explore a routing structure with pipeline links, then scheduling all transmissions in a bottom-up manner. The reinforcement schedule accelerates the aggregation by exploiting unused channels and time slots left off at every scheduling round. LIRE is evaluated in a variety of simulation scenarios through theoretical analysis and performance comparisons with a state-of-the-art scheme. The simulation results show that LIRE reduces more than 80% aggregation delay compared to the existing scheme.</div>


Author(s):  
Raymond Greenlaw ◽  
H. James Hoover ◽  
Walter L. Ruzzo

We consider the selection of two basketball teams at a neighborhood playground to illustrate the greedy method. Usually the top two players are designated captains. All other players line up while the captains alternate choosing one player at a time. Usually, the players are picked using a greedy strategy. That is, the captains choose the best unclaimed player. The system of selection of choosing the best, most obvious, or most convenient remaining candidate is called the greedy method. Greedy algorithms often lead to easily implemented efficient sequential solutions to problems. Unfortunately, it also seems to be that sequential greedy algorithms frequently lead to solutions that are inherently sequential — the solutions produced by these algorithms cannot be duplicated rapidly in parallel, unless NC equals P. In the following subsections we will examine this phenomenon. We illustrate some of the important aspects of greedy algorithms using one that constructs a maximal independent set in a graph. An independent set is a set of vertices of a graph that are pairwise nonadjacent. A maximum independent set is such a set of largest cardinality. It is well known that finding maximum independent sets is NP-hard. An independent set is maximal if no other vertex can be added while maintaining the independent set property. In contrast to the maximum case, finding maxima? independent sets is very easy. Figure 7.1.1 depicts a simple polynomial time sequential algorithm computing a maximal independent set. The algorithm is a greedy algorithm: it processes the vertices in numerical order, always attempting to add the lowest numbered vertex that has not yet been tried. The sequential algorithm in Figure 7.1.1, having processed vertices 1,... , j -1, can easily decide whether to include vertex j. However, notice that its decision about j potentially depends on its decisions about all earlier vertices — j will be included in the maximal independent set if and only if all j' less than j and adjacent to it were excluded.


Sign in / Sign up

Export Citation Format

Share Document