How much does randomness help with locally checkable problems?

TL;DR

This paper investigates the impact of randomness on locally checkable labeling problems (LCLs), revealing that some LCLs benefit from subexponential speedups due to randomness, which was previously unknown.

Contribution

The paper demonstrates the existence of LCLs that benefit from randomness with subexponential improvements, specifically showing an LCL with a gap between deterministic and randomized complexities.

Findings

Existence of LCLs with subexponential randomized speedup

An LCL with deterministic complexity Θ(log^2 n)

Randomized complexity Θ(log n log log n)

Abstract

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 $\Theta(\log n)$ rounds in the LOCAL model, while the randomized complexity of the problem is $\Theta(\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 $\Theta(\log^2 n)$ rounds and randomized complexity $\Theta(\log n \log \log n)$ rounds.

Equations

$$R(n)$$

$$\frac{D(n)}{R(n)}=\Theta\biggl{(}\frac{\log n}{\log\log n}\biggr{)}.$$

$$\frac{D(n)}{R(n)}\gg \log n.$$

$$\bigl{(}\Sigma^{\mathcal{G}}_{V,{\operatorname{in}}}\times\{\mathsf{Port}_{1},\dots,\mathsf{Port}_{\Delta},\mathsf{NoPort}\}\bigr{)}\cup\Sigma^{\mathcal{G}}_{E,{\operatorname{in}}}\cup\Sigma^{\mathcal{G}}_{B,{\operatorname{in}}}$$

$${\Sigma }_{V,\mathrm{out}}^{\mathcal{G}}\cup {\Sigma }_{E,\mathrm{out}}^{\mathcal{G}}\cup {\Sigma }_{B,\mathrm{out}}^{\mathcal{G}}=\mathsf{GadOk}\dot{\cup }{L}_{\mathsf{Err}}.$$

$${\Sigma }_{\mathrm{list}}=2^{\{{\mathsf{Port}}_1,\dots ,{\mathsf{Port}}_{\Delta }\}}\times {\Sigma }_{V,\mathrm{in}}^{\Pi }\times ({\Sigma }_{E,\mathrm{in}}^{\Pi }{)}^{\Delta }\times ({\Sigma }_{B,\mathrm{in}}^{\Pi }{)}^{\Delta }\times {\Sigma }_{V,\mathrm{out}}^{\Pi }\times ({\Sigma }_{E,\mathrm{out}}^{\Pi }{)}^{\Delta }\times ({\Sigma }_{B,\mathrm{out}}^{\Pi }{)}^{\Delta }.$$

$$\ell^{v}_{{\operatorname{list}}}=\bigl{(}S,\iota^{V},\iota^{E}_{1},\dots,\iota^{E}_{\Delta},\iota^{B}_{1},\dots,\iota^{B}_{\Delta},o^{V},o^{E}_{1},\dots,o^{E}_{\Delta},o^{B}_{1},\dots,o^{B}_{\Delta}\bigr{)}$$

$${\iota }^V,{\iota }_{\alpha (1)}^E,\dots ,{\iota }_{\alpha (|S|)}^E,{\iota }_{\alpha (1)}^B,\dots ,{\iota }_{\alpha (|S|)}^B$$

$$o^V,o_{\alpha (1)}^E,\dots ,o_{\alpha (|S|)}^E,o_{\alpha (1)}^B,\dots ,o_{\alpha (|S|)}^B,$$

$${\iota }^{V,u},{\iota }^{V,v},{\iota }_{\alpha (i)}^{E,u},{\iota }_{\alpha (i)}^{B,u},{\iota }_{\alpha (j)}^{B,v}$$

$$o^{V,u},o^{V,v},o_{\alpha (i)}^{E,u},o_{\alpha (i)}^{B,u},o_{\alpha (j)}^{B,v},$$

$$\bigl{(}o^{V},o^{E}_{\alpha(1)},\dots,o^{E}_{\alpha(\deg(u))},o^{B}_{\alpha(1)},\dots,o^{B}_{\alpha(\deg(u))}\bigr{)}=\bigl{(}q^{V},q^{E}_{1},\dots,q^{E}_{\deg(u)},q^{B}_{1},\dots,q^{B}_{\deg(u)}\bigr{)}.$$

Full text

• How much does randomness help with locally checkable problems?

Alkida Balliu  $\cdot$  alkida.balliu@aalto.fi  $\cdot$  Aalto University

Sebastian Brandt  $\cdot$  brandts@ethz.ch  $\cdot$  ETH Zurich

Dennis Olivetti  $\cdot$  dennis.olivetti@aalto.fi  $\cdot$  Aalto University

Jukka Suomela  $\cdot$  jukka.suomela@aalto.fi  $\cdot$  Aalto University

• Abstract. 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 $\Theta(\log n)$ rounds in the LOCAL model, while the randomized complexity of the problem is $\Theta(\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 $\Theta(\log^{2}n)$ rounds and randomized complexity $\Theta(\log n\log\log n)$ rounds.

1 Introduction

Locality of locally checkable problems.

One of the big themes in the theory of distributed graph algorithms is locality: given a graph problem, how far does an individual node need to see in order to be able to produce its own part of the solution? This idea is formalized as the time complexity in the LOCAL model [18, 22] of distributed computing.

While we are still very far from understanding the locality of all possible graph problems, there is one highly relevant family of graph problems that is now close to being completely characterized: locally checkable labeling problems, or in brief LCLs. In essence, LCLs are graph problems in which feasible solutions are easy to verify in a distributed setting—if a solution looks good in all local neighborhoods, it is also good globally. This family of problems was introduced in the seminal paper by Naor and Stockmeyer [20] in the 1990s, and while the groundwork for understanding the locality of LCLs was done already in the 1980s–1990s [15, 10, 21, 18, 19], most of the progress is from the past four years [3, 2, 5, 8, 7, 11, 12, 13, 14, 9, 6].

There are many relevant graph classes to study, but for our purposes the most interesting case is general bounded-degree graphs. We only assume that there is some constant upper bound $\Delta$ on the maximum degree of the graph, and other than that there is no promise about the structure of the input graph. If there are $n$ nodes, the nodes will have unique identifiers from $\{1,2,\dotsc,\operatorname{poly}(n)\}$, and initially each node knows $n$, $\Delta$, its own identifiers, and its own degree—everything else it has to learn through communication.

For bounded-degree graphs, the state of the art is summarized in Figure 1. The figure represents the landscape of all possible distributed time complexities of LCL problems, both for deterministic and randomized algorithms. There are infinite families of problems with distinct time complexities, but there are also large gaps: for example, Chang et al. [8] showed that there is no LCL with a time complexity in the range $\omega(\log^{*}n)$ and $o(\log n)$. For deterministic algorithms, the work of characterizing possible time complexities of LCL problems is near-complete.

Role of randomness.

What we aim at understanding is how much randomness helps with LCLs. As shown in Figure 1, there are some problems in which randomness helps exponentially. The most prominent example is sinkless orientation: its deterministic complexity is $\Theta(\log n)$, while the randomized complexity is $\Theta(\log\log n)$ [5, 8, 12].

On the one hand, it is known that there is at most an exponential gap between deterministic and randomized complexities [8]. On the other hand, there are also lower bounds that exclude many possible combinations of deterministic and randomized time complexities. As illustrated in Figure 1, the work by Chang and Pettie [7] and Fischer and Ghaffari [11] implies that there is no LCL with deterministic complexity $\Theta(\log n)$ and randomized complexity e.g. $\Theta(\sqrt{\log n})$. If a problem can be solved in deterministic logarithmic time, then either randomness helps a lot or not at all.

Sinkless orientation and closely related problems such as $\Delta$-coloring and algorithmic Lovász local lemma are currently the only LCLs for which randomness is known to help. Indeed, all known results previous to our work are compatible with the following conjecture:

Conjecture**.**

If the deterministic complexity of an LCL is $\Theta(\log n)$, then its randomized complexity is either $\Theta(\log n)$ or $\Theta(\log\log n)$. Otherwise the randomized complexity is asymptotically equal to the deterministic complexity.

In particular, randomness helps exponentially or not at all.

We show that the conjecture is false. We show that there are LCL problems that benefit from randomness, but only polynomially. We show how to construct, e.g., an LCL with deterministic complexity $\Theta(\log^{2}n)$ rounds and randomized complexity $\Theta(\log n\log\log n)$ rounds.

The role of randomness in distributed computing is a key research question, and it has been extensively studied. In fact, in their book on graph coloring, Barenboim and Elkin [4] write “Perhaps the most fundamental open problem in this field is to understand the power and limitations of randomization.” We make a step forward in the understanding of this fundamental question.

Technique: padding.

The main technical idea is to introduce the concept of padding in the construction of LCL problems—the basic idea is inspired by the padding technique in the classical computational complexity theory [1, Sect. 2.6].

We start with an LCL problem $\Pi$ and a suitable family of gadgets $\mathcal{G}$. Then we use the gadgets to construct a new graph problem $\Pi^{\prime}$ such that both deterministic and randomized complexity of $\Pi^{\prime}$ is higher than those of $\Pi$. More concretely, let $\Pi$ be the problem of finding a sinkless orientation, with randomized complexity $\Theta(\log\log n)$ and deterministic complexity $\Theta(\log n)$, and let $\mathcal{G}$ be a suitable family of tree-like graphs. By applying $\mathcal{G}$ to $\Pi$, we obtain $\Pi^{\prime}$ in which both randomized and deterministic time complexity have increased by a factor of $\Theta(\log n)$; hence the randomized complexity of $\Pi^{\prime}$ is $\Theta(\log n\log\log n)$ and the deterministic complexity is $\Theta(\log^{2}n)$. By applying $\mathcal{G}$ to $\Pi^{\prime}$ recursively, we can then further obtain randomized complexity $\Theta(\log^{i}n\log\log n)$ and deterministic complexity $\Theta(\log^{i+1}n)$ for any constant $i$.

Figure 2 shows what we would ideally like to do: given a hard instance $G$ for $\Pi$, we replace each node with a suitable gadget to obtain a hard instance $G^{\prime}$ for $\Pi^{\prime}$. The intuition here is that padding increases distances, so if all gadgets happened to be trees of depth $x$, then solving $\Pi^{\prime}$ on $G^{\prime}$ is exactly $x$ times as hard as solving $\Pi$ on $G$.

This would be easy to implement if we had a promise that the input is of a suitable form, but with a promise one can trivially construct LCLs with virtually any complexity. The key challenge is implementing the idea so that $\Pi^{\prime}$ is an LCL in the strict sense and we can control its distributed time complexity also in the family of all bounded-degree graphs. Some challenges we need to address include:

What if we have an input graph $G^{\prime}$ that is not of the right form, i.e., it does not consist of valid gadgets connected to each other? 2. 2.

What if we have an input graph $G^{\prime}$ in which the gadgets have different depths?

The first challenge we overcome by making the gadgets locally checkable. In essence, a node will be able to see within distance $O(\log n)$ if it is part of an invalid gadget, and it is also able to construct a locally checkable proof of error. LCL $\Pi^{\prime}$ is defined so that we have to either solve the original problem $\Pi$ or produce locally checkable proofs of errors. This ensures that:

• •

An algorithm solving $\Pi^{\prime}$ cannot cheat and claim that the input is invalid if this is not the case.

• •

The adversary who constructs input $G^{\prime}$ never benefits from a construction that contains invalid gadgets, as they will in essence result in “don’t care” nodes that only make solving $\Pi^{\prime}$ easier.

See e.g. [16, 17] for more details on the concept of locally checkable proofs; in our case it will be essential that errors have a locally checkable proof with constantly many bits per node so that we can interpret it as an LCL.

The second challenge we overcome by choosing the original problem $\Pi$ and the gadget family $\mathcal{G}$ so that the worst case input that the adversary can construct is essentially of the following form:

• •

Start with an $n$-node graph $G$ that is a worst-case input for $\Pi$.

• •

Replace each node with an $n$-sized gadget, which has depth $\Theta(\log n)$.

This way in the worst case the adversary can construct a graph $G^{\prime}$ with $N=n^{2}$ nodes, and if solving $\Pi$ on $G$ took $\Theta(\log\log n)$ rounds for randomized algorithms and $\Theta(\log n)$ rounds for deterministic algorithms, then solving $\Pi^{\prime}$ on $G^{\prime}$ will take $\Theta(\log n\log\log n)=\Theta(\log N\log\log N)$ rounds for randomized algorithms and $\Theta(\log^{2}n)=\Theta(\log^{2}N)$ rounds for deterministic algorithms. We can show that a different balance between the size of $G$ and the depth of each gadget will not result in a harder instance; both much larger and much smaller gadgets will only make the problem easier.

Discussion and open questions.

If we write $D(n)$ for the deterministic complexity and $R(n)$ for the randomized complexity of a given LCL, we have now seen that we can engineer LCLs that satisfy e.g. any of the following:

[TABLE]

However, if we look at the ratio $D(n)/R(n)$, we see that all examples with $R(n)=o(D(n))$ happen to satisfy

[TABLE]

The main open question is whether we can construct LCLs with

[TABLE]

This question is closely connected to the complexity of network decompositions: the result of Ghaffari et al. [13] implies that, in the context of LCLs, any randomized algorithm running in time $R(n)$ can be transformed to a deterministic algorithm running in time D(n)=O\bigl{(}R(n)\mathsf{ND}(n)+R(n)\log^{2}n\bigr{)}, where $\mathsf{ND}(n)$ is the time required to compute a $(\log n,\log n)$-network decomposition in graphs of size $n$ with a deterministic distributed algorithm. A recent breakthrough by Rozhoň and Ghaffari [23] showed that the network decomposition problem can be solved in polylogarithmic time. In particular, they provided an algorithm running in $O(\log^{7}n)$ rounds in the LOCAL model. This implies that the ratio $D(n)/R(n)$ cannot be more than polylogarithmic. However, whether the ratio can be superlogarithmic is an open question: if we could improve our result slightly and show the existence of LCLs satisfying $D(n)/R(n)=\omega(\log^{2}n)$, we would obtain a superlogarithmic lower bounds for the network decomposition problem—a long-standing open question.

2 Preliminaries

Model.

The LOCAL model is synchronous, that is, the computation proceeds in synchronous rounds. At each round, each entity sends messages to its neighbors, receives messages from them, and performs some computation based on the data it receives. In this model, the size of messages can be arbitrarily large, and the computational power of an entity is not bounded. The time complexity $T$ of an algorithm running in the LOCAL model is given by the number of rounds that entities need to run the algorithm in order to solve a problem.

The LOCAL model is equivalent to a model where each entity: (i) gathers its radius-$T$ neighborhood, i.e., the entity learns the structure of the network around it up to distance $T$, along with the inputs that the entities in this neighborhood might have; (ii) performs some computation based on the data that has been gathered; (iii) produces its own local output.

A distributed network is represented by a graph with nodes and edges, where a node represents a specific entity of the network, and there is an edge between two nodes if and only if there is a communication link between the entities that they represent. We denote a graph by $G=(V,E)$, where $V$ is the set of nodes and $E$ the set of edges. The degree $d$ of a node is the number of its incident edges. The incident edges are numbered, that is, we assume that a node has ports numbered from $1$ to $d$ where incident edges are connected to. Each node, when receiving a message, knows the port from which the message arrives. We denote by $\Delta$ the maximum degree in the graph.

For technical reasons, we deviate from the usual assumptions and we allow $G$ to be disconnected and to contain self loops and parallel edges. While all upper and lower bounds that we will present hold in this larger class of graphs, our final results hold for simple graphs as well.

Locally checkable labeling problems.

LCL problems are defined on constant degree graphs, i.e., graphs where $\Delta=O(1)$. Each node has an input label from a constant-size set $\Sigma_{\operatorname{in}}$, and must produce an output label from a constant-size set $\Sigma_{\operatorname{out}}$. The output must be locally checkable, that is, there must exist a constant-time distributed algorithm that can check the correctness of a solution. If the solution is globally correct, this algorithm must accept on all nodes, otherwise it must reject on at least one node. A distributed algorithm $\mathcal{A}$ solving an LCL problem in time $T(n)$ is an algorithm that, for any graph $G$ with $n$ nodes, given $n$ and $\Delta$, runs in $T(n)$ rounds and outputs a label for each node, such that the LCL constraints are satisfied at each node. For randomized algorithms, we require global high probability of success, that is, the probability that the solution is wrong must be at most $\frac{1}{n}$.

An example of an LCL problem is the proper ($\Delta+1$)-coloring of the nodes of a graph: nodes have all the same input, that is a special character denoting the empty input label, and they must produce as output a color in $\{1,\dots,\Delta+1\}$. In a proper coloring it must hold that, for any pair of neighbors, their colors are different. It is easy to see that, if the graph is properly colored, each node will see a proper solution locally, otherwise there will be two neighbor nodes that will have the same color, noticing the error. Many other natural problems fall in the category of LCLs, such as edge coloring, maximal matching, maximal independent set, sinkless orientation, etc.

Deviating from the common way of writing inputs and outputs of LCLs only on nodes (or, occasionally, edges), we will write inputs and outputs on nodes, edges, and node-edge pairs. This allows us to conveniently assign different labels to each half of an edge, something we will make use of in Section 4. For technical reasons we restrict our considerations to the subclass of LCLs where the local constraints determining whether a solution is correct can be checked “on nodes and edges”. Note that almost all commonly studied LCL problems can be reformulated in this form, by requiring each node to return, apart from its own output, also the outputs of all nodes at a constant distance. Formally, these node-edge-checkable LCLs, or ne-LCLs, are defined as follows.

Node-edge-checkable LCLs.

Let $B=\{(v,e)\in V\times E\mid v\in e\}$ be the set of incident node-edge pairs. The input to an ne-LCL is given by assigning an input label $i\in\Sigma_{{\operatorname{in}}}$ to each $x\in V\cup E\cup B$; a solution to an ne-LCL is given by each node $v$ assigning an output label $o\in\Sigma_{{\operatorname{out}}}$ to itself and to each “incident” element of $V\cup E\cup B$, where for each edge $e=\{u,v\}$, nodes $u$ and $v$ have to choose the same output label for $e$. Apart from the sets $\Sigma_{{\operatorname{in}}}$ and $\Sigma_{{\operatorname{out}}}$ of input and output labels, an ne-LCL is defined by a set $C_{N}$ of node constraints and a set $C_{E}$ of edge constraints, where $C_{N}$ describes for each node $v$ which output label configurations on $\{v\}\cup\{\{v,u\}\in E\}\cup\{(v,e)\in B\}$ are correct (depending on the input labels on those nodes, edges, and node-edge pairs), and $C_{E}$ describes for each edge $e=\{u,v\}$ which output label configurations on $\{u,v,e,(u,e),(v,e)\}$ are correct (again, depending on the input labels on those elements of $V\cup E\cup B$). Note that $C_{N}$ and $C_{E}$ do not depend on the choice of $v$ or $e$ in the above description, or on the port numbers or identifiers assigned to the edges or nodes of the graph.

As an example, let us see how sinkless orientation can be formulated as an ne-LCL. Each node $v$ has to output on each incident edge, or more precisely on each $(v,e)\in B$, either the label $\mathsf{out}$ (outgoing) or the label $\mathsf{in}$ (incoming). The constraint on nodes is that there must exist an incident edge labeled $\mathsf{out}$. This guarantees that no node is a sink. The constraint on edges is that, whenever an endpoint is labeled $\mathsf{in}$, the other endpoint must be labeled $\mathsf{out}$, and vice versa. This guarantees that the edges are oriented consistently. Note that in this example, the constraints are independent of any input labels. See Figure 3 for an illustration.

3 Padded LCLs

In this section we provide a technique that constructs new LCLs in a black box manner. More precisely, given an ne-LCL $\Pi$ and a collection of graphs, so-called gadgets, with certain properties, we can construct a new ne-LCL $\Pi^{\prime}$ with changed deterministic and randomized complexities. Informally, the idea is that the hard graphs for $\Pi^{\prime}$ are so-called padded graphs, i.e., graphs obtained by taking some graph $G$ and replacing each node of $G$ with a gadget, thereby “padding” $G$. See Figure 2 for an example.

Our new ne-LCL $\Pi^{\prime}$ is constructed in a way that ensures that in such a padded graph solving $\Pi^{\prime}$ is equivalent to solving $\Pi$ on the underlying initial graph $G$. Moreover, the padding itself will make sure that the distances between nodes of $G$ increase; in other words, simulating an algorithm on $G$ that solves $\Pi$ incurs an additional communication overhead. Consequently the hard graphs for $\Pi^{\prime}$ are given by those instances where the underlying graph $G$ belongs to the hard graphs for $\Pi$ and the size of the gadgets used in the padding is finely balanced such that (1) the underlying graph $G$ is large enough (as a function of the number $n$ of nodes of the padded graph) to ensure a sufficiently large runtime for solving $\Pi$ on $G$, and (2) the gadgets are large enough to ensure a sufficiently large communication overhead.

We will start the section by defining gadgets and families thereof; in particular, we will describe their special properties that will enable us to define $\Pi^{\prime}$ and prove that it has the desired complexities. Then we will give a formal definition of padded graphs which, intuitively, are the key concept for the subsequent definition of the new ne-LCL $\Pi^{\prime}$, even though, formally, they do not appear in the definition. After defining $\Pi^{\prime}$, we will conclude the section by showing how the complexity of the new ne-LCL $\Pi^{\prime}$ is related to the complexity of the old ne-LCL $\Pi$.

The exact relation between the complexities of the two ne-LCLs (which relies on the subsequently defined concept of a $(d,\Delta)$-gadget family) is given in Theorem 1. Let $T_{\operatorname{det}}(\Pi,N)$, resp. $T_{\operatorname{rand}}(\Pi,N)$, denote the deterministic, resp. randomized, complexity of an LCL $\Pi$ on instances of size $N$. Then the following holds.

Theorem 1**.**

Let $f\colon\mathbb{N}\to\mathbb{N}$ be a function such that, for each $x\in\mathbb{N}$, we have $f(x)\leq x$ and there exists some $y\in\mathbb{N}$ with $f(y)=x$. For each ne-LCL problem $\Pi$ and each $(d,\Delta)$-gadget family $\mathcal{G}$, there exists an ne-LCL problem $\Pi^{\prime}$ with deterministic complexity O\bigl{(}T_{\operatorname{det}}(\Pi,n)\cdot d(n)\bigr{)} and \Omega\bigl{(}T_{\operatorname{det}}(\Pi,f(n))\cdot d(\frac{n}{f(n)})\bigr{)} and randomized complexity O\bigl{(}T_{\operatorname{rand}}(\Pi,n)\cdot d(n)\bigr{)} and \Omega\bigl{(}T_{\operatorname{rand}}(\Pi,f(n))\cdot d(\frac{n}{f(n)})\bigr{)}.

3.1 Gadgets

Definition 2**.**

An $(n,D)_{\Delta}$-gadget $F$ is a (labeled) connected graph that satisfies the following:

• •

The number of nodes is $n$.

• •

There are exactly $\Delta$ special nodes labeled $\mathsf{Port}_{i}$, for $1\leq i\leq\Delta$, called ports. All other nodes are labeled $\mathsf{NoPort}$.

• •

The diameter of $F$ and hence also the pairwise distances between the ports are at most $D$.

Let $d\colon\mathbb{N}\to\mathbb{N}$ be some function. A $(d,\Delta)$-gadget family $\mathcal{G}$ is a set of graphs satisfying the following:

• •

Each $G\in\mathcal{G}$ is an $(n,O(d(n)))_{\Delta}$-gadget for some $n$.

• •

For each $n\in\mathbb{N}$, there exists some $G\in\mathcal{G}$ with $\Theta(n)$ nodes such that the pairwise distances between the ports are all in $\Theta(d(n))$. Let this gadget be ${\hat{G}}_{n}$.

• •

There is an ne-LCL $\Psi_{\mathcal{G}}$ with the following properties, where $H$ denotes the input graph for $\Psi_{\mathcal{G}}$.

• –

The output label set for $\Psi_{\mathcal{G}}$ is $\{\mathsf{GadOk}\}\mathbin{\dot{\cup}}L_{\mathsf{Err}}$, for some finite set $L_{\mathsf{Err}}$.

• –

If $H\in\mathcal{G}$, then the unique (globally) correct solution for $\Psi_{\mathcal{G}}$ uses only the output label $\mathsf{GadOk}$.

• –

If $H\notin\mathcal{G}$, then there exists a (globally) correct solution for $\Psi_{\mathcal{G}}$ that uses only output labels from $L_{\mathsf{Err}}$.

• –

There is a deterministic distributed algorithm $\mathcal{V}$ that, given an upper bound $n$ of $N$, where $N$ is the number of nodes of $H$, solves $\Psi_{\mathcal{G}}$ in $O(d(n))$ rounds. Moreover, if $H\notin\mathcal{G}$, then $\mathcal{V}$ uses only output labels from $L_{\mathsf{Err}}$. We call the (global) output of $\mathcal{V}$ a locally checkable proof of error.

3.2 Padded graphs

Intuitively, a padded graph is a graph obtained by starting from some arbitrary graph and replacing each node with a gadget $F\in\mathcal{G}$. We now formally define the family $\mathcal{G}(G)$ of padded graphs for a given graph $G$.

Definition 3**.**

Given a graph $G$ with maximum degree $\Delta$ and a $(d,\Delta)$-gadget family $\mathcal{G}$, the graph family $\mathcal{G}(G)$ is the set of all graphs that can be obtained by the following process.

Start from $G=(V,E)$. For each node $v\in V$ pick a gadget $F\in\mathcal{G}$, where different gadgets may be picked for different nodes. Let $C_{v}$ be the gadget chosen for node $v$. The final graph is the union of the $C_{v}$ (over all $v\in V$), augmented by the following additional edges: for any edge $\{u,v\}\in E$ connecting port $a$ of $u$ to port $b$ of $v$, add an edge between node $\mathsf{Port}_{a}$ of $C_{u}$ and $\mathsf{Port}_{b}$ of $C_{v}$. Moreover, in the final graph we label each edge already present in the union of the $C_{v}$ with $\mathsf{GadEdge}$, and each edge that has been added in the augmentation step with $\mathsf{PortEdge}$.

3.3 New LCL

Given an LCL $\Pi$ and a $(d,\Delta)$-gadget family $\mathcal{G}$, in this section we define a new LCL $\Pi^{\prime}$ that, informally, can be described as follows. Each edge $e$ of the input graph $G$ for $\Pi^{\prime}$ is assigned a special label that indicates whether $e$ belongs to a gadget or to “the underlying graph”, denoted by $H$. Intuitively, $H$ is the graph obtained by contracting the connected components induced by the edges labeled as belonging to a gadget. For each such connected component, there are two possibilities: Either it constitutes a gadget from our gadget family $\mathcal{G}$, in which case we call it a valid gadget, or it does not, in which case we call it an invalid gadget.

In each invalid gadget, $\Pi^{\prime}$ can be solved correctly by the containing nodes providing a locally checkable proof of the invalidity of the gadget. Consider the graph obtained by deleting all gadgets where the contained nodes proved an error. Assuming that all invalid gadgets have been claimed to be invalid by their contained nodes (we do not require that nodes in an invalid gadget actually choose this option) and consequently deleted, the obtained graph $G^{\prime}$ may still not be a padded graph as described in Section 3.2. In fact, while padded graphs satisfy that a gadget $F$ corresponding to node $v$ of degree $d$ has nodes $\mathsf{Port}_{1},\ldots,\mathsf{Port}_{d}$ connected to port nodes of other gadgets, $G^{\prime}$ may have some port nodes connected to removed gadgets, thus valid port nodes are an arbitrary subset of $\{\mathsf{Port}_{i}~{}|~{}1\leq i\leq\Delta\}$. This implies that we can transform $G^{\prime}$ to a valid padded graph in a natural way, by just mapping the $d$ ($0\leq d\leq\Delta$) valid port nodes to the ports from $1$ to $d$. We will actually require nodes to produce such a mapping, and mark each port node as valid or invalid (see Figure 4 for an example). Then, $\Pi^{\prime}$ is solved correctly if the nodes solve $\Pi$ on the graph obtained from $G^{\prime}$ by contracting all valid gadgets.

Some care is needed to ensure that the above rough outline can be expressed in terms of ne-LCL constraints and to deal with the subtleties introduced thereby. We now proceed by defining $\Pi^{\prime}$.

Let the ne-LCL $\Pi$ be given by input label set $\Sigma^{\Pi}_{V,{\operatorname{in}}}\cup\Sigma^{\Pi}_{E,{\operatorname{in}}}\cup\Sigma^{\Pi}_{B,{\operatorname{in}}}$, output label set $\Sigma^{\Pi}_{V,{\operatorname{out}}}\cup\Sigma^{\Pi}_{E,{\operatorname{out}}}\cup\Sigma^{\Pi}_{B,{\operatorname{out}}}$, node constraint set $C^{\Pi}_{V}$, and edge constraint set $C^{\Pi}_{E}$. Let $\mathcal{G}$ be an arbitrary $(d,\Delta)$-gadget family and let $\Psi_{\mathcal{G}}$ be as described in Definition 2. Recall that the graphs in $\mathcal{G}$ are labeled. Let

[TABLE]

denote the labels used for labeling the graphs in $\mathcal{G}$, which will be our input labels for $\Psi_{\mathcal{G}}$. Let $\Sigma^{\mathcal{G}}_{V,{\operatorname{out}}}\cup\Sigma^{\mathcal{G}}_{E,{\operatorname{out}}}\cup\Sigma^{\mathcal{G}}_{B,{\operatorname{out}}}$, $C^{\mathcal{G}}_{V}$, and $C^{\mathcal{G}}_{E}$ denote the output labels, node constraints, and edge constraints for $\Psi_{\mathcal{G}}$, respectively. In particular, we have

[TABLE]

W.l.o.g., we can (and will) assume that both in $\Pi$ and in $\Psi_{\mathcal{G}}$, each element of $V\times E\times B$ is assigned exactly one input label (and each will receive exactly one output label) as we can encode multiple labels in one label and add an “empty label” for the case that no label was assigned. However, for convenience, we might deviate from this underlying encoding in the description of the new ne-LCL $\Pi^{\prime}$. We now give a formal definition of $\Pi^{\prime}$. We will later provide an informal explanation of each part.

Input labels.

• •

Each node has a label in $\Sigma^{\Pi}_{V,{\operatorname{in}}}\times\Sigma^{\mathcal{G}}_{V,{\operatorname{in}}}\times\{\mathsf{Port}_{1},\dots,\mathsf{Port}_{\Delta},\mathsf{NoPort}\}$.

• •

Each edge has a label in $\Sigma^{\Pi}_{E,{\operatorname{in}}}\times\Sigma^{\mathcal{G}}_{E,{\operatorname{in}}}\times\{\mathsf{PortEdge},\mathsf{GadEdge}\}$.

• •

Each element of $B$ has a label in $\Sigma^{\Pi}_{B,{\operatorname{in}}}\times\Sigma^{\mathcal{G}}_{B,{\operatorname{in}}}$.

Output labels.

• •

Each node must label itself with a label from $\Sigma_{{\operatorname{list}}}\times\{\mathsf{PortErr}_{1},\mathsf{PortErr}_{2},\mathsf{NoPortErr}\}\times\Sigma^{\mathcal{G}}_{V,{\operatorname{out}}}$, where

[TABLE]

• •

Each edge must be labeled with either $\epsilon$ or a label from $\Sigma^{\mathcal{G}}_{E,{\operatorname{out}}}$.

• •

Each element of $B$ must be labeled with either $\epsilon$ or a label from $\Sigma^{\mathcal{G}}_{B,{\operatorname{out}}}$.

Constraints.

Each edge with input label $\mathsf{PortEdge}$ has to be labeled $\epsilon$, each edge with input label $\mathsf{GadEdge}$ has to be labeled with a label from $\Sigma^{\mathcal{G}}_{E,{\operatorname{out}}}$. Each $(v,e)\in B$ has to be labeled $\epsilon$ if $e$ has input label $\mathsf{PortEdge}$, and with a label from $\Sigma^{\mathcal{G}}_{B,{\operatorname{out}}}$ if $e$ has input label $\mathsf{GadEdge}$. 2. 2.

On each connected component of the subgraph induced by the edges labeled $\mathsf{GadEdge}$, the ne-LCL $\Psi_{\mathcal{G}}$ has to be solved correctly. Put in a local way, for each node $v$ the node constraints $C^{V}_{\mathcal{G}}$ of $\Psi_{\mathcal{G}}$ have to be satisfied, where we ignore each edge incident to $v$ that is labeled $\mathsf{PortEdge}$, and for each edge with input label $\mathsf{GadEdge}$ the edge constraints $C^{E}_{\mathcal{G}}$ of $\Psi_{\mathcal{G}}$ have to be satisfied.

Remark*.*

Here, as in the following descriptions, we will consider the labels defined above as a collection of several labels in the canonical way, e.g., each edge has three input labels, one each from $\Sigma^{\Pi}_{E,{\operatorname{in}}}$, $\Sigma^{\mathcal{G}}_{E,{\operatorname{in}}}$, and $\{\mathsf{PortEdge},\mathsf{GadEdge}\}$. Also, for simplicity, we will not explicitly mention which of the labels are relevant for the respective constraint if this is clear from the context. For instance, the (only) labels the above constraint for solving $\Psi_{\mathcal{G}}$ talks about (apart from the labels from $\{\mathsf{PortEdge},\mathsf{GadEdge}\}$ that determine which edges are considered for the constraint) are the input and output labels for $\Psi_{\mathcal{G}}$, i.e., the input labels from $\Sigma^{\smash{\mathcal{G}}}_{V,{\operatorname{in}}}$, $\{\mathsf{Port}_{1},\dots,\mathsf{Port}_{\Delta},\mathsf{NoPort}\}$, $\Sigma^{\smash{\mathcal{G}}}_{E,{\operatorname{in}}}$, and $\Sigma^{\smash{\mathcal{G}}}_{B,{\operatorname{in}}}$, and the output labels from $\Sigma^{\smash{\mathcal{G}}}_{V,{\operatorname{out}}}$, $\Sigma^{\smash{\mathcal{G}}}_{E,{\operatorname{out}}}$, and $\Sigma^{\smash{\mathcal{G}}}_{B,{\operatorname{out}}}$. 3. 3.

Each node $v$ has to be labeled $\mathsf{PortErr}_{2}$ if and only if $v$ has input label $\mathsf{Port}_{i}$ for some $i$ and, either there is no incident edge labeled $\mathsf{PortEdge}$, or there are at least two incident edges labeled $\mathsf{PortEdge}$. Otherwise $v$ has to be labeled either $\mathsf{PortErr}_{1}$ or $\mathsf{NoPortErr}$. 4. 4.

For each edge $e=\{u,v\}$ with input label $\mathsf{PortEdge}$ the following holds: If $u$ and $v$ are labeled $\mathsf{Port}_{i}$ and $\mathsf{Port}_{j}$ for some $1\leq i,j\leq\Delta$, respectively, and the output label $\in\Sigma^{\mathcal{G}}_{V,{\operatorname{out}}}$ of both $u$ and $v$ is $\mathsf{GadOk}$, then the output label $\in\{\mathsf{PortErr}_{1},\mathsf{PortErr}_{2},\mathsf{NoPortErr}\}$ of both $u$ and $v$ cannot be $\mathsf{PortErr}_{1}$; if $u$ is labeled $\mathsf{Port}_{i}$ for some $i$ and at least one of $u$ and $v$ has input label $\mathsf{NoPort}$ or an output label from $L_{\mathsf{Err}}$, then the output label $\in\{\mathsf{PortErr}_{1},\mathsf{PortErr}_{2},\mathsf{NoPortErr}\}$ of $u$ cannot be $\mathsf{NoPortErr}$. 5. 5.

For each node $v$ with incident edges $e_{1},\dots,e_{k}$, if at least one of $v,e_{1},\dots,e_{k},(v,e_{1}),\dots,(v,e_{k})$ is assigned an output label from $L_{\mathsf{Err}}$ and none of the node constraints mentioned above are violated, then the node constraint for $v$ is always satisfied, irrespective of the conditions below. If all of the mentioned elements of $V\cup E\cup B$ are assigned an output label from $\{\mathsf{GadOk},\epsilon\}$, then the following conditions have to be satisfied for $v$, where

[TABLE]

denotes the $\Sigma_{{\operatorname{list}}}$-part of the output label assigned to $v$:

• •

If $v$ is labeled $\mathsf{Port}_{i}$ for some $1\leq i\leq\Delta$, then the label $\mathsf{Port}_{i}$ is an element of $S$ if and only if the output $\in\{\mathsf{PortErr}_{1},\mathsf{PortErr}_{2},\mathsf{NoPortErr}\}$ of $v$ is $\mathsf{NoPortErr}$.

• •

If $v$ is labeled $\mathsf{Port}_{1}$, then $\iota^{V}$ is $v$’s input label from $\Sigma^{\Pi}_{V,{\operatorname{in}}}$.

• •

If $v$ is labeled $\mathsf{Port}_{i}$ for some $1\leq i\leq\Delta$, and $\mathsf{Port}_{i}\in S$, then for any incident edge $e$ labeled $\mathsf{PortEdge}$, the labels $\iota^{E}_{i}$ and $\iota^{B}_{i}$ coincide with $e$’s input label from $\Sigma^{\Pi}_{E,{\operatorname{in}}}$ and $(v,e)$’s input label from $\Sigma^{\Pi}_{B,{\operatorname{in}}}$, respectively.

• •

The output label of $v$ encodes a configuration that satisfies the node constraints from $C^{\Pi}_{V}$. More precisely, let $\alpha$ be the bijection that monotonically maps the elements of $\{1,\dots,|S|\}$ to the indices of the elements in $S$, and consider a (hypothetical) node $u$ of degree $|S|$ with incident edges $e^{\prime}_{1},\dots,e^{\prime}_{|S|}$. Then labeling $u,e^{\prime}_{1},\dots,e^{\prime}_{|S|},(u,e^{\prime}_{1}),\dots,(u,e^{\prime}_{|S|})$ with input labels

[TABLE]

and output labels

[TABLE]

respectively, yields a correct node configuration at $u$ according to $C^{\Pi}_{V}$. 6. 6.

Similarly, for each edge $e=\{u,v\}$, if at least one of $u,v,e,(u,e),(v,e)$ is assigned an output label from $L_{\mathsf{Err}}$ and none of the node constraints mentioned above are violated, then the edge constraint for $e$ is always satisfied, irrespective of the conditions below. If all of the mentioned elements of $V\cup E\cup B$ are assigned output labels from $\{\mathsf{GadOk},\epsilon\}$, then the following conditions have to be satisfied for $e$, where $\ell^{u}_{{\operatorname{list}}}$ and $\ell^{v}_{{\operatorname{list}}}$ denote the $\Sigma_{{\operatorname{list}}}$-part of the output labels assigned to $u$ and $v$, respectively, and we use the above notation augmented with a superscript to indicate the respective node:

• •

If $e$ is labeled $\mathsf{GadEdge}$, then $\ell^{u}_{{\operatorname{list}}}=\ell^{v}_{{\operatorname{list}}}$.

• •

If $e$ is labeled $\mathsf{PortEdge}$, and $u$ and $v$ are labeled $\mathsf{Port}_{i}$ and $\mathsf{Port}_{j}$ for some $1\leq i,j\leq\Delta$, respectively, then $\iota^{E,u}_{\alpha(i)}=\iota^{E,v}_{\alpha(j)}$ and $o^{E,u}_{\alpha(i)}=o^{E,v}_{\alpha(j)}$, and, for a (hypothetical) edge $e^{\prime}=\{u^{\prime},v^{\prime}\}$, labeling $u^{\prime},v^{\prime},e^{\prime},(u^{\prime},e^{\prime}),(v^{\prime},e^{\prime})$ with input labels

[TABLE]

and output labels

[TABLE]

respectively, yields a correct edge configuration at $e^{\prime}$ according to $C^{\Pi}_{E}$.

Informal description.

• •

Input labels. Elements of $B$ can be intuitively seen as endpoints of an edge, thus we will refer to them as “half-edges”. Each node, each edge, and each half-edge has an input for $\Pi$ and an input for $\Psi_{\mathcal{G}}$. Also, each node (resp. edge) may have a special label indicating if it is a port node (resp. edge).

• •

Output labels. Each node must produce a tuple $(s,p,g)$. The labeling $g$ must be a valid output for $\Psi_{\mathcal{G}}$. The labeling $p$ is used to indicate the (in)correctness of the port connections. The labeling $s=(l,i,o)$ is the one that actually contains a solution for $\Pi$. First, $l$ contains a list of valid ports of the gadget. Then, $i$ contains a copy of all the inputs of the port nodes, as well as the inputs of their edges and half-edges, that is, everything that is needed to know the input of a virtual node. Finally, $o$ contains the output of the virtual node, described as node, edges and half-edges outputs. All these labels will be useful to check the validity of the output for $\Pi$ in a local manner.

• •

Constraints. For each aforementioned constraint, we provide an informal description, by following the same order.

We require that outputs for $\Psi_{\mathcal{G}}$ do not cross gadget boundaries. Thus, we require that port edges and half-edges are labeled $\epsilon$, while everything else must actually contain outputs for $\Psi_{\mathcal{G}}$. 2. 2.

Each connected component, given by removing port edges from the graph, must provide a valid solution for $\Psi_{\mathcal{G}}$. 3. 3.–4.

Port nodes do not output errors only in the case in which they are connected to exactly one other port node, and both of them are in a correct gadget. 4. 5.

Nodes claiming that the gadget is correct must:

• –

Produce a list of valid ports of the gadget.

• –

Copy the node input of $\mathsf{Port}_{1}$, that will be treated as the input for the virtual node (this is an arbitrary choice, but since nodes may be provided with different inputs for $\Pi$, we need nodes to agree on some specific input for the virtual node).

• –

Copy edge and half-edge inputs of port nodes to the output.

• –

Produce outputs that are correct w.r.t. the constraints of $\Pi$. 5. 6.

On edges we first check that nodes of the same gadget are giving the same output. Then, port edges check that the edge constraints for $\Pi$ are satisfied on the virtual edges.

3.4 Upper and lower bounds

We now proceed by showing upper and lower bounds for the defined ne-LCL $\Pi^{\prime}$, which, together, will then imply Theorem 1. Intuitively, in order to solve $\Pi^{\prime}$, nodes can do the following. They start exploring the graph to see if they are in a valid gadget. If they see that their gadget is invalid, then they can produce a locally checkable proof of error. Otherwise, they need to solve the original problem, by first seeing which ports are connected to exactly one valid gadget (on all other ports they can output $\mathsf{PortErr}_{1}$ or $\mathsf{PortErr}_{2}$), and then simulating the algorithm for the original problem $\Pi$ on the graph obtained by contracting the valid gadgets to a node and ignoring invalid gadgets.

3.4.1 Upper bound

Lemma 4**.**

Problem $\Pi^{\prime}$ can be solved in $O(T_{\operatorname{det}}(\Pi,n)\cdot d(n))$ rounds deterministically, and in $O(T_{\operatorname{rand}}(\Pi,n)\cdot d(n))$ rounds randomized.

Proof.

Let $\mathcal{V}$ be the algorithm guaranteed by Definition 2, able to produce a locally checkable proof of the (in)validity of the gadget or, equivalently, solving the ne-LCL $\Psi_{\mathcal{G}}$. Each node $v$ starts by executing $\mathcal{V}$ on the connected components of the subgraph obtained by ignoring edges labeled $\mathsf{PortEdge}$, which can be done in time $O(d(n))$ where $n$ denotes the number of nodes of the input graph. For simplicity, we will refer to these connected components as gadgets, where we say that a gadget is valid if $\mathcal{V}$ returns label $\mathsf{GadOk}$ everywhere in the gadget, and invalid if $\mathcal{V}$ returns at least one label from $L_{\mathsf{Err}}$. Node $v$ then outputs the labels returned by $\mathcal{V}$ on itself and the incident edges and elements of $B$, thereby providing the part of the output labels corresponding to $\Sigma^{\smash{\mathcal{G}}}_{V,{\operatorname{out}}}$, $\Sigma^{\smash{\mathcal{G}}}_{E,{\operatorname{out}}}$, and, $\Sigma^{\smash{\mathcal{G}}}_{B,{\operatorname{out}}}$, respectively, in the description of the output labels. Since $\mathcal{V}$ solves $\Psi_{\mathcal{G}}$, this takes care of Constraint 2; by outputting $\epsilon$ on all edges with input label $\mathsf{PortEdge}$ and all associated elements of $B$, we see that also Constraint 1 is satisfied.

If $v$ is a node labeled $\mathsf{NoPort}$, then it outputs $\mathsf{NoPortErr}$. If $v$ is labeled $\mathsf{Port}_{i}$ for some $i$, then it gathers its constant-radius neighborhood and checks whether it is a “valid” port: If $v$ has no incident edge labeled $\mathsf{PortEdge}$ or at least two incident edges labeled $\mathsf{PortEdge}$, then it outputs $\mathsf{PortErr}_{2}$. If $v$ has exactly one incident edge labeled $\mathsf{PortEdge}$, then it checks whether itself or the other endpoint $u$ of the edge is labeled $\mathsf{NoPort}$ or outputs an element of $L_{\mathsf{Err}}$ after executing $\mathcal{V}$. If one of the conditions is satisfied, then $v$ outputs $\mathsf{PortErr}_{1}$, otherwise it outputs $\mathsf{NoPortErr}$. This takes care of Constraints 3 and 4.

If a gadget is invalid, then by Constraints 5 and 6, the constraint for each node and edge in the gadget is satisfied, and we simply complete the outputs for all nodes in the gadget in an arbitrary way that conforms to the output label specifications. Hence, what remains is to assign to each node $v$ in a valid gadget the $\Sigma_{{\operatorname{list}}}$-part \ell^{v}_{{\operatorname{list}}}=\bigl{(}S,\iota^{V},\iota^{E}_{1},\dots,\iota^{E}_{\Delta},\iota^{B}_{1},\dots,\iota^{B}_{\Delta},o^{V},o^{E}_{1},\dots,o^{E}_{\Delta},o^{B}_{1},\dots,o^{B}_{\Delta}\bigr{)} of the output label in a way that ensures that Constraints 5 and 6 are satisfied. This is the part where, intuitively, we solve the original problem $\Pi$ on the graph obtained by ignoring all invalid gadgets and contracting the valid gadgets to single nodes which are then connected by the edges labeled $\mathsf{PortEdge}$. We proceed as follows, considering only nodes in valid gadgets. Each node collects all input and hitherto produced output information contained in its gadget and the gadget’s radius-$1$ neighborhood, and uses the obtained knowledge to determine the first part of $\ell^{v}_{{\operatorname{list}}}$ by choosing $S,\iota^{V},\iota^{E}_{1},\dots,\iota^{E}_{\Delta},\iota^{B}_{1},\dots,\iota^{B}_{\Delta}$ in a way that conforms to Constraint 5. The choices for the mentioned labels immediately follow from the conditions in Constraint 5 (or can be freely chosen, for some labels).

For determining the second part of $\ell^{v}_{{\operatorname{list}}}$ (corresponding to the actual outputs in the solution of $\Pi$), each node solves the original problem $\Pi$ as follows:

• •

If the aim is a deterministic algorithm for $\Pi^{\prime}$, then gather the radius-$O(T_{\operatorname{det}}(\Pi,n)\cdot d(n))$ neighborhood; if the aim is a randomized algorithm, then gather the radius-$O(T_{\operatorname{rand}}(\Pi,n)\cdot d(n))$ neighborhood.

• •

Construct a (partial) virtual graph $H$ by contracting each valid gadget to a single node and deleting all nodes in invalid gadgets—note that this may result in a graph $H$ with parallel edges and/or self-loops, which is why, in our model, we allow graphs to contain these. For each virtual node $u$, assign port numbers from $1$ to $\deg(u)$ to the incident edges in the only way that respects the order of the indices of the gadget’s $\mathsf{Port}_{i}$ nodes the corresponding $\mathsf{PortEdge}$ edges are connected to.

• •

Assign, as identifier of a virtual node, the smallest id of its associated gadget.

• •

Compute $q=(q^{V},q^{E}_{1},\dots,q^{E}_{\deg(u)},q^{B}_{1},\dots,q^{B}_{\deg(u)})$, a valid solution for $\Pi$ for the current virtual node and its incident edges and elements of $B$, where the indices indicate the corresponding port for the respective edge or element of $B$.

Now, each node $v$ in a valid gadget transforms the output $q$ of the virtual node $u$ corresponding to the gadget into the desired tuple $(o^{V},o^{E}_{1},\dots,o^{E}_{\Delta},o^{B}_{1},\dots,o^{B}_{\Delta})$ as follows. Recall the function $\alpha$ defined in Constraint 5, and set

[TABLE]

Note that, by construction $\deg(u)=|S|$. Now it is straightforward (if somewhat cumbersome) to check that this completion of the output of $v$ satisfies the last bullet of Constraint 5 and the first of Constraint 6. The remaining second bullet of Constraint 6 follows from the fact that the computed outputs $q$ form a valid solution to ne-LCL $\Pi$.

We need to show that, given their radius-$O(T_{\operatorname{det}}(\Pi,n)\cdot d(n))$ neighborhood, resp. radius-$O(T_{\operatorname{rand}}(\Pi,n)\cdot d(n))$ neighborhood in the randomized case, nodes can actually find a valid solution for the original problem $\Pi$. To this end, we want to show that after collecting this neighborhood nodes can see up to a radius of at least $T_{\operatorname{det}}(\Pi,n)$, resp. $T_{\operatorname{rand}}(\Pi,n)$, in the virtual graph, and that any virtual graph has size at most $n$. This follows from the following observations:

• •

In the worst case a gadget has diameter $O(d(n))$, where the worst case occurs if there is a single gadget containing all the nodes of the graph.

• •

In the worst case for the size of the virtual graph each gadget has just constant size. Even in this case the virtual graph has at most $n$ nodes.

Hence, each node can simulate a $T_{\operatorname{det}}(\Pi,n)$-round, resp. $T_{\operatorname{rand}}(\Pi,n)$-round, algorithm for $\Pi$ (whose existence is guaranteed by $\Pi$’s time complexity) on the virtual graph and thus find a valid solution for $\Pi$, as required. Note that this simulated algorithm assumes that the input graph for $\Pi$ (i.e., the virtual graph) has size $n$, which is an assumption that is consistent with the view of each node since we allow disconnected graphs (which is important in case a node sees the whole virtual graph, which is then interpreted as a connected component of an $n$-node graph). It follows that, in the randomized case, the failure probability of our obtained algorithm for $\Pi^{\prime}$ is upper bounded by the failure probability of the used algorithm for $\Pi$ since the algorithm for $\Pi^{\prime}$ only fails if the algorithm for $\Pi$ would fail on an $n$-node graph that contains the virtual graph as a connected component. In particular, the obtained randomized algorithm gives a correct output w.h.p.

Since the gathering process dominates the execution time, the time complexity of the obtained algorithm is $O(T_{\operatorname{det}}(\Pi,n)\cdot d(n))$ in the deterministic case, and $O(T_{\operatorname{rand}}(\Pi,n)\cdot d(n))$ in the randomized case. Note that this algorithm works also on graphs containing self-loops and parallel edges. ∎

3.4.2 Lower bound

Lemma 5**.**

Let $f\colon\mathbb{N}\to\mathbb{N}$ be a function such that, for each $x\in\mathbb{N}$, we have $f(x)\leq x$ and there exists some $y\in\mathbb{N}$ with $f(y)=x$. Solving problem $\Pi^{\prime}$ requires $\Omega(T_{\operatorname{det}}(\Pi,f(n))\cdot d(\frac{n}{f(n)}))$ rounds deterministically and $\Omega(T_{\operatorname{rand}}(\Pi,f(n))\cdot d(\frac{n}{f(n)}))$ rounds randomized.

Proof.

We start by proving the randomized lower bound. For a contradiction, assume that there is a $o(T_{\operatorname{rand}}(\Pi,f(n))\cdot d(\frac{n}{f(n)}))$-round randomized algorithm $\mathcal{A}$ that solves $\Pi^{\prime}$ w.h.p. Recall the $(d,\Delta)$-gadget family $\mathcal{G}$ used to define $\Pi^{\prime}$. Let $N$ be the largest integer with $N\leq n/f(n)$ such that there exists a gadget $G_{N}\in\mathcal{G}$ with $N$ nodes such that the pairwise distances between the ports of $G_{N}$ are all in $\Theta(d(N))$. Let $H$ be an arbitrary graph with $f(n)$ nodes, and consider the padded graph $H^{\prime}\in\mathcal{G}(H)$ obtained by choosing gadget $G_{N}$ for each node of $H$. Let $H^{\prime\prime}$ be the $n$-node graph obtained by adding $n-N\cdot f(n)$ isolated nodes to $H^{\prime}$.

Consider what happens if the nodes in $H$ simulate $\mathcal{A}$ on $H^{\prime\prime}$. Since each node of $H$ has been expanded into a valid gadget, a valid solution for $\Pi^{\prime}$ found by $\mathcal{A}$ on the subgraph $H^{\prime}$ of $H^{\prime\prime}$ yields a valid solution for $\Pi$ on $H$, by the definition of problem $\Pi^{\prime}$. Hence, due to the properties of our function $f$, we have transformed $\mathcal{A}$ into an algorithm $\mathcal{A}^{\prime}$ for $\Pi^{\prime}$, and the failure probability of $\mathcal{A}^{\prime}$ on graphs of size $f(n)\leq n$ is upper bounded by the failure probability of $\mathcal{A}$ on graphs of size $n$. It follows that $\mathcal{A}^{\prime}$ is correct w.h.p. Moreover, in order to simulate $\mathcal{A}$, it is sufficient if each node of $H$ collects its radius-$o(T_{\operatorname{rand}}(\Pi,f(n))\cdot d(\frac{n}{f(n)}))/\Theta(d(N))$, due to the runtime of $\mathcal{A}$ and the definition of $G_{N}$. By Definition 2 and the definition of $N$, we have $N=\Theta(n/f(n))$; therefore, the runtime of $\mathcal{A}$ is $o(T_{\operatorname{rand}}(\Pi,f(n)))$. This yields a contradiction to the definition of $T_{\operatorname{rand}}(\Pi,f(n))$ and proves the randomized lower bound. The deterministic lower bound is proved analogously, the only difference being that we do not have to worry about failure probabilities. ∎

Theorem 1 now follows from Lemmas 4 and 5.

4 A $(\log,\Delta)$-gadget family

In this section we present a $(\log,\Delta)$-gadget family, and prove that it satisfies the properties described in Definition 2. Hence, we will prove the following theorem.

Theorem 6**.**

There exists a $(\log,\Delta)$-gadget family.

Informally, each gadget in the $(\log,\Delta)$-gadget family is composed by $\Delta$ sub-gadgets. Each sub-gadget is a complete binary tree where we add horizontal edges, creating a path that traverses nodes of the same level. The bottom right node of each sub-gadget is a port (see Figure 5). Then, we add a node, that we call center, and connect it to the root of each sub-gadget (see Figure 6). Also, we add constant-size input labels to the gadget to make its structure locally checkable.

As stated in Definition 2, $\Psi_{\mathcal{G}}$ must be a ne-LCL. For the sake of readability, we will define $\Psi$ as a constant radius checkable LCL. Then, we will show how to modify it and obtain a ne-LCL $\Psi_{\mathcal{G}}$.

4.1 Sub-gadget

For any parameter $h$, it is possible to construct sub-gadgets of height $h$. Let $(\ell_{u},x_{u})$ be the coordinates of a node $u$ of the sub-gadget. For any node $u$, it holds $0\leq\ell_{u}<h$ and $0\leq x_{u}<2^{\ell_{u}}$. Let $u$ and $v$ be two nodes with coordinates $(\ell_{u},x_{u})$ and $(\ell_{v},x_{v})$ respectively, such that $\ell_{v}\leq\ell_{u}$ and $x_{v}\leq x_{u}$. There is an edge between $u$ and $v$ if and only if:

• •

$(\ell_{v},x_{v})=(\ell_{u}-1,\lfloor\frac{x_{u}}{2}\rfloor)$, or

• •

$(\ell_{u},x_{u})=(\ell_{v},x_{v}+1)$.

Sub-gadget labels.

We make a sub-gadget locally checkable by adding constant-size labels in the following way. First of all, each node $u=(\ell_{u},x_{u})$ has labels:

• •

$\mathsf{Index}_{i}$, where $1\leq i\leq\Delta$;

• •

$\mathsf{Port}_{i}$, where $1\leq i\leq\Delta$, if $\ell_{u}=h-1$ and $x_{u}=2^{\ell_{u}}-1$.

Moreover, each edge $e=\{u,v\}$ has a label on both endpoints, $L_{u}(e)$ and $L_{v}(e)$. Each label $L_{u}(e)$ is chosen as follows:

• •

$L_{u}(e)=\mathsf{Parent}$ if $(\ell_{v},x_{v})=(\ell_{u}-1,\lfloor\frac{x_{u}}{2}\rfloor)$;

• •

$L_{u}(e)=\mathsf{Right}$ if $(\ell_{v},x_{v})=(\ell_{u},x_{u}+1)$;

• •

$L_{u}(e)=\mathsf{Left}$ if $(\ell_{v},x_{v})=(\ell_{u},x_{u}-1)$;

• •

$L_{u}(e)=\mathsf{LChild}$ if $(\ell_{v},x_{v})=(\ell_{u}+1,2x_{u})$;

• •

$L_{u}(e)=\mathsf{RChild}$ if $(\ell_{v},x_{v})=(\ell_{u}+1,2x_{u}+1)$.

See Figure 5 for an example of a sub-gadget.

4.2 Local checkability of a sub-gadget

Let $L_{1},L_{2},\dots,L_{k}$ be $k$ labels. We denote by $u(L_{1},L_{2},\dots,L_{k})$ the node reached from $u$ by following edges labeled $L_{1},L_{2},\dots,L_{k}$. Each node $u$ of the sub-gadget checks the following local constraints.

Each node $u$ checks the following to guarantee some basic properties:

1. (a)

there are no self loops or parallel edges; 2. (b)

for any two incident edges $e,e^{\prime}$, $L_{u}(e)\neq L_{u}(e^{\prime})$; 3. (c)

it must be labeled $\mathsf{Index}_{i}$ for some $i$, and its neighbors must be labeled $\mathsf{Index}_{i}$ as well; 4. (d)

if $u$ is labeled $\mathsf{Port}_{i}$ and $\mathsf{Index}_{j}$, then $i=j$. 2. 2.

Each node $u$ checks the following to guarantee a correct internal structure of the sub-gadget:

1. (a)

for each edge $e=\{u,v\}$, if $L_{u}(e)=\mathsf{Left}$ then $L_{v}(e)=\mathsf{Right}$, and vice versa; 2. (b)

for each edge $e=\{u,v\}$, if $L_{u}(e)=\mathsf{Parent}$ then $L_{v}(e)=\mathsf{RChild}$ or $L_{v}(e)=\mathsf{LChild}$, and vice versa; 3. (c)

$u(\mathsf{LChild},\mathsf{Right},\mathsf{Parent})=u$, if the path exists; 4. (d)

$u(\mathsf{Right},\mathsf{LChild},\mathsf{Left},\mathsf{Parent})=u$, if the path exists. 3. 3.

Each node $u$ checks the following to guarantee the correct boundaries of the sub-gadget:

1. (a)

$u$ does not have an incident edge labeled $\mathsf{Right}$ if and only if neither $u(\mathsf{Parent})$ does, if it exists; 2. (b)

$u$ does not have an incident edge labeled $\mathsf{Left}$, if and only if neither $u(\mathsf{Parent})$ does, if it exists; 3. (c)

if $u$ does not have an incident edge with label $\mathsf{Right}$ and it has an incident edge $e=\{u,v\}$ labeled $L_{e}(u)=\mathsf{Parent}$, then $L_{e}(v)=\mathsf{RChild}$; 4. (d)

if $u$ does not have an incident edge labeled $\mathsf{Left}$ and it has an incident edge $e=\{u,v\}$ labeled $L_{e}(u)=\mathsf{Parent}$, then $L_{e}(v)=\mathsf{LChild}$; 5. (e)

if $u$ does not have incident edges labeled $\mathsf{Right}$ and $\mathsf{Left}$, then it is the root of the sub-gadget and it has only two incident edges with labels $\mathsf{LChild}$ and $\mathsf{RChild}$; 6. (f)

$u$ has an incident edge labeled $\mathsf{RChild}$ if and only if it also has an incident edge labeled $\mathsf{LChild}$; 7. (g)

if $u$ does not have incident edges with labels $L_{u}(e)=\mathsf{LChild}$ or $L_{u}(e)=\mathsf{RChild}$, then neither does $u(\mathsf{Left})$ and $u(\mathsf{Right})$ (if they exist); 8. (h)

$u$ is labeled $\mathsf{Port}_{i}$ if and only if it does not have incident edges labeled $\mathsf{Right}$, $\mathsf{LChild}$, and $\mathsf{RChild}$.

If the above constraints are satisfied, we say that the sub-gadget has a valid structure.

Correctness.

We want to show two things: a valid sub-gadget satisfies all the above constrains, and, any graph that satisfies the above constraints is a valid sub-gadget. It is clear that the first property holds. In order to prove the second property, we will proceed as follows. First we will show that a graph that satisfies the above constraints must have a node that does not contain incident edges labeled $\mathsf{RChild}$ or $\mathsf{LChild}$. Then, assuming we have such a node in the graph, we prove that it is a valid sub-gadget.

Lemma 7**.**

Let $G$ be a graph with $n$ nodes that satisfy the local constraints of a sub-gadget, then $G$ is a valid sub-gadget.

Proof.

By constraints 1a–1d, each node satisfies the basic properties of a valid sub-gadget, such as the consistency of the labels. Constraints 2a–2d ensure that the internal structure of the graph looks like a valid sub-gadget. Assume, by contradiction, that all nodes in $G$ have an incident edge with label $\mathsf{RChild}$. By constraint 3f, all nodes have also an incident edge labeled $\mathsf{LChild}$. In order for each node to have $2$ children, such that no node has two incident edges labeled $\mathsf{Parent}$, we need to have $2n$ nodes in $G$, which is a contradiction. This means that there exists a node $u$ in $G$ that is not a parent. By constraint 3g, we ensure that also nodes $u(\mathsf{Left})$ and $u(\mathsf{Right})$, if they exist, do not have incident edges with labels $\mathsf{RChild}$ or $\mathsf{LChild}$, ensuring that $G$ has a bottom boundary, as desired.

Suppose that all nodes $u$ that do not have incident edges labeled $\mathsf{RChild}$ or $\mathsf{LChild}$ have also an incident edge labeled $\mathsf{Right}$. Notice that $u(\mathsf{Right})$ cannot end in a node that has incident edges with labels $\mathsf{RChild}$ or $\mathsf{LChild}$, since it would contradict constraint 3g. Also, by constraint 1a, self loops are not allowed. Hence, by constraint 2a every node in the bottom boundary must have incident edges with labels $\mathsf{Right}$ and $\mathsf{Left}$. This means that the bottom boundary wraps around horizontally, forming a cycle. By constraints 3a and 3b, the graph $G$ will continue to wrap around horizontally, and since the internal structure is valid, the size of these cycles must halve each time, reaching a node $u$ (the root) that satisfies $u(\mathsf{Right})=u$, which contradicts constraint 1a.

Hence, among nodes that have no incident edges labeled with $\mathsf{RChild}$ or $\mathsf{LChild}$, there must exist a node $u$ such that it does not have an incident edge $\mathsf{Right}$. This implies that there must exist also a node $v$ that does not have an incident edge labeled $\mathsf{Left}$. Constraints 2a–2d and constraints 3a–3e ensure that $G$ has left and right boundaries according to the ones of a valid sub-gadget. Putting all together, we conclude that $G$ has the structure of a valid sub-gadget. ∎

4.3 Gadget

A gadget is composed by $\Delta$ sub-gadgets, and the root of each sub-gadget is connected to a central node, labeled $\mathsf{Center}$. Let $u$ be a central node, then each edge $e=\{u,v\}$ has the following labels:

• •

let $\mathsf{Index}_{i}$ be the label of node $v$, then $L_{u}(e)=\mathsf{Down}_{i}$;

• •

$L_{v}(e)=\mathsf{Up}$.

See Figure 6 for an example of a gadget.

Local checkability.

In addition to the constraints described for a sub-gadget, each node $u$ checks also the following local constraints:

if $u$ does not have an incident edge labeled $\mathsf{Parent}$, it checks that it has exactly one neighbor labeled $\mathsf{Center}$; 2. 2.

if $u$ is labeled with $\mathsf{Center}$, it checks that:

1. (a)

$u$ is connected to exactly $\Delta$ nodes (roots of sub-gadgets); 2. (b)

for any edge $\{u,v\}$, let $\mathsf{Index}_{i}$ be the label of node $v$, then $L_{u}(e)=\mathsf{Down}_{i}$; 3. (c)

for any edge $\{u,v\}$, $L_{v}(e)=\mathsf{Up}$; 4. (d)

let $v$ and $w$ be neighbors of $u$, if $v$ is labeled $\mathsf{Index}_{i}$ and $w$ is labeled $\mathsf{Index}_{j}$, then $i\neq j$.

If the above constraints are satisfied, we say that a gadget is valid.

Correctness.

It is easy to see that a gadget satisfies all the above constrains. We want to show that any graph that satisfies the above constraints is a gadget (notice that we have already shown the local checkability of a sub-gadget and its correctness, so we will assume that we are dealing with valid sub-gadgets).

Lemma 8**.**

Let $G$ be a graph with $n$ nodes that satisfies the local constraints of a gadget, then $G$ is a valid gadget.

Proof.

In Lemma 7 we have shown the correctness of a single sub-gadget. We still need to show that there cannot be edges among different sub-gadgets. This is ensured by constraint 2d and the constraint that, for each node, label $\mathsf{Index}$ must be the same as the one of its neighbors. Also, constraint 1 guarantees the existence of a node labeled $\mathsf{Center}$. By constraints 2a–2d, we have that the central node is correctly connected to the $\Delta$ sub-gadgets, ensuring that the graph has the structure of a valid gadget. ∎

4.4 LCL problem $\Psi$

We now define a constant radius checkable LCL problem $\Psi$, where either:

• •

all nodes output $\mathsf{Ok}$, or

• •

all nodes output a (possibly different) error label.

On one hand, if the structure of a gadget is invalid, nodes must be able to prove that there is an error. On the other hand, if the structure of the gadget is valid, then nodes must not be able to claim that there is an error. Notice that we allow nodes to output $\mathsf{Ok}$ even if the gadget is invalid. Moreover, if the gadget is invalid, we show that it is possible to prove that there is an error in $O(\log n)$ rounds. More precisely, the possible error output labels of the nodes are the following:

• •

an error label $\mathsf{Error}$;

• •

an error pointer label in $\{\mathsf{Right},\mathsf{Left},\mathsf{Parent},\mathsf{RChild},\mathsf{Up},\mathsf{Down}_{i}\}$.

The error output labels must satisfy the following locally checkable constraints.

A node outputs either $\mathsf{Error}$ or exactly one error pointer. 2. 2.

A node outputs $\mathsf{Error}$ if and only if the input labeling does not satisfy the local constraints given in Sections 4.2 and 4.3. 3. 3.

Let $u$ be a node that outputs an error pointer, then the following hold.

1. (a)

If the error pointer is $\mathsf{Right}$, then $u(\mathsf{Right})$ outputs $\mathsf{Error}$ or an error pointer $\mathsf{Right}$. 2. (b)

If the error pointer is $\mathsf{Left}$, then $u(\mathsf{Left})$ outputs $\mathsf{Error}$ or an error pointer $\mathsf{Left}$. 3. (c)

If the error pointer is $\mathsf{Parent}$, then $u(\mathsf{Parent})$ outputs $\mathsf{Error}$ or an error pointer in $\{\mathsf{Parent},\mathsf{Left},\mathsf{Right},\mathsf{Up}\}$. 4. (d)

If the error pointer is $\mathsf{RChild}$, then $u(\mathsf{RChild})$ outputs $\mathsf{Error}$ or an error pointer in $\{\mathsf{RChild},\mathsf{Right},\mathsf{Left}\}$. 5. (e)

If the error pointer is $\mathsf{Up}$ and $u$ has label $\mathsf{Index}_{i}$, then $u(\mathsf{Up})$ outputs $\mathsf{Error}$ or an error pointer $\mathsf{Down}_{j}$, where $j\neq i$. 6. (f)

If the error pointer is $\mathsf{Down}_{i}$, then $u(\mathsf{Down}_{i})$ outputs $\mathsf{Error}$ or an error pointer $\mathsf{RChild}$.

Lemma 9**.**

There does not exist an algorithm that, on a valid gadget, outputs error labels that satisfy the local constraints at all nodes.

Proof.

We show that if a gadget is valid, then it is not possible to output error labels such that the above constraints are locally satisfied at all nodes. Hence, suppose we have a gadget that has a valid structure where nodes produce error labels. First of all, since the gadget is valid, then there is no node outputting $\mathsf{Error}$, as it would violate the local constraints described above. Hence, nodes can only output error pointers in $\{\mathsf{Right},\mathsf{Left},\mathsf{Parent},\mathsf{RChild},\mathsf{Up},\mathsf{Down}_{i}\}$. There are two cases:

all nodes of all sub-gadgets point towards the node labeled $\mathsf{Center}$ (i.e., the central node is a sink); 2. 2.

the central node points towards the root of a sub-gadget.

In the first case, all error chains will end up at the central node that cannot output $\mathsf{Error}$, which violates the error constraints. So, suppose that the node labeled $\mathsf{Center}$ produces an error pointer, that is, it outputs $\mathsf{Down}_{i}$ for some $1\leq i\leq\Delta$. This means that we just need to show that we cannot cheat inside a sub-gadget. Hence, consider a sub-gadget, and suppose that the central node points towards the root of this sub-gadget. Notice that the root node cannot output $\mathsf{Up}$, since it would violate the error pointer constraints. Hence, all nodes $u$ of the sub-gadget must output an error pointer in $\{\mathsf{Right},\mathsf{Left},\mathsf{Parent},\mathsf{RChild}\}$. The following hold.

• •

If the error pointer is $\mathsf{Right}$, then, according to the error label specifications, $u(\mathsf{Right})$ can only output $\mathsf{Right}$ or $\mathsf{Error}$. Since the structure is valid, no node will output $\mathsf{Error}$, hence this chain will propagate until it reaches a node in the sub-gadget that does not have an incident edge labeled $\mathsf{Right}$, which contradicts constraint 3a. The case when the error pointer is $\mathsf{Left}$ is analogous.

• •

If the error pointer is $\mathsf{Parent}$, then, according to the error label specifications, the chain either reaches the root of the sub-gadget, or, at some point, a node in the chain outputs either $\mathsf{Left}$ or $\mathsf{Right}$. The latter case is handled above, while in the former case, according to the error label constraints, the root should output $\mathsf{Up}$ (since it cannot output $\mathsf{Error}$). But the root cannot point $\mathsf{Up}$ since, in that case, the root and the central node would point to each other, contradicting constraint 3e.

• •

If the error pointer is $\mathsf{RChild}$, then, according to the specifications, $u(\mathsf{RChild})$ can only output an error label in $\{\mathsf{RChild},\mathsf{Right},\mathsf{Left}\}$ (since it cannot output $\mathsf{Error}$). This chain cannot end at a node $v$ that has been reached traversing only edges labeled $\mathsf{RChild}$, as in that case $v$ should output $\mathsf{Error}$, which is not allowed. So, at some point of the chain, there is a node that outputs $\mathsf{Right}$ or $\mathsf{Left}$, and, as shown above, this would lead to a violation of the constraints. ∎

4.5 Upper bound

We show an algorithm $\mathcal{V}$ that satisfies Definition 2, i.e., given an upper bound $n$ on the size of the graph, in case of a valid gadget, it outputs $\mathsf{Ok}$ at every node, while in case of an invalid gadget, $\mathcal{V}$ is able to provide error labels in $O(\log n)$ rounds satisfying the error constraints. Let $u(L_{1}^{i_{1}},L_{2}^{i_{2}},\dots,L_{k}^{i_{k}})$ be the node reached from $u$ by following label $L_{1}$ $i_{1}$ times, label $L_{2}$ $i_{2}$ times, and so on. The algorithm is as follows.

Each node gathers its constant-radius neighborhood and checks if the constraints in Sections 4.2 and 4.3 are satisfied. 2. 2.

If the specifications of a valid gadget are not satisfied in a node’s constant-radius neighborhood, then the node outputs $\mathsf{Error}$. 3. 3.

If the constraints are satisfied in the constant-radius neighborhood of node $u$, then $u$ gathers its $O(\log n)$-radius neighborhood. 4. 4.

If a node does not see any error in its $O(\log n)$-radius neighborhood, then it outputs $\mathsf{Ok}$. 5. 5.

If a node $u$ labeled $\mathsf{Center}$ sees an error in its $O(\log n)$-radius neighborhood, then $u$ outputs $\mathsf{Down}_{i}$ if the error can be reached by following the labels $u(\mathsf{Down}_{i}^{1},\mathsf{RChild}^{i_{1}},\mathsf{Right}^{i_{2}})$ or $u(\mathsf{Down}_{i}^{1},\mathsf{RChild}^{j_{1}},\mathsf{Left}^{j_{2}})$, where $i_{1},i_{2},j_{1},j_{2}\geq 0$, breaking ties by choosing the smallest label $\mathsf{Down}_{i}$ that satisfies the above. 6. 6.

If a node $u$ not labeled $\mathsf{Center}$ sees an error in its $O(\log n)$-radius neighborhood, then it acts according to the following specifications, that a node checks in order.

1. (a)

if there exists an error that can be reached following $u(\mathsf{Right}^{i})$, where $i\geq 1$, $u$ outputs $\mathsf{Right}$; 2. (b)

if there exists an error that can be reached following $u(\mathsf{Left}^{i})$, where $i\geq 1$, $u$ outputs $\mathsf{Left}$; 3. (c)

if there exists an error that can be reached following the labels $u(\mathsf{Parent}^{i_{1}},\mathsf{Right}^{i_{2}})$ or $u(\mathsf{Parent}^{j_{1}},\mathsf{Left}^{j_{2}})$, where $i_{1},j_{1}\geq 1$ and $i_{2},j_{2}\geq 0$, then $u$ outputs $\mathsf{Parent}$; 4. (d)

if there exists an error that can be reached following the labels $u(\mathsf{RChild}^{i_{1}},\mathsf{Right}^{i_{2}})$ or $u(\mathsf{RChild}^{j_{1}},\mathsf{Left}^{j_{2}})$, where $i_{1},j_{1}\geq 1$ and $i_{2},j_{2}\geq 0$, then $u$ outputs $\mathsf{RChild}$; 5. (e)

if none of the above happens, it means that node $u$ is in a valid sub-gadget and the error is outside this sub-gadget; in this case, node $u$ outputs $\mathsf{Parent}$ if it has an incident edge with that label, otherwise $u$ outputs $\mathsf{Up}$.

Lemma 10**.**

The time complexity of algorithm $A$ is $O(\log n)$.

Proof.

By definition, algorithm $A$ runs in $O(\log n)$ rounds. Also, notice that a valid sub-gadget is a complete binary tree-like structure, and there is a node (the central one) that is connected to the root of each sub-gadget. This means that, in $O(\log n)$ rounds, a node either sees an error or it sees all the gadget. So, if a gadget looks like a valid structure from the perspective of a node, it means that it is globally a valid gadget, and in that case every node outputs $\mathsf{Ok}$. We need to show that, in case of an invalid gadget, the algorithm produces valid error labels, that is, the constraints described in Section 4.4 are satisfied at each node that outputs $\mathsf{Error}$ or an error pointer.

Consider a gadget that has an invalid structure. According to the specifications of algorithm $A$, a node outputs $\mathsf{Error}$ if and only if the constraints that determine a valid gadget are not satisfied in its constant-radius neighborhood, as desired. So, consider a node $u$ that outputs an error pointer, and let us denote with $w$ a node that outputs $\mathsf{Error}$ that is at distance $O(\log n)$ from $u$.

If there is a path that connects node $u$ to a node $w$ by using only labels $\mathsf{Right}$, then $u$ will output $\mathsf{Right}$. This holds for every node between $u$ and $w$, resulting in an error chain that traverses only edges labeled $\mathsf{Right}$, and ends at a node that witnesses an error. This error chain behaves according to constraint 3a in Section 4.4. 2. 2.

If the above does not apply, then $u$ checks if there is a path connecting $u$ and a node $w$ using only labels $\mathsf{Left}$, and if that is the case, $u$ outputs $\mathsf{Left}$. Similarly as before, this chain satisfies constraint 3b in Section 4.4. 3. 3.

If the above cases do not hold, then node $u$ checks if there is a path that connects $u$ and a node $w$ using $i\geq 1$ times the label $\mathsf{Parent}$, followed by $j\geq 0$ times $\mathsf{Right}$ or $k\geq 0$ times $\mathsf{Left}$. If that is the case, $u$ outputs $\mathsf{Parent}$. This error chain, either ends at an ancestor of $u$ that outputs $\mathsf{Error}$, or, at some point in the error chain there will be an ancestor $v$ of $u$ that reaches a node $w$ following only $\mathsf{Right}$, or only $\mathsf{Left}$ labels, ending the error chain at a node outputting $\mathsf{Error}$. This error chain behaves according to constraint 3c in Section 4.4. 4. 4.

If the above cases do not apply, then node $u$ checks whether there is a path connecting $u$ and $w$ using $i\geq 1$ times the label $\mathsf{RChild}$, followed by $j\geq 0$ times $\mathsf{Right}$ or $k\geq 0$ times $\mathsf{Left}$, and if that is the case, $u$ outputs $\mathsf{RChild}$. Again, this chain ends either at a descendant that outputs $\mathsf{Error}$, or, at some point there will be a node $v$ that can reach $w$ following only $\mathsf{Right}$, or only $\mathsf{Left}$ labels, behaving according to constraint 3d in Section 4.4. 5. 5.

If a node $u$ not having incident edges labeled $\mathsf{Down}_{i}$ (i.e., $u$ is not a central node) passes all the above checks, it means that it cannot reach a node $w$ that outputs $\mathsf{Error}$ without traversing an edge labeled $\mathsf{Up}$. Hence $u$ is a node of a valid sub-gadget, and the error is somewhere else. In this case, all nodes in the valid sub-gadget point towards the central node, that is, a node outputs $\mathsf{Parent}$ if it has an incident edge with such a label, otherwise it outputs $\mathsf{Up}$, satisfying constraints 3c and 3e in Section 4.4. 6. 6.

The central node $u$ can only output an error pointer $\mathsf{Down}_{i}$, breaking ties by choosing the label $\mathsf{Down}_{i}$ having smallest index, such that an error can be reached by following $u(\mathsf{Down}_{i}^{1},\mathsf{RChild}^{i_{1}},\mathsf{Right}^{i_{2}})$ or $u(\mathsf{Down}_{i}^{1},\mathsf{RChild}^{j_{1}},\mathsf{Left}^{j_{2}})$ ($i_{1},i_{2},j_{1},j_{2}\geq 0$). Notice that the central node cannot point to the root of a valid sub-gadget, since no error can be reached from it following labels $\mathsf{RChild}$, or $\mathsf{Right}$, or $\mathsf{Left}$. It is easy to see that if $u(\mathsf{Down}_{i})$ outputs $\mathsf{Error}$, then the constraints are satisfied. Otherwise, for the same reasoning used in point 4, we conclude that the error chain behaves according to constraint 3c in Section 4.4.

Notice that at least one of the above cases apply when a node sees an error. Hence, a node outputs an error or an error pointer if and only if the structure is invalid. ∎

4.6 Node-edge checkability of the gadget

We now show how to modify problem $\Psi$ defined in Section 4.4 and obtain a ne-LCL $\Psi_{\mathcal{G}}$. For this purpose, we must show that the validity of the output of nodes is checkable according to some node and edge constraints.

First of all, it is easy to see that all error pointers can be expressed as node and edge constraints. For example, consider the constraint “If the error pointer is $\mathsf{Right}$, then $u(\mathsf{Right})$ outputs $\mathsf{Error}$ or an error pointer $\mathsf{Right}$”. We can encode this constraint by requiring the following.

• •

Node constraints: a node outputs consistently on all its incident edges, i.e., if a node outputs $\mathsf{Right}$ on one incident edge, it must output $\mathsf{Right}$ on all other incident edges.

• •

Edge constraints: for an edge $e=\{u,v\}$ input labeled $L_{u}(e)=\mathsf{Right}$ and $L_{v}(e)=\mathsf{Left}$, if $u$’s side output label is $\mathsf{Right}$, $v$’s side output label is either $\mathsf{Right}$ or $\mathsf{Error}$.

All other error pointer constraints can be encoded in a similar way.

Handling the label $\mathsf{Error}$ requires more care. In fact, as it is defined, $\Psi$ allows nodes to output $\mathsf{Error}$ if they locally see an inconsistency in the gadget structure. While this output is checkable by exploring a constant radius neighborhood, it may not necessarily be node-edge checkable. The cases that require more attention are constraints 1a, 2c, and 2d of Section 4.2, since all the others can be handled similarly as we did with error pointers.

Handling constraint 1a.

According to constraint 1a, we need to allow nodes to output $\mathsf{Error}$ if there are self loops or parallel edges. It seems not possible to prove the presence of a self loop or parallel edges in the node-edge formalism. Thus, instead of requiring the nodes to prove the presence of a self loop or a parallel edge, we require the input labeling to prove the absence of self loops and parallel edges. For this purpose, as input label for the nodes of the gadget, we add a distance-$2$ coloring with $O(\Delta^{2})$ colors. It is trivial to see that self loops do not admit a proper coloring of the graph. Also, in case of parallel edges, there are two edges connected to the same neighbor, violating the constraint of being a proper distance-$2$ coloring. In order to make everything node-edge checkable, we require that the color of each node is replicated on all its incident edges as well (recall that each edge may be input labeled differently on each side).

We now show how to handle the case in which there is a node $v$ such that it has two incident edges ending on nodes with the same color $c$ (this includes the parallel edges case). In this case, node $v$ is allowed to output $\mathsf{Error}$ by specifying a color $c$ and two incident edges that connect $v$ to neighbors of color $c$. The constraints are as follows (see Figure 7 for an example):

• •

Node constraints: two edges must be specified, outputting on each of them the same color $c$.

• •

Edge constraints: if an edge is output labeled $c$ on one side, it is input labeled with the same color on the other side.

Other distance-$2$ color errors can be handled similarly.

Notice that, having a distance-$2$ coloring in input does not change the complexity of $\mathcal{V}$, that is, it still remains not possible to claim that there is an error in a valid instance.

Handling constraint 2d.

We now show how to handle constraint 2d, as constraint 2c can be handled similarly. Constraint 2d allows a node $u$ to output $\mathsf{Error}$ if $u(\mathsf{Right},\mathsf{LChild},\mathsf{Left},\mathsf{Parent})\neq u$ (if the path exists). We show how $u$ and its neighbors can prove the error claim in a node-edge checkable manner. The idea is that nodes $u$, $u(\mathsf{Right})$, $u(\mathsf{Right},\mathsf{LChild})$, $u(\mathsf{Right},\mathsf{LChild},\mathsf{Left})$, and $u(\mathsf{Right},\mathsf{LChild},\mathsf{Left},\mathsf{Parent})$, can label themselves with a chain of labels such as $A,B,C,D,E$. In a valid graph, this is not possible because $u$ would have both labels $A$ and $E$. These labels can be node-edge checked. For example:

• •

Node constraints: if a node is labeled $A$, it must have label $A$ on all its incident edges

• •

Edge constraints: if an edge is labeled $A$ and $\mathsf{Right}$ on one side, it needs to be labeled $B$ on the other side.

The node-edge constraints are similar for nodes that output labels different from $A$ in the chain. See Figure 8 for an example.

Finally, we would like that all nodes that do not satisfy locally constraint 2d are able to produce such a proof. The problem is that we do not currently allow overlapping chains, as it would allow to produce errors in valid graphs. This can be solved by requiring nodes to properly color the chains. That is, each chain has a color from a large enough palette, and nodes can participate to different chains by tagging each label with the color of the chain. For example, a node could output $\{(c_{1},A),(c_{2},E)\}$. Since we are in bounded degree graphs, and since chains have constant length, this requires an additive term of $O(\log^{*}n)$ rounds on the running time of algorithm $\mathcal{V}$, thus the complexity of $\mathcal{V}$ does not change.

4.7 Validity of the gadget family

In this section we presented a gadget family $\mathcal{G}$ and proved that it satisfies some properties. Now we show that it is a $(\log,\Delta)$-gadget family, i.e., it satisfies the properties in Definition 2, proving Theorem 6. Consider a graph $G=(V,E)\in\mathcal{G}$, where $|V|=n$. Then $G$ satisfies the following.

• •

The number of nodes is trivially $n$.

• •

Each of the $\Delta$ sub-gadgets has a port node labeled $\mathsf{Port}_{i}$, where $1\leq i\leq\Delta$.

• •

Each sub-gadget has a complete binary tree-like structure, hence its diameter is $O(\log n)$. Since the root of each sub-gadget is connected to the central node, the diameter of the gadget and the pairwise distance between the ports is $O(\log n)$.

The above observations show that, according to Definition 2, any $n$-node gadget $G\in\mathcal{G}$ is an $(n,O(\log n))_{\Delta}$-gadget. Moreover, we showed that checking whether a graph $G$ is contained in $\mathcal{G}$ is a ne-LCL solvable in $O(\log n)$ communication rounds, given an upper bound $n$ on the size of the network. In order to show that $\mathcal{G}$ is really a $(\log,\Delta)$-gadget family, we still need to show that, for any $n\in\mathbb{N}$, there exists a $G\in\mathcal{G}$ with $\Theta(n)$ nodes such that the pairwise distances between the ports are all in $\Theta(\log n)$. This is indeed satisfied by those gadgets $G\in\mathcal{G}$ having all $\Delta$ sub-gadgets of the same size.

5 Putting things together

In this section, we combine our findings of Sections 3 and 4 in order to provide a family of LCL problems where randomization helps, but only subexponentially. We obtain this family by starting from the sinkless orientation problem and recursively applying Theorem 1.

More precisely, we define a family of LCLs $\Pi^{i}$ having deterministic complexity $\Theta(\log^{i}n)$ and randomized complexity $\Theta(\log^{i-1}n\log\log n)$, for any constant $i=1,2,\dotsc$. The base case $i=1$ is given by the sinkless orientation problem, for which deterministic and randomized tight bounds of $\Theta(\log n)$ and $\Theta(\log\log n)$, respectively, are known [12, 8, 5]. Note that these bounds also hold in our setting, where we allow self-loops, parallel edges, and disconnected graphs. The problem $\Pi^{i+1}$ is obtained by applying Theorem 1 to $\Pi^{i}$ and the $(\log,\Delta)$-gadget family whose existence we proved in Theorem 6, where we set $f(x):=\lfloor\sqrt{x}\rfloor$.

From Theorem 1, we know that, given a problem $\Pi$ of time complexity $T(\Pi,n)$ and using a $(\log,\Delta)$-gadget family and the specified function $f(x)$, we obtain a new LCL $\Pi^{\prime}$ of complexity O\bigl{(}T(\Pi,n)\cdot\log n\bigr{)} and \Omega\bigl{(}T(\Pi,\sqrt{n})\cdot\log(\sqrt{n})\bigr{)}, for both the deterministic and the randomized case. Starting from problem $\Pi^{i}$ having deterministic and randomized complexities $\Theta(\log^{i}n)$ and $\Theta(\log^{i-1}n\log\log n)$, we obtain that the problem $\Pi^{i+1}$ has:

• •

Deterministic complexity O\bigl{(}\log^{i}n\log n\bigr{)} and \Omega\bigl{(}\log^{i}(\sqrt{n})\log(\sqrt{n})\bigr{)}, obtaining a tight complexity of $\Theta(\log^{i+1}n)$.

• •

Randomized complexity O\bigl{(}\log^{i-1}n\log\log n\log n\bigr{)} and \Omega\bigl{(}\log^{i-1}(\sqrt{n})\log\log(\sqrt{n})\log(\sqrt{n})\bigr{)}, obtaining a tight complexity of $\Theta(\log^{i}n\log\log n)$.

From the above observations, we obtain the following theorem.

Theorem 11**.**

There exist LCL problems with deterministic complexity $\Theta(\log^{i}n)$ and randomized complexity $\Theta(\log^{i-1}n\log\log n)$, for any $i=1,2,\dotsc$.

Acknowledgments

We thank Fabian Kuhn for discussions related to network decompositions. This work was supported in part by the Academy of Finland, Grant 285721.