Invitation to Local Algorithms

Abstract

This text provides an introduction to distributed local algorithms -- an area at the intersection of theoretical computer science and discrete mathematics. We collect recent results in the area and demonstrate how they lead to a clean theory. We also discuss many connections of local algorithms to fields such as parallel, distributed, and sublinear algorithms, or descriptive combinatorics.

Figures (9)

• Figure 1: An example local algorithm that uses three colors to color a long cycle, a small part of which is shown. First, every vertex flips a coin and selects itself with probability $1/2$. Second, a vertex unselects itself whenever a neighbor is selected. Third, selected vertices color themselves red and each selected vertex is then responsible for coloring the subsequent vertices until the next selected one with alternating colors.
• Figure 2: This picture shows the two fundamentally different ways of understanding local algorithms. Left: A $t(n)$-round local algorithm can be seen as a distributed protocol where in each round, each node can send any message to any of its neighbors. The computers start with the knowledge of their unique identifier (or a random string). Right: A local algorithm with round complexity $t(n)$ can be seen as a function that maps each possible $t(n)$-hop neighborhood to an output label. Applying this function to every vertex of the input graph always has to solve our problem: For example, if our problem is a coloring problem, the first two local neighborhoods in the above table need to map the two vertices with labels 77 and 43 to different colors, since the two labeled 2-hop neighborhoods could be a part of the same graph (which is, in fact, shown on the left).
• Figure 3: This picture shows a network decomposition with $c = 2$ color classes and $d = 2$ diameter. It also shows how network decomposition is used to convert an input sequential local algorithm (of local complexity $1$) into a distributed local algorithm in \ref{['thm:sequential_vs_distributed_complexity']}. Left: The color classes of the network decompositions are ordered as (red, blue). We iterate over the color classes and in one iteration, we consider each cluster separately and simulate an input sequential local algorithm in it (see the node ordering inside each cluster). When the algorithm is simulated in blue clusters, it has access to the output of neighboring red vertices. Right: The partial simulations of the sequential local algorithm in each cluster are consistent with a single run of that algorithm over all vertices.
• Figure 4: This picture illustrates the second phase of the algorithm from \ref{['thm:network_decomposition_deterministic']}, in a simple example graph. Left: At the beginning of the second phase, the clusters are already separated according to their first bit. In particular, if the identifier starts with $1$, the cluster is in the top connected component, while if the identifier starts with $0$, the corresponding cluster is in one of the two bottom connected components. In the second phase, a cluster is active (blue) if its second bit in the identifier is $0$, and inactive (red) otherwise. In the first step of this phase, each red vertex proposes to join an arbitrary neighboring blue cluster, provided that there is one (the arrows in the picture). The active cluster then either decides to grow (cluster $1001$) or the vertices that proposed to it are deleted (cluster $1011$). Note that if a cluster decides to delete its boundary, it does not neighbor any red nodes from that point on. Middle: After one step of our algorithm, the inactive cluster with identifier $1111$ became disconnected but its weak-diameter remains the same as at the beginning of the phase. In the second step of this phase, each red vertex again proposes to join an arbitrary neighboring blue cluster. Right: The picture shows the resulting clustering after the second phase is finished. Note that the only two adjacent clusters with identifiers $1011$ and $1001$ will be separated in the following, third, phase, as their identifiers differ on the third position.
• Figure 5: The definition of the $1.5$-round algorithm $\mathcal{A}'$ derived from a $2$-round algorithm $\mathcal{A}$: The algorithm $\mathcal{A}'$ considers all compatible one-node extensions of its neighborhood containing $4$ nodes to $5$-node-neighborhoods (in the picture, this corresponds to the following node having the identifier $12, 13, \dots, n^{O(1)}$, and the possibility that the node does not exist). The algorithm considers all possible answers that $\mathcal{A}$ returns for those neighborhoods (the picture shows that the red and the blue color are two of those possible answers). The color that $\mathcal{A}'$ uses to color the edge it is centered on is simply the set of all colors that $\mathcal{A}$ returns for some extension (in the picture, it is the set containing the red and the blue color).

Theorems & Definitions (68)

• Definition 1.1: A local problem
• Definition 1.2: Local algorithm
• Definition 1.3: Sequential local algorithms
• Theorem 1.4: *ghaffari_kuhn_maus2017slocal
• Definition 1.4: Network decomposition
• Theorem 1.5: ghaffari2024near
• proof : Proof of \ref{['thm:sequential_vs_distributed_complexity']}
• Theorem 1.6: *ghaffari_harris_kuhn2018derandomizing
• proof
• Theorem 1.7: *ghaffari_harris_kuhn2018derandomizing