Dispersion is (Almost) Optimal under (A)synchrony

TL;DR

This work advances dispersion of $k$ mobile agents on an $n$-node anonymous, port-labeled graph by introducing two novel techniques: empty-node-driven DFS progress with oscillation for the synchronous setting, and an asynchronous probing extension that achieves near-optimal time. The SYNC result establishes an $O(k)$-round dispersion with memory $O(\log (k+\Delta))$, while the ASYNC result provides an $O(k\log k)$-epoch dispersion with the same memory bound, using $O(\log (k+\Delta))$ bits per agent. Both rely on fast empty-node discovery and careful handling of DFS meetings, enabling efficient scalability to general initial configurations via a KS-style merging framework. Overall, the paper substantially tightens the time-memory tradeoffs in both synchronous and asynchronous models and introduces techniques potentially useful beyond dispersion, such as robust empty-node probing and oscillation-based coverage.

Abstract

The dispersion problem has received much attention recently in the distributed computing literature. In this problem, $k\leq n$ agents placed initially arbitrarily on the nodes of an $n$-node, $m$-edge anonymous graph of maximum degree $Δ$ have to reposition autonomously to reach a configuration in which each agent is on a distinct node of the graph. Dispersion is interesting as well as important due to its connections to many fundamental coordination problems by mobile agents on graphs, such as exploration, scattering, load balancing, relocation of self-driven electric cars (robots) to recharge stations (nodes), etc. The objective has been to provide a solution that optimizes simultaneously time and memory complexities. There exist graphs for which the lower bound on time complexity is $Ω(k)$. Memory complexity is $Ω(\log k)$ per agent independent of graph topology. The state-of-the-art algorithms have (i) time complexity $O(k\log^2k)$ and memory complexity $O(\log(k+Δ))$ under the synchronous setting [DISC'24] and (ii) time complexity $O(\min\{m,kΔ\})$ and memory complexity $O(\log(k+Δ))$ under the asynchronous setting [OPODIS'21]. In this paper, we improve substantially on this state-of-the-art. Under the synchronous setting as in [DISC'24], we present the first optimal $O(k)$ time algorithm keeping memory complexity $O(\log (k+Δ))$. Under the asynchronous setting as in [OPODIS'21], we present the first algorithm with time complexity $O(k\log k)$ keeping memory complexity $O(\log (k+Δ))$, which is time-optimal within an $O(\log k)$ factor despite asynchrony. Both results were obtained through novel techniques to quickly find empty nodes to settle agents, which may be of independent interest.

Figures (7)

• Figure 1: An illustration of which nodes of an arbitrary tree $T$ are occupied with a settler and which nodes are left empty. ( left) Tree $T$ after nodes at even depth are occupied with a settler. ( right) Tree $T$ after adjustment through removing some settlers and putting new settlers.
• Figure 2: An illustration of how settlers (shown in circle with slanted lines) cover the empty nodes through oscillation shown as groups inside dashed boundaries. There is exactly one oscillating settler in each group that is responsible for oscillation to cover the empty nodes (at most 2 for the sibling case, otherwise at most 3). Oscillations are two types: (i) An oscillating settler at even depth $d$ covers at most 3 empty nodes at depth $d+1$ (ii) An oscillating settler at even/odd depth $d$ covers at most 2 empty sibling nodes at same depth $d$. The settlers shown as solid black circles are non-oscillating settlers for this figure.
• Figure 3: An illustration of how groups are formed for oscillation for a branching node $w$. Groups are formed according to the port numbers in increasing orders for the children that satisfy the oscillation criteria.
• Figure 4: An illustration of how non-oscillating settlers become oscillating when DFS progresses adding more nodes in $T_{DFS}$. Three non-oscillating settlers ($y$, $w$, and $w"$) in Fig. \ref{['fig:oscillation1']} now became oscillating (shown in the circle with diamonds) covering empty nodes in their respective groups.
• Figure 5: An illustration of how Sync_Probe() (Algorithm \ref{['alg: sync_super_probe()']}) finds a fully unsettled neighbor at a node $w$ (if exists one). In the figure, port-9 and port-10 neighbors of $w$ were found to be fully unsettled. DFS does its forward move by exiting through port-9 of $w$.

Theorems & Definitions (22)

• Lemma 1
• proof
• Lemma 2
• proof
• Lemma 3
• proof
• Lemma 4
• proof
• Lemma 5
• proof