How Long It Takes for an Ordinary Node with an Ordinary ID to Output?

TL;DR

This paper investigates the average running time of individual nodes in distributed algorithms, comparing it with traditional worst-case measures, and explores how these complexities relate under various models and problem classes.

Contribution

It introduces the concept of node-averaged and ID-averaged time-complexity, showing their relationships with classical complexity and randomized algorithms in distributed computing.

Findings

Exponential gap between node-averaged and worst-case time for leader election.

Node-averaged and worst-case complexities are similar for LCL problems on sparse graphs.

ID-averaged complexity aligns with the expected randomized algorithm complexity.

Abstract

In the context of distributed synchronous computing, processors perform in rounds, and the time-complexity of a distributed algorithm is classically defined as the number of rounds before all computing nodes have output. Hence, this complexity measure captures the running time of the slowest node(s). In this paper, we are interested in the running time of the ordinary nodes, to be compared with the running time of the slowest nodes. The node-averaged time-complexity of a distributed algorithm on a given instance is defined as the average, taken over every node of the instance, of the number of rounds before that node output. We compare the node-averaged time-complexity with the classical one in the standard LOCAL model for distributed network computing. We show that there can be an exponential gap between the node-averaged time-complexity and the classical time-complexity, as witnessed by, e.g., leader election. Our first main result is a positive one, stating that, in fact, the two time-complexities behave the same for a large class of problems on very sparse graphs. In particular, we show that, for LCL problems on cycles, the node-averaged time complexity is of the same order of magnitude as the slowest node time-complexity. In addition, in the LOCAL model, the time-complexity is computed as a worst case over all possible identity assignments to the nodes of the network. In this paper, we also investigate the ID-averaged time-complexity, when the number of rounds is averaged over all possible identity assignments. Our second main result is that the ID-averaged time-complexity is essentially the same as the expected time-complexity of randomized algorithms (where the expectation is taken over all possible random bits used by the nodes, and the number of rounds is measured for the worst-case identity assignment). Finally, we study the node-averaged ID-averaged time-complexity.

Equations

$$\underset{I\in \mathcal{I}\mathcal{D}}{\max }\underset{v\in G}{\max }{r}_{G,I,A}(v)\text{and }\underset{I\in \mathcal{I}\mathcal{D}}{\max }\frac{1}{n}\sum _{v\in G}{r}_{G,I,A}(v).$$

$$\frac{1}{|\mathcal{I}\mathcal{D}|}\sum _{I\in \mathcal{I}\mathcal{D}}\left(\underset{v\in G}{\max }{r}_{G,I,A}(v)\right)\text{and }\frac{1}{|\mathcal{I}\mathcal{D}|}\sum _{I\in \mathcal{I}\mathcal{D}}\left(\frac{1}{n}\sum _{v\in G}{r}_{G,I,A}(v)\right).$$

$$a(p)=\underset{1\le k\le \lceil p/2\rceil }{\max }\left\{k+a(k-1)+a(p-k)\right\}.$$

$$a(p)=\lceil \frac{p}{2}\rceil +a\left(\lceil \frac{p}{2}\rceil \right)+a\left(\lceil \frac{p}{2}\rceil -1\right).$$

$$r(v)\le 2k+2t+\underset{u\in S(v,k,k+2t)}{\max }r(u).$$

$$M=\underset{u\in S(v,k,k+2t)}{\max }r(u)\text{and }B=B(v,k+2t+M).$$

$$\alpha .r(v)-\beta \le \frac{1}{|S(v,1,r(v)/2)|}\sum _{u\in S(v,1,r(v)/2)}r(u).$$

$$r(v)\le 2k+2t+\underset{u\in S(v,k,k+2t)}{\max }r(u),$$

$$r(v)-2k-2t\le \sum _{u\in S(v,k,k+2t)}r(u).$$

