DGA 1

In each round r = 1, 2, 3, . . ., each node performs two steps.

1. it sends an arbitrarily large message to each of its neighbors,
2. it is allowed to perform some arbitrarily complex internal computation on the knowledge it has accumulated so far.

Each node is required to execute the same algorithm, which is what we call a distributed algorithm.

A list of colors is assigned to each node as input, and the task is to assign to each node a color from the respective list such that the entire coloring satisfies certain constraints, e.g., being a proper coloring

• The distributed algorithm executed in each node
  1. is not only responsible for determining which messages to send,
  2. but also to decide when the node finishes its computation/communication.

This means each node has to decide at some point that it terminates, at which point it has to output its local problem.

When considering problems where the output is “on edges”, e.g., if the task is to compute some coloring of the edges, or if the considered problem is a matching problem, we will assume that each node has to output the local part of the global output corresponding to each incident edge.

In a symmetric input graph, e.g., a cycle, each node has exactly the same information at the beginning of the computation and since each node executes the exact same algorithm, each node will send precisely the same messages to its neighbors in the first round. Now, after the first round of communication, we still have exactly the same knowledge at each node, so also in the second round each node will send the exact same messages. By induction, we obtain that, in each round, each node will behave exactly the same as any other node; in particular, each node will give the exact same output.

But this implies that certain problems cannot be solved at all; for instance, it is impossible to compute a proper coloring as, no matter which algorithm is chosen, each node will output the same color.

A simple way to avoid these impossibilities is providing some symmetry breaking information.

This symmetry breaking information is different when talking about deterministic and randomized algorithms (or the deterministic and randomized LOCAL model):

• In the deterministic LOCAL model, each node (additionally to the information already specified before) is equipped with a unique numerical identifier (ID) from \({1, \dots, n^{c}}\), for some constant \(c\ge 1\).
• In the randomized LOCAL model, each node (additionally to the information already specified before) is equipped with its own private random bit string of arbitrary length. Each bit of the random bit string is chosen uniformly at random, and the randomized LOCAL model does not provide unique IDs.

We begin with the definition of the runtime or (time) complexity of an algorithm on a fixed graph.

In the randomized LOCAL model, things are a little bit more complicated due to the fact that we allow randomized algorithms to fail with a small probability. More precisely, the randomized algorithms that we will consider are Monte-Carlo algorithms, i.e., we require that there exists an upper bound on the runtime of the algorithm that is independent of the random bits, but allow that the algorithm yields an incorrect output with a certain probability.

There exists a \(T(n)\text{-round}\) algorithm for some problem \(\Pi\) (on some graph class \(\mathcal{G}\)) if and only if there exists a deterministic function \(\mathcal{B}\) from the space of all possible centered \(T(n)\text{-hop}\) neighborhoods of a node in an \(n\text{-node}\) graph to the set of allowed output labels in \(\Pi\) such that, for each \(G \in \mathcal{G}\), the solution obtained by having each node gather its \(T(|V(G)|)\text{-hop}\) neighborhood and then applying the function \(\mathcal{B}\) yields a correct output.

We will often identify the function \(\mathcal{B}\) with the algorithm associated with it (that collects the \(T(n)\text{-hop}\) neighborhood at each node and then applies \(\mathcal{B}\)). Also, due to Theorem 2.6 we can restrict attention to algorithms of this particular form whenever we study whether a problem can be solved with a certain complexity. It will be useful to have both of these equivalent viewpoints; sometimes it will be more convenient to consider algorithms in the form of a function that maps \(T(n)\text{-hop}\) neighborhoods to output labels and sometimes it will be more convenient to consider algorithms that actually send around messages (that are potentially small and easy to understand).

Here is a simple corollary of the fact that we can view algorithms as functions defined on the space of \(T(n)\text{-hop}\) neighborhoods.

Every problem (that admits a correct solution) can be solved in \(n\) rounds in the deterministic (and randomized) LOCAL model.

