arXiv subjects

Alkida Balliu

Publications and source records attributed to Alkida Balliu.

At least 37 records · Page 2Linked to original sources

arXiv2022

Distributed Maximal Matching and Maximal Independent Set on Hypergraphs

We investigate the distributed complexity of maximal matching and maximal independent set (MIS) in hypergraphs in the LOCAL model. A maximal matching of a hypergraph $H=(V_H,E_H)$ is a maximal disjoint set $M\subseteq E_H$ of hyperedges and an MIS $S\subseteq V_H$ is a maximal set of nodes such that no hyperedge is fully contained in $S$. Both problems can be solved by a simple sequential greedy algorithm, which can be implemented naively in $O(Δr + \log^* n)$ rounds, where $Δ$ is the maximum degree, $r$ is the rank, and $n$ is the number of nodes. We show that for maximal matching, this naive algorithm is optimal in the following sense. Any deterministic algorithm for solving the problem requires $Ω(\min\{Δr, \log_{Δr} n\})$ rounds, and any randomized one requires $Ω(\min\{Δr, \log_{Δr} \log n\})$ rounds. Hence, for any algorithm with a complexity of the form $O(f(Δ, r) + g(n))$, we have $f(Δ, r) \in Ω(Δr)$ if $g(n)$ is not too large, and in particular if $g(n) = \log^* n$ (which is the optimal asymptotic dependency on $n$ due to Linial's lower bound [FOCS'87]). Our lower bound proof is based on the round elimination framework, and its structure is inspired by a new round elimination fixed point that we give for the $Δ$-vertex coloring problem in hypergraphs. For the MIS problem on hypergraphs, we show that for $Δ\ll r$, there are significant improvements over the naive $O(Δr + \log^* n)$-round algorithm. We give two deterministic algorithms for the problem. We show that a hypergraph MIS can be computed in $O(Δ^2\cdot\log r + Δ\cdot\log r\cdot \log^* r + \log^* n)$ rounds. We further show that at the cost of a worse dependency on $Δ$, the dependency on $r$ can be removed almost entirely, by giving an algorithm with complexity $Δ^{O(Δ)}\cdot\log^* r + O(\log^* n)$.

cs.DS↗

arXiv2022

Locally Checkable Problems in Rooted Trees

Consider any locally checkable labeling problem $Π$ in rooted regular trees: there is a finite set of labels $Σ$, and for each label $x \in Σ$ we specify what are permitted label combinations of the children for an internal node of label $x$ (the leaf nodes are unconstrained). This formalism is expressive enough to capture many classic problems studied in distributed computing, including vertex coloring, edge coloring, and maximal independent set. We show that the distributed computational complexity of any such problem $Π$ falls in one of the following classes: it is $O(1)$, $Θ(\log^* n)$, $Θ(\log n)$, or $n^{Θ(1)}$ rounds in trees with $n$ nodes (and all of these classes are nonempty). We show that the complexity of any given problem is the same in all four standard models of distributed graph algorithms: deterministic $\mathsf{LOCAL}$, randomized $\mathsf{LOCAL}$, deterministic $\mathsf{CONGEST}$, and randomized $\mathsf{CONGEST}$ model. In particular, we show that randomness does not help in this setting, and the complexity class $Θ(\log \log n)$ does not exist (while it does exist in the broader setting of general trees). We also show how to systematically determine the complexity class of any such problem $Π$, i.e., whether $Π$ takes $O(1)$, $Θ(\log^* n)$, $Θ(\log n)$, or $n^{Θ(1)}$ rounds. While the algorithm may take exponential time in the size of the description of $Π$, it is nevertheless practical: we provide a freely available implementation of the classifier algorithm, and it is fast enough to classify many problems of interest.

cs.DC↗

arXiv2022

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, \dotsc$, 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.

cs.DC↗

arXiv2022

Exponential Speedup Over Locality in MPC with Optimal Memory

Locally Checkable Labeling (LCL) problems are graph problems in which a solution is correct if it satisfies some given constraints in the local neighborhood of each node. Example problems in this class include maximal matching, maximal independent set, and coloring problems. A successful line of research has been studying the complexities of LCL problems on paths/cycles, trees, and general graphs, providing many interesting results for the LOCAL model of distributed computing. In this work, we initiate the study of LCL problems in the low-space Massively Parallel Computation (MPC) model. In particular, on forests, we provide a method that, given the complexity of an LCL problem in the LOCAL model, automatically provides an exponentially faster algorithm for the low-space MPC setting that uses optimal global memory, that is, truly linear. While restricting to forests may seem to weaken the result, we emphasize that all known (conditional) lower bounds for the MPC setting are obtained by lifting lower bounds obtained in the distributed setting in tree-like networks (either forests or high girth graphs), and hence the problems that we study are challenging already on forests. Moreover, the most important technical feature of our algorithms is that they use optimal global memory, that is, memory linear in the number of edges of the graph. In contrast, most of the state-of-the-art algorithms use more than linear global memory. Further, they typically start with a dense graph, sparsify it, and then solve the problem on the residual graph, exploiting the relative increase in global memory. On forests, this is not possible, because the given graph is already as sparse as it can be, and using optimal memory requires new solutions.