$$\sum _{k=1}^{r(v)/2-2t}\left(r(v)-2k-2t\right)=\frac{r(v{)}^2}{4}-t\cdot r(v)+\frac{r(v)}{2}-2t\ge \frac{r(v{)}^2}{4}-3t\cdot r(v).$$

$$\sum _{k=1}^{r(v)/2-2t}\sum _{u\in S(v,k,k+2t)}r(u)\le (2t+1)\times \sum _{u\in S(v,1,r(v)/2)}r(u).$$

$$(2t+1)\times \sum _{u\in S(v,1,r(v)/2)}r(u)\le (2t+1)\times \frac{q\cdot r(v)}{2}\times \frac{1}{|S(v,1,r(v)/2)|}\times \sum _{u\in S(v,1,r(v)/2)}r(u).$$

$$\frac{r(v{)}^2}{4}-3t\cdot r(v)\le 2t\cdot q\cdot r(v)\frac{1}{|S(v,1,r(v)/2)|}\sum _{u\in S(v,1,r(v)/2)}r(u).$$

$$\alpha .r(v)-\beta \le \frac{1}{|S(v,1,r(v)/2)|}\sum _{u\in S(v,1,r(v)/2)}r(u)$$

$$\mathbb{E}(|V_k|||V_{k-1}|)=\sum _{v\in V_{k-1}}\mathbb{P}(v\text{ does not stop at round k})\le \beta |V_{k-1}|$$

$$\sum _{k}k(V_k-V_{k-1})\le \sum _{k}k{V}_k.$$

Full text

1 Introduction

The $\mathsf{LOCAL}$ model [23] is a standard model of distributed network computing. In this model, the network is abstracted as a graph, and the nodes perform in rounds to solve some task. At each round, each node can send messages to its neighbours in the graph, receive messages and perform some computation. The (time) complexity of an algorithm solving some task is measured by the number of rounds before the task is completed, which usually depends on the size of the network, that is, its number of nodes.

A classic assumption in the $\mathsf{LOCAL}$ model is that the nodes know the size of the network a priori. As a consequence, in many algorithms, each node can compute from the start how many rounds are needed to solve the task, and stops after that number of rounds. There have been efforts to remove such a priori knowledge about the graph, that is to avoid that the algorithm uses parameters such as the size of the graph, but also the arboricity [3] or the maximum degree [20]). Quite recently a general technique, called pruning algorithms, has been developed to remove the assumption that the nodes know the size $n$ of the network [16]. In other words, [16] provides a method to transform a non-uniform algorithm into a uniform algorithm. The basic idea is to guess the number of nodes and to apply a non-uniform algorithm with this guess. The output can be incorrect, as the algorithm is only certified to be correct when it is given the actual number of nodes in the graph. The technique consists in virtually removing from the graph the nodes that have correct outputs, and to repeat the previous procedure with a new guess that is twice as large as the previous guess. Eventually all nodes have an output after a certain number of iterations, and the solution that is computed is correct. Note that with the resulting uniform algorithm some nodes can output very quickly, and some others can output much later. So far, only the classic measure of complexity, i.e. the time before all nodes stop and output, has been studied, even for algorithms with a such discrepancies in the running times. In other words, only the behaviour of the slowest node has been considered. In this paper, we introduce a new measure of complexity, which is an average measure, in opposition to the usual measure which is a worst-case measure. More precisely, we define the running time of a node as the number of rounds before it outputs, and consider the average of the running times of the nodes. We argue that, when studying the locality of problems and of algorithms, it is worth to also consider this measure. Indeed it describes the typical local behaviour of the algorithm, that is, the behaviour of an ordinary node.

