The randomized online-LOCAL model captures a number of models of computing; it is at least as strong as all of these models: - the classical LOCAL model of distributed graph algorithms, - the quantum version of the LOCAL model, - finitely dependent distributions [e.g. Holroyd 2016], - any model that does not violate physical causality [Gavoille, Kosowski, Markiewicz, DISC 2009], - the SLOCAL model [Ghaffari, Kuhn, Maus, STOC 2017], and - the dynamic-LOCAL and online-LOCAL models [Akbari et al., ICALP 2023]. In general, the online-LOCAL model can be much stronger than the LOCAL model. For example, there are locally checkable labeling problems (LCLs) that can be solved with logarithmic locality in the online-LOCAL model but that require polynomial locality in the LOCAL model. However, in this work we show that in trees, many classes of LCL problems have the same locality in deterministic LOCAL and randomized online-LOCAL (and as a corollary across all the above-mentioned models). In particular, these classes of problems do not admit any distributed quantum advantage. We present a near-complete classification for the case of rooted regular trees. We also fully classify the super-logarithmic region in unrooted regular trees. Finally, we show that in general trees (rooted or unrooted, possibly irregular, possibly with input labels) problems that are global in deterministic LOCAL remain global also in the randomized online-LOCAL model.

In prior work, Gupta et al. (SPAA 2022) presented a distributed algorithm for multiplying sparse n x n matrices, using n computers. They assumed that the input matrices are uniformly sparse---there are at most d non-zeros in each row and column---and the task is to compute a uniformly sparse part of the product matrix. Initially each computer knows one row of each input matrix, and eventually each computer needs to know one row of the product matrix. In each communication round each computer can send and receive one O(łog n)-bit message. Their algorithm solves this task in O(d^1.907 ) rounds, while the trivial bound is O(d^2).

We present a deterministic algorithm for solving a wide range of dynamic programming problems in trees in O(log D) rounds in the massively parallel computation model (MPC), with O(nδ) words of local memory per machine, for any given constant 0 < δ < 1. Here D is the diameter of the tree and n is the number of nodes---we emphasize that our running time is independent of n.

Abstract Consider any locally checkable labeling problem $$\Pi $$ Π in rooted regular trees: there is a finite set of labels $$\Sigma $$ Σ , and for each label $$x \in \Sigma $$ x ∈ Σ 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 $$\Pi $$ Π falls in one of the following classes: it is O(1), $$\Theta (\log ^* n)$$ Θ ( log ∗ n ) , $$\Theta (\log n)$$ Θ ( log n ) , or $$n^{\Theta (1)}$$ 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}$$ LOCAL , randomized $$\mathsf {LOCAL}$$ LOCAL , deterministic $$\mathsf {CONGEST}$$ CONGEST , and randomized $$\mathsf {CONGEST}$$ CONGEST model. In particular, we show that randomness does not help in this setting, and the complexity class $$\Theta (\log \log n)$$ Θ ( 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 $$\Pi $$ Π , i.e., whether $$\Pi $$ Π takes O(1), $$\Theta (\log ^* n)$$ Θ ( log ∗ n ) , $$\Theta (\log n)$$ Θ ( log n ) , or $$n^{\Theta (1)}$$ n Θ ( 1 ) rounds. While the algorithm may take exponential time in the size of the description of $$\Pi $$ Π , 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.

The locality of a graph problem is the smallest distance T such that each node can choose its own part of the solution based on its radius-T neighborhood. In many settings, a graph problem can be solved efficiently with a distributed or parallel algorithm if and only if it has a small locality. In this work we seek to automate the study of solvability and locality: given the description of a graph problem Π, we would like to determine if Π is solvable and what is the asymptotic locality of Π as a function of the size of the graph. Put otherwise, we seek to automatically synthesize efficient distributed and parallel algorithms for solving Π. We focus on locally checkable graph problems; these are problems in which a solution is globally feasible if it looks feasible in all constant-radius neighborhoods. Prior work on such problems has brought primarily bad news: questions related to locality are undecidable in general, and even if we focus on the case of labeled paths and cycles, determining locality is PSPACE-hard (Balliu et al., PODC 2019). We complement prior negative results with efficient algorithms for the cases of unlabeled paths and cycles and, as an extension, for rooted trees. We study locally checkable graph problems from an automata-theoretic perspective by representing a locally checkable problem Π as a nondeterministic finite automaton M over a unary alphabet. We identify polynomial-time-computable properties of the automaton M that near-completely capture the solvability and locality of Π in cycles and paths, with the exception of one specific case that is co-NP-complete.

We study matrix multiplication in the low-bandwidth model: There are n computers, and we need to compute the product of two n × n matrices. Initially computer i knows row i of each input matrix. In one communication round each computer can send and receive one O(logn)-bit message. Eventually computer i has to output row i of the product matrix.

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.

Consider any locally checkable labeling problem Π in rooted regular trees: there is a finite set of labels Σ, and for each label χ x Σ 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.

The locality of a graph problem is the smallest distance $T$ such that each node can choose its own part of the solution based on its radius-$T$ neighborhood. In many settings, a graph problem can be solved efficiently with a distributed or parallel algorithm if and only if it has a small locality. In this work we seek to automate the study of solvability and locality: given the description of a graph problem $Π$, we would like to determine if $Π$ is solvable and what is the asymptotic locality of $Π$ as a function of the size of the graph. Put otherwise, we seek to automatically synthesize efficient distributed and parallel algorithms for solving $Π$. We focus on locally checkable graph problems; these are problems in which a solution is globally feasible if it looks feasible in all constant-radius neighborhoods. Prior work on such problems has brought primarily bad news: questions related to locality are undecidable in general, and even if we focus on the case of labeled paths and cycles, determining locality is $\mathsf{PSPACE}$-hard (Balliu et al., PODC 2019). We complement prior negative results with efficient algorithms for the cases of unlabeled paths and cycles and, as an extension, for rooted trees. We introduce a new automata-theoretic perspective for studying locally checkable graph problems. We represent a locally checkable problem $Π$ as a nondeterministic finite automaton $\mathcal{M}$ over a unary alphabet. We identify polynomial-time-computable properties of the automaton $\mathcal{M}$ that near-completely capture the solvability and locality of $Π$ in cycles and paths, with the exception of one specific case that is $\mbox{co-$\mathsf{NP}$}$-complete.

Given a text $T$ of length $n$ and a pattern $P$ of length $m$, the approximate pattern matching problem asks for computation of a particular \emph{distance} function between $P$ and every $m$-substring of $T$. We consider a $(1\pm\varepsilon)$ multiplicative approximation variant of this problem, for $\ell_p$ distance function. In this paper, we describe two $(1+\varepsilon)$-approximate algorithms with a runtime of $\widetilde{O}(\frac{n}{\varepsilon})$ for all (constant) non-negative values of $p$. For constant $p \ge 1$ we show a deterministic $(1+\varepsilon)$-approximation algorithm. Previously, such run time was known only for the case of $\ell_1$ distance, by Gawrychowski and Uznański [ICALP 2018] and only with a randomized algorithm. For constant $0 \le p \le 1$ we show a randomized algorithm for the $\ell_p$, thereby providing a smooth tradeoff between algorithms of Kopelowitz and Porat [FOCS~2015, SOSA~2018] for Hamming distance (case of $p=0$) and of Gawrychowski and Uznański for $\ell_1$ distance.