arXiv subjects

Fabian Kuhn

Publications and source records attributed to Fabian Kuhn.

At least 19 recordsLinked to original sources

arXiv2026

Greedy-Like Defective Coloring: Distributed Algorithms and Applications

A $d$-defective $c$-coloring of a graph $G=(V,E)$ is a coloring of the nodes $V$ with $c$ colors such that every node has at most $d$ neighbors of the same color. Distributed algorithms for computing different variants of defective coloring are at the core of most deterministic state-of-the-art distributed coloring algorithms, and they are also an important tool in many other distributed graph algorithms. In several cases, the overall complexity could be improved if some version of defective coloring could be solved more efficiently. Barenboim and Elkin [STOC '09] introduced a two-pass greedy algorithm that uses $p^2$ colors with defect $\lfloor Δ/p\rfloor$ in $O(Δ+\log^{\ast} n)$ rounds. This remains the best defect/color tradeoff for $O(\log^{\ast} n)$-time algorithms in bounded-degree graphs. This paper expands the capabilities of this two-pass algorithm. First, we generalize it to the \emph{list defective coloring} problem (Fuchs and Kuhn, [DISC '23]). Consequently, we obtain an alternative algorithm for computing a proper $(Δ+1)$-coloring in $\tilde{O}(\sqrtΔ) + O(\log^{\ast} n)$ rounds in the CONGEST model. Second, we analyze a generalized two-pass algorithm for standard defective colorings. We prove that if the number of colors $c$ is not a perfect square, we can improve the state-of-the-art defect for distributed $c$-colorings by a constant factor in most cases. However, we also prove a limitation: for any $c\geq 1$, this generalized algorithm cannot achieve a $c$-coloring with defect below $(1-o(1))\cdotΔ/\sqrt{c}$.

cs.DC↗

arXiv2026

Distributed $(Δ+1)$-Coloring in Graphs of Bounded Neighborhood Independence

The distributed coloring problem is arguably one of the key problems studied in the area of distributed graph algorithms. The most standard variant of the problem asks for a proper vertex coloring of a graph with $Δ+ 1$ colors, where $Δ$ is the maximum degree of the graph. Despite an immense amount of work on distributed coloring problems in the distributed setting, determining the deterministic complexity of $(Δ+ 1)$-coloring in the standard message passing model remains one of the most important open questions of the area. In this paper, we aim to improve our understanding of the deterministic complexity of $(Δ+ 1)$-coloring as a function of $Δ$ in a special family of graphs for which significantly faster algorithms are already known. The neighborhood independence $θ$ of a graph is the maximum number of pairwise non-adjacent neighbors of some node of the graph. In general, in graphs of neighborhood independence $θ= O(1)$ (e.g., line graphs), it is known that $(Δ+ 1)$-coloring can be solved in $2^{O(\sqrt{\log Δ})} + O(\log^* n)$ rounds. In the present paper, we significantly improve this result, and we show that in graphs of bounded neighborhood independence, a $(Δ+ 1)$-coloring can be computed in $(\log Δ)^{O(\log \log Δ/ \log \log \log Δ)} + O(\log^* n)$ rounds and thus in quasipolylogarithmic time in $Δ$. Additionally, we show that when $θ= o(Δ^{1/8})$, one can color the graph in $o(\sqrtΔ) + O(\log^* n)$ rounds, which is faster than the current best known coloring algorithms do on general graphs. We also show that the known approach that leads to a polylogarithmic in $Δ$ algorithm for $(2Δ- 1)$-edge coloring already fails for edge colorings of hypergraphs of rank at least 3.

cs.DC↗

arXiv2026

List Defective Colorings: Distributed Algorithms and Applications