In some contexts partial solutions are useful. For example, consider the scenario in which two tasks are to be performed one after the other. In such a case, it may happen that, on some part of the graph a partial solution for the first task is computed quickly. We can take advantage of this to start the second task in that part of the network, while the other nodes are still working on the first task. (Note that knowing if the first task is finished can be impossible locally, and one has to design the second algorithms such that it can start at different rounds on different nodes.) Consider a second scenario in which a global operator has to take a decision based on the outcome of a local algorithm. In that case, a partial solution may also be sufficient. For example the operator can detect that the network is in a bad state, and start immediately a recovery procedure without waiting for all nodes to finish. Such situations are a motivation for the study of graph property testing, where a centralized algorithm probes the network on a sublinear number of nodes and take a decision based on this partial knowledge. We refer to the survey on graph property testing [14] for more examples of applications. When such partial solutions are useful, one would like to design algorithms that stop as soon as possible, and the average of the running times of the nodes is then a measure one would like to minimize.

Another classic assumption in the $\mathsf{LOCAL}$ model is that the nodes are given distinct identifiers. These identifiers (or IDs for short), are distinct binary strings on $O(\log n)$ bits, that is, distinct integers from a polynomially large space. The usual way to measure the complexity of an algorithm is again to consider the worst-case behaviour, that is, the performance of the algorithm on the worst ID assignment. We argue that the average performances over all ID assignments is also worth considering. Indeed many lower bounds are based on the fact that, as the identifiers can be viewed as set by an adversary, they do not really help to break symmetry. For example, on a path, one may consider the identifier assignment $1,2,...,n$, and argue that if the nodes only consider the relative ordering of the identifiers in their neighbourhoods, then many nodes have the same view, and thus they cannot break symmetry. It is interesting to study if such specific constructions are required, or if one can design lower bounds that are robust against arbitrary ID assignment. We cannot expect that IDs are always set in a perfect way for the task we consider, but it may seem excessive to consider that they are set in an adversarial way, which naturally leads to the question of random assignments. We study the complexity of algorithms on random ID assignment, as the average over all possible ID assignments of the running time of the slowest node. Finally, the typical behaviour of an algorithm can arguably be the expected running time of an ordinary node on a random ID assignment. That is, the standard complexity but averaged on both nodes and ID assignments.

For the sake of concreteness, here is an example of the type of questions tackled in this paper. Consider the classic task of 3-colouring a ring of $n$ nodes. It is known that this task requires $\Omega(\log^{*}\!n)$ rounds [17]. This bound also holds for randomized algorithms [21]. The question tackled in this paper are of the following form: is it the case that a node typically outputs after a constant number of rounds, or is the $\Omega(\log^{*}\!n)$ lower bound robust to this spatial averaging? And what about the complexity of the problem on a random ID assignment?

Our results.

Our first result is that averaging on the nodes can have a dramatic effect on the time complexity of solving a task in the $\mathsf{LOCAL}$ model. Indeed, for leader election on cycles, there is an exponential gap between the node-averaged complexity and the classic complexity. That is, the slowest node outputs after a number of rounds that is exponentially larger than the time complexity of an ordinary node. This contrasts with our next result, for very sparse graphs. We say that a graph has linearly bounded growth, if there exists a constant $q$ such that every ball of radius $r$ has at most $q.r$ nodes. For such graphs, we show that, for many classic tasks, the two measures are of the same order of magnitude. More precisely for a class of tasks that generalizes the class of locally checkable labellings ($\mathsf{LCL}$ for short) [22], we show the following lemma, that we call local average lemma. For a given algorithm, either no node has running time much larger than the average running time in its neighbourhood, or there exists an algorithm that is strictly better. As a consequence when proving lower bounds for these problems, one can use the fact that, loosely speaking, there is no peak in the distribution of the running times of the nodes. Then, to show that the average running time is large, it is sufficient to show that there exists a set of nodes with large running times, that are well spread out in the network. This local average lemma can be used to show, for example, that for $\mathsf{LCL}$ problems on cycles, the landscape of complexities known for the slowest node (either $\Theta(1)$, $\Theta(\log^{*}\!n)$ or $\Theta(n)$) is the same for an ordinary node.