cs.DC↗

arXiv2022

Node and Edge Averaged Complexities of Local Graph Problems

The node-averaged complexity of a distributed algorithm running on a graph $G=(V,E)$ is the average over the times at which the nodes $V$ of $G$ finish their computation and commit to their outputs. We study the node-averaged complexity for some distributed symmetry breaking problems and provide the following results (among others): - The randomized node-averaged complexity of computing a maximal independent set (MIS) in $n$-node graphs of maximum degree $Δ$ is at least $Ω\big(\min\big\{\frac{\logΔ}{\log\logΔ},\sqrt{\frac{\log n}{\log\log n}}\big\}\big)$. This bound is obtained by a novel adaptation of the well-known KMW lower bound [JACM'16]. As a side result, we obtain the same lower bound for the worst-case randomized round complexity for computing an MIS in trees -- this essentially answers open problem 11.15 in the book of Barenboim and Elkin and resolves the complexity of MIS on trees up to an $O(\sqrt{\log\log n})$ factor. We also show that, $(2,2)$-ruling sets, which are a minimal relaxation of MIS, have $O(1)$ randomized node-averaged complexity. - For maximal matching, we show that while the randomized node-averaged complexity is $Ω\big(\min\big\{\frac{\logΔ}{\log\logΔ},\sqrt{\frac{\log n}{\log\log n}}\big\}\big)$, the randomized edge-averaged complexity is $O(1)$. Further, we show that the deterministic edge-averaged complexity of maximal matching is $O(\log^2Δ+ \log^* n)$ and the deterministic node-averaged complexity of maximal matching is $O(\log^3Δ+ \log^* n)$. - Finally, we consider the problem of computing a sinkless orientation of a graph. The deterministic worst-case complexity of the problem is known to be $Θ(\log n)$, even on bounded-degree graphs. We show that the problem can be solved deterministically with node-averaged complexity $O(\log^* n)$, while keeping the worst-case complexity in $O(\log n)$.

cs.DC↗

arXiv2022

Sinkless Orientation Made Simple

The sinkless orientation problem plays a key role in understanding the foundations of distributed computing. The problem can be used to separate two fundamental models of distributed graph algorithms, LOCAL and SLOCAL: the locality of sinkless orientation is $Ω(\log n)$ in the deterministic LOCAL model and $O(\log \log n)$ in the deterministic SLOCAL model. Both of these results are known by prior work, but here we give new simple, self-contained proofs for them.

cs.DC↗

arXiv2022

Distributed Lower Bounds for Ruling Sets

Given a graph $G = (V,E)$, an $(α, β)$-ruling set is a subset $S \subseteq V$ such that the distance between any two vertices in $S$ is at least $α$, and the distance between any vertex in $V$ and the closest vertex in $S$ is at most $β$. We present lower bounds for distributedly computing ruling sets. More precisely, for the problem of computing a $(2, β)$-ruling set in the LOCAL model, we show the following, where $n$ denotes the number of vertices, $Δ$ the maximum degree, and $c$ is some universal constant independent of $n$ and $Δ$. $\bullet$ Any deterministic algorithm requires $Ω\left(\min \left\{ \frac{\log Δ}{β\log \log Δ} , \log_Δn \right\} \right)$ rounds, for all $β\le c \cdot \min\left\{ \sqrt{\frac{\log Δ}{\log \log Δ}} , \log_Δn \right\}$. By optimizing $Δ$, this implies a deterministic lower bound of $Ω\left(\sqrt{\frac{\log n}{β\log \log n}}\right)$ for all $β\le c \sqrt[3]{\frac{\log n}{\log \log n}}$. $\bullet$ Any randomized algorithm requires $Ω\left(\min \left\{ \frac{\log Δ}{β\log \log Δ} , \log_Δ\log n \right\} \right)$ rounds, for all $β\le c \cdot \min\left\{ \sqrt{\frac{\log Δ}{\log \log Δ}} , \log_Δ\log n \right\}$. By optimizing $Δ$, this implies a randomized lower bound of $Ω\left(\sqrt{\frac{\log \log n}{β\log \log \log n}}\right)$ for all $β\le c \sqrt[3]{\frac{\log \log n}{\log \log \log n}}$. For $β> 1$, this improves on the previously best lower bound of $Ω(\log^* n)$ rounds that follows from the 30-year-old bounds of Linial [FOCS'87] and Naor [J.Disc.Math.'91]. For $β= 1$, i.e., for the problem of computing a maximal independent set, our results improve on the previously best lower bound of $Ω(\log^* n)$ on trees, as our bounds already hold on trees.

cs.DC↗

arXiv2022

Distributed $Δ$-Coloring Plays Hide-and-Seek

We prove several new tight distributed lower bounds for classic symmetry breaking graph problems. As a basic tool, we first provide a new insightful proof that any deterministic distributed algorithm that computes a $Δ$-coloring on $Δ$-regular trees requires $Ω(\log_Δn)$ rounds and any randomized algorithm requires $Ω(\log_Δ\log n)$ rounds. We prove this result by showing that a natural relaxation of the $Δ$-coloring problem is a fixed point in the round elimination framework. As a first application, we show that our $Δ$-coloring lower bound proof directly extends to arbdefective colorings. We exactly characterize which variants of the arbdefective coloring problem are "easy", and which of them instead are "hard". As a second application, which we see as our main contribution, we use the structure of the fixed point as a building block to prove lower bounds as a function of $Δ$ for a large class of distributed symmetry breaking problems. For example, we obtain a tight lower bound for the fundamental problem of computing a $(2,β)$-ruling set. This is an exponential improvement over the best existing lower bound for the problem, which was proven in [FOCS '20]. Our lower bound even applies to a much more general family of problems that allows for almost arbitrary combinations of natural constraints from coloring problems, orientation problems, and independent set problems, and provides a single unified proof for known and new lower bound results for these types of problems. Our lower bounds as a function of $Δ$ also imply lower bounds as a function of $n$. We obtain, for example, that maximal independent set, on trees, requires $Ω(\log n / \log \log n)$ rounds for deterministic algorithms, which is tight.

cs.DC↗

arXiv2022

Distributed Edge Coloring in Time Polylogarithmic in $Δ$

We provide new deterministic algorithms for the edge coloring problem, which is one of the classic and highly studied distributed local symmetry breaking problems. As our main result, we show that a $(2Δ-1)$-edge coloring can be computed in time $\mathrm{poly}\logΔ+ O(\log^* n)$ in the LOCAL model. This improves a result of Balliu, Kuhn, and Olivetti [PODC '20], who gave an algorithm with a quasi-polylogarithmic dependency on $Δ$. We further show that in the CONGEST model, an $(8+\varepsilon)Δ$-edge coloring can be computed in $\mathrm{poly}\logΔ+ O(\log^* n)$ rounds. The best previous $O(Δ)$-edge coloring algorithm that can be implemented in the CONGEST model is by Barenboim and Elkin [PODC '11] and it computes a $2^{O(1/\varepsilon)}Δ$-edge coloring in time $O(Δ^\varepsilon + \log^* n)$ for any $\varepsilon\in(0,1]$.

cs.DC↗

arXiv2021

Lower bounds for maximal matchings and maximal independent sets

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 (1987, 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 any algorithm that finds a maximal matching or maximal independent set with probability at least $1-1/n$ requires $Ω(\min\{Δ,\log \log n / \log \log \log n\})$ rounds in the LOCAL model of distributed computing. As a corollary, it follows that any deterministic algorithm that finds a maximal matching or maximal independent set requires $Ω(\min\{Δ, \log n / \log \log n\})$ rounds; this is an improvement over prior lower bounds also as a function of $n$.

cs.DC↗

arXiv2021

Improved Distributed Fractional Coloring Algorithms

We prove new bounds on the distributed fractional coloring problem in the LOCAL model. Fractional $c$-colorings can be understood as multicolorings as follows. For some natural numbers $p$ and $q$ such that $p/q\leq c$, each node $v$ is assigned a set of at least $q$ colors from $\{1,\dots,p\}$ such that adjacent nodes are assigned disjoint sets of colors. The minimum $c$ for which a fractional $c$-coloring of a graph $G$ exists is called the fractional chromatic number $χ_f(G)$ of $G$. Recently, [Bousquet, Esperet, and Pirot; SIROCCO '21] showed that for any constant $ε>0$, a fractional $(Δ+ε)$-coloring can be computed in $Δ^{O(Δ)} + O(Δ\cdot\log^* n)$ rounds. We show that such a coloring can be computed in only $O(\log^2 Δ)$ rounds, without any dependency on $n$. We further show that in $O\big(\frac{\log n}ε\big)$ rounds, it is possible to compute a fractional $(1+ε)χ_f(G)$-coloring, even if the fractional chromatic number $χ_f(G)$ is not known. That is, this problem can be approximated arbitrarily well by an efficient algorithm in the LOCAL model. For the standard coloring problem, it is only known that an $O\big(\frac{\log n}{\log\log n}\big)$-approximation can be computed in polylogarithmic time in the LOCAL model. We also show that our distributed fractional coloring approximation algorithm is best possible. We show that in trees, which have fractional chromatic number $2$, computing a fractional $(2+ε)$-coloring requires at least $Ω\big(\frac{\log n}ε\big)$ rounds. We finally study fractional colorings of regular grids. In [Bousquet, Esperet, and Pirot; SIROCCO '21], it is shown that in regular grids of bounded dimension, a fractional $(2+ε)$-coloring can be computed in time $O(\log^* n)$. We show that such a coloring can even be computed in $O(1)$ rounds in the LOCAL model.

cs.DC↗

arXiv2021

Local Mending

In this work we introduce the graph-theoretic notion of mendability: for each locally checkable graph problem we can define its mending radius, which captures the idea of how far one needs to modify a partial solution in order to "patch a hole." We explore how mendability is connected to the existence of efficient algorithms, especially in distributed, parallel, and fault-tolerant settings. It is easy to see that $O(1)$-mendable problems are also solvable in $O(\log^* n)$ rounds in the LOCAL model of distributed computing. One of the surprises is that in paths and cycles, a converse also holds in the following sense: if a problem $Π$ can be solved in $O(\log^* n)$, there is always a restriction $Π' \subseteq Π$ that is still efficiently solvable but that is also $O(1)$-mendable. We also explore the structure of the landscape of mendability. For example, we show that in trees, the mending radius of any locally checkable problem is $O(1)$, $Θ(\log n)$, or $Θ(n)$, while in general graphs the structure is much more diverse.

cs.DC↗

arXiv2021

Improved Distributed Lower Bounds for MIS and Bounded (Out-)Degree Dominating Sets in Trees

Recently, Balliu, Brandt, and Olivetti [FOCS '20] showed the first $ω(\log^* n)$ lower bound for the maximal independent set (MIS) problem in trees. In this work we prove lower bounds for a much more relaxed family of distributed symmetry breaking problems. As a by-product, we obtain improved lower bounds for the distributed MIS problem in trees. For a parameter $k$ and an orientation of the edges of a graph $G$, we say that a subset $S$ of the nodes of $G$ is a $k$-outdegree dominating set if $S$ is a dominating set of $G$ and if in the induced subgraph $G[S]$, every node in $S$ has outdegree at most $k$. Note that for $k=0$, this definition coincides with the definition of an MIS. For a given $k$, we consider the problem of computing a $k$-outdegree dominating set. We show that, even in regular trees of degree at most $Δ$, in the standard \LOCAL model, there exists a constant $ε>0$ such that for $k\leq Δ^ε$, for the problem of computing a $k$-outdegree dominating set, any randomized algorithm requires at least $Ω(\min\{\logΔ,\sqrt{\log\log n}\})$ rounds and any deterministic algorithm requires at least $Ω(\min\{\logΔ,\sqrt{\log n}\})$ rounds. The proof of our lower bounds is based on the recently highly successful round elimination technique. We provide a novel way to do simplifications for round elimination, which we expect to be of independent interest. Our new proof is considerably simpler than the lower bound proof in [FOCS '20]. In particular, our round elimination proof uses a family of problems that can be described by only a constant number of labels. The existence of such a proof for the MIS problem was believed impossible by the authors of [FOCS '20].

cs.DC↗

arXiv2021

Locally Checkable Labelings with Small Messages

A rich line of work has been addressing the computational complexity of locally checkable labelings (LCLs), illustrating the landscape of possible complexities. In this paper, we study the landscape of LCL complexities under bandwidth restrictions. Our main results are twofold. First, we show that on trees, the CONGEST complexity of an LCL problem is asymptotically equal to its complexity in the LOCAL model. An analog statement for general (non-LCL) problems is known to be false. Second, we show that for general graphs this equivalence does not hold, by providing an LCL problem for which we show that it can be solved in $O(\log n)$ rounds in the LOCAL model, but requires $\tildeΩ(n^{1/2})$ rounds in the CONGEST model.

cs.DS↗

arXiv2020

Almost Global Problems in the LOCAL Model

The landscape of the distributed time complexity is nowadays well-understood for subpolynomial complexities. When we look at deterministic algorithms in the LOCAL model and locally checkable problems (LCLs) in bounded-degree graphs, the following picture emerges: - There are lots of problems with time complexities of $Θ(\log^* n)$ or $Θ(\log n)$. - It is not possible to have a problem with complexity between $ω(\log^* n)$ and $o(\log n)$. - In general graphs, we can construct LCL problems with infinitely many complexities between $ω(\log n)$ and $n^{o(1)}$. - In trees, problems with such complexities do not exist. However, the high end of the complexity spectrum was left open by prior work. In general graphs there are LCL problems with complexities of the form $Θ(n^α)$ for any rational $0 < α\le 1/2$, while for trees only complexities of the form $Θ(n^{1/k})$ are known. No LCL problem with complexity between $ω(\sqrt{n})$ and $o(n)$ is known, and neither are there results that would show that such problems do not exist. We show that: - In general graphs, we can construct LCL problems with infinitely many complexities between $ω(\sqrt{n})$ and $o(n)$. - In trees, problems with such complexities do not exist. Put otherwise, we show that any LCL with a complexity $o(n)$ can be solved in time $O(\sqrt{n})$ in trees, while the same is not true in general graphs.

cs.DC↗

arXiv2020

Distributed Edge Coloring in Time Quasi-Polylogarithmic in Delta

The problem of coloring the edges of an $n$-node graph of maximum degree $Δ$ with $2Δ- 1$ colors is one of the key symmetry breaking problems in the area of distributed graph algorithms. While there has been a lot of progress towards the understanding of this problem, the dependency of the running time on $Δ$ has been a long-standing open question. Very recently, Kuhn [SODA '20] showed that the problem can be solved in time $2^{O(\sqrt{\logΔ})}+O(\log^* n)$. In this paper, we study the edge coloring problem in the distributed LOCAL model. We show that the $(\mathit{degree}+1)$-list edge coloring problem, and thus also the $(2Δ-1)$-edge coloring problem, can be solved deterministically in time $\log^{O(\log\logΔ)}Δ+ O(\log^* n)$. This is a significant improvement over the result of Kuhn [SODA '20].

cs.DC↗

arXiv2020

How much does randomness help with locally checkable problems?

Locally checkable labeling problems (LCLs) are distributed graph problems in which a solution is globally feasible if it is locally feasible in all constant-radius neighborhoods. Vertex colorings, maximal independent sets, and maximal matchings are examples of LCLs. On the one hand, it is known that some LCLs benefit exponentially from randomness---for example, any deterministic distributed algorithm that finds a sinkless orientation requires $Θ(\log n)$ rounds in the LOCAL model, while the randomized complexity of the problem is $Θ(\log \log n)$ rounds. On the other hand, there are also many LCLs in which randomness is useless. Previously, it was not known if there are any LCLs that benefit from randomness, but only subexponentially. We show that such problems exist: for example, there is an LCL with deterministic complexity $Θ(\log^2 n)$ rounds and randomized complexity $Θ(\log n \log \log n)$ rounds.

cs.DC↗

arXiv2020

Classification of distributed binary labeling problems

We present a complete classification of the deterministic distributed time complexity for a family of graph problems: binary labeling problems in trees. These are locally checkable problems that can be encoded with an alphabet of size two in the edge labeling formalism. Examples of binary labeling problems include sinkless orientation, sinkless and sourceless orientation, 2-vertex coloring, perfect matching, and the task of coloring edges red and blue such that all nodes are incident to at least one red and at least one blue edge. More generally, we can encode e.g. any cardinality constraints on indegrees and outdegrees. We study the deterministic time complexity of solving a given binary labeling problem in trees, in the usual LOCAL model of distributed computing. We show that the complexity of any such problem is in one of the following classes: $O(1)$, $Θ(\log n)$, $Θ(n)$, or unsolvable. In particular, a problem that can be represented in the binary labeling formalism cannot have time complexity $Θ(\log^* n)$, and hence we know that e.g. any encoding of maximal matchings has to use at least three labels (which is tight). Furthermore, given the description of any binary labeling problem, we can easily determine in which of the four classes it is and what is an asymptotically optimal algorithm for solving it. Hence the distributed time complexity of binary labeling problems is decidable, not only in principle, but also in practice: there is a simple and efficient algorithm that takes the description of a binary labeling problem and outputs its distributed time complexity.

cs.DC↗