DAG 2

The proof idea is by contradiction.

Assume there is a fast algorithm, say one running in \(n/5\) rounds. Then each node sees only its radius-\(n/5\) neighborhood. Pick two disjoint local neighborhoods around two center nodes, with disjoint ID sets. Ask the fixed algorithm what colors those two center nodes output on those local views. Since the two local views are disjoint, the outputs are determined independently. Then:

• if the algorithm gives the same color to both centers, connect the two regions so that the centers end up at odd distance;
• if the algorithm gives different colors, connect them so that they end up at even distance.

In either case, the chosen outputs cannot be extended to a valid 2-coloring of the resulting path. Therefore no such \(n/5\)-round algorithm can exist, giving an \(\Omega(n)\) lower bound.

The lecture also notes:

• there is a trivial \(O(n)\) algorithm,
• and an \(O(n/2)\) upper bound is easy because with radius \(n/2\) a node essentially knows its position in the path.

So the main qualitative message is:

Dropping from 3 colors to 2 colors changes the complexity from \(\Theta(\log^* n)\) to linear.

The first phase, the bit-based reduction from many colors down to 6 colors, still works.

Why? Because in that phase each node only needs a well-defined parent-like reference. In a rooted tree, every non-root node has a parent. If every node chooses its new color so that it differs from its parent, then the resulting labeling is still a proper coloring. Hence the first phase extends essentially unchanged and yields a 6-coloring of rooted trees in \(\Theta(\log^* n)\) rounds.

On a directed path, every node has only two neighbors, so a node of the currently highest color can always choose a new color from \(\{1,2,3\}\) different from both neighbors.

In a rooted tree, however, a node may have many children. Then its parent and children together may already occupy all three low colors, so the same greedy step no longer works. The obstacle is not the first phase, but the final reduction to 3 colors.

Each node passes its own color down to all its children. Thus:

• every child takes the old color of its parent,
• the root, which has no parent, simply picks any color different from its previous one.

Suppose after shift-down a node \(v\) gets the old color of its parent, and its parent gets the old color of the grandparent. Then the new edge colors correspond exactly to colors that were already on adjacent nodes one level higher in the old proper coloring. Since the old coloring was proper, those colors were different; hence the new coloring is proper as well.

Starting from a proper 6-coloring:

1. Apply shift-down so that siblings become monochromatic.
2. Reduce color 6 greedily to a smaller color.
3. Apply shift-down again.
4. Reduce from 5 colors to 4.
5. Apply shift-down again.
6. Reduce from 4 colors to 3.

This costs only a constant number of extra rounds, so asymptotically nothing changes.

Even after making children monochromatic, a node may still see:

• one color on all children,
• a different color on the parent.

Then if the node itself has the third color, there is no free 2-color choice left. So the same basic obstruction as on directed paths remains.

The lecture concludes:

There is a deterministic distributed algorithm that computes a proper 3-coloring of rooted trees in \(\Theta(\log^* n)\) rounds.

This is striking because trees may have arbitrarily large degree, yet 3 colors still suffice in the rooted setting with no asymptotic slowdown.

Each node arbitrarily chooses one neighbor as its “parent”, and informs the neighbor at the other end of the edge about this fact. This induces a directed structure in which every node has one outgoing edge. That structure may contain cycles, so it is not necessarily a rooted forest. However, the correctness arguments from the rooted-tree algorithm are local: what matters is only that each node tries to differ from its chosen parent. Therefore the same algorithm still works and gives a weak 3-coloring in \(\Theta(\log^* n)\) rounds.

An alternative suggestion is to choose the neighbor with highest ID, which would avoid cycles and produce actual rooted trees/forests. The lecture notes that this is a valid observation, though later uses will make arbitrary-parent selection more flexible.

So the rooted-tree machinery already yields:

Weak 3-coloring of general graphs can be computed in \(\Theta(\log^* n)\) rounds.

For each possible neighbor position, each node selects that neighbor as parent and runs the weak-3-coloring algorithm. So if a node has degree \(\Delta\), it conceptually participates in \(\Delta\) different weak-3-coloring executions, each guaranteeing that it differs from one designated neighbor.

Each node collects all the 3-colors it obtained into a tuple: \[ (c_1,c_2,\dots,c_\Delta). \]