We then move on to averaging on the identifier assignments. That is, we consider the expected behaviour of deterministic algorithms on random ID assignments. This topic happens to be related with the expected complexity of randomized algorithms. We show that even though these two models have specific properties, namely the independence of the random strings for randomized algorithms, and the uniqueness of the identifiers for random ID assignments, the complexities are essentially the same. It follows that the results known for randomized algorithms can be translated to random assignments.

Finally we prove that averaging on both nodes and IDs, can have an important impact on the complexity. We take the example of 3-colouring an $n$-node cycle. From the previous results of the paper, and from the literature, we know that this task has complexity $\Omega(\log^{*}\!n)$ for both the average on the nodes and the average on the identifiers. Quite surprisingly, when averaging on both the nodes and the ID assignments, the complexity becomes constant. In other words, deterministic and randomized complexity of ordinary nodes are clearly separated. Such separation contrasts with the case of the classic measure where randomized constant-time algorithms for $\mathsf{LCL}$ can be derandomized to get constant-time deterministic algorithms [22].

Related works.

The $\mathsf{LOCAL}$ model was defined formally in [17], and a standard book on the topic is [23]. The problem of leader election, studied in section 3, is a classic problem in distributed computing [2, 19].

Deterministic algorithms stopping after different number of rounds on different nodes have been studied in contexts where the parameters of the graph, such as the degree or the number of vertices, are unknown. Such algorithms are called uniform algorithm, because it is the same algorithm that is run on every graph, independently of the parameters. A work that is particularly relevant to us is [16]. In this paper the authors prove that for a wide class of problems, one can remove the assumption that the nodes know the size $n$ of the network. This is done by applying a general method to transform a non-uniform algorithm into a uniform one, without increasing of the asymptotic running time. In this framework, called pruning algorithms, some nodes may stop very early and some may run for much longer time. Such algorithms justify the study of the behaviour of an ordinary node and not only of the behaviour of the slowest node.

The local average lemma of section 4 applies to problems that are local in the sense that the nodes can check in constant time if a given solution is correct. This is an extension of the well-studied notion of locally checkable labelling (or $\mathsf{LCL}$ for short) [22]. The original $\mathsf{LCL}$ requires in addition that the size of the inputs and outputs are bounded. Also the set of correct labellings usually studied, e.g. in distributed decision [10] or in $\mathsf{LCL}$, do not depend on the identifiers of the graph, a restriction that is not needed in the current paper.

Randomized algorithms, that turn out to be equivalent to algorithms working on random ID assignments, form a well-studied subject, going back to the 80s with algorithms for finding a maximal independent set [1, 18]. Recently, improvements on classic problems have been obtained [13, 15] along with an exponential separation between randomized and deterministic complexity [6] (see also [4]). In [13], the author, by advocating the study of the so-called local complexity for a randomized algorithms, conveys the same message as the current paper: the behaviour of a typical node is worth considering, even if some nodes of the graph have much worst behaviour.

In this paper, two relaxation of the classic measure are considered, from worst-case to average, on the nodes and on the IDs. An aspect that we do not consider is the structure of the graph. We refer to [12] and references therein, for the topic of local algorithms on random graphs.

2 Model and definitions

Graphs and neighbourhoods.

The graphs considered in this paper are simple connected graphs, and throughout the text $n$ will denote the number of nodes in the graph. The distance between two nodes is the number of edges on a shortest path between these nodes, that is, the hop-distance. The $k$-neighbourhood of a node $v$ in a graph $G$, is the graph induced by the nodes at distance at most $k$ from $v$. Every node is given a distinct identifier on $O(\log n)$ bits, or equivalently an integer from a polynomially large range.

Distributed algorithms.