Proof. For each possible input graph (including the distribution of the unique IDs), fix one solution. Now, let each node \(v\) gather its (centered) \(n\text{-hop}\) neighborhood, which will encompass the whole graph, and then apply the function \(\mathcal{B}\) to this neighborhood that first maps the neighborhood to the fixed solution for it and then selects as function value the part of the global output that corresponds to \(v\). The global output of this algorithm will be precisely the solution for the input graph fixed above and therefore correct. Moreover, by Theorem 2.5 we know that then the observation also holds for randomized algorithms.

We denote the diameter of a graph \(G\) by \(D = D(G)\). The proof of Observation 2.2 shows that also \(D\) rounds (which might be much smaller than \(n\) rounds) suffice to solve any problem that admits a correct solution (on any input graph of the considered graph class).

As \(n\) rounds suffice for essentially every problem, we would ideally like to have much faster algorithms when considering specific problems. Complexities that we aim for (depending on the problem) include \(O(\mathrm{poly}(\log n))\) and \(O(\log^{*} n)\).

This was a lot of information, and it may take a bit of time to digest all of it and get a good intuition for algorithms in the LOCAL model. Let’s start by having a look at an example of a LOCAL model algorithm in action. The setting will be simple, but the algorithm still interesting (and beautiful).

Idea of the proof. The proof constructs two directed paths that look identical from the local perspective of two carefully chosen nodes, so any \(n/5\)-round deterministic algorithm must produce the same outputs at those nodes in both graphs. However, the global parity of the distance between the two nodes is different in the two graphs. Since a proper 2-coloring of a path is completely determined by parity, the two nodes must have the same color in one graph and different colors in the other. This is impossible, yielding a contradiction.

Proof. Assume for contradiction that there exists a deterministic algorithm \(A\) that computes a proper 2-coloring of directed paths in \(n/5\) rounds.

