We show that any randomised Monte Carlo distributed algorithm for the Lovász local lemma requires Ω(log log n) communication rounds, assuming that it finds a correct assignment with high probability. Our result holds even in the special case of d = O(1), where d is the maximum degree of the dependency graph. By prior work, there are distributed algorithms for the Lovász local lemma with a running time of O(log n) rounds in bounded-degree graphs, and the best lower bound before our work was Ω(log * n) rounds [Chung et al. 2014].

In this work, we use algebraic methods for studying distance computation and subgraph detection tasks in the congested clique model. Specifically, we adapt parallel matrix multiplication implementations to the congested clique, obtaining an O(n 1−2/ω ) round matrix multiplication algorithm, where ω < 2.3728639 is the exponent of matrix multiplication. In conjunction with known techniques from centralised algorithmics, this gives significant improvements over previous best upper bounds in the congested clique model. The highlight results include: -triangle and 4-cycle counting in O(n 0.158 ) rounds, improving upon the O(n 1/3 ) algorithm of Dolev et al. [DISC 2012], -a (1 + o(1))-approximation of all-pairs shortest paths in O(n 0.158 ) rounds, improving upon theÕ(n 1/2 )-round (2 + o(1))-approximation algorithm of Nanongkai [STOC 2014], and computing the girth in O(n 0.158 ) rounds, which is the first non-trivial solution in this model.In addition, we present a novel constant-round combinatorial algorithm for detecting 4-cycles.

A local algorithm is a distributed algorithm that runs in constant time, independently of the size of the network. Being highly scalable and fault-tolerant, such algorithms are ideal in the operation of large-scale distributed systems. Furthermore, even though the model of local algorithms is very limited, in recent years we have seen many positive results for non-trivial problems. This work surveys the state-of-the-art in the field, covering impossibility results, deterministic local algorithms, randomised local algorithms, and local algorithms for geometric graphs.

Large SDN networks will be partitioned in multiple controller domains; each controller is responsible for one domain, and the controllers of adjacent domains may need to communicate to enforce global policies. This paper studies the implications of the local network view of the controllers. In particular, we establish a connection to the field of local algorithms and distributed computing, and discuss lessons for the design of a distributed control plane. We show that existing local algorithms can be used to develop efficient coordination protocols in which each controller only needs to respond to events that take place in its local neighborhood. However, while existing algorithms can be used, SDN networks also suggest a new approach to the study of locality in distributed computing. We introduce the so-called supported locality model of distributed computing. The new model is more expressive than the classical models that are commonly used in the design and analysis of distributed algorithms, and it is a better match with the features of SDN networks.

No abstract

There are distributed graph algorithms for finding maximal matchings and maximal independent sets in O(∆ + log * n) communication rounds; here n is the number of nodes and ∆ is the maximum degree. The lower bound by Linial (1987Linial ( , 1992 shows that the dependency on n is optimal: these problems cannot be solved in o(log * n) rounds even if ∆ = 2.However, the dependency on ∆ is a long-standing open question, and there is currently an exponential gap between the upper and lower bounds.We prove that the upper bounds are tight. We show that maximal matchings and maximal independent sets cannot be found in o(∆ + log log n/ log log log n) rounds with any randomized algorithm in the LOCAL model of distributed computing.As a corollary, it follows that there is no deterministic algorithm for maximal matchings or maximal independent sets that runs in o(∆ + log n/ log log n) rounds; this is an improvement over prior lower bounds also as a function of n.

This work studies decision problems from the perspective of nondeterministic distributed algorithms. For a yes-instance there must exist a proof that can be verified with a distributed algorithm: all nodes must accept a valid proof, and at least one node must reject an invalid proof. We focus on locally checkable proofs that can be verified with a constanttime distributed algorithm. For example, it is easy to prove that a graph is bipartite: the locally checkable proof gives a 2-colouring of the graph, which only takes 1 bit per node. However, it is more difficult to prove that a graph is not bipartite-it turns out that any locally checkable proof requires Ω(log n) bits per node. In this work we classify graph problems according to their local proof complexity, i.e., how many bits per node are needed in a locally checkable proof. We establish tight or near-tight results for classical graph properties such as the chromatic number. We show that the proof complexities form a natural hierarchy of complexity classes: for many classical graph problems, the proof complexity is either 0, Θ(1), Θ(log n), or poly(n) bits per node. Among the most difficult graph properties are symmetric graphs, which require Ω(n 2) bits per node, and non-3-colourable graphs, which require Ω(n 2 / log n) bits per node-any pure graph property admits a trivial proof of size O(n 2).

LCLs or locally checkable labelling problems (e.g. maximal independent set, maximal matching, and vertex colouring) in the LOCAL model of computation are very well-understood in cycles (toroidal 1-dimensional grids): every problem has a complexity of O(1), Θ(log * n), or Θ(n), and the design of optimal algorithms can be fully automated.This work develops the complexity theory of LCL problems for toroidal 2-dimensional grids. The complexity classes are the same as in the 1-dimensional case: O(1), Θ(log * n), and Θ(n). However, given an LCL problem it is undecidable whether its complexity is Θ(log * n) or Θ(n) in 2-dimensional grids.Nevertheless, if we correctly guess that the complexity of a problem is Θ(log * n), we can completely automate the design of optimal algorithms. For any problem we can find an algorithm that is of a normal form A • S k , where A is a finite function, S k is an algorithm for finding a maximal independent set in kth power of the grid, and k is a constant.Finally, partially with the help of automated design tools, we classify the complexity of several concrete LCL problems related to colourings and orientations. arXiv:1702.05456v2 [cs.DC] 24 May 2017 1.1 Problem setting: LCL problems on grids 92 33 77 57 49 26 71 79 8 62 48 24 31 21 15 30 60 67 0 5 17 95 23 47 87 80 25 38 20 64 45 61 91 51 69 1 74 55 3 98 88 99 58 53 63 40 16 2 39Grids. In this work, we study distributed algorithms in a setting where the underlying input graph is a grid. Specifically, we consider the complexity of locally checkable labelling problems, or LCL problems, in the standard LOCAL model of distributed complexity, and consider graphs that are toroidal two-dimensional n × n grids with a consistent orientation; we focus on the two-dimensional case for concreteness, but most of our results generalise to d-dimensional grids of arbitrary dimensions. This setting occupies a middle ground between the wellunderstood directed n-cycles [10,32], where all solvable LCL problems are known to have deterministic time complexity either O(1), Θ(log * n) or Θ(n), and the more complicated setting of general n-vertex graphs, where intermediate problems with time complexities such as Θ(log n) are known to exist, even for bounded-degree graphs. Grid-like systems with local dynamics also occur frequently in the study of real-world phenomena. However, grids have so far not been systematically studied from a distributed computing perspective.LOCAL model and LCL problems. In the LOCAL model of distributed computing, nodes are labelled with unique numerical identifiers with O(log n) bits. A time-t algorithm in this model is simply a mapping from radius-t neighbourhoods to local outputs; equivalently, it can be interpreted as a message-passing algorithm in which the nodes exchange messages for t synchronous rounds and then announce their local outputs.LCL problems are graph problems for which the feasibility of a solution can be verified by checking the solution for each O(1)-radius neighbourhood; if all local neighbourhoods look valid, the s...