The algorithms studied in this paper can be defined in two ways. In both definitions, the nodes are synchronized and work in rounds, and for both the computational power of the nodes is unbounded. In the first definition, at each round, every node can exchange messages with its neighbours, and perform some computation. There is no bound on the size of the messages. A given node chooses an output after some number of rounds, and different nodes can stop at different rounds. After the output, a node can continue to transmit messages and perform computations, but it cannot change its output. In other words, the nodes do not go to a sleep mode once they have output, but the output is irrevocable. In the second definition, each node starts with the information of its [math]-neighbourhood, and increases the size of this view at each round. That is, after $k$ rounds, it knows its $k$-neighbourhood. This $k$-neighborhood includes the structure of the graph in this neighbourhood, along with the identifiers and the inputs of each node. At some round, it chooses an output and stops. These two definitions are equivalent. On one hand, if we start from the first definition, we can assume that each round every node sends to its neighbours all the information it has about the graph (remember that the message size is unbounded)111There is a subtlety here, which is that after $k$ rounds in the message-passing algorithm a node cannot know the edges that are between nodes at distance exactly $k$ from it. For the sake of simplicity, we consider the proper $k$-neighbourhoods, as it does not affect the asymptotics of the algorithms.. Then after $k$ rounds, a node has gathered the information about its $k$-neighbourhood. On the other hand, given a $k$-neighbourhood, a node can simulate the run of the other nodes, and compute the messages that it would receive if the nodes were using a message-passing algorithm.

Complexity measures studied.

The running time of a node is the number of rounds before it outputs. With the second definition, the running time of the algorithm can be described in a more combinatorial way: it is the minimum integer $k$ such that the node can choose an (irrevocable) output based only on the view of radius $k$. Let the set of legal ID assignments be denoted by $\mathcal{ID}$. Given a graph $G$, an identifier assignment $I:v\mapsto\mathcal{ID}$, some input $x$, an algorithm $A$, and a node $v$, we denote by $r_{G,I,x,A}(v)$ the running time of node $v$ in this context. When the context is clear, we simply use $r(v)$. We now define the different measures of complexity used in this paper. Given a graph $G$, and an algorithm $A$, we call complexity of the slowest node complexity or classic complexity, and complexity of an ordinary node or node-averaged complexity respectively, the following quantities:

[TABLE]

In the second part of this paper, we consider the running time of the slowest node-averaged on the identifier assignments, and the running time averages on both the identifiers assignments and the nodes, that is, the following measures:

[TABLE]

Tasks and languages.

The tasks or problems that we want to solve in a distributed manner, are formalized with the notion of language. A language $\mathcal{L}$ is a set of configurations of the form $(G,I,x,y)$, where $G$ is a graph, $I$ an identifier assignment, and $x$ and $y$ are functions from the nodes of the graph to a set of labels. We are interested in constructing these languages, which means that given a graph $G$, an ID assignment $I$ and inputs given by the function $x$, we want to compute locally a function $y$ such that $(G,I,x,y)$ is in the language $\mathcal{L}$. The languages considered are such that for every $(G,I,x)$, there exists a legal output $y$. Note that usually, the identifier assignment is not part of the language [10, 11, 22], but our results hold for this more general version.

Knowledge of the size of the network.

In section 3, we use the most general option regarding the knowledge of $n$ by the nodes: we assume such knowledge for lower bounds, whereas for upper bounds we do not require it. For section 4, we assume that nodes do not have the knowledge of $n$. For the randomized part we assume this knowledge for the sake of simplicity, and we refer to subsection 4.4 of [16] for a technique to remove such assumptions for randomized algorithms.

Additional notations.

Throughout the paper, the expression with high probability means with probability at least $1-1/n$. Also, for a set $X$, $|X|$ denotes the cardinal of the set.

3 Exponential gap for a global language

The complexity of an ordinary node is bounded by the complexity of the slowest node by definition. In this section, we show that the gap between these two quantities can be exponential.

Theorem 3.1**.**

The gap between the node-averaged complexity and the classic complexity can be exponential.