Construct two directed paths \(G\) and \(G'\), each with \(n\) nodes. In \(G\), the sequence of IDs along the edge orientation is

\[ 1,2,3,\dots,n. \]

In \(G'\), the sequence is

\[ 1,2,\dots,\lceil n/2 \rceil,\ \lceil n/2 \rceil+2,\dots,n+1. \]

Now consider the two nodes with IDs

\[ \lceil n/5 \rceil + 2 \quad\text{and}\quad \lceil 4n/5 \rceil - 1. \]

For sufficiently large \(n\), each of these two nodes has exactly the same radius-\(n/5\) neighborhood in \(G\) and in \(G'\). Since \(A\) runs in \(n/5\) rounds, the output of a node depends only on its radius-\(n/5\) neighborhood. Therefore, each of the two selected nodes must produce the same output in \(G\) and in \(G'\).

However, the distance between these two nodes is even in one of the graphs and odd in the other. In any proper 2-coloring of a path, two nodes at even distance must receive the same color, while two nodes at odd distance must receive different colors. Hence, in one of the two graphs, the selected nodes must output the same color, and in the other they must output different colors.

This contradicts the fact that the local neighborhoods of the selected nodes are identical in \(G\) and \(G'\), which forces the algorithm to produce the same outputs in both graphs. Therefore, no deterministic algorithm can compute a proper 2-coloring of directed paths in \(n/5\) rounds. \(\square\)

As we obtain a contradiction for any sufficiently large n, the proof of Theorem 3.1 implies a lower bound of \(\Omega(n)\) rounds. Hence, we cannot obtain a sublinear complexity if we only allow 2 colors. Let’s try with 3 …

Here is a simple but elegant deterministic algorithm that computes a 3-coloring on directed paths quickly. The algorithm (let’s call it \(\mathcal{A}\)) proceeds in 3 phases. In Phase 1, algorithm \(\mathcal{A}\) finds a proper coloring of the directed path using a large color palette. In Phase 2, the coloring will be changed step by step to a proper coloring that uses only a very small color palette. In Phase 3, the new coloring will be changed to a 3-coloring.

Phase 1 How can we obtain a proper coloring of the directed path if we don’t care about the number of colors we use? Well, essentially we are already given one by the definition of the LOCAL model. Recall that in the deterministic LOCAL model, each node is equipped with a unique ID from the space \(\{1, \ldots, n^{c}\}\). We can simply interpret the IDs as colors and thereby obtain a proper coloring with color palette \(\{1, \ldots, n^{c}\}\).

Phase 2 This is when the magic happens. Phase 2 consists of several rounds, in each of which each node selects a new (temporary) color for itself. Moreover, we always preserve the property that the coloring is proper while reducing the size of the used color palette. More precisely, in each round each node \(w\) sends its current color \(c_w\) to its child \(v\), and then \(v\) chooses a new color \(c_v'\) based only on its current color \(c_v\) and the current color \(c_w\) of its parent, as follows:

First, \(v\) computes the smallest position \(i\) at which the two colors \(c_v\) and \(c_w\), given as bit strings, differ (such an index exists as we preserve the property that the computed coloring is proper at all times). Then \(v\) sets \(c_v' := (i, c_v[i])\) where \(c_v[i]\) denotes the bit at position \(i\). Again, we can naturally encode the new color as a bit string, for the next round of Phase 2.

Phase 3 As we will see in the analysis, at the end of Phase 2 the used color palette is of size 6, i.e., each node has a color from the space \(\{1, \ldots, 6\}\). Now, we reduce the palette to size 3 in 3 rounds as follows (where each node sends its color to its neighbors in each of the 3 rounds). In the first round, each node of color 6 chooses as its new color the smallest color that none of its neighbors has, while all other nodes keep their color. In the second round, each node of color 5 chooses as its new color the smallest color that none of its neighbors has, while all other nodes keep their color. In the third round, each node of color 4 chooses as its new color the smallest color that none of its neighbors has, while all other nodes keep their color.

Using algorithm \(\mathcal{A}\), we can now prove the following statement.

There is a deterministic algorithm that computes a 3-coloring on directed paths in \(O(\log^{*} n)\) rounds.

Proof. We claim that \(\mathcal{A}\) is such an algorithm. In order to show that this is the case, we need to argue that during the execution of \(\mathcal{A}\) the computed coloring always remains proper and analyze the complexity of \(\mathcal{A}\) (and fix the number of rounds that we execute Phase 2 for).

For the purpose of showing that the coloring always remains a proper coloring, consider an arbitrary node \(v\) and its parent \(w\). In Phase 2, the two new colors \(c_v' = (i, c_v[i])\) and \(c_w' = (j, c_w[j])\) differ since, if \(i = j\), then \(c_v[i] \neq c_w[i] = c_w[j]\), by the definition of \(i\). (Note that we can assume by induction that the two previous colors \(c_v\) and \(c_w\) were not identical.) In Phase 3, if any of \(v\) and \(w\) changes its color, it always makes sure (by the definition of Phase 3) that it chooses a color that the other node does not have. Note that it cannot happen that both \(v\) and \(w\) change color at the same time since they have different colors (again, by induction). It follows that the coloring always remains proper.

Now, for how many rounds do we execute \(\mathcal{A}\) in Phase 2? If the color palette before a round in Phase 2 has size \(S\), then the size of the color palette after the round is \(2\lceil \log S \rceil\). As we start with a color palette of size \(n^{c}\), after \(O(\log^{*} n)\) rounds, the color palette is of size 6.

Hence, we will execute \(\mathcal{A}\) in Phase 2 for \(O(\log^{*} n)\) rounds and obtain the guarantee that the coloring at the end of Phase 2 is a proper 6-coloring, which in turn guarantees that the final coloring is indeed a 3-coloring. (How does a node know that Phase 2 is over for itself?)

Since Phase 1 can be executed in 0 rounds, Phase 2 in \(O(\log^{*} n)\) rounds, and Phase 3 in 3 rounds, we obtain an overall complexity of \(O(\log^{*} n)\), as desired.