For any neighbor \(u\), there is at least one coordinate corresponding to the execution where that neighbor was the designated parent; in that coordinate, the node’s color must differ from \(u\)’s. Hence the full tuples of adjacent nodes are always different. Therefore the tuple itself is a proper coloring.

Each coordinate has 3 possibilities, so the tuple space has size: \[ 3^\Delta. \]

Thus one obtains a proper \(3^\Delta\)-coloring.

If the \(\Delta\) weak-3-colorings were run one after another, the runtime would be \[ O(\Delta \log^* n). \]

But in the LOCAL model there is no message-size restriction, so all these independent executions can be run in parallel. Therefore the factor \(\Delta\) disappears, and the runtime remains: \[ O(\log^* n). \]

This is an important methodological point from the lecture: in the LOCAL model, independent algorithms can be executed simultaneously essentially for free.

The lecture points out that nodes may not know the global maximum degree. This is handled as a technicality:

• nodes can participate only in as many executions as make sense locally,
• if another node has larger degree, it simply participates in more parallel executions,
• tuples of different lengths are still distinguishable, so this causes no real conceptual problem.

Hence the main result is:

General graphs admit a proper \(3^\Delta\)-coloring in \(O(\log^* n)\) rounds.

If one literally reduces colors one by one from \(3^\Delta\) down to \(\Delta+1\), that takes \[ O(3^\Delta) \] additional rounds, so the total becomes \[ O(\log^* n + 3^\Delta). \] This is not small in \(\Delta\), but it has the valuable form \[ O(\log^* n + f(\Delta)). \]

There is also a subtle issue if nodes do not know the global largest color currently present. The global rule “only the highest-color nodes move” is localized as follows:

A node is allowed to change its color if it is the maximum within its closed neighborhood (itself plus neighbors).

Two adjacent nodes cannot both be local maxima in a conflicting way, so the usual correctness argument still works. This illustrates a general theme of the lecture: global arguments often need to be localized.

While we often focus on the complexity of an algorithm as a function of \(n\), it is also common to use a more fine-grained viewpoint and consider complexities that are a function of both \(n\) and \(\Delta\). If, for instance, we could find an algorithm (for some problem) that has a very small dependency on \(n\) and a potentially much larger dependency on \(\Delta\), we can still argue that this is a good algorithm for graphs with small maximum degree. A prime example are complexities of the form \[ O(\log^{*} n + f(\Delta)) \] where \(f\) is some function. Many algorithms with a complexity of this form have been developed for many important problems (such as the algorithm Corollary 1.3 is based on).

In fact, we can ask the following interesting question for every problem \(\Pi\). What is the asymptotically smallest function \(f\) such that \(\Pi\) can be solved in \[ O(\log^{*} n + f(\Delta)) \] rounds? We will study this question for various problems. Note that such a function \(f\) does not necessarily exist; we will see some natural problems that do not admit algorithms with a complexity of the form \[ O(\log^{*} n + f(\Delta)). \] In fact, \(\Delta\)-coloring is such a problem, i.e., by reducing the size of the color palette by \(1\) (from \(\Delta+1\) to \(\Delta\)), we obtain a fundamental complexity separation.

Of course, one can also ask for a pure dependency on \(\Delta\), i.e., for algorithms with a complexity of the form \[ O(f(\Delta)) \] for some function \(f\). However, as it turns out, many problems require at least \[ \Omega(\log^{*} n) \] rounds to be solved, which rules out any \(O(f(\Delta))\)-round algorithms (why?).

A popular setting (which we will consider later in the course) is the constant-degree setting in which we are given a fixed upper bound for the maximum degree \(\Delta\). As \(\Delta\) is a constant in this setting, it also holds for any function \(f\) that \(f(\Delta)\) is a constant. Hence, every problem for which we can find an algorithm with complexity \[ O(\log^{*} n + f(\Delta)) \] for some \(f\) must have complexity \[ O(\log^{*} n). \] Note that in this setting, the dependency on \(\Delta\), i.e., the choice of \(f\), does not matter; in fact, Corollary 1.3 directly implies that the complexity of \((\Delta+1)\)-coloring in the constant-degree setting is \[ O(\log^{*} n)! \]

This provides another good reason to study complexities of the form \[ O(\log^{*} n + f(\Delta)). \]