Dispersion is (Almost) Optimal under (A)synchrony

2025-03-20

AI Summary

This paper addresses the dispersion problem for $k$ mobile agents on anonymous graphs: given an $n$-node, $m$-edge graph, the goal is to relocate agents to distinct nodes. We propose efficient distributed algorithms for both synchronous and asynchronous models. In the synchronous model, we achieve the first time-optimal $O(k)$ algorithm—matching the tight lower bound. In the asynchronous model, we improve the state-of-the-art time complexity from $O(min{m, kDelta})$ to $O(k log k)$, approaching the theoretical lower bound. Our key innovation is a fast empty-node discovery mechanism combining hash-based indexing with randomized walks, augmented by lightweight state encoding. Both algorithms use only $O(log(k + Delta))$ memory per agent—significantly improving upon prior work in both time and space efficiency.

Technology Category

• Search and Optimization: Distributed Search
• Planning, Routing, and Scheduling: Optimization of Spatio-temporal Systems
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web
• Web Mining and Content Analysis: Content-based information diffusion

Abstract

The dispersion problem has received much attention recently in the distributed computing literature. In this problem, $kleq n$ agents placed initially arbitrarily on the nodes of an $n$-node, $m$-edge anonymous graph of maximum degree $Delta$ 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 $Omega(k)$. Memory complexity is $Omega(log k)$ per agent independent of graph topology. The state-of-the-art algorithms have (i) time complexity $O(klog^2k)$ and memory complexity $O(log(k+Delta))$ under the synchronous setting [DISC'24] and (ii) time complexity $O(min{m,kDelta})$ and memory complexity $O(log(k+Delta))$ 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+Delta))$. Under the asynchronous setting as in [OPODIS'21], we present the first algorithm with time complexity $O(klog k)$ keeping memory complexity $O(log (k+Delta))$, 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.

Problem

• Optimize time and memory for agent dispersion in graphs.
• Achieve optimal O(k) time in synchronous settings.
• Develop efficient algorithms for asynchronous agent dispersion.

Innovation

• Optimal O(k) time algorithm for synchronous setting
• O(k log k) time algorithm for asynchronous setting
• Memory complexity O(log(k+Δ)) maintained in both settings