The distributed coloring problem is at the core of the area of distributed graph algorithms and it is a problem that has seen tremendous progress over the last few years. Much of the remarkable recent progress on deterministic distributed coloring algorithms is based on two main tools: a) defective colorings in which every node of a given color can have a limited number of neighbors of the same color and b) list coloring, a natural generalization of the standard coloring problem that naturally appears when colorings are computed in different stages and one has to extend a previously computed partial coloring to a full coloring. In this paper, we introduce 'list defective colorings', which can be seen as a generalization of these two coloring variants. Essentially, in a list defective coloring instance, each node $v$ is given a list of colors $x_{v,1},\dots,x_{v,p}$ together with a list of defects $d_{v,1},\dots,d_{v,p}$ such that if $v$ is colored with color $x_{v, i}$, it is allowed to have at most $d_{v, i}$ neighbors with color $x_{v, i}$. We highlight the important role of list defective colorings by showing that faster list defective coloring algorithms would directly lead to faster deterministic $(Δ+1)$-coloring algorithms in the LOCAL model. Further, we extend a recent distributed list coloring algorithm by Maus and Tonoyan [DISC '20]. Slightly simplified, we show that if for each node $v$ it holds that $\sum_{i=1}^p \big(d_{v,i}+1)^2 > \mathrm{deg}_G^2(v)\cdot polylogΔ$ then this list defective coloring instance can be solved in a communication-efficient way in only $O(\logΔ)$ communication rounds. This leads to the first deterministic $(Δ+1)$-coloring algorithm in the standard CONGEST model with a time complexity of $O(\sqrtΔ\cdot polylog Δ+\log^* n)$, matching the best time complexity in the LOCAL model up to a $polylogΔ$ factor.

cs.DC↗

arXiv2026

The Distributed Complexity Landscape on Trees Depends on the Knowledge About the Network Size

One of the central models in distributed computing is Linial's LOCAL model [SIAM J. Comp. 1992]. Over time, researchers have studied distributed graph problems in the LOCAL model under slightly different assumptions, such as whether nodes know the exact network size $n$, only a polynomial upper bound on $n$, or nothing at all. We ask whether these differences are merely technical or fundamentally affect the theory of Locally Checkable Labelings (LCLs), one of the most studied problem classes. LCLs are graph problems whose valid solutions can be characterized by a finite set of allowed constant-radius neighborhoods. Since their introduction by Naor and Stockmeyer [FOCS 1995], they have become central in distributed computing, and the last decade has seen major progress in understanding their complexity. For example, Chang, Kopelowitz, and Pettie [FOCS 2016] showed that the randomized complexity of any LCL on $n$-node graphs is at least its deterministic complexity on $\sqrt{\log n}$-node graphs. Later, Chang and Pettie [FOCS 2017] showed that any randomized $n^{o(1)}$-round algorithm for LCLs on bounded-degree trees can be turned into a deterministic $O(\log n)$-round algorithm. Then, Balliu et al. [STOC 2018] showed that such automatic speedups are impossible for general bounded-degree graphs. However, these results fundamentally rely on nodes knowing $n$. How much does this assumption affect the theory of LCLs? Our work shows that if nodes are oblivious to $n$, or know only a polynomial upper bound on it, then even on trees, the theory of LCLs changes significantly. While the fundamental classification of problems remains the same, we show the landscape becomes much more complex: for example, for LCLs, randomness helps in more cases; some problems have very unnatural complexities; and some have a lower bound that depends on which definition of $Ω$ we use!

cs.DC↗

arXiv2026

Classification of Local Optimization Problems in Directed Cycles

We present a complete classification of the distributed computational complexity of local optimization problems in directed cycles for both the deterministic and the randomized LOCAL model. We show that for any local optimization problem $Π$ (that can be of the form min-sum, max-sum, min-max, or max-min, for any local cost or utility function over some finite alphabet), and for any constant approximation ratio $α$, the task of finding an $α$-approximation of $Π$ in directed cycles has one of the following complexities: 1. $O(1)$ rounds in deterministic LOCAL, $O(1)$ rounds in randomized LOCAL, 2. $Θ(\log^* n)$ rounds in deterministic LOCAL, $O(1)$ rounds in randomized LOCAL, 3. $Θ(\log^* n)$ rounds in deterministic LOCAL, $Θ(\log^* n)$ rounds in randomized LOCAL, 4. $Θ(n)$ rounds in deterministic LOCAL, $Θ(n)$ rounds in randomized LOCAL. Moreover, for any given $Π$ and $α$, we can determine the complexity class automatically, with an efficient (centralized, sequential) meta-algorithm, and we can also efficiently synthesize an asymptotically optimal distributed algorithm. Before this work, similar results were only known for local search problems (e.g., locally checkable labeling problems). The family of local optimization problems is a strict generalization of local search problems, and it contains numerous commonly studied distributed tasks, such as the problems of finding approximations of the maximum independent set, minimum vertex cover, minimum dominating set, and minimum vertex coloring.

cs.DC↗

arXiv2026

Distributed Algorithms for Potential Problems

In this work, we present a fast distributed algorithm for local potential problems: these are graph problems where the task is to find a locally optimal solution where no node can unilaterally improve the utility in its local neighborhood by changing its own label. A simple example of such a problem is the task of finding a locally optimal cut, i.e., a cut where for each node at least half of its incident edges are cut edges. The distributed round complexity of the locally optimal cut problem has been wide open; the problem is known to require $Ω(\log n)$ rounds in the deterministic LOCAL model and $Ω(\log \log n)$ rounds in the randomized LOCAL model, but the only known upper bound is the trivial brute-force solution of $O(n)$ rounds. Locally optimal cut in constant-degree graphs is perhaps the simplest example of a locally checkable labeling problem for which there is still such a large gap between current upper and lower bounds. We show that in constant-degree graphs, all local potential problems, including locally optimal cut, can be solved in $\log^{O(1)} n$ rounds, both in the deterministic and randomized LOCAL models. In particular, the deterministic round complexity of the locally optimal cut problem is now settled to $\log^{Θ(1)} n$. Our algorithms also apply to the general case of graphs of maximum degree $Δ$. For the special case of locally optimal cut, we obtain a randomized algorithm that runs in $O(Δ^{2} \log^{6} n)$ rounds, which can be derandomized at polylogarithmic cost with standard techniques. Furthermore, we show that a dependence in $Δ$ is necessary: we prove a lower bound of $Ω(\min\{Δ,\sqrt{n}\})$ rounds, even in the quantum-LOCAL model; in particular, there is no polylogarithmic-round algorithm for the general case.

cs.DC↗

arXiv2025

On the Complexity of Distributed Edge Coloring and Orientation Problems

Understanding the role of randomness when solving locally checkable labeling (LCL) problems in the LOCAL model has been one of the top priorities in the research on distributed graph algorithms in recent years. For LCL problems in bounded-degree graphs, it is known that randomness cannot help more than polynomially, except in one case: if the deterministic complexity of an LCL problem is in $Ω(\log n)$ and its randomized complexity is in $o(\log n)$, then the randomized complexity is guaranteed to be $poly(\log \log n)$. However, the fundamental question of \emph{which} problems with a deterministic complexity of $Ω(\log n)$ can be solved exponentially faster using randomization still remains wide open. We make a step towards answering this question by studying a simple, but natural class of LCL problems: so-called degree splitting problems. These problems come in two varieties: coloring problems where the edges of a graph have to be colored with $2$ colors and orientation problems where each edge needs to be oriented. For $Δ$-regular graphs (where $Δ=O(1)$), we obtain the following results. - We gave an exact characterization of the randomized complexity of all problems where the edges need to be colored with two colors, say red and blue, and which have a deterministic complexity of $O(\log n)$. - For edge orientation problems, we give a partial characterization of the problems that have a randomized complexity of $Ω(\log n)$ and the problems that have a randomized complexity of $poly\log\log n$. While our results are cleanest to state for the $Δ$-regular case, all our algorithms naturally generalize to nodes of any degree $d<Δ$ in general graphs of maximum degree $Δ$.

cs.DS↗

arXiv2025

Distributed Computation with Local Advice

In this work we study local computation with advice: the goal is to solve a graph problem $Π$ with a distributed algorithm in $T(Δ)$ communication rounds, for some function $T$ that only depends on the maximum degree $Δ$ of the graph, and the key question is how many bits of advice per node are needed. Some of our results regard Locally Checkable Labeling problems (LCLs), which are constraint-satisfaction graph problems that can be defined with a finite set of valid input/output-labeled neighborhoods. Our main results are: - Any LCL can be solved with only $1$ bit of advice per node in graphs with sub-exponential growth. Moreover, we can make the set of nodes that carry advice bits arbitrarily sparse. As a corollary, any LCL admits a locally checkable proof with $1$ bit per node in graphs with sub-exponential growth. - The assumption of sub-exponential growth is complemented by a conditional lower bound: assuming the Exponential-Time Hypothesis, there are locally checkable labeling problems that cannot be solved in general with any constant number of bits per node. - In any graph we can find an almost-balanced orientation with $1$ bit of advice per node, and again we can make the advice arbitrarily sparse. As a corollary, we can also compress an arbitrary subset of edges so that a node of degree $d$ stores only $d/2 + 2$ bits, and we can decompress it locally, in $T(Δ)$ rounds. - In any graph of maximum degree $Δ$, we can find a $Δ$-coloring (if it exists) with $1$ bit of advice per node, and again, we can make the advice arbitrarily sparse. - In any $3$-colorable graph, we can find a $3$-coloring with $1$ bit of advice per node. As a corollary, in bounded-degree graphs there is a locally checkable proof that certifies $3$-colorability with $1$ bit of advice per node.

cs.DC↗

arXiv2025

An Efficient Massively Parallel Constant-Factor Approximation Algorithm for the $k$-Means Problem

In this paper, we present an efficient massively parallel approximation algorithm for the $k$-means problem. Specifically, we provide an MPC algorithm that computes a constant-factor approximation to an arbitrary $k$-means instance in $O(\log\log n \cdot \log\log\log n)$ rounds. The algorithm uses $O(n^σ)$ bits of memory per machine, where $σ> 0$ is a constant that can be made arbitrarily small. The global memory usage is $O(n^{1+\varepsilon})$ bits for an arbitrarily small constant $\varepsilon > 0$, and is thus only slightly superlinear. Recently, Czumaj, Gao, Jiang, Krauthgamer, and Veselý showed that a constant-factor bicriteria approximation can be computed in $O(1)$ rounds in the MPC model. However, our algorithm is the first constant-factor approximation for the general $k$-means problem that runs in $o(\log n)$ rounds in the MPC model. Our approach builds upon the foundational framework of Jain and Vazirani. The core component of our algorithm is a constant-factor approximation for the related facility location problem. While such an approximation was already achieved in constant time in the work of Czumaj et al.\ mentioned above, our version additionally satisfies the so-called Lagrangian Multiplier Preserving (LMP) property. This property enables the transformation of a facility location approximation into a comparably good $k$-means approximation.

cs.DS↗

arXiv2025

Faster CONGEST Approximation Algorithms for Maximum Weighted Independent Set in Sparse Graphs

The maximum independent set problem is a classic optimization problem that has also been studied quite intensively in the distributed setting. While the problem is hard to approximate in general, there are good approximation algorithms known for several sparse graph families. In this paper, we consider deterministic distributed CONGEST algorithms for the weighted version of the problem in trees and graphs of bounded arboricity. For trees, we prove that the task of deterministically computing a $(1-ε)$-approximate solution to the maximum weight independent set (MWIS) problem has a tight $Θ(\log^*(n) / ε)$ complexity. The lower bound already holds on unweighted oriented paths. On the upper bound side, we show that the bound can be achieved even in unrooted trees. For graphs $G=(V,E)$ of arboricity $β>1$, we give two algorithms. If the sum of all node weights is $w(V)$, we show that for any $ε>0$, an independent set of weight at least $(1-ε)\cdot \frac{w(V)}{4β}$ can be computed in $O(\log^2(β/ε)/ε+ \log^* n)$ rounds. This result is obtained by a direct application of the local rounding framework of Faour, Ghaffari, Grunau, Kuhn, and Rozhoň [SODA '23]. We further show that for any $ε>0$, an independent set of weight at least $(1-ε)\cdot\frac{w(V)}{2β+1}$ can be computed in $O(\log^3(β)\cdot\log(1/ε)/ε^2 \cdot\log n)$ rounds. This improves on a recent result of Gil [OPODIS '23], who showed that a $1/\lfloor(2+ε)β\rfloor$-approximation to the MWIS problem can be computed in $O(β\cdot\log n)$ rounds. As an intermediate step, we design an algorithm to compute an independent set of total weight at least $(1-ε)\cdot\sum_{v\in V}\frac{w(v)}{deg(v)+1}$ in time $O(\log^3(Δ)\cdot\log(1/ε)/ε+ \log^* n)$, where $Δ$ is the maximum degree of the graph.

cs.DS↗

arXiv2025

A $(3+\varepsilon)$-Approximate Correlation Clustering Algorithm in Dynamic Streams

Grouping together similar elements in datasets is a common task in data mining and machine learning. In this paper, we study streaming algorithms for correlation clustering, where each pair of elements is labeled either similar or dissimilar. The task is to partition the elements and the objective is to minimize disagreements, that is, the number of dissimilar elements grouped together and similar elements that get separated. Our main contribution is a semi-streaming algorithm that achieves a $(3 + \varepsilon)$-approximation to the minimum number of disagreements using a single pass over the stream. In addition, the algorithm also works for dynamic streams. Our approach builds on the analysis of the PIVOT algorithm by Ailon, Charikar, and Newman [JACM'08] that obtains a $3$-approximation in the centralized setting. Our design allows us to sparsify the input graph by ignoring a large portion of the nodes and edges without a large extra cost as compared to the analysis of PIVOT. This sparsification makes our technique applicable in models such as semi-streaming, where sparse graphs can typically be handled much more efficiently. Our work improves on the approximation ratio of the recent single-pass $5$-approximation algorithm and on the number of passes of the recent $O(1/\varepsilon)$-pass $(3 + \varepsilon)$-approximation algorithm [Behnezhad, Charikar, Ma, Tan FOCS'22, SODA'23]. Our algorithm is also more robust and can be applied in dynamic streams. Furthermore, it is the first single pass $(3 + \varepsilon)$-approximation algorithm that uses polynomial post-processing time.

cs.DS↗

arXiv2024

Towards Fully Automatic Distributed Lower Bounds

In the past few years, a successful line of research has lead to lower bounds for several fundamental local graph problems in the distributed setting. These results were obtained via a technique called round elimination. On a high level, the round elimination technique can be seen as a recursive application of a function that takes as input a problem $Π$ and outputs a problem $Π'$ that is one round easier than $Π$. Applying this function recursively to concrete problems of interest can be highly nontrivial, which is one of the reasons that has made the technique difficult to approach. The contribution of our paper is threefold. Firstly, we develop a new and fully automatic method for finding lower bounds of $Ω(\log_Δn)$ and $Ω(\log_Δ\log n)$ rounds for deterministic and randomized algorithms, respectively, via round elimination. Secondly, we show that this automatic method is indeed useful, by obtaining lower bounds for defective coloring problems. We show that the problem of coloring the nodes of a graph with $3$ colors and defect at most $(Δ- 3)/2$ requires $Ω(\log_Δn)$ rounds for deterministic algorithms and $Ω(\log_Δ\log n)$ rounds for randomized ones. We note that lower bounds for coloring problems are notoriously challenging to obtain, both in general, and via the round elimination technique. Both the first and (indirectly) the second contribution build on our third contribution -- a new and conceptually simple way to compute the one-round easier problem $Π'$ in the round elimination framework. This new procedure provides a clear and easy recipe for applying round elimination, thereby making a substantial step towards the greater goal of having a fully automatic procedure for obtaining lower bounds in the distributed setting.

cs.DC↗

arXiv2024

Shared Randomness Helps with Local Distributed Problems

By prior work, we have many results related to distributed graph algorithms for problems that can be defined with local constraints; the formal framework used in prior work is locally checkable labeling problems (LCLs), introduced by Naor and Stockmeyer in the 1990s. It is known, for example, that if we have a deterministic algorithm that solves an LCL in $o(\log n)$ rounds, we can speed it up to $O(\log^*n)$ rounds, and if we have a randomized $O(\log^*n)$ rounds algorithm, we can derandomize it for free. It is also known that randomness helps with some LCL problems: there are LCL problems with randomized complexity $Θ(\log\log n)$ and deterministic complexity $Θ(\log n)$. However, so far there have not been any LCL problems in which the use of shared randomness has been necessary; in all prior algorithms it has been enough that the nodes have access to their own private sources of randomness. Could it be the case that shared randomness never helps with LCLs? Could we have a general technique that takes any distributed graph algorithm for any LCL that uses shared randomness, and turns it into an equally fast algorithm where private randomness is enough? In this work we show that the answer is no. We present an LCL problem $Π$ such that the round complexity of $Π$ is $Ω(\sqrt n)$ in the usual randomized \local model with private randomness, but if the nodes have access to a source of shared randomness, then the complexity drops to $O(\log n)$. As corollaries, we also resolve several other open questions related to the landscape of distributed computing in the context of LCL problems. In particular, problem $Π$ demonstrates that distributed quantum algorithms for LCL problems strictly benefit from a shared quantum state. Problem $Π$ also gives a separation between finitely dependent distributions and non-signaling distributions.

cs.DC↗

arXiv2024

Simpler and More General Distributed Coloring Based on Simple List Defective Coloring Algorithms

In this paper, we give list coloring variants of simple iterative defective coloring algorithms. Formally, in a list defective coloring instance, each node $v$ of a graph is given a list $L_v$ of colors and a list of allowed defects $d_v(x)$ for the colors. Each node $v$ needs to be colored with a color $x\in L_v$ such that at most $d_v(x)$ neighbors of $v$ also pick the same color $x$. For a defect parameter $d$, it is known that by making two sweeps in opposite order over the nodes of an edge-oriented graph with maximum outdegree $β$, one can compute a coloring with $O(β^2/d^2)$ colors such that every node has at most $d$ outneighbors of the same color. We generalize this and show that if all nodes have lists of size $p^2$ and $\forall v:\sum_{x\in L_v}(d_v(x)+1)>p\cdotβ$, we can make two sweeps of the nodes such that at the end, each node $v$ has chosen a color $x\in L_v$ for which at most $d_v(x)$ outneighbors of $v$ are colored with color $x$. Our algorithm is simpler and computationally significantly more efficient than existing algorithms for similar list defective coloring problems. We show that the above result can in particular be used to obtain an alternative $\tilde{O}(\sqrtΔ)+O(\log^* n)$-round algorithm for the $(Δ+1)$-coloring problem in the CONGEST model. The neighborhood independence $θ$ of a graph is the maximum number of pairwise non-adjacent neighbors of some node of the graph. It is known that by doing a single sweep over the nodes of a graph of neighborhood independence $θ$, one can compute a $d$-defective coloring with $O(θ\cdot Δ/d)$ colors. We extend this approach to the list defective coloring setting and use it to obtain an efficient recursive coloring algorithm for graphs of neighborhood independence $θ$. In particular, if $θ=O(1)$, we get an $(\logΔ)^{O(\log\logΔ)}+O(\log^* n)$-round algorithm.

cs.DS↗

arXiv2024

Completing the Node-Averaged Complexity Landscape of LCLs on Trees

The node-averaged complexity of a problem captures the number of rounds nodes of a graph have to spend on average to solve the problem in the LOCAL model. A challenging line of research with regards to this new complexity measure is to understand the complexity landscape of locally checkable labelings (LCLs) on families of bounded-degree graphs. Particularly interesting in this context is the family of bounded-degree trees as there, for the worst-case complexity, we know a complete characterization of the possible complexities and structures of LCL problems. A first step for the node-averaged complexity case has been achieved recently [DISC '23], where the authors in particular showed that in bounded-degree trees, there is a large complexity gap: There are no LCL problems with a deterministic node-averaged complexity between $ω(\log^* n)$ and $n^{o(1)}$. For randomized algorithms, they even showed that the node-averaged complexity is either $O(1)$ or $n^{Ω(1)}$. In this work we fill in the remaining gaps and give a complete description of the node-averaged complexity landscape of LCLs on bounded-degree trees. Our contributions are threefold. - On bounded-degree trees, there is no LCL with a node-averaged complexity between $ω(1)$ and $(\log^*n)^{o(1)}$. - For any constants $0 0$, there exists a constant $c$ and an LCL problem with node-averaged complexity between $Ω((\log^* n)^c)$ and $O((\log^* n)^{c+\varepsilon})$. - For any constants $0<α\leq 1/2$ and $\varepsilon>0$, there exists an LCL problem with node-averaged complexity $Θ(n^x)$ for some $x\in [α, α+\varepsilon]$.

cs.DC↗

arXiv2024

No distributed quantum advantage for approximate graph coloring

We give an almost complete characterization of the hardness of $c$-coloring $χ$-chromatic graphs with distributed algorithms, for a wide range of models of distributed computing. In particular, we show that these problems do not admit any distributed quantum advantage. To do that: 1) We give a new distributed algorithm that finds a $c$-coloring in $χ$-chromatic graphs in $\tilde{\mathcal{O}}(n^{\frac{1}α})$ rounds, with $α= \bigl\lfloor\frac{c-1}{χ- 1}\bigr\rfloor$. 2) We prove that any distributed algorithm for this problem requires $Ω(n^{\frac{1}α})$ rounds. Our upper bound holds in the classical, deterministic LOCAL model, while the near-matching lower bound holds in the non-signaling model. This model, introduced by Arfaoui and Fraigniaud in 2014, captures all models of distributed graph algorithms that obey physical causality; this includes not only classical deterministic LOCAL and randomized LOCAL but also quantum-LOCAL, even with a pre-shared quantum state. We also show that similar arguments can be used to prove that, e.g., 3-coloring 2-dimensional grids or $c$-coloring trees remain hard problems even for the non-signaling model, and in particular do not admit any quantum advantage. Our lower-bound arguments are purely graph-theoretic at heart; no background on quantum information theory is needed to establish the proofs.

cs.DC↗

arXiv2024

On the Node-Averaged Complexity of Locally Checkable Problems on Trees

Over the past decade, a long line of research has investigated the distributed complexity landscape of locally checkable labeling (LCL) problems on bounded-degree graphs, culminating in an almost-complete classification on general graphs and a complete classification on trees. The latter states that, on bounded-degree trees, any LCL problem has deterministic worst-case time complexity $O(1)$, $Θ(\log^* n)$, $Θ(\log n)$, or $Θ(n^{1/k})$ for some positive integer $k$, and all of those complexity classes are nonempty. Moreover, randomness helps only for (some) problems with deterministic worst-case complexity $Θ(\log n)$, and if randomness helps (asymptotically), then it helps exponentially. In this work, we study how many distributed rounds are needed on average per node in order to solve an LCL problem on trees. We obtain a partial classification of the deterministic node-averaged complexity landscape for LCL problems. As our main result, we show that every problem with worst-case round complexity $O(\log n)$ has deterministic node-averaged complexity $O(\log^* n)$. Then we show how using randomization we can speed this up and show that every problem with worst case round complexity $O(\log n)$ has randomized node-averaged complexity $O(1)$. We further establish bounds on the node-averaged complexity of problems with worst-case complexity $Θ(n^{1/k})$: we show that all these problems have node-averaged complexity $\widetildeΩ(n^{1 / (2^k - 1)})$, and that this lower bound is tight for some problems. The lower bound holds even for the randomized case and the upper bound is a deterministic algorithm.

cs.DS↗

arXiv2023

Toward Online Mobile Facility Location on General Metrics

We introduce an online variant of mobile facility location (MFL) (introduced by Demaine et al. [SODA' 07]). We call this new problem online mobile facility location (OMFL). In the OMFL problem, initially, we are given a set of $k$ mobile facilities with their starting locations. One by one, requests are added. After each request arrives, one can make some changes to the facility locations before the subsequent request arrives. Each request is always assigned to the nearest facility. The cost of this assignment is the distance from the request to the facility. The objective is to minimize the total cost, which consists of the relocation cost of facilities and the distance cost of requests to their nearest facilities. We provide a lower bound for the OMFL problem that even holds on uniform metrics. A natural approach to solve the OMFL problem for general metric spaces is to utilize hierarchically well-separated trees (HSTs) and directly solve the OMFL problem on HSTs. In this paper, we provide the first step in this direction by solving a generalized variant of the OMFL problem on uniform metrics that we call G-OMFL. We devise a simple deterministic online algorithm and provide a tight analysis for the algorithm. The second step remains an open question. Inspired by the $k$-server problem, we introduce a new variant of the OMFL problem that focuses solely on minimizing movement cost. We refer to this variant as M-OMFL. Additionally, we provide a lower bound for M-OMFL that is applicable even on uniform metrics.

cs.DS↗