We illustrate this phenomenon on the classic problem of leader election. The language of leader election is the set of graphs with arbitrary IDs, with no inputs and binary outputs, such that exactly one node has label 1, and the others have label 0.

Proposition 3.2** (Folklore).**

Leader election on an $n$-node ring requires $\Theta(n)$ rounds (for the slowest node).

This result is part of the folklore, but we prove this statement for completeness. The complexity of leader election in various models is discussed in [2, 19].

Proof 3.3**.**

Let $A$ be an algorithm for leader election, which has access to the size of the graph. Suppose that the slowest node complexity of $A$ is $c(n)\in o(n)$. Let $n_{0}$ be a large enough constant such that $2c(n_{0})+1<n_{0}/2$. Consider a ring $R_{1}$ of length $n_{0}$. After running the algorithm $A$ on $R_{1}$, a node $v_{1}$ is elected to be the leader. This node $v_{1}$ outputs 1, after at most $c(n_{0})$ steps. That is, $v_{1}$ outputs based on a view that contains at most $2c(n_{0})+1$ nodes. Because of the definition of $n_{0}$, this view contains less than $n_{0}/2$ nodes. Let $I_{1}$ be the set of identifiers in this view. Now consider another ring $R_{2}$ of length $n_{0}$, whose set of identifiers does not contain any of the IDs of $I_{1}$. Again, a node $v_{2}$ is designated as the leader, and its view contains less than $n_{0}/2$ nodes. Now consider the ring made by concatenating the two views, and adding dummy nodes with fresh identifiers, to make sure that the ring has size $n_{0}$. Because the identifiers are all distinct, this is a proper instance. Then, as $v_{1}$ and $v_{2}$ have the same view as in $R_{1}$ and $R_{2}$ respectively, with the same graph size $n_{0}$, they output the same as in $R_{1}$ and $R_{2}$ respectively. That is, they both output 1, and thus produce a configuration that is not in the language, which a contradiction.

Proposition 3.4**.**

The complexity of an ordinary node for leader election on an $n$-node ring is $O(\log n)$.

Proof 3.5**.**

Consider the following algorithm. Each node increases its radius until one of the two following situations occurs. First, if it detects an ID that is larger than its own, it outputs 0. Second, if it can see the whole ring, and can detect no ID is larger than its own, then it outputs 1. It is easy to see that this algorithm is correct: exactly one node will output 1, the node with the largest ID. Note that this algorithm is order-invariant in the sense of [22], i.e. the algorithm does not take into account the identifiers themselves, but only their relative ordering in its view. In particular, the algorithm does not require the knowledge of $n$. We show that the node-averaged complexity of this algorithm is logarithmic in $n$.

Let us first make an observation. Consider the nodes with the $k$ largest identifiers, and mark them. The nodes that are not marked form $k$ paths. (Some of these paths can be empty, if two marked nodes are adjacent). A key property is that the behaviour of the algorithm on one path is independent of the other paths. More precisely, we claim that on a given path the algorithm will have the same behaviour whatever the sizes and the identifier distributions of the other paths are. Fix a path, and a node $v$, in this path. By definition, $v$ has an identifier that is smaller than the ones of the two marked nodes at the endpoints of the path. Therefore, either it stops before reaching an endpoint, or exactly when it reaches one of the marked nodes. As a consequence, such a node will output based only on its knowledge of the path. This simple observation implies that we can study the behaviour of the algorithm on each path separately. Let $p$ be an integer, and let us consider a path of length $p$ with two additional marked nodes at each endpoint. Thanks to order-invariance, it is sufficient to study the behaviour of the algorithm on this path with all the relative ordering of identifiers. Let $a(p)$ be the maximum over all these identifier assignments of the sum of the running times of the nodes. We claim that this function obeys the following recurrence relation:

[TABLE]

Consider the node $v$ with the largest identifier in the path (excluding the marked endpoints). As noted before, it must reach one of the endpoints to stop. Then if we mark this node, the behaviour of the algorithm on the two subpath is independent of the context, and the maximum sums of running times in each path is $a(p_{1})$ and $a(p_{2})$ for the first subpath of length $p_{1}$ and the second of length $p_{2}$ respectively. Then the only parameter is the distance $k$ from $v$ to the closest endpoint. Given such an integer $k$, $a(p)$ is then equal to $k+a(k-1)+a(p-k)$. One can then check by induction that this maximum is always met for the value $k=\lceil p/2\rceil$. Then an alternative formula is:

[TABLE]

The sequence $a(n)$, defined by the induction formula above, along with initial values $a(0)=0$ and $a(1)=1$, is known to be in $\theta(n\log n)$. For references and more information about this sequence, see [26].

When running the algorithm, the node with the largest identifier will see the whole graph and detect it has the largest ID, and then output 1. Its running time is then $\lceil n/2\rceil$. We can then mark this node, and apply the result of the previous paragraphs to the path made by the remaining nodes. Consequently, the sum of the running times of the nodes is equal to $\lceil n/2\rceil+a(n-1)$ which is in $\theta(n\log n)$. Thereafter, the complexity of an ordinary node is logarithmic in $n$.

Note that analysis of the same flavour already exist in the literature, see for example [25] p.125. Theorem 3.1 follows from propositions 3.2 and 3.4.

4 Local average lemma and application

This section is devoted to proving that, for local languages on very sparse graphs, the complexity of an ordinary node is basically the same as the one of the slowest node. This proof is based on a local average lemma. Given a graph and an algorithm, let us define informally a peak, as a node whose running time is much larger than the average running time in its neighbourhood at some distance. The lemma states that, for local languages, and for algorithm that are somehow optimal, there is no such peak.

4.1 Intuition on 3-colouring of a ring

In order to give an intuition of the lemma and its proof, and to justify the notions we introduce in the next paragraph, let us consider the example of 3-colouring a cycle. Consider an algorithm for the problem, and three adjacent nodes $u$, $v$ and $w$, in this order in a cycle. We claim that if $r(v)>\max(r(u),r(w))+1$, then the algorithm can be speeded up. Note that after $\max(r(u),r(w))+1$ steps, $v$ has a view that contains the whole views of $u$ and $w$. Then $u$ can simulate the computations of $u$ and $w$, and deduce the colours they output, and output a non-conflicting colour. As a consequence if one wants to prove a lower bound on the average of the running times, one can assume that $r(v)\leq\max(r(u),r(w))+1$. This leads to the fact there is no peak: every node with high running time has at least one neighbour with similar running time, and then the average running time at distance 1 cannot be smaller than half the running time of $v$. The lemma is a generalization of this observation, for further neighbours, more general graphs and more general problems.

4.2 Additional definitions

In order to state the lemma we need to introduce a few notions.

Class $\mathsf{LCL\textsuperscript{*}}$.

We consider a large class of distributed problems that we call $\mathsf{LCL\textsuperscript{*}}$, which includes the well-known class of $\mathsf{LCL}$ problems [22], and the more general class $\mathsf{LD}$ [11]. A language $\mathcal{L}$ is in $\mathsf{LCL\textsuperscript{*}}$, if there exists a constant-time verification algorithm, that is an algorithm $\mathcal{V}$ performing in a constant number of rounds, with binary output, accept or reject, such that the following holds. For every configuration $(G,I,x,y)$, $\mathcal{V}$ accepts at every node, if and only if the graph is in the language $\mathcal{L}$. The running time of $\mathcal{V}$ is called the verification radius. No bound on the size of the inputs and output is necessary, and the language can depend on the identifiers.

Graphs with linearly bounded growth.

A graph has linearly bounded growth if there exists a constant $q$ such that if any ball of radius $r$ contains at most $qr$ nodes. The constant $q$ is called the growth parameter. For example a cycle has linearly bounded growth, with parameter $3$.

Minimal algorithms.

We would like to write a statement of the following form: given a node $v$ whose running time is $r$, the nodes of its neighbourhood have running times whose average is roughly $r$. This type of statement cannot hold in general as we could artificially increase the radius of a node by modifying the algorithm. But as we are interested in lower bounds we can consider algorithms that are in some sense optimal. More precisely, let $A$ and $A^{\prime}$ be two distributed algorithms for some language $\mathcal{L}$. We say that $A$ is smaller than $A^{\prime}$, if on every graph, every ID assignment and inputs, and on every node, the running time of $A$ is at most the running time of $A^{\prime}$. For lower bounds on the node-averaged complexity, it is sufficient to study algorithms that are minimal for this ordering. Indeed, if an algorithm that is not minimal has low complexity, then there exists a minimal algorithms that has at most this complexity.

Knowledge of $n$.

In this section the algorithm do not have the knowledge of $n$.

Additional notations.

Let us denote by $B(v,k,G,I,x)$ the subgraph of $G$, with identifiers $I$, and inputs $x$, induced by the nodes at distance at most $k$ from a node $v$. Likewise, given two integers $k_{1}<k_{2}$, let $S(v,k_{1},k_{2},G,I,x)$ be the induced graphs with IDs and inputs, induced by the set of nodes whose distance to $v$ is at least $k_{1}$ and at most $k_{2}$. Such set of nodes are referred to as crowns in the following. When the context is unambiguous, we may omit $G$, $I$ and $x$.

4.3 Lemma statement

Lemma 4.1** (Local average lemma).**

Let $\mathcal{L}$ be a language in $\mathsf{LCL\textsuperscript{*}}$, and let $\mathcal{F}$ be a graph family with linearly bounded growth and $A$ be a minimal algorithm for $\mathcal{L}$. There exists two positive constants $\alpha$ and $\beta$, such that for any graph of $\mathcal{F}$, ID assignment, inputs, and node $v$, the average of the running time of $A$ on the nodes at distance at most $r(v)/2$ from $v$, is at least $\alpha.r(v)-\beta$.

4.4 Proof of the lemma

Let $\mathcal{L}$, $A$, $G$, $I$, $v$ and $x$ be respectively, a language, a minimal algorithm, a graph, an ID assignment, a node and an input assignment as in the lemma. In this proof, several graphs, inputs, IDs and algorithms are considered ; when not specified, we refer to the elements we have just defined. For example $r(v)$ refers to the running time of $A$ on $v$ in G, with $I$ and $x$. Let $\mathcal{V}$ be the verification algorithm of $\mathcal{L}$, and let $t$ be the verification radius of $\mathcal{V}$. Let $q$ be the growth parameter of $\mathcal{F}$.

The proof is in two steps, that we highlight with two technical claims. The first claim relates the running time of a node with the running time of the nodes in a crown around it. The proof uses a simulation argument as in the example of 3-colouring in subsection 4.1, and we call it the simulation step in the following.

Claim 1** (Simulation step).**

For every integer $k$:

[TABLE]

Proof 4.2** (Proof (Simulation step)).**

For the sake of contradiction, suppose the inequality does not hold for some fixed $k$. Let us use the following notations:

[TABLE]

As in the simulation of subsection 4.1, we show how to craft a new algorithm $A^{\prime}$, smaller than $A$.

Definition of $A^{\prime}$.

Consider a node $w$ of a graph $H$, with ID assignment $I_{H}$, and inputs $x_{H}$. The behaviour of $A^{\prime}$ on this graph differs from the behaviour of $A$ only if the following conditions are fulfilled (see figure 4.4):

1. (1)

The running time of $A$ on $w$ in $(H,I_{H},x_{H})$, is at least $2k+2t+M$ ; 2. (2)

The node $w$ is at distance at most $k$ from a node $v_{H}$ whose neighbourhood at distance $k+2t+M$ is exactly